# Befehlszeilenwerkzeug

Installieren Sie den Befehl oleafly unter Windows, macOS oder Linux, bauen und prüfen Sie Projekte aus einem Terminal oder in CI, gleichen Sie mit einem Online-LaTeX-Dienst ab und verbinden Sie Coding-Agenten über seinen MCP-Server und Skill.

Oleafly bringt `oleafly` mit, ein Befehlszeilenwerkzeug, das mit denselben Projekten arbeitet wie die App. Bauen oder prüfen Sie ein Paper aus einem Terminal, einem Skript oder CI. Geben Sie einem Coding-Agenten einen verlässlichen Zugang zu Ihrem Projekt. Gleichen Sie mit einem Online-LaTeX-Dienst oder einem Oleafly-Server ab, oder führen Sie den Oleafly-Agenten aus, ohne die App zu öffnen.

Es kommt auf jeder Plattform mit der App. Diese Seite behandelt die Befehle in Oleafly 0.4.8 und später. Frühere Versionen hatten weniger, fixieren Sie in Skripten, die davon abhängen, also Ihre Oleafly-Version.

## Installieren

| System | Wo die App ihn ablegt | `oleafly` in Ihren PATH legen |
|---|---|---|
| Windows | `oleafly-cli.exe` neben der App, in `%LOCALAPPDATA%\Oleafly` beim Setup-Programm oder in `C:\Program Files\Oleafly` beim MSI-Paket | **Installieren** in der Zeile **Terminalbefehl** unter **Einstellungen → Allgemein** kopiert ihn nach `%LOCALAPPDATA%\Oleafly\bin\oleafly.exe` und fügt diesen Ordner Ihrem PATH hinzu |
| macOS | `Oleafly.app/Contents/MacOS/oleafly-cli` | **Installieren** in der Zeile **Terminalbefehl** legt einen Link `oleafly` in `/usr/local/bin` an, wenn Sie dort schreiben dürfen, sonst in `~/.local/bin` |
| Linux-Pakete (.deb, .rpm) | `/usr/bin/oleafly-cli` | Nichts zu tun: Das Paket installiert `/usr/bin/oleafly` |
| Linux-AppImage | Im AppImage | **Installieren** kopiert ihn nach `~/.local/bin/oleafly` |

Programme, die Oleafly startet, etwa das eigene Terminal und die CLI-Agenten, finden `oleafly` immer in ihrem PATH, auch bevor Sie es installieren. Die Variable `OLEAFLY_CLI` enthält den vollständigen Pfad.

### Windows

1. Öffnen Sie **Einstellungen → Allgemein** und wählen Sie **Installieren** in der Zeile **Terminalbefehl**.
2. Öffnen Sie ein neues PowerShell- oder Eingabeaufforderungsfenster. Bereits geöffnete Fenster behalten den alten PATH.
3. Prüfen Sie, ob es funktioniert:

```powershell
Get-Command oleafly
oleafly version
```

**Entfernen** in derselben Zeile löscht die Kopie und nimmt den Ordner wieder aus Ihrem PATH. Aktualisiert sich Oleafly, erneuert es die Kopie beim nächsten Start.

### macOS

Verschieben Sie Oleafly zuerst in den Ordner „Programme“. Eine Kopie, die vom Disk-Image aus läuft, zeigt statt **Installieren** die Meldung „Verschieben Sie Oleafly zuerst in den Ordner ‚Programme‘“.

Der Befehl ist ein Link auf die App, sodass eine Aktualisierung von Oleafly auch den Befehl aktualisiert. Liegt der Ordner nicht in Ihrem PATH, zeigt die Zeile, welche Anweisung Sie Ihrem Shell-Profil hinzufügen müssen. Prüfen Sie es mit `command -v oleafly`.

### Linux

Die Pakete .deb und .rpm legen `oleafly` in Ihren PATH, sobald Sie sie installieren. `oleafly` ohne weitere Angaben öffnet die App.

Das AppImage braucht eine Kopie, weil die Dateien in einem AppImage verschwinden, wenn es beendet wird. Ersetzen Sie das AppImage durch ein neueres, bietet die Zeile **Aktualisieren** an. Liegt `~/.local/bin` nicht in Ihrem PATH, zeigt die Zeile, welche Anweisung Sie hinzufügen müssen.

