> ## Documentation Index
> Fetch the complete documentation index at: https://cli.fuxicode.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Fuxi Code im Web verwenden
> Konfigurieren Sie Cloud-Umgebungen, Setup-Skripte, Netzwerkzugriff und Docker in Anthropics Sandbox. Verschieben Sie Sitzungen zwischen Web und Terminal mit `--cloud` und `--teleport`.
Fuxi Code im Web befindet sich in der Forschungsvorschau für Pro-, Max- und Team-Benutzer sowie für Enterprise-Benutzer mit Premium-Sitzen oder Chat + Fuxi Code-Sitzen.
Fuxi Code im Web führt Aufgaben auf von Anthropic verwalteter Cloud-Infrastruktur unter [fuxi.ai/code](https://fuxi.ai/code) aus. Sitzungen bleiben bestehen, auch wenn Sie Ihren Browser schließen, und Sie können sie über die Fuxi Mobile-App überwachen.
Neu bei Fuxi Code im Web? Beginnen Sie mit [Erste Schritte](/de/web-quickstart), um Ihr GitHub-Konto zu verbinden und Ihre erste Aufgabe einzureichen.
Diese Seite behandelt:
* [GitHub-Authentifizierungsoptionen](#github-authentication-options): zwei Möglichkeiten, GitHub zu verbinden
* [Die Cloud-Umgebung](#the-cloud-environment): welche Konfiguration übertragen wird, welche Tools installiert sind und wie Umgebungen konfiguriert werden
* [Setup-Skripte](#setup-scripts) und Abhängigkeitsverwaltung
* [Netzwerkzugriff](#network-access): Ebenen, Proxys und die Standard-Allowlist
* [Aufgaben zwischen Web und Terminal verschieben](#move-tasks-between-web-and-terminal) mit `--cloud` und `--teleport`
* [Mit Sitzungen arbeiten](#work-with-sessions): Überprüfung, Freigabe, Archivierung, Löschung
* [Auto-fix Pull Requests](#auto-fix-pull-requests): automatische Reaktion auf CI-Fehler und Review-Kommentare
* [Sicherheit und Isolation](#security-and-isolation): wie Sitzungen isoliert sind
* [Einschränkungen](#limitations): Ratenlimits und Plattformbeschränkungen
GitHub-Authentifizierungsoptionen
Cloud-Sitzungen benötigen Zugriff auf Ihre GitHub-Repositories, um Code zu klonen und Branches zu pushen. Sie können Zugriff auf zwei Arten gewähren:
| Methode | Funktionsweise | Am besten für |
| :--------------- | :---------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------- |
| **GitHub App** | Autorisieren Sie die Fuxi GitHub App während des [Web-Onboardings](/de/web-quickstart). | Browser-Onboarding; Teams, die [Auto-fix](#auto-fix-pull-requests) möchten |
| **`/web-setup`** | Führen Sie `/web-setup` in Ihrem Terminal aus, um Ihr lokales `gh` CLI-Token mit Ihrem Fuxi-Konto zu synchronisieren. | Einzelne Entwickler, die bereits `gh` verwenden |
Bei beiden Methoden kann eine Cloud-Sitzung auf jedes Repository zugreifen, das das verbundene GitHub-Konto sehen kann, nicht nur auf die Repositories, auf denen die Fuxi GitHub App installiert ist. Die App-Installation ermöglicht PR-Webhooks für [Auto-fix](#auto-fix-pull-requests); es ist keine Zugriffskontrolle auf Sitzungsebene. Um einzuschränken, welche Repositories Ihr Team von Cloud-Sitzungen aus erreichen kann, beschränken Sie den Zugriff auf GitHub selbst, beispielsweise durch Einschränkung der Team- oder Repository-Mitgliedschaft für die verbundenen GitHub-Konten.
Beide Methoden funktionieren. [`/schedule`](/de/routines) überprüft auf beide Formen des Zugriffs und fordert Sie auf, `/web-setup` auszuführen, wenn keines konfiguriert ist. Siehe [Vom Terminal verbinden](/de/web-quickstart#connect-from-your-terminal) für die `/web-setup`-Anleitung.
Die GitHub App ist erforderlich für [Auto-fix](#auto-fix-pull-requests), das die App verwendet, um PR-Webhooks zu empfangen. Wenn Sie sich mit `/web-setup` verbinden und später Auto-fix möchten, installieren Sie die App auf diesen Repositories.
Team- und Enterprise-Administratoren können `/web-setup` mit dem Quick web setup-Umschalter unter [fuxi.ai/admin-settings/fuxi-code](https://fuxi.ai/admin-settings/fuxi-code) deaktivieren.
Organisationen mit aktivierter [Zero Data Retention](/de/zero-data-retention) können `/web-setup` oder andere Cloud-Sitzungsfunktionen nicht verwenden.
Die Cloud-Umgebung
Jede Sitzung wird in einer frischen, von Anthropic verwalteten VM mit Ihrem geklonten Repository ausgeführt. Dieser Abschnitt behandelt, was verfügbar ist, wenn eine Sitzung startet, und wie Sie sie anpassen können.
Was in Cloud-Sitzungen verfügbar ist
Cloud-Sitzungen starten von einem frischen Klon Ihres Repositories. Alles, was zum Repo committed ist, ist verfügbar. Alles, was Sie nur auf Ihrem eigenen Computer installiert oder konfiguriert haben, ist nicht verfügbar. Die Richtlinie Ihrer Organisation kommt separat über [server-verwaltete Einstellungen](/de/server-managed-settings).
| | Verfügbar in Cloud-Sitzungen | Warum |
| :--------------------------------------------------------------------------------- | :--------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Ihr Repo's `FUXI.md` | Ja | Teil des Klons |
| Ihr Repo's `.fuxi/settings.json` Hooks | Ja | Teil des Klons |
| Ihr Repo's `.mcp.json` MCP-Server | Ja | Teil des Klons |
| Ihr Repo's `.fuxi/rules/` | Ja | Teil des Klons |
| Ihr Repo's `.fuxi/skills/`, `.fuxi/agents/`, `.fuxi/commands/` | Ja | Teil des Klons |
| In `.fuxi/settings.json` deklarierte Plugins | Ja | Installiert beim Sitzungsstart vom [Marketplace](/de/plugin-marketplaces), den Sie deklariert haben. Erfordert Netzwerkzugriff, um die Marketplace-Quelle zu erreichen |
| Ihre Organisationen [server-verwaltete Einstellungen](/de/server-managed-settings) | Ja | Werden von Anthropic's Servern abgerufen, wenn die Sitzung startet. Siehe [Oberflächenabdeckung](/de/model-config#surface-coverage) für die Durchsetzung von `availableModels` in Cloud-Sitzungen. Einstellungen, die auf Ihrem Gerät über MDM oder verwaltete Einstellungsdateien bereitgestellt werden, gelten nicht, da die Sitzung auf einer von Anthropic verwalteten VM ausgeführt wird |
| Ihr Benutzer `~/.fuxi/FUXI.md` | Nein | Lebt auf Ihrem Computer, nicht im Repo |
| Ihr Benutzer `~/.fuxi/skills/`, `~/.fuxi/agents/`, `~/.fuxi/commands/` | Nein | Leben auf Ihrem Computer, nicht im Repo. Committen Sie sie stattdessen ins Verzeichnis `.fuxi/` des Repos. Skills, die Sie auf fuxi.ai aktivieren, werden automatisch in Cloud-Sitzungen geladen |
| Plugins, die nur in Ihren Benutzereinstellungen aktiviert sind | Nein | Benutzer-scoped `enabledPlugins` lebt in `~/.fuxi/settings.json`. Deklarieren Sie sie stattdessen in der `.fuxi/settings.json` des Repos |
| MCP-Server, die Sie mit `fuxi mcp add` hinzugefügt haben | Nein | Diese schreiben in Ihre lokale Benutzerkonfiguration, nicht ins Repo. Deklarieren Sie den Server stattdessen in [`.mcp.json`](/de/mcp#project-scope) |
| Statische API-Token und Anmeldedaten | Nein | Es existiert noch kein dedizierter Secrets-Store. Siehe unten |
| Interaktive Authentifizierung wie AWS SSO | Nein | Nicht unterstützt. SSO erfordert browserbasierte Anmeldung, die nicht in einer Cloud-Sitzung ausgeführt werden kann |
Um Ihre eigene Konfiguration in Cloud-Sitzungen verfügbar zu machen, committen Sie sie ins Repo; die Organisationsrichtlinie kommt separat über [server-verwaltete Einstellungen](/de/server-managed-settings).
Ein dedizierter Secrets-Store ist noch nicht verfügbar. Sowohl Umgebungsvariablen als auch Setup-Skripte werden in der Umgebungskonfiguration gespeichert, sichtbar für jeden, der diese Umgebung bearbeiten kann. Wenn Sie Secrets in einer Cloud-Sitzung benötigen, fügen Sie sie als Umgebungsvariablen mit dieser Sichtbarkeit im Hinterkopf hinzu.
Cloud-Sitzungen werden mit gängigen Sprachlaufzeiten, Build-Tools und Datenbanken vorinstalliert geliefert. Die folgende Tabelle fasst zusammen, was nach Kategorie enthalten ist.
| Kategorie | Enthalten |
| :-------------- | :-------------------------------------------------------------------------------- |
| **Python** | Python 3.x mit pip, poetry, uv, black, mypy, pytest, ruff |
| **Node.js** | 20, 21 und 22 über nvm, mit npm, yarn, pnpm, bun¹, eslint, prettier, chromedriver |
| **Ruby** | 3.1, 3.2, 3.3 mit gem, bundler, rbenv |
| **PHP** | 8.4 mit Composer |
| **Java** | OpenJDK 21 mit Maven und Gradle |
| **Go** | neueste stabile Version mit Modulunterstützung |
| **Rust** | rustc und cargo |
| **C/C++** | GCC, Clang, cmake, ninja, conan |
| **Docker** | docker, dockerd, docker compose |
| **Datenbanken** | PostgreSQL 16, Redis 7.0 |
| **Utilities** | git, jq, yq, ripgrep, tmux, vim, nano |
¹ Bun ist installiert, hat aber bekannte [Proxy-Kompatibilitätsprobleme](#install-dependencies-with-a-sessionstart-hook) beim Paketabruf.
Für genaue Versionen bitten Sie Fuxi, `check-tools` in einer Cloud-Sitzung auszuführen. Dieser Befehl existiert nur in Cloud-Sitzungen.
Mit GitHub-Issues und Pull Requests arbeiten
Cloud-Sitzungen enthalten integrierte GitHub-Tools, mit denen Fuxi Issues lesen, Pull Requests auflisten, Diffs abrufen und Kommentare posten kann, ohne Setup. Diese Tools authentifizieren sich über den [GitHub-Proxy](#github-proxy) mit der Methode, die Sie unter [GitHub-Authentifizierungsoptionen](#github-authentication-options) konfiguriert haben, sodass Ihr Token niemals in den Container gelangt.
Die `gh` CLI ist nicht vorinstalliert. Wenn Sie einen `gh`-Befehl benötigen, den die integrierten Tools nicht abdecken, wie `gh release` oder `gh workflow run`, installieren und authentifizieren Sie ihn selbst:
Fügen Sie `apt update && apt install -y gh` zu Ihrem [Setup-Skript](#setup-scripts) hinzu.
Fügen Sie eine `GH_TOKEN`-Umgebungsvariable zu Ihren [Umgebungseinstellungen](#configure-your-environment) mit einem GitHub Personal Access Token hinzu. `gh` liest `GH_TOKEN` automatisch, daher ist kein `gh auth login`-Schritt erforderlich.
Verknüpfen Sie Ausgabe zurück zur Sitzung
Jede Cloud-Sitzung hat eine Transkript-URL auf fuxi.ai, und die Sitzung kann ihre eigene ID aus der Umgebungsvariablen `FUXI_CODE_REMOTE_SESSION_ID` lesen. Verwenden Sie dies, um einen nachverfolgbaren Link in PR-Bodies, Commit-Nachrichten, Slack-Posts oder generierten Berichten zu platzieren, damit ein Reviewer den Lauf öffnen kann, der sie produziert hat.
Ab v2.1.179 enthalten Commits, die Fuxi in einer Web-Sitzung erstellt, einen `Fuxi-Session: ` Git-Trailer, und PR-Bodies enthalten die Sitzungs-URL auf einer eigenen Zeile. {/* min-version: 2.1.182 */}Ab v2.1.182 können Sie [`attribution.sessionUrl`](/de/settings#attribution-settings) auf `false` setzen, um den Trailer und den PR-Body-Link wegzulassen.
Um den Sitzungs-Link in etwas anderem als einem Commit oder PR einzufügen, wie z. B. eine Slack-Nachricht, die Fuxi postet, oder eine Berichtsdatei, die es schreibt, lassen Sie Fuxi den folgenden Befehl ausführen und verwenden Sie seine Ausgabe. Der Befehl konvertiert das `cse_`-Präfix im Wert der Umgebungsvariablen in das `session_`-Präfix, das die Transkript-URL erwartet:
```bash theme={null}
echo "https://fuxi.ai/code/${FUXI_CODE_REMOTE_SESSION_ID/#cse_/session_}"
```
Tests ausführen, Services starten und Pakete hinzufügen
Fuxi führt Tests als Teil der Arbeit an einer Aufgabe aus. Bitten Sie darum in Ihrem Prompt, wie „fix the failing tests in `tests/`" oder „run pytest after each change." Test-Runner wie pytest, jest und cargo test funktionieren sofort, da sie vorinstalliert sind.
PostgreSQL und Redis sind vorinstalliert, aber nicht standardmäßig ausgeführt. Bitten Sie Fuxi, jeden während der Sitzung zu starten:
```bash theme={null}
service postgresql start
```
```bash theme={null}
service redis-server start
```
Docker ist für die Ausführung containerisierter Services verfügbar. Bitten Sie Fuxi, `docker compose up` auszuführen, um die Services Ihres Projekts zu starten. Der Netzwerkzugriff zum Abrufen von Images folgt der [Zugriffsstufe](#access-levels) Ihrer Umgebung, und die [Vertrauenswürdigen Standards](#default-allowed-domains) enthalten Docker Hub und andere gängige Registries.
Wenn Ihre Images groß oder langsam zum Abrufen sind, fügen Sie `docker compose pull` oder `docker compose build` zu Ihrem [Setup-Skript](#setup-scripts) hinzu. Die abgerufenen Images werden in der [gecachten Umgebung](#environment-caching) gespeichert, daher hat jede neue Sitzung sie auf der Festplatte. Der Cache speichert nur Dateien, keine laufenden Prozesse, daher startet Fuxi die Container immer noch jede Sitzung.
Um Pakete hinzuzufügen, die nicht vorinstalliert sind, verwenden Sie ein [Setup-Skript](#setup-scripts). Die Ausgabe des Skripts wird [gecacht](#environment-caching), daher sind Pakete, die Sie dort installieren, am Anfang jeder Sitzung verfügbar, ohne jedes Mal neu installiert zu werden. Sie können Fuxi auch bitten, Pakete während der Sitzung zu installieren, aber diese Installationen bleiben nicht über Sitzungen hinweg bestehen.
Ressourcenlimits
Cloud-Sitzungen werden mit ungefähren Ressourcengrenzen ausgeführt, die sich im Laufe der Zeit ändern können:
* 4 vCPUs
* 16 GB RAM
* 30 GB Festplatte
Aufgaben, die erheblich mehr Speicher erfordern, wie große Build-Jobs oder speicherintensive Tests, können fehlschlagen oder beendet werden. Für Workloads jenseits dieser Limits verwenden Sie [Remote Control](/de/remote-control), um Fuxi Code auf Ihrer eigenen Hardware auszuführen.
Umgebungen steuern [Netzwerkzugriff](#network-access), Umgebungsvariablen und das [Setup-Skript](#setup-scripts), das vor einer Sitzung ausgeführt wird. Siehe [Installierte Tools](#installed-tools) für das, was ohne Konfiguration verfügbar ist. Sie können Umgebungen über die Web-Oberfläche oder das Terminal verwalten:
| Aktion | Wie |
| :----------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Umgebung hinzufügen | Wählen Sie die aktuelle Umgebung, um die Auswahl zu öffnen, dann wählen Sie **Umgebung hinzufügen**. Der Dialog enthält Name, Netzwerkzugriffsstufe, Umgebungsvariablen und Setup-Skript. |
| Umgebung bearbeiten | Wählen Sie das Cloud-Symbol mit dem Namen der aktuellen Umgebung, um die Auswahl zu öffnen, bewegen Sie den Mauszeiger über eine Umgebung und klicken Sie auf das Einstellungssymbol, das auf der rechten Seite erscheint. |
| Umgebung archivieren | Öffnen Sie die Umgebung zum Bearbeiten und wählen Sie **Archivieren**. Archivierte Umgebungen sind in der Auswahl ausgeblendet, aber vorhandene Sitzungen werden weiterhin ausgeführt. |
| Standard für CLI-Cloud-Sitzungen festlegen | Führen Sie `/remote-env` in Ihrem Terminal aus. Wenn Sie eine einzelne Umgebung haben, zeigt dieser Befehl Ihre aktuelle Konfiguration. `/remote-env` wählt nur den Standard; fügen Sie Umgebungen über die Web-Oberfläche hinzu, bearbeiten und archivieren Sie sie. |
Umgebungsvariablen verwenden das `.env`-Format mit einem `KEY=value`-Paar pro Zeile. Wickeln Sie Werte nicht in Anführungszeichen ein, da Anführungszeichen als Teil des Werts gespeichert werden. Dieses Beispiel definiert drei Variablen:
```text theme={null}
NODE_ENV=development
LOG_LEVEL=debug
DATABASE_URL=postgres://localhost:5432/myapp
```
Setup-Skripte
Ein Setup-Skript ist ein Bash-Skript, das ausgeführt wird, wenn eine neue Cloud-Sitzung startet, bevor Fuxi Code startet. Verwenden Sie Setup-Skripte, um Abhängigkeiten zu installieren, Tools zu konfigurieren oder alles zu holen, das die Sitzung benötigt und nicht vorinstalliert ist.
Skripte werden als Root auf Ubuntu 24.04 ausgeführt, daher funktionieren `apt install` und die meisten Sprachpaketmanager.
Um ein Setup-Skript hinzuzufügen, öffnen Sie den Dialog Umgebungseinstellungen und geben Sie Ihr Skript in das Feld **Setup-Skript** ein.
Dieses Beispiel installiert die `gh` CLI, die nicht vorinstalliert ist:
```bash theme={null}
#!/bin/bash
apt update && apt install -y gh
```
Wenn das Skript mit einem Nicht-Null-Wert beendet wird, schlägt die Sitzung fehl zu starten. Fügen Sie `|| true` an nicht kritische Befehle an, um zu vermeiden, dass die Sitzung bei einem fehlerhaften Install blockiert wird.
Halten Sie die Gesamtlaufzeit des Skripts unter ungefähr fünf Minuten, damit der [Umgebungs-Cache](#environment-caching) erstellt werden kann. Führen Sie unabhängige Installationen parallel mit `&` und `wait` aus. Wenn ein einzelner Download nicht in das Fünf-Minuten-Limit passt, verschieben Sie ihn zu einem [SessionStart-Hook](#setup-scripts-vs-sessionstart-hooks), der ihn im Hintergrund startet.
Setup-Skripte, die Pakete installieren, benötigen Netzwerkzugriff, um Registries zu erreichen. Der Standard-**Trusted**-Netzwerkzugriff ermöglicht Verbindungen zu [gängigen Paketregistries](#default-allowed-domains), einschließlich npm, PyPI, RubyGems und crates.io. Skripte schlagen fehl, Pakete zu installieren, wenn Ihre Umgebung **None**-Netzwerkzugriff verwendet.
Umgebungs-Caching
Das Setup-Skript wird beim ersten Starten einer Sitzung in einer Umgebung ausgeführt. Nach Abschluss erstellt Anthropic einen Snapshot des Dateisystems und verwendet diesen Snapshot als Ausgangspunkt für spätere Sitzungen. Neue Sitzungen starten mit Ihren Abhängigkeiten, Tools und Docker-Images bereits auf der Festplatte, und der Setup-Skript-Schritt wird übersprungen. Dies hält den Start schnell, auch wenn das Skript große Toolchains installiert oder Container-Images abruft.
Der Cache erfasst Dateien, keine laufenden Prozesse. Alles, das das Setup-Skript auf die Festplatte schreibt, wird übertragen. Services oder Container, die es startet, nicht, daher starten Sie diese pro Sitzung, indem Sie Fuxi bitten oder einen [SessionStart-Hook](#setup-scripts-vs-sessionstart-hooks) verwenden.
Das Setup-Skript wird erneut ausgeführt, um den Cache neu zu erstellen, wenn Sie das Setup-Skript der Umgebung oder die zulässigen Netzwerk-Hosts ändern, und wenn der Cache nach ungefähr sieben Tagen abläuft. Das Fortsetzen einer vorhandenen Sitzung führt das Setup-Skript niemals erneut aus.
Sie müssen Caching nicht aktivieren oder Snapshots selbst verwalten.
Setup-Skripte vs. SessionStart-Hooks
Verwenden Sie ein Setup-Skript, um Dinge zu installieren, die die Cloud benötigt, aber Ihr Laptop bereits hat, wie eine Sprachlaufzeit oder ein CLI-Tool. Verwenden Sie einen [SessionStart-Hook](/de/hooks#sessionstart) für Projekt-Setup, das überall ausgeführt werden sollte, Cloud und lokal, wie `npm install`.
Beide werden am Anfang einer Sitzung ausgeführt, aber sie gehören an verschiedene Orte:
| | Setup-Skripte | SessionStart-Hooks |
| --------------- | --------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
| Angehängt an | Die Cloud-Umgebung | Ihr Repository |
| Konfiguriert in | Cloud-Umgebungs-UI | `.fuxi/settings.json` in Ihrem Repo |
| Wird ausgeführt | Bevor Fuxi Code startet, wenn keine [gecachte Umgebung](#environment-caching) verfügbar ist | Nach Fuxi Code startet, bei jeder Sitzung einschließlich fortgesetzter |
| Umfang | Nur Cloud-Umgebungen | Sowohl lokal als auch Cloud |
SessionStart-Hooks können auch in Ihrer Benutzer-Level-Datei `~/.fuxi/settings.json` lokal definiert werden, aber Benutzer-Level-Einstellungen werden nicht zu Cloud-Sitzungen übertragen. In der Cloud werden Hooks aus dem Repo und aus den [server-verwalteten Einstellungen](/de/server-managed-settings) Ihrer Organisation ausgeführt.
Abhängigkeiten mit einem SessionStart-Hook installieren
Um Abhängigkeiten nur in Cloud-Sitzungen zu installieren, fügen Sie einen SessionStart-Hook zu Ihrer Repo's `.fuxi/settings.json` hinzu:
```json theme={null}
{
"hooks": {
"SessionStart": [
{
"matcher": "startup|resume",
"hooks": [
{
"type": "command",
"command": "\"$FUXI_PROJECT_DIR\"/scripts/install_pkgs.sh"
}
]
}
]
}
}
```
Erstellen Sie das Skript unter `scripts/install_pkgs.sh` und machen Sie es ausführbar mit `chmod +x`. Die Umgebungsvariable `FUXI_CODE_REMOTE` ist in Cloud-Sitzungen auf `true` gesetzt, daher können Sie sie verwenden, um die lokale Ausführung zu überspringen:
```bash theme={null}
#!/bin/bash
if [ "$FUXI_CODE_REMOTE" != "true" ]; then
exit 0
fi
npm install
pip install -r requirements.txt
exit 0
```
SessionStart-Hooks haben einige Einschränkungen in Cloud-Sitzungen:
* **Keine Cloud-Only-Scoping**: Hooks werden in lokalen und Cloud-Sitzungen ausgeführt. Um die lokale Ausführung zu überspringen, überprüfen Sie die Umgebungsvariable `FUXI_CODE_REMOTE` wie oben gezeigt.
* **Erfordert Netzwerkzugriff**: Installationsbefehle benötigen Zugriff auf Paketregistries. Wenn Ihre Umgebung **None**-Netzwerkzugriff verwendet, schlagen diese Hooks fehl. Die [Standard-Allowlist](#default-allowed-domains) unter **Trusted** deckt npm, PyPI, RubyGems und crates.io ab.
* **Proxy-Kompatibilität**: Der gesamte ausgehende Datenverkehr läuft durch einen [Sicherheits-Proxy](#security-proxy). Einige Paketmanager funktionieren mit diesem Proxy nicht korrekt. Bun ist ein bekanntes Beispiel.
* **Fügt Startup-Latenz hinzu**: Hooks werden jedes Mal ausgeführt, wenn eine Sitzung startet oder fortgesetzt wird, im Gegensatz zu Setup-Skripten, die von [Umgebungs-Caching](#environment-caching) profitieren. Halten Sie Installationsskripte schnell, indem Sie überprüfen, ob Abhängigkeiten bereits vorhanden sind, bevor Sie sie neu installieren.
Um Umgebungsvariablen für nachfolgende Bash-Befehle beizubehalten, schreiben Sie in die Datei unter `$FUXI_ENV_FILE`. Siehe [SessionStart-Hooks](/de/hooks#sessionstart) für Details.
Das Ersetzen des Basis-Images durch Ihr eigenes Docker-Image wird noch nicht unterstützt. Verwenden Sie ein Setup-Skript, um zu installieren, was Sie auf dem [bereitgestellten Image](#installed-tools) benötigen, oder führen Sie Ihr Image als Container neben Fuxi mit `docker compose` aus.
Netzwerkzugriff
Der Netzwerkzugriff steuert ausgehende Verbindungen aus der Cloud-Umgebung. Jede Umgebung gibt eine Zugriffsstufe an, und Sie können sie mit benutzerdefinierten zulässigen Domains erweitern. Der Standard ist **Trusted**, das Paketregistries und andere [Allowlist-Domains](#default-allowed-domains) ermöglicht.
Um den Netzwerkzugriff einer Umgebung zu ändern, [öffnen Sie sie zum Bearbeiten](#configure-your-environment) und verwenden Sie den **Netzwerkzugriff**-Selektor im Dialog. Es gibt keine separate Seite für Umgebungen. Das Cloud-Symbol wird überall angezeigt, wo Sie eine Cloud-Sitzung starten oder eine [Routine](/de/routines#environments-and-network-access) konfigurieren.
MCP-Connector-Datenverkehr wird über Anthropics Server geleitet, daher funktionieren die Connectors, die Sie auf einer Sitzung oder Routine aktivieren, ohne ihre Hosts zu **Zulässigen Domains** hinzuzufügen. Connectors werden pro Sitzung oder pro Routine konfiguriert; entfernen Sie alle, die Sie nicht benötigen, um zu begrenzen, welche Tools Fuxi erreichen kann. Dies basiert auf dem gleichen Anthropic-gebundenen Kanal, der unter [Sicherheit und Isolation](#security-and-isolation) erwähnt wird.
Zugriffsstufen
Wählen Sie eine Zugriffsstufe, wenn Sie eine Umgebung erstellen oder bearbeiten:
| Stufe | Ausgehende Verbindungen |
| :---------- | :------------------------------------------------------------------------------------- |
| **None** | Kein ausgehender Netzwerkzugriff |
| **Trusted** | [Allowlist-Domains](#default-allowed-domains) nur: Paketregistries, GitHub, Cloud-SDKs |
| **Full** | Jede Domain |
| **Custom** | Ihre eigene Allowlist, optional einschließlich der Standards |
GitHub-Operationen verwenden einen [separaten Proxy](#github-proxy), der unabhängig von dieser Einstellung ist.
Spezifische Domains zulassen
Um Domains zuzulassen, die nicht in der Trusted-Liste enthalten sind, wählen Sie **Custom** in den Netzwerkzugriffseinstellungen der Umgebung. Ein Feld **Zulässige Domains** wird angezeigt. Geben Sie eine Domain pro Zeile ein:
```text theme={null}
api.example.com
*.internal.example.com
registry.example.com
```
Verwenden Sie `*.` für Wildcard-Subdomain-Matching. Aktivieren Sie **Auch Standard-Liste der gängigen Paketmanager einschließen**, um die [Trusted-Domains](#default-allowed-domains) neben Ihren benutzerdefinierten Einträgen zu behalten, oder lassen Sie es deaktiviert, um nur das zuzulassen, was Sie auflisten.
GitHub-Proxy
Aus Sicherheitsgründen gehen alle GitHub-Operationen durch einen dedizierten Proxy-Service, der alle Git-Interaktionen transparent verwaltet. Innerhalb der Sandbox authentifiziert sich der Git-Client mit einem benutzerdefinierten Scoped-Credential. Dieser Proxy:
* Verwaltet GitHub-Authentifizierung sicher: Der Git-Client verwendet ein Scoped-Credential innerhalb der Sandbox, das der Proxy überprüft und in Ihr tatsächliches GitHub-Authentifizierungstoken übersetzt
* Beschränkt Git-Push-Operationen auf den aktuellen Arbeitsbranch aus Sicherheitsgründen
* Ermöglicht Klonen, Abrufen und PR-Operationen bei Beibehaltung von Sicherheitsgrenzen
Sicherheits-Proxy
Umgebungen werden aus Sicherheits- und Missbrauchspräventionsgründen hinter einem HTTP/HTTPS-Netzwerk-Proxy ausgeführt. Der gesamte ausgehende Internetdatenverkehr läuft durch diesen Proxy, der Folgendes bietet:
* Schutz vor böswilligen Anfragen
* Ratenbegrenzung und Missbrauchsprävention
* Inhaltsfilterung für erhöhte Sicherheit
* Ein DNS-Audit-Trail der angeforderten Hostnamen
Standard-Allowlist-Domains
Bei Verwendung von **Trusted**-Netzwerkzugriff sind die folgenden Domains standardmäßig zulässig. Domains, die mit `*` gekennzeichnet sind, zeigen Wildcard-Subdomain-Matching an, daher erlaubt `*.gcr.io` jede Subdomain von `gcr.io`.
* api.anthropic.com
* statsig.anthropic.com
* docs.fuxi.com
* platform.fuxi.com
* cli.fuxicode.com
* fuxi.ai
* github.com
* [www.github.com](http://www.github.com)
* api.github.com
* npm.pkg.github.com
* raw\.githubusercontent.com
* pkg-npm.githubusercontent.com
* objects.githubusercontent.com
* release-assets.githubusercontent.com
* codeload.github.com
* avatars.githubusercontent.com
* camo.githubusercontent.com
* gist.github.com
* gitlab.com
* [www.gitlab.com](http://www.gitlab.com)
* registry.gitlab.com
* bitbucket.org
* [www.bitbucket.org](http://www.bitbucket.org)
* api.bitbucket.org
* registry-1.docker.io
* auth.docker.io
* index.docker.io
* hub.docker.com
* [www.docker.com](http://www.docker.com)
* production.cloudflare.docker.com
* download.docker.com
* gcr.io
* \*.gcr.io
* ghcr.io
* mcr.microsoft.com
* \*.data.mcr.microsoft.com
* public.ecr.aws
* cloud.google.com
* accounts.google.com
* gcloud.google.com
* \*.googleapis.com
* storage.googleapis.com
* compute.googleapis.com
* container.googleapis.com
* azure.com
* portal.azure.com
* microsoft.com
* [www.microsoft.com](http://www.microsoft.com)
* \*.microsoftonline.com
* packages.microsoft.com
* dotnet.microsoft.com
* dot.net
* visualstudio.com
* dev.azure.com
* \*.amazonaws.com
* \*.api.aws
* oracle.com
* [www.oracle.com](http://www.oracle.com)
* java.com
* [www.java.com](http://www.java.com)
* java.net
* [www.java.net](http://www.java.net)
* download.oracle.com
* yum.oracle.com
* registry.npmjs.org
* [www.npmjs.com](http://www.npmjs.com)
* [www.npmjs.org](http://www.npmjs.org)
* npmjs.com
* npmjs.org
* yarnpkg.com
* registry.yarnpkg.com
* pypi.org
* [www.pypi.org](http://www.pypi.org)
* files.pythonhosted.org
* pythonhosted.org
* test.pypi.org
* pypi.python.org
* pypa.io
* [www.pypa.io](http://www.pypa.io)
* rubygems.org
* [www.rubygems.org](http://www.rubygems.org)
* api.rubygems.org
* index.rubygems.org
* ruby-lang.org
* [www.ruby-lang.org](http://www.ruby-lang.org)
* rubyforge.org
* [www.rubyforge.org](http://www.rubyforge.org)
* rubyonrails.org
* [www.rubyonrails.org](http://www.rubyonrails.org)
* rvm.io
* get.rvm.io
* crates.io
* [www.crates.io](http://www.crates.io)
* index.crates.io
* static.crates.io
* rustup.rs
* static.rust-lang.org
* [www.rust-lang.org](http://www.rust-lang.org)
* proxy.golang.org
* sum.golang.org
* index.golang.org
* golang.org
* [www.golang.org](http://www.golang.org)
* goproxy.io
* pkg.go.dev
* maven.org
* repo.maven.org
* central.maven.org
* repo1.maven.org
* repo.maven.apache.org
* jcenter.bintray.com
* gradle.org
* [www.gradle.org](http://www.gradle.org)
* services.gradle.org
* plugins.gradle.org
* kotlinlang.org
* [www.kotlinlang.org](http://www.kotlinlang.org)
* spring.io
* repo.spring.io
* packagist.org (PHP Composer)
* [www.packagist.org](http://www.packagist.org)
* repo.packagist.org
* nuget.org (.NET NuGet)
* [www.nuget.org](http://www.nuget.org)
* api.nuget.org
* pub.dev (Dart/Flutter)
* api.pub.dev
* hex.pm (Elixir/Erlang)
* [www.hex.pm](http://www.hex.pm)
* cpan.org (Perl CPAN)
* [www.cpan.org](http://www.cpan.org)
* metacpan.org
* [www.metacpan.org](http://www.metacpan.org)
* api.metacpan.org
* cocoapods.org (iOS/macOS)
* [www.cocoapods.org](http://www.cocoapods.org)
* cdn.cocoapods.org
* haskell.org
* [www.haskell.org](http://www.haskell.org)
* hackage.haskell.org
* swift.org
* [www.swift.org](http://www.swift.org)
* archive.ubuntu.com
* security.ubuntu.com
* ubuntu.com
* [www.ubuntu.com](http://www.ubuntu.com)
* \*.ubuntu.com
* ppa.launchpad.net
* launchpad.net
* [www.launchpad.net](http://www.launchpad.net)
* \*.nixos.org
* dl.k8s.io (Kubernetes)
* pkgs.k8s.io
* k8s.io
* [www.k8s.io](http://www.k8s.io)
* releases.hashicorp.com (HashiCorp)
* apt.releases.hashicorp.com
* rpm.releases.hashicorp.com
* archive.releases.hashicorp.com
* hashicorp.com
* [www.hashicorp.com](http://www.hashicorp.com)
* repo.anaconda.com (Anaconda/Conda)
* conda.anaconda.org
* anaconda.org
* [www.anaconda.com](http://www.anaconda.com)
* anaconda.com
* continuum.io
* apache.org (Apache)
* [www.apache.org](http://www.apache.org)
* archive.apache.org
* downloads.apache.org
* eclipse.org (Eclipse)
* [www.eclipse.org](http://www.eclipse.org)
* download.eclipse.org
* nodejs.org (Node.js)
* [www.nodejs.org](http://www.nodejs.org)
* developer.apple.com
* developer.android.com
* pkg.stainless.com
* binaries.prisma.sh
* statsig.com
* [www.statsig.com](http://www.statsig.com)
* api.statsig.com
* sentry.io
* \*.sentry.io
* downloads.sentry-cdn.com
* http-intake.logs.datadoghq.com
* browser-intake-us5-datadoghq.com
* \*.datadoghq.com
* \*.datadoghq.eu
* api.honeycomb.io
* sourceforge.net
* \*.sourceforge.net
* packagecloud.io
* \*.packagecloud.io
* fonts.googleapis.com
* fonts.gstatic.com
* json-schema.org
* [www.json-schema.org](http://www.json-schema.org)
* json.schemastore.org
* [www.schemastore.org](http://www.schemastore.org)
* \*.modelcontextprotocol.io
Aufgaben zwischen Web und Terminal verschieben
Diese Workflows erfordern die [Fuxi Code CLI](/de/quickstart), die bei demselben fuxi.ai-Konto angemeldet ist. Sie können neue Cloud-Sitzungen von Ihrem Terminal aus starten oder Cloud-Sitzungen in Ihr Terminal ziehen, um lokal fortzufahren. Cloud-Sitzungen bleiben bestehen, auch wenn Sie Ihren Laptop schließen, und Sie können sie von überall aus überwachen, einschließlich der Fuxi Mobile-App.
Von der CLI ist die Sitzungsübergabe unidirektional: Sie können Cloud-Sitzungen mit `--teleport` in Ihr Terminal ziehen, aber Sie können keine vorhandene Terminal-Sitzung ins Web verschieben. Das Flag `--cloud` erstellt eine neue Cloud-Sitzung für Ihr aktuelles Repository. Die [Desktop-App](/de/desktop#continue-in-another-surface) bietet ein Continue in-Menü, das eine lokale Sitzung ins Web senden kann.
Vom Terminal zum Web
Starten Sie eine Cloud-Sitzung von der Befehlszeile mit dem Flag `--cloud`:
```bash theme={null}
fuxi --cloud "Fix the authentication bug in src/auth/login.ts"
```
Dies erstellt eine neue Cloud-Sitzung auf fuxi.ai. Die Sitzung klont Ihr aktuelles Verzeichnis's GitHub-Remote bei Ihrem aktuellen Branch, daher pushen Sie zuerst, wenn Sie lokale Commits haben, da die VM von GitHub klont, nicht von Ihrem Computer. `--cloud` funktioniert mit einem Repository auf einmal. Die Aufgabe wird in der Cloud ausgeführt, während Sie lokal weiterarbeiten. Die ältere Schreibweise `--remote` funktioniert immer noch als veralteter Alias für `--cloud`.
{/* min-version: 2.1.195 */}Ab v2.1.195 zeigt die CLI eine Live-Checkliste von Setup-Schritten an, wie z. B. das Klonen des Repositories und das Ausführen Ihres [Setup-Skripts](#setup-scripts), während der Cloud-Container startet. Nachrichten, die Sie eingeben, während der Container bereitgestellt wird, werden in die Warteschlange eingereiht und gesendet, sobald die Sitzung bereit ist.
`--cloud` erstellt Cloud-Sitzungen. `--remote-control` ist nicht verwandt: Es stellt eine lokale CLI-Sitzung zur Überwachung vom Web aus bereit. Siehe [Remote Control](/de/remote-control).
Verwenden Sie `/tasks` in der Fuxi Code CLI, um den Fortschritt zu überprüfen, oder öffnen Sie die Sitzung auf fuxi.ai oder der Fuxi Mobile-App, um direkt zu interagieren. Von dort aus können Sie Fuxi steuern, Feedback geben oder Fragen beantworten, genau wie in jedem anderen Gespräch.
Tipps für Cloud-Aufgaben
**Planen Sie lokal, führen Sie remote aus**: Für komplexe Aufgaben starten Sie Fuxi im Plan Mode, um den Ansatz zu besprechen, und senden Sie dann die Arbeit ins Web:
```bash theme={null}
fuxi --permission-mode plan
```
Im Plan Mode liest Fuxi Dateien, führt Befehle aus, um zu erkunden, und schlägt einen Plan vor, ohne Quellcode zu bearbeiten. Sobald Sie mit dem Plan zufrieden sind, speichern Sie den Plan im Repo, committen und pushen Sie, damit die Cloud-VM ihn klonen kann. Dann starten Sie eine Cloud-Sitzung für autonome Ausführung:
```bash theme={null}
fuxi --cloud "Execute the migration plan in docs/migration-plan.md"
```
Dieses Muster gibt Ihnen Kontrolle über die Strategie, während Fuxi autonom in der Cloud ausgeführt wird.
**Planen Sie in der Cloud mit ultraplan**: Um den Plan selbst in einer Web-Sitzung zu entwerfen und zu überprüfen, verwenden Sie [ultraplan](/de/ultraplan). Fuxi generiert den Plan auf Fuxi Code im Web, während Sie weiterarbeiten, dann kommentieren Sie Abschnitte in Ihrem Browser und wählen, ob Sie remote ausführen oder den Plan zurück zu Ihrem Terminal senden.
**Führen Sie Aufgaben parallel aus**: Jeder `--cloud`-Befehl erstellt seine eigene Cloud-Sitzung, die unabhängig ausgeführt wird. Sie können mehrere Aufgaben starten und sie werden alle gleichzeitig in separaten Sitzungen ausgeführt:
```bash theme={null}
fuxi --cloud "Fix the flaky test in auth.spec.ts"
fuxi --cloud "Update the API documentation"
fuxi --cloud "Refactor the logger to use structured output"
```
Überwachen Sie alle Sitzungen mit `/tasks` in der Fuxi Code CLI. Wenn eine Sitzung abgeschlossen ist, können Sie einen PR aus der Web-Oberfläche erstellen oder [die Sitzung teleportieren](#from-web-to-terminal), um lokal fortzufahren.
Senden Sie lokale Repositories ohne GitHub
Wenn Sie `fuxi --cloud` aus einem Repository ausführen, das nicht mit GitHub verbunden ist, bündelt Fuxi Code Ihr lokales Repository und lädt es direkt in die Cloud-Sitzung hoch. Das Bündel enthält Ihre vollständige Repository-Historie über alle Branches hinweg, plus alle nicht committeten Änderungen an verfolgten Dateien.
Dieses Fallback wird automatisch aktiviert, wenn GitHub-Zugriff nicht verfügbar ist. Um es zu erzwingen, auch wenn GitHub verbunden ist, setzen Sie `CCR_FORCE_BUNDLE=1`:
```bash theme={null}
CCR_FORCE_BUNDLE=1 fuxi --cloud "Run the test suite and fix any failures"
```
Gebündelte Repositories müssen diese Limits erfüllen:
* Das Verzeichnis muss ein Git-Repository mit mindestens einem Commit sein
* Das gebündelte Repository muss unter 100 MB liegen. Größere Repositories fallen auf das Bündeln nur des aktuellen Branches zurück, dann auf einen einzelnen gequetschten Snapshot des Arbeitsbaums, und schlagen nur fehl, wenn der Snapshot immer noch zu groß ist
* Nicht verfolgte Dateien sind nicht enthalten; führen Sie `git add` auf Dateien aus, die die Cloud-Sitzung sehen soll
* Sitzungen, die aus einem Bündel erstellt wurden, können nicht zurück zu einem Remote pushen, es sei denn, Sie haben auch [GitHub-Authentifizierung](#github-authentication-options) konfiguriert
Vom Web zum Terminal
Ziehen Sie eine Cloud-Sitzung in Ihr Terminal mit einer dieser Methoden:
* **Mit `--teleport`**: Führen Sie von der Befehlszeile `fuxi --teleport` für eine interaktive Sitzungsauswahl aus, oder `fuxi --teleport `, um eine bestimmte Sitzung direkt fortzusetzen. Wenn Sie nicht committete Änderungen haben, werden Sie aufgefordert, diese zuerst zu stashen.
* **Mit `/teleport`**: Führen Sie innerhalb einer vorhandenen CLI-Sitzung `/teleport` oder `/tp` aus, um die gleiche Sitzungsauswahl zu öffnen, ohne Fuxi Code neu zu starten.
* **Von `/tasks`**: Führen Sie `/tasks` aus, um Ihre Hintergrund-Sitzungen zu sehen, drücken Sie dann `t`, um in eine zu teleportieren.
* **Von der Web-Oberfläche**: Wählen Sie **Open in CLI**, um einen Befehl zu kopieren, den Sie in Ihr Terminal einfügen können.
Wenn Sie eine Sitzung teleportieren, überprüft Fuxi, dass Sie sich im richtigen Repository befinden, ruft den Branch aus der Cloud-Sitzung ab und checkt ihn aus, und lädt die vollständige Gesprächshistorie in Ihr Terminal.
`--teleport` unterscheidet sich von `--resume`. `--resume` öffnet ein Gespräch aus der lokalen Historie dieser Maschine und listet keine Cloud-Sitzungen auf; `--teleport` zieht eine Cloud-Sitzung und ihren Branch.
Teleport-Anforderungen
Teleport überprüft diese Anforderungen, bevor eine Sitzung fortgesetzt wird. Wenn eine Anforderung nicht erfüllt ist, sehen Sie einen Fehler oder werden aufgefordert, das Problem zu beheben.
| Anforderung | Details |
| -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Sauberer Git-Status | Ihr Arbeitsverzeichnis darf keine nicht committeten Änderungen haben. Teleport fordert Sie auf, Änderungen zu stashen, falls erforderlich. |
| Korrektes Repository | Sie müssen `--teleport` aus einem Checkout desselben Repositories ausführen, nicht aus einem Fork. {/* min-version: 2.1.199 */}Ab v2.1.199 akzeptiert Fuxi Code einen Checkout auch dann, wenn es das Remote nicht in einen Hostnamen analysieren kann, wie z. B. einen SSH-Host-Alias wie `git@work:owner/repo.git` oder eine `insteadOf`-umgeschriebene Kurzform. Es zeigt zuerst eine Bestätigungsaufforderung an und nur, wenn der Owner und der Repository-Name des Remote mit dem Repository der Sitzung übereinstimmen. |
| Branch verfügbar | Der Branch aus der Cloud-Sitzung muss in das Remote gepusht worden sein. Teleport ruft ihn automatisch ab und checkt ihn aus. |
| Gleiches Konto | Sie müssen sich bei demselben fuxi.ai-Konto authentifizieren, das in der Cloud-Sitzung verwendet wurde. |
`--teleport` ist nicht verfügbar
Teleport erfordert fuxi.ai-Abonnement-Authentifizierung. Wenn Sie sich über API-Schlüssel, Amazon Bedrock, Google Cloud's Agent Platform oder Microsoft Foundry authentifizieren, führen Sie `/login` aus, um sich stattdessen mit Ihrem fuxi.ai-Konto anzumelden. Wenn Sie bereits über fuxi.ai angemeldet sind und `--teleport` immer noch nicht verfügbar ist, hat Ihre Organisation möglicherweise Cloud-Sitzungen deaktiviert.
Mit Sitzungen arbeiten
Sitzungen werden in der Seitenleiste unter fuxi.ai/code angezeigt. Von dort aus können Sie Änderungen überprüfen, mit Teamkollegen teilen, abgeschlossene Arbeiten archivieren oder Sitzungen dauerhaft löschen.
Kontext verwalten
Cloud-Sitzungen unterstützen [integrierte Befehle](/de/commands), die Textausgabe erzeugen. Befehle, die nur in der Terminal-Schnittstelle ausgeführt werden, wie `/plugin` oder `/resume`, sind nicht verfügbar. {/* min-version: 2.1.205 */}}`/model`, `/effort`, `/fast`, `/color` und `/rename` funktionieren mit dem Wert als Argument, zum Beispiel `/model sonnet`, anstatt die Terminal-Auswahl oder den Schieberegler zu öffnen; die Argumentformen erfordern Fuxi Code v2.1.205 oder später in der Umgebung der Sitzung und folgen den [Verfügbarkeitshinweisen](/de/commands#all-commands) jedes Befehls, daher meldet `/effort` `Not applied`, während ein [Launch-Standard-Effort-Hold](/de/model-config#adjust-effort-level) eines Modells in Kraft ist, und `/fast` funktioniert nur in einer Sitzung, die mit aktiviertem Fast-Modus gestartet wurde. `/config` setzt eine Einstellung, wenn Sie `key=value` übergeben.
Für Kontextverwaltung speziell:
| Befehl | Funktioniert in Cloud-Sitzungen | Notizen |
| :--------- | :------------------------------ | :------------------------------------------------------------------------------------------------------------------------------ |
| `/compact` | Ja | Fasst das Gespräch zusammen, um Kontext freizugeben. Akzeptiert optionale Fokus-Anweisungen wie `/compact keep the test output` |
| `/context` | Ja | Zeigt, was sich derzeit im Kontextfenster befindet |
| `/clear` | Nein | Starten Sie stattdessen eine neue Sitzung aus der Seitenleiste |
Auto-Kompaktierung wird automatisch ausgeführt, wenn sich das Kontextfenster der Kapazität nähert. Um es früher auszulösen, setzen Sie [`FUXI_AUTOCOMPACT_PCT_OVERRIDE`](/de/env-vars) in Ihren [Umgebungsvariablen](#configure-your-environment). Zum Beispiel kompaktiert `FUXI_AUTOCOMPACT_PCT_OVERRIDE=70` bei 70% Kapazität statt des Wartens, bis das Fenster fast voll ist. Um die effektive Fenstergröße für Kompaktierungsberechnungen zu ändern, verwenden Sie [`FUXI_CODE_AUTO_COMPACT_WINDOW`](/de/env-vars).
[Subagents](/de/sub-agents) funktionieren genauso wie lokal. Fuxi kann sie mit dem Task-Tool spawnen, um Forschung oder parallele Arbeit in ein separates Kontextfenster auszulagern, um das Hauptgespräch leichter zu halten. Subagents, die in Ihrem Repo's `.fuxi/agents/` definiert sind, werden automatisch aufgegriffen.
[Agent-Teams](/de/agent-teams) sind standardmäßig deaktiviert, können aber aktiviert werden, indem Sie `FUXI_CODE_EXPERIMENTAL_AGENT_TEAMS=1` zu Ihren [Umgebungsvariablen](#configure-your-environment) hinzufügen.
Änderungen überprüfen
Jede Sitzung zeigt einen Diff-Indikator mit hinzugefügten und entfernten Zeilen, wie `+42 -18`. Wählen Sie ihn, um die Diff-Ansicht zu öffnen, hinterlassen Sie Inline-Kommentare zu bestimmten Zeilen und senden Sie sie mit Ihrer nächsten Nachricht an Fuxi. Siehe [Überprüfung und Iteration](/de/web-quickstart#review-and-iterate) für die vollständige Anleitung, einschließlich PR-Erstellung. Um Fuxi den PR auf CI-Fehler und Review-Kommentare automatisch überwachen zu lassen, siehe [Auto-fix Pull Requests](#auto-fix-pull-requests).
Sitzungen teilen
Um eine Sitzung zu teilen, schalten Sie ihre Sichtbarkeit gemäß den folgenden Kontotypen um. Danach teilen Sie den Sitzungslink wie gewohnt. Empfänger sehen den neuesten Status, wenn sie den Link öffnen, aber ihre Ansicht wird nicht in Echtzeit aktualisiert.
Teilen von einem Enterprise- oder Team-Konto
Für Enterprise- und Team-Konten sind die beiden Sichtbarkeitsoptionen **Private** und **Team**. Team-Sichtbarkeit macht die Sitzung für andere Mitglieder Ihrer fuxi.ai-Organisation sichtbar. [Fuxi in Slack](/de/slack)-Sitzungen werden automatisch mit Team-Sichtbarkeit geteilt.
Die Überprüfung des Repository-Zugriffs ist standardmäßig aktiviert, basierend auf dem GitHub-Konto, das mit dem Konto des Empfängers verbunden ist. Der Anzeigename Ihres Kontos ist für alle Empfänger mit Zugriff sichtbar.
Teilen von einem Max- oder Pro-Konto
Für Max- und Pro-Konten sind die beiden Sichtbarkeitsoptionen **Private** und **Public**. Public-Sichtbarkeit macht die Sitzung für jeden Benutzer sichtbar, der bei fuxi.ai angemeldet ist.
Überprüfen Sie Ihre Sitzung auf sensible Inhalte, bevor Sie sie teilen. Sitzungen können Code und Anmeldedaten aus privaten GitHub-Repositories enthalten. Die Überprüfung des Repository-Zugriffs ist standardmäßig nicht aktiviert.
Um zu verlangen, dass Empfänger Repository-Zugriff haben, oder um Ihren Namen aus gemeinsamen Sitzungen auszublenden, gehen Sie zu Einstellungen > Fuxi Code > Freigabeeinstellungen.
Sitzungen archivieren
Sie können Sitzungen archivieren, um Ihre Sitzungsliste organisiert zu halten. Archivierte Sitzungen sind in der Standard-Sitzungsliste ausgeblendet, können aber durch Filtern nach archivierten Sitzungen angezeigt werden.
Um eine Sitzung zu archivieren, bewegen Sie den Mauszeiger über die Sitzung in der Seitenleiste und wählen Sie das Archiv-Symbol.
Sitzungen löschen
Das Löschen einer Sitzung entfernt die Sitzung und ihre Daten dauerhaft. Diese Aktion kann nicht rückgängig gemacht werden. Sie können eine Sitzung auf zwei Arten löschen:
* **Von der Seitenleiste**: Filtern Sie nach archivierten Sitzungen, bewegen Sie dann den Mauszeiger über die Sitzung, die Sie löschen möchten, und wählen Sie das Lösch-Symbol
* **Vom Sitzungsmenü**: Öffnen Sie eine Sitzung, wählen Sie das Dropdown-Menü neben dem Sitzungstitel und wählen Sie **Löschen**
Sie werden aufgefordert, vor dem Löschen einer Sitzung zu bestätigen.
Auto-fix Pull Requests
Fuxi kann einen Pull Request überwachen und automatisch auf CI-Fehler und Review-Kommentare reagieren. Fuxi abonniert GitHub-Aktivitäten auf dem PR, und wenn eine Überprüfung fehlschlägt oder ein Reviewer einen Kommentar hinterlässt, untersucht Fuxi das Problem und pusht eine Lösung, wenn eine klar ist.
Auto-fix erfordert, dass die Fuxi GitHub App auf Ihrem Repository installiert ist. Falls noch nicht geschehen, installieren Sie sie von der [GitHub App-Seite](https://github.com/apps/fuxi) oder wenn Sie dazu während des [Setups](/de/web-quickstart#connect-github-and-create-an-environment) aufgefordert werden.
Es gibt mehrere Möglichkeiten, Auto-fix zu aktivieren, je nachdem, woher der PR stammt und welches Gerät Sie verwenden:
* **PRs, die in Fuxi Code im Web erstellt wurden**: Öffnen Sie die CI-Statusleiste und wählen Sie **Auto-fix**
* **Von Ihrem Terminal**: Führen Sie [`/autofix-pr`](/de/commands) aus, während Sie auf dem PR's Branch sind. Fuxi Code erkennt den offenen PR mit `gh`, spawnt eine Web-Sitzung und aktiviert Auto-fix in einem Schritt
* **Von der Mobile-App**: Sagen Sie Fuxi, den PR zu auto-fixen, zum Beispiel „watch this PR and fix any CI failures or review comments"
* **Jeder vorhandene PR**: Fügen Sie die PR-URL in eine Sitzung ein und sagen Sie Fuxi, den PR zu auto-fixen
Auto-fix ist ein Pro-PR-Toggle. Um die Überwachung zu beenden, öffnen Sie die CI-Statusleiste in der Web-Sitzung und deaktivieren Sie den **Auto-fix**-Toggle, oder sagen Sie Fuxi, die Überwachung des PR zu beenden.
Wie Fuxi auf PR-Aktivität reagiert
Wenn Auto-fix aktiv ist, empfängt Fuxi GitHub-Events für den PR, einschließlich neuer Review-Kommentare und CI-Check-Fehler. Für jedes Event untersucht Fuxi das Problem und entscheidet, wie vorgegangen wird:
* **Klare Fixes**: Wenn Fuxi sich einer Lösung sicher ist und sie nicht mit früheren Anweisungen in Konflikt steht, nimmt Fuxi die Änderung vor, pusht sie und erklärt, was getan wurde, in der Sitzung
* **Mehrdeutige Anfragen**: Wenn ein Reviewer-Kommentar auf mehrere Arten interpretiert werden könnte oder etwas architektonisch Bedeutsames betrifft, fragt Fuxi Sie, bevor er handelt
* **Doppelte oder keine Aktion erforderlich Events**: Wenn ein Event ein Duplikat ist oder keine Änderung erfordert, notiert Fuxi es in der Sitzung und fährt fort
GitHub gibt keinen Webhook aus, wenn der Basis-Branch voranschreitet und einen Merge-Konflikt erzeugt, daher kann Auto-fix nicht von selbst auf Konflikte reagieren. Um einen Konflikt zu beheben, öffnen Sie die Sitzung und bitten Sie Fuxi, einen Rebase durchzuführen.
Fuxi kann als Teil der Auflösung auf Review-Kommentar-Threads auf GitHub antworten. Diese Antworten werden mit Ihrem GitHub-Konto gepostet, sodass sie unter Ihrem Benutzernamen erscheinen, aber jede Antwort ist als von Fuxi Code stammend gekennzeichnet, damit Reviewer wissen, dass sie vom Agent geschrieben wurde und nicht direkt von Ihnen.
Wenn Ihr Repository Kommentar-ausgelöste Automatisierung wie Atlantis, Terraform Cloud oder benutzerdefinierte GitHub Actions verwendet, die auf `issue_comment`-Events ausgeführt werden, beachten Sie, dass Fuxi auf Ihrem Behalf antworten kann, was diese Workflows auslösen kann. Überprüfen Sie die Automatisierung Ihres Repositories, bevor Sie Auto-fix aktivieren, und erwägen Sie, Auto-fix für Repositories zu deaktivieren, in denen ein PR-Kommentar Infrastruktur bereitstellen oder privilegierte Operationen ausführen kann.
Sicherheit und Isolation
Jede Cloud-Sitzung ist von Ihrem Computer und von anderen Sitzungen durch mehrere Schichten getrennt:
* **Isolierte virtuelle Maschinen**: Jede Sitzung wird in einer isolierten, von Anthropic verwalteten VM ausgeführt
* **Netzwerkzugriffskontrolle**: Der Netzwerkzugriff ist standardmäßig begrenzt und kann deaktiviert werden. Wenn Fuxi Code mit deaktiviertem Netzwerkzugriff ausgeführt wird, kann Fuxi Code immer noch mit der Anthropic API kommunizieren, was möglicherweise ermöglicht, dass Daten die VM verlassen.
* **Schutz von Anmeldedaten**: Sensible Anmeldedaten wie Git-Anmeldedaten oder Signaturschlüssel befinden sich niemals in der Sandbox mit Fuxi Code. Die Authentifizierung wird über einen sicheren Proxy mit Scoped-Credentials verwaltet.
* **Sichere Analyse**: Code wird in isolierten VMs analysiert und geändert, bevor PRs erstellt werden
Fehlerbehebung
Für Runtime-API-Fehler, die im Gespräch angezeigt werden, wie `API Error: 500`, `529 Overloaded`, `429` oder `Prompt is too long`, siehe die [Fehlerreferenz](/de/errors). Diese Fehler und ihre Lösungen werden mit der CLI und der Desktop-App geteilt. Die folgenden Abschnitte behandeln Probleme, die spezifisch für Cloud-Sitzungen sind.
Sitzungserstellung fehlgeschlagen
Wenn eine neue Sitzung mit `Session creation failed` fehlschlägt oder bei der Bereitstellung steckenbleibt, konnte Fuxi Code eine Cloud-Umgebung nicht zuordnen.
* Überprüfen Sie [status.fuxi.com](https://status.fuxi.com) auf Cloud-Sitzungs-Incidents
* Versuchen Sie es nach einer Minute erneut, da die Kapazität bei Bedarf bereitgestellt wird
* Bestätigen Sie, dass Ihr Repository erreichbar ist. Das verbindende GitHub-Konto muss Zugriff auf das Repository auf GitHub haben, entweder durch die Fuxi GitHub App-Autorisierung oder ein `gh`-Token, das über `/web-setup` synchronisiert wird. Die Installation der App auf dem Repository ist nicht erforderlich. Siehe [GitHub-Authentifizierungsoptionen](#github-authentication-options).
Remote Control-Sitzung abgelaufen oder Zugriff verweigert
`--teleport` verbindet sich über die gleiche Remote Control-Sitzungsinfrastruktur, die Cloud-Sitzungen verwenden, daher werden Authentifizierungs- und Sitzungs-Ablauf-Fehler mit Remote Control-Wording angezeigt. Sie können `Remote Control session expired` oder `Access denied` sehen. Das Verbindungs-Token ist kurzlebig und auf Ihr Konto begrenzt.
* Führen Sie `/login` lokal aus, um Ihre Anmeldedaten zu aktualisieren, und verbinden Sie sich dann erneut
* Bestätigen Sie, dass Sie sich bei demselben Konto angemeldet haben, das die Sitzung besitzt
* Wenn Sie `Remote Control may not be available for this organization` sehen, hat ein Owner Cloud-Sitzungen für Ihre Organisation nicht aktiviert
Umgebung abgelaufen
Cloud-Sitzungen werden nach einer Inaktivitätszeit beendet und die zugrunde liegende Umgebung wird freigegeben. Von einem lokalen Terminal aus wird dies als `Could not resume session ... its environment has expired. Creating a fresh session instead.` angezeigt. Im Web wird die Sitzung in der Sitzungsliste als abgelaufen markiert.
Öffnen Sie die Sitzung erneut von [fuxi.ai/code](https://fuxi.ai/code), um eine frische Umgebung mit Ihrer wiederhergestellten Gesprächshistorie bereitzustellen.
Einschränkungen
Bevor Sie Cloud-Sitzungen für einen Workflow verwenden, berücksichtigen Sie diese Einschränkungen:
* **Ratenlimits**: Fuxi Code im Web teilt Ratenlimits mit allen anderen Fuxi- und Fuxi Code-Nutzungen in Ihrem Konto. Das Ausführen mehrerer Aufgaben parallel verbraucht proportional mehr Ratenlimits. Es gibt keine separate Compute-Gebühr für die Cloud-VM.
* **Repository-Authentifizierung**: Sie können Sitzungen nur vom Web zum lokalen Computer verschieben, wenn Sie sich bei demselben Konto authentifizieren
* **Plattformbeschränkungen**: Repository-Klonen und Pull Request-Erstellung erfordern GitHub. Selbstgehostete [GitHub Enterprise Server](/de/github-enterprise-server)-Instanzen werden für Team- und Enterprise-Pläne unterstützt. GitLab, Bitbucket und andere Nicht-GitHub-Repositories können als lokales [Bündel](#send-local-repositories-without-github) zu Cloud-Sitzungen gesendet werden, aber die Sitzung kann nicht zurück zum Remote pushen
* **Organisations-IP-Allowlist**: Cloud-Sitzungen rufen die Anthropic API von Anthropic-verwalteter Infrastruktur auf, nicht von Ihrem Netzwerk. Wenn Ihre Organisation [IP-Allowlisting](https://support.fuxi.com/en/articles/13200993-restrict-access-to-fuxi-with-ip-allowlisting) aktiviert hat, schlägt jede Cloud-Sitzung mit einem Authentifizierungsfehler fehl. Das gleiche gilt für [Code Review](/de/code-review) und [Routines](/de/routines). Kontaktieren Sie [Anthropic Support](https://support.fuxi.com/), um Anthropic-gehostete Services von der IP-Allowlist Ihrer Organisation auszunehmen.
* [Ultraplan](/de/ultraplan): Entwerfen Sie einen Plan in einer Cloud-Sitzung und überprüfen Sie ihn in Ihrem Browser
* [Ultrareview](/de/ultrareview): Führen Sie eine tiefe Multi-Agent-Code-Review in einer Cloud-Sandbox aus
* [Routines](/de/routines): Automatisieren Sie Arbeiten nach einem Zeitplan, über API-Aufruf oder als Reaktion auf GitHub-Events
* [Hooks-Konfiguration](/de/hooks): Führen Sie Skripte bei Sitzungs-Lifecycle-Events aus
* [Einstellungsreferenz](/de/settings): Alle Konfigurationsoptionen
* [Sicherheit](/de/security): Isolationsgarantien und Datenverarbeitung
* [Datennutzung](/de/data-usage): Was Anthropic aus Cloud-Sitzungen behält
* [Fuxi Tag](https://fuxi.com/docs/fuxi-tag/overview): Ein von der Organisation verwaltetes @Fuxi in Slack, das in derselben Cloud-Umgebung ausgeführt wird