### Prüfen, ob es funktioniert

`oleafly version` gibt die Version der App und die Engines aus, die der Befehl verwenden würde. `oleafly doctor` prüft die Engines, die App, Git, den Terminalbefehl und Ihre MCP-Clients und gibt für alles Fehlende eine Abhilfe aus. Es funktioniert auch außerhalb eines Projekts.

## Ein Projekt bauen

`oleafly .` öffnet den aktuellen Ordner in der App. Jeder andere Befehl arbeitet mit dem Ordner, in dem Sie sich befinden; `-C` gefolgt von einem Pfad richtet ihn auf einen anderen Ordner.

```sh
cd ~/papers/thesis
oleafly init --engine typst
oleafly build
oleafly log --diagnostics
oleafly -C ~/papers/review --json build
```

- `oleafly init` macht den aktuellen Ordner zu einem Projekt. `--engine` akzeptiert `tectonic`, `latexmk`, `typst` oder `markdown`.
- `oleafly new` gefolgt von einem Ordner und `--template` mit einer Vorlagen-ID erstellt ein Projekt aus einer Vorlage. `oleafly templates list --all` listet die Vorlagen auf.
- `oleafly build` verwendet die Engine und die Einstellungen des Projekts, so wie die App es tut: das Tectonic, Typst und Pandoc, die mit Oleafly kommen, oder das LaTeX, das Sie installiert haben. `--main` baut ein anderes Dokument des Projekts, `--compiler` wählt den LaTeX-Compiler für latexmk-Projekte, `-o` kopiert das PDF an einen anderen Ort und `--timeout` setzt das Limit in Sekunden.
- Ein Ordner, den Sie in der App an Ort und Stelle geöffnet haben, wird mit der Engine und dem Hauptdokument gebaut, die Sie dort gewählt haben, in den eigenen Build-Ordner der App.
- Die App und der Befehl bauen nie dasselbe Projekt gleichzeitig: Der zweite wartet auf den ersten. Ein fehlgeschlagener Build behält das letzte gute PDF.
- `oleafly watch` baut bei jedem Speichern neu. `oleafly log --diagnostics` listet Fehler und Warnungen mit Datei und Zeile auf, und `oleafly clean` entfernt die Build-Ausgabe.

Zu den Besonderheiten von Typst siehe [Typst-Projekte](/docs/typst/#build-from-the-command-line).

## Von einem Coding-Agenten aus nutzen

Coding-Agenten arbeiten am besten mit drei Dingen, die der Befehl ihnen gibt: `oleafly context` für die Karte des Projekts, `--json` für Ergebnisse, die sie lesen können, und Exit-Codes, die sagen, was schiefgelaufen ist. Es gibt drei Wege, einen Agenten zu verbinden.

### Der Skill oleafly-cli

Oleafly liefert einen Skill namens `oleafly-cli` mit. Er bringt einem Agenten die Befehle, die JSON-Ausgabe und die Exit-Codes bei, dazu den Ablauf, der am besten funktioniert: den Kontext lesen, bearbeiten, bauen, die Diagnosen lesen, den ersten Fehler beheben.

Im Terminal von Oleafly und in den CLI-Agenten, die es startet, wählen Sie den Skill wie jeden anderen. Für einen Agenten, den Sie selbst ausführen, schalten Sie **Einstellungen → KI-Assistent → Skills → Skills mit anderen Agenten auf diesem Computer teilen** ein. Oleafly verknüpft dann seine Skills, `oleafly-cli` eingeschlossen, mit den Ordnern, die andere Coding-Agenten lesen, etwa `~/.claude/skills`, `~/.codex/skills` und `~/.agents/skills`. `oleafly skills path` gibt aus, wo die Skills liegen, für Agenten, die einen anderen Ordner lesen.

### Einen Agenten per MCP verbinden

`oleafly mcp` ist ein MCP-Server, der über Standardeingabe und Standardausgabe spricht. Hat die App Ihr Projekt geöffnet, reicht er Aufrufe an den eigenen [MCP-Server](/docs/mcp/) der App weiter, sodass der Agent jedes App-Werkzeug und Ihre Freigabeabfragen bekommt. Andernfalls arbeitet er für sich, mit Lesewerkzeugen (Projektstatus, Projektkarte, Dateien, Suche, Protokolle, der Doctor-Bericht, Zitationsabfrage) und `compile`. Es gibt weder eine URL noch ein Token zu kopieren, und Node.js muss nicht installiert werden.

Am schnellsten richten Sie es mit `oleafly mcp config --client` gefolgt von `claude-code`, `claude-desktop`, `codex`, `cursor` oder `gemini` ein. Der Befehl gibt den Eintrag für diesen Client aus; mit `--write` wird er für Sie eingetragen, mit einer Sicherung der Datei des Clients. Starten Sie den Client danach neu oder verbinden Sie ihn erneut. In einem Projekt schreibt er die Einstellungen des Projekts; anderswo schreibt er Ihre Benutzereinstellungen, mit dem vollständigen Pfad des Befehls, weil Apps, die Sie vom Desktop aus starten, Ihren PATH womöglich nicht sehen.

#### Claude Code

```sh
claude mcp add --scope user oleafly -- oleafly mcp
```

In einem Projekt fügt `oleafly mcp config --client claude-code --write` den Server stattdessen der `.mcp.json` des Projekts hinzu.

#### Claude Desktop

Claude Desktop startet Server ohne Projektordner, sein Eintrag arbeitet also immer über die App: Lassen Sie Oleafly mit Ihrem Projekt geöffnet. Verwenden Sie den vollständigen Pfad zu `oleafly`. Verdoppeln Sie unter Windows jeden Backslash im Pfad.

```json title="claude_desktop_config.json"
{
  "mcpServers": {
    "oleafly": {
      "command": "/usr/local/bin/oleafly",
      "args": ["mcp", "--bridge", "always"]
    }
  }
}
```

Die Datei liegt unter macOS in `~/Library/Application Support/Claude` und unter Windows in `%APPDATA%\Claude`.

#### Codex

```toml title="~/.codex/config.toml"
[mcp_servers.oleafly]
command = "oleafly"
args = ["mcp"]
tool_timeout_sec = 300
```

#### Cursor

Verwenden Sie `~/.cursor/mcp.json` für jedes Projekt oder `.cursor/mcp.json` innerhalb eines einzelnen Projekts.

```json title="~/.cursor/mcp.json"
{
  "mcpServers": {
    "oleafly": {
      "command": "oleafly",
      "args": ["mcp"]
    }
  }
}
```

#### Gemini CLI

```json title="~/.gemini/settings.json"
{
  "mcpServers": {
    "oleafly": {
      "command": "oleafly",
      "args": ["mcp"],
      "timeout": 300000
    }
  }
}
```

### Einem Agenten das ganze Projekt geben

`oleafly context` erstellt die Karte des Projekts: seine Dateien, die Gliederung, Labels, Zitationen, fehlende Dateien, offene Verweise und die Probleme des letzten Builds. `--format md` liefert Text zum Einfügen in einen Prompt; `--format json` liefert dieselbe Karte für ein Programm.

## Ein Paper vor der Einreichung prüfen

`oleafly check` führt die [Preflight-Prüfungen](/docs/preflight/) für das Projekt aus, mit denselben Ergebnissen wie das Preflight-Bedienfeld: Referenzen, Zitationen, Labels, fehlende Dateien, Felder des Literaturverzeichnisses, Abbildungen und Anonymisierung für das Blind-Review. Prüfungen, die das kompilierte PDF brauchen, verwenden den letzten Build.

`oleafly lint` führt die LaTeX- und BibTeX-Prüfungen aus und, in den Builds, die sie enthalten, Rechtschreibung und Grammatik. `--fix` wendet die Korrekturen an, die sich gefahrlos anwenden lassen.

Beide akzeptieren `--format human`, `json` oder `sarif`, und `--exit-code` lässt sie mit 9 enden, wenn sie Probleme finden. SARIF funktioniert mit Code-Scanning-Diensten wie dem von GitHub: Schreiben Sie den Bericht mit `oleafly check --format sarif -o preflight.sarif`, laden Sie ihn mit der Action `upload-sarif` hoch, und jeder Fund erscheint im Pull-Request an seiner Zeile.

## Mit einem Online-LaTeX-Dienst abgleichen

`oleafly remote` lädt Projekte aus Ihrem Konto beim Online-LaTeX-Dienst herunter und hält einen Ordner mit einem davon abgeglichen, mit demselben Zusammenführen, das die App verwendet.

### Anmelden

Anmeldungen liegen im verschlüsselten Speicher der App, sodass eine in der App vorgenommene Anmeldung auch auf der Befehlszeile funktioniert und umgekehrt.

- `oleafly auth login online --with-token` speichert ein Git-Token aus den Kontoeinstellungen des Dienstes. Verknüpfen und Abgleichen brauchen eines.
- `oleafly auth login online --from-browser firefox` kopiert Ihre Anmeldung aus einem Browser auf diesem Computer, zum Auflisten und Herunterladen von Projekten. Firefox funktioniert auf jedem System; Chrome, Edge und Brave funktionieren unter macOS. `--cookie-stdin` liest stattdessen ein Sitzungs-Cookie.
- `oleafly auth login git --host https://gitlab.com` speichert ein Token für einen Git-Host.
- `oleafly auth status` listet jede Anmeldung und ihre Herkunft auf, ohne ein Geheimnis zu zeigen.
- `oleafly auth logout` entfernt eine Anmeldung.

:::caution[Tokens aus dem Shell-Verlauf heraushalten]
Tokens gehen über die Standardeingabe hinein, zum Beispiel mit `oleafly auth login online --with-token < token.txt`, nie als Argumente. In einem Terminal fragt der Befehl danach, ohne anzuzeigen, was Sie tippen. `oleafly auth token` gibt ein gespeichertes Token für Skripte aus, behandeln Sie seine Ausgabe also wie ein Passwort.
:::

### Projekte importieren und abgleichen

```sh
oleafly remote list
oleafly remote import 64a1f0c2e5b7 --into ~/papers
cd ~/papers/thesis
oleafly remote link
oleafly remote sync
```

- `oleafly remote import` lädt Projekte in neue Ordner herunter. Es funktioniert mit jedem Konto.
- `oleafly remote link` verbindet einen Ordner über die Git-Integration des Dienstes mit seinem Online-Projekt, was ein Git-Token braucht.
- `oleafly remote sync` führt Online-Änderungen in den Ordner zusammen und sendet Ihre. `--dry-run` zeigt, was sich ändern würde, und `--no-push` führt zusammen, ohne zu senden.
- Wurde eine Datei auf beiden Seiten geändert, schreibt der Abgleich nichts und endet mit 8. Führen Sie ihn erneut mit `--resolve` aus, gefolgt vom Pfad der Datei und `=local` oder `=remote`, für jede Datei.
- `oleafly remote diff` zeigt, was sich unterscheidet; mit `--exit-code` endet es mit 9, wenn sich Dateien unterscheiden, und mit 8, wenn sie in Konflikt stehen. `--latexdiff --pdf` baut ein markiertes PDF Ihrer Änderungen, mit latexdiff aus Ihrer TeX-Distribution.
- `oleafly remote status`, `oleafly remote unlink` und `oleafly remote open` zeigen die Verknüpfung, entfernen sie und öffnen das Projekt in Ihrem Browser.

## Mit einem Oleafly-Server arbeiten

`oleafly server sign-in` gefolgt von der Adresse des Servers meldet die Befehlszeile mit einem Code an, den Sie in Ihrem Browser bestätigen. Die Befehlszeile ist auf dem Server ein eigenes Gerät, getrennt von der App.

- `oleafly server status` und `oleafly server projects` zeigen Ihre Server und geteilte Projekte.
- `oleafly server share` zeigt den Link eines Projekts und schaltet die Freigabe per Link und Kommentare ein oder aus.
- `oleafly server members` listet die Personen eines Projekts auf und fügt sie hinzu, entfernt sie oder ändert sie. Nur die Inhaberin oder der Inhaber kann Freigabe und Mitglieder ändern.
- `oleafly server comments` listet Kommentare auf, fügt welche hinzu, antwortet darauf und erledigt sie. Ein Kommentar, der sich nicht sofort senden lässt, wird aufbewahrt und beim nächsten Mal gesendet.

Ein Projekt zum ersten Mal zu teilen geschieht in der App. Siehe [Live-Zusammenarbeit](/docs/collaboration/).

## Den Oleafly-Agenten aus einem Terminal ausführen

`oleafly ask` beantwortet eine Frage zum Projekt, ohne etwas zu ändern. `oleafly agent run` erledigt eine Aufgabe.

```sh
oleafly ask "Which sections cite Smith 2021?"
oleafly agent run --allow write "Fix the overfull boxes in chapter 3"
```

- Der Agent kann das Projekt immer lesen. `--allow` fügt `write`, `commands` oder `network` hinzu, und er lehnt alles ab, was Sie nicht erlaubt haben. Er hält nie an, um eine Frage zu stellen.
- Änderungen gehen zuerst in einen Prüfordner in `.oleafly/agent-runs/`. `oleafly agent apply` gefolgt von diesem Ordner schreibt sie in das Projekt, und `--apply` beim Lauf schreibt sie sofort.
- Anbieter, Modell und Aufwand kommen aus den Einstellungen der App oder aus `--provider`, `--model` und `--effort`. Der Schlüssel kommt aus der eigenen Umgebungsvariable des Anbieters, etwa `ANTHROPIC_API_KEY`, oder aus dem verschlüsselten Speicher der App.
- `--json` gibt ein Ergebnis aus, wenn der Lauf endet, und `--events` fügt für jedes Ereignis eine JSON-Zeile hinzu, während er arbeitet.

### Forschungsaufgaben nach dem Beenden weiterlaufen lassen

Markieren Sie eine [Forschungsaufgabe](/docs/research-tasks/) mit **Weiterlaufen, wenn Oleafly geschlossen ist**. Beenden Sie Oleafly, übernimmt ein kleiner Hintergrundhelfer diese Aufgaben, und ihre Experimentläufe gehen weiter. Ein Schritt, der Ihre Freigabe braucht, hält die Aufgabe an und sendet eine Benachrichtigung. Öffnen Sie Oleafly wieder, übernimmt es die Aufgaben zurück und zeigt, was geschehen ist. Schalten Sie dies aus oder starten Sie den Helfer bei der Anmeldung unter **Einstellungen → Forschung → Hintergrundaufgaben**. `oleafly daemon status` zeigt, was der Helfer gerade tut.

## Befehlsreferenz

Jeder Befehl erklärt seine Optionen mit `--help`. Die vollständige Referenz liegt im Repository: [docs/cli.md](https://github.com/Oleafly/Oleafly/blob/main/docs/cli.md).

### Projekte und Builds

| Befehl | Was er tut |
|---|---|
| `oleafly open` | Öffnet einen Ordner in der App (`oleafly .` für den aktuellen) |
| `oleafly init` | Macht den aktuellen Ordner zu einem Projekt |
| `oleafly new` | Erstellt ein Projekt, aus einer Vorlage, wenn Sie eine nennen |
| `oleafly templates` | Listet Vorlagen auf und zeigt eine |
| `oleafly build` | Baut das Projekt |
| `oleafly watch` | Baut bei jedem Speichern neu |
| `oleafly clean` | Entfernt die Build-Ausgabe |
| `oleafly log` | Zeigt das Protokoll des letzten Builds oder seine Probleme |
| `oleafly doctor` | Prüft Engines, die App und Ihre Einrichtung |
| `oleafly version` | Zeigt die Version und die verwendeten Engines |
| `oleafly project info` | Zeigt die Einstellungen des Projekts |
| `oleafly projects list` | Listet die Projekte der App auf |
| `oleafly config` | Liest und setzt Projekt- und App-Einstellungen |

### Schreiben und Referenzen

| Befehl | Was er tut |
|---|---|
| `oleafly cite` | Gibt BibTeX für eine DOI, arXiv-ID, ISBN oder PubMed-ID aus; `--add` fügt es dem Literaturverzeichnis hinzu |
| `oleafly literature` | Durchsucht OpenAlex, Semantic Scholar, Crossref, arXiv und PubMed |
| `oleafly bib check` | Findet Einträge, die zu keinem echten Datensatz passen |
| `oleafly bib clean` | Korrigiert Zitationsschlüssel und entfernt Duplikate; `--apply` schreibt die Änderungen |
| `oleafly stats` | Zählt Wörter, Überschriften, Abbildungen und Formeln |
| `oleafly synctex` | Ordnet eine Quellzeile dem PDF zu und umgekehrt |
| `oleafly export` | Exportiert das Dokument nach Word, HTML, Markdown, EPUB und mehr |
| `oleafly convert` | Wandelt eine Datei in ein anderes Format um |
| `oleafly typst` | Listet Typst-Versionen auf, installiert und entfernt sie |
| `oleafly checkpoint` | Listet die Checkpoints der App auf, vergleicht und kopiert sie |

### Agenten und Automatisierung

| Befehl | Was er tut |
|---|---|
| `oleafly context` | Erstellt die Karte des Projekts für eine Person oder einen Agenten |
| `oleafly mcp` | Führt den MCP-Server aus; `mcp config` richtet einen Client ein |
| `oleafly skills` | Listet die Skills auf und gibt aus, wo sie liegen |
| `oleafly ask` | Beantwortet eine Frage zum Projekt |
| `oleafly agent` | Führt den Oleafly-Agenten für eine Aufgabe aus |
| `oleafly daemon` | Führt den Helfer aus, der Aufgaben am Laufen hält, und steuert ihn |

### Prüfungen

| Befehl | Was er tut |
|---|---|
| `oleafly check` | Führt die Preflight-Prüfungen aus |
| `oleafly lint` | Führt die Prüfungen für LaTeX, BibTeX, Rechtschreibung und Grammatik aus |

### Konten und Abgleich

| Befehl | Was er tut |
|---|---|
| `oleafly auth` | Meldet bei Online-LaTeX-Diensten, Oleafly-Servern und Git-Hosts an |
| `oleafly remote` | Importiert, verknüpft und gleicht Online-Projekte ab |
| `oleafly server` | Arbeitet mit Oleafly-Servern: Projekte, Freigabe, Mitglieder, Kommentare |

### Shell und Hilfe

| Befehl | Was er tut |
|---|---|
| `oleafly completions` | Gibt Shell-Vervollständigungen für bash, zsh, fish, PowerShell oder elvish aus |
| `oleafly man` | Gibt die Handbuchseite aus |
| `oleafly help exit-codes` | Erklärt die Exit-Codes |

### Optionen für jeden Befehl

| Option | Was sie tut |
|---|---|
| `-C` gefolgt von einem Pfad | Führt den Befehl in einem anderen Projektordner aus |
| `--json` | Gibt ein JSON-Ergebnis aus |
| `--events` | Gibt den Fortschritt als JSON-Zeilen vor dem Ergebnis aus |
| `--quiet` | Gibt nur das Ergebnis aus |
| `--log` | Zeigt das Compiler-Protokoll nicht (`none`), nur sein Ende (`tail`) oder ganz (`full`) |
| `--no-input` | Stellt nie eine Frage |
| `--color` | Steuert die Farbe: `auto`, `always` oder `never` |

## Ausgabe für Skripte

### JSON-Ausgabe

Mit `--json` gibt jeder Befehl ein JSON-Objekt aus: `schema_version`, `ok`, `command`, die eigenen Felder des Befehls und `warnings`. Schlägt ein Befehl fehl, enthält `error` ein `kind`, einen stabilen `code` und eine `message`. Wenn sie helfen, enthält es außerdem einen `hint`, `details` und `"retryable": true`, falls ein neuer Versuch funktionieren kann. Prüfen Sie `schema_version`, bevor Sie sich auf ein Feld verlassen.

```json
{
  "schema_version": 1,
  "type": "result",
  "ok": false,
  "command": "remote sync",
  "error": {
    "kind": "conflict",
    "code": "remote.conflicts",
    "message": "2 files changed both here and online.",
    "hint": "Pick a side with --resolve PATH=local or --resolve PATH=remote, then sync again.",
    "details": { "conflicts": ["main.tex", "refs.bib"] }
  },
  "warnings": []
}
```

`--events` fügt vor dem Ergebnis pro Fortschrittsereignis eine JSON-Zeile hinzu.

### Exit-Codes

`oleafly help exit-codes` gibt dieselbe Tabelle aus.

| Code | Bedeutung |
|---|---|
| 0 | Es hat funktioniert |
| 1 | In Oleafly ist etwas schiefgegangen |
| 2 | Der Befehl wurde falsch verwendet, oder er braucht `--yes`, um fortzufahren |
| 3 | Das Projekt fehlt oder ist ungültig, oder ein Pfad zeigt aus ihm heraus |
| 4 | Ein benötigtes Werkzeug oder die Oleafly-App ist nicht installiert |
| 5 | Der Build ist fehlgeschlagen |
| 6 | Sie müssen sich anmelden |
| 7 | Das Netzwerk ist ausgefallen |
| 8 | Etwas anderes hält das Projekt, oder ein Abgleich hat Konflikte |
| 9 | Eine Prüfung hat Probleme gefunden |
| 130 | Sie haben Strg+C gedrückt |

### Fragen, Farbe und Protokolle

Der Befehl stellt ohne Terminal nie eine Frage. `--no-input` schaltet Fragen ebenfalls aus, und das tut auch eine Variable `CI`; ein Befehl, der ein Ja braucht, schlägt dann mit Exit-Code 2 fehl und verlangt `--yes`. `NO_COLOR` oder `--color never` schaltet die Farbe aus. Pfade, die das Projekt verlassen würden, werden abgelehnt.

### Umgebungsvariablen

| Variable | Verwendung |
|---|---|
| `OLEAFLY_DATA_DIR` | Der Datenordner von Oleafly, wenn er nicht `~/.oleafly` ist |
| `OLEAFLY_TECTONIC`, `OLEAFLY_LATEXMK`, `OLEAFLY_TYPST`, `OLEAFLY_PANDOC` | Ein Compiler, der statt des von Oleafly gefundenen verwendet wird |
| `OLEAFLY_APP` | Die Oleafly-App, die `oleafly open` startet |
| `OLEAFLY_ONLINE_GIT_TOKEN` | Ein Git-Token für den Online-LaTeX-Dienst, das statt eines gespeicherten verwendet wird |
| `OLEAFLY_CLI` | Wird von Oleafly für Programme gesetzt, die es startet: der vollständige Pfad des Befehls |
| `CI` | Ist sie gesetzt, stellt der Befehl nie eine Frage |
| `NO_COLOR` | Ist sie gesetzt, hat die Ausgabe keine Farbe |

## Fehlerbehebung

| Symptom | Was Sie versuchen können |
|---|---|
| `oleafly` wird nicht gefunden | Öffnen Sie ein neues Terminal. Prüfen Sie dann mit `Get-Command oleafly` unter Windows oder `command -v oleafly` unter macOS und Linux und fügen Sie Ihrem Shell-Profil die Zeile hinzu, die die Einstellungen zeigen |
| `oleafly doctor` meldet eine fehlende Engine | Installieren Sie sie mit dem Befehl, den doctor ausgibt, oder öffnen Sie das Projekt einmal in der App |
| Ein MCP-Client kann den Server nicht starten | Führen Sie den konfigurierten Befehl in einem Terminal aus, verwenden Sie den vollständigen Pfad aus `oleafly mcp config` und führen Sie `oleafly doctor` aus |
| Exit-Code 6 | Führen Sie `oleafly auth status` aus und melden Sie sich dann erneut an |
| Exit-Code 8 bei einem Abgleich | Führen Sie den Abgleich erneut aus, mit `--resolve` für jede Datei, die er auflistet |
| Unter macOS zeigen die Einstellungen „Verschieben Sie Oleafly zuerst in den Ordner ‚Programme‘“ | Verschieben Sie die App, öffnen Sie sie aus „Programme“ und wählen Sie dann **Installieren** |

## Verwandte Seiten

- [Typst-Projekte](/docs/typst/#build-from-the-command-line)
- [Per MCP verbinden](/docs/mcp/)
- [CLI-Agenten](/docs/cli-agents/)
- [Preflight-Prüfungen](/docs/preflight/)
- [Forschungsaufgaben](/docs/research-tasks/)