# CLI Referenz

## Grundlegende Verwendung

Führe einfach den Befehl aus – Argumente sind nicht erforderlich:

```bash
npx termbridge
```

Damit wird alles gestartet: lokaler Server, tmux-Sitzung und der standardmäßige Cloudflare-Tunnel.

Wenn du `termbridge` ohne Unterbefehl ausführst, entspricht das `termbridge start`.

Du kannst `termbridge start` auch explizit mit allen Flags ausführen:

```bash
termbridge start --port 8080 --proxy 5173 --session dev --kill-on-exit --no-qr --tunnel cloudflare
```

## Flags

| Flag | Funktion | Standardwert |
|------|--------------|---------|
| `--port <port>` | Verwendet einen bestimmten Port statt eines zufälligen | Zufällig |
| `--proxy <port>` | Leitet einen lokalen Dev-Server weiter (aktiviert die Ansichten „Terminal“ und „Vorschau“) | – |
| `--session <name>` | Legt den Namen der tmux-Sitzung fest | Automatisch generiert |
| `--kill-on-exit` | Bereinigt tmux-Sitzungen, wenn Termbridge beendet wird | Aus |
| `--no-qr` | Gibt den QR-Code nicht aus (nützlich für Skripte) | Aus |
| `--no-tunnel` | Deaktiviert den Tunnel (erfordert `--public-url`) | Aus |
| `--public-url <url>` | Öffentliche URL bei deaktiviertem Tunnel | – |
| `--tunnel <provider>` | Tunnelanbieter (`cloudflare` oder `none`) | cloudflare |
| `--tunnel-token <token>` | Verwendet ein benanntes Cloudflare-Tunnel-Token (erfordert `--port`) | – |
| `--tunnel-url <url>` | Öffentliche URL für den benannten Tunnel (mit `--tunnel-token` erforderlich) | – |
| `--backend <backend>` | Terminal-Backend (`tmux` oder `sandbox-daytona`) | tmux |
| `--sandbox-repo <url>` | Repository-URL zum Klonen in die Daytona-Sandbox | – |
| `--sandbox-branch <branch>` | Branch, der in der Sandbox ausgecheckt wird | – |
| `--sandbox-path <path>` | Repository-Pfad in der Sandbox | Aus dem Repository-Namen abgeleitet |
| `--sandbox-name <name>` | Sandbox-Name | Zufällige `termbridge-<hex>` |
| `--sandbox-preview-port <port>` | Vorschau-Port in der Sandbox | – |
| `--sandbox-public` | Erstellt eine öffentliche Sandbox | Aus (im direkten Modus an) |
| `--sandbox-direct` | Führt den Server in der Daytona-Sandbox aus (ohne Tunnel) | Aus |
| `--dev-proxy-url <url>` | Leitet den Vorschau-Traffic an diese URL statt an `localhost:<proxy port>` weiter (wird von den Dev-Skripten verwendet) | – |
| `-h`, `--help` | Gibt den Hilfetext aus | – |

Jede andere Option führt zu `unknown option: <flag>`. Ein `--version`-Flag gibt es nicht.

Ein Flag hat Vorrang vor seiner Umgebungsvariablen, mit einer Ausnahme: `TERMBRIDGE_TUNNEL` setzt sich derzeit gegen `--tunnel` und `--no-tunnel` durch ([#5](https://github.com/inline0/termbridge/issues/5)).

> **Hinweis**
> Die integrierte `termbridge --help`-Ausgabe führt weiterhin `--daytona-*`-Flags und `--backend tmux | daytona` auf. Diese Namen werden abgelehnt; verwende die `--sandbox-*`-Flags und `--backend sandbox-daytona` aus der obigen Tabelle ([#1](https://github.com/inline0/termbridge/issues/1)).

## Beispiele

### Mit einer bestehenden tmux-Sitzung verbinden

Wenn bereits eine tmux-Sitzung läuft:

```bash
termbridge --session my-session
```

### Fester Port und benutzerdefinierte Sitzung

```bash
termbridge --port 8080 --session codex
```

### Sauber beenden (keine Sitzungen bleiben zurück)

```bash
termbridge --kill-on-exit
```

### Skripte (keine QR-Ausgabe)

```bash
termbridge --no-qr
```

### Einen Vite-Dev-Server weiterleiten

```bash
# Start your Vite app first
cd my-app && npm run dev  # runs on port 5173

# Then start Termbridge with proxy
termbridge --proxy 5173
```

Mit der Schaltfläche **Ansichten** kannst du zwischen Terminal und Vorschau wechseln. Die Vorschau lädt deine App über den Proxy mit HMR-Unterstützung.

### Benannter Cloudflare-Tunnel (tokenbasiert)

Wenn du ein Cloudflare-Konto hast und die Ratenlimits von trycloudflare umgehen möchtest:

```bash
termbridge --port 8080 --tunnel-token <TOKEN> --tunnel-url https://term.example.com
```

### Tunnel deaktivieren (eigene öffentliche URL verwenden)

```bash
termbridge --no-tunnel --public-url https://example.com
```

## Umgebungsvariablen

Termbridge liest Umgebungsvariablen aus der Shell und aus einer `.env`-Datei im Verzeichnis, in dem du es ausführst. Bereits in der Shell gesetzte Variablen haben Vorrang vor denen in der `.env`-Datei.

### Grundeinstellungen

| Variable | Funktion |
|----------|--------------|
| `TERMBRIDGE_SESSIONS=2` | Erstellt beim Start mehrere tmux-Sitzungen |
| `TERMBRIDGE_TMUX_CWD=/path` | Arbeitsverzeichnis für neue tmux-Sitzungen |
| `TERMBRIDGE_PUBLIC_URL=https://example.com` | Öffentliche URL bei deaktiviertem Tunnel |
| `TERMBRIDGE_TUNNEL=none` | Deaktiviert den Tunnel |
| `TERMBRIDGE_TUNNEL_TOKEN=<token>` | Token für benannten Tunnel (erfordert `TERMBRIDGE_TUNNEL_URL`) |
| `TERMBRIDGE_TUNNEL_URL=https://term.example.com` | Öffentliche URL für den benannten Tunnel |

### Erweitert

Der direkte Daytona-Modus setzt diese Werte für den Server, der in der Sandbox läuft. Du kannst sie auch selbst festlegen.

| Variable | Funktion |
|----------|--------------|
| `TERMBRIDGE_HOST=0.0.0.0` | Adresse, an die der Server gebunden wird (Standard: `127.0.0.1`). Die ausgegebene lokale URL zeigt immer `127.0.0.1`. |
| `TERMBRIDGE_COOKIE_SAMESITE=lax` | `SameSite`-Wert des Sitzungscookies: `lax`, `strict` oder `none` (Standard: `Lax` oder `None` im direkten Modus) |
| `TERMBRIDGE_SHARE_FILE=/path/share-url.txt` | Schreibe den Freigabe-URL zusätzlich in diese Datei |
| `TERMBRIDGE_HIDE_TERMINAL_SWITCHER=1` | Terminal-Umschalter in der UI ausblenden |
| `TERMBRIDGE_TMUX_PATH_PREFIX=/path/bin` | Dies `PATH` in jeder tmux-Sitzung voranstellen, die Termbridge startet oder verbindet (wird als `export`-Befehl in die Sitzung eingegeben) |

### Entwicklung

| Variable | Funktion |
|----------|--------------|
| `TERMBRIDGE_INSECURE_COOKIE=1` | HTTP-Cookies erlauben (nur lokale Entwicklung) |
| `TERMBRIDGE_PROXY_PORT=5173` | Proxy-Port für das dev:beam:proxy-Skript |
| `TERMBRIDGE_DEV_UI=http://127.0.0.1:5000` | Vite-Dev-UI-URL überschreiben |
| `TERMBRIDGE_DEV_PORT=3000` | Port des Termbridge-Servers in der Entwicklung überschreiben (Standard: `8787`) |
| `TERMBRIDGE_DEV_SESSION=codex` | tmux-Sitzungsname für `dev:beam` (Standard: `codex`) |
| `TERMBRIDGE_SKIP_BUILD=1` | CLI-Build in `dev:beam` überspringen |

### Sandbox (Daytona)

| Variable | Funktion |
|----------|--------------|
| `TERMBRIDGE_BACKEND=sandbox-daytona` | Daytona-Sandbox-Backend verwenden |
| `TERMBRIDGE_SANDBOX_DIRECT=true` | Termbridge innerhalb der Sandbox ausführen |
| `TERMBRIDGE_SANDBOX_SERVER_PORT=8080` | Port des Servers in der Sandbox |
| `TERMBRIDGE_SANDBOX_AGENTS=claude-code,codex` | Authentifizierung für Agents automatisch installieren und synchronisieren |
| `TERMBRIDGE_SANDBOX_AGENT_ENV=...` | Zusätzliche Umgebungsvariablen weiterleiten |
| `TERMBRIDGE_SANDBOX_AGENT_AUTH_PATHS=...` | Lokale Authentifizierungsdateien synchronisieren |

Die vollständige Daytona-Konfiguration findest du in der [Daytona-Anleitung](https://termbridge.inline0.dev/de/docs/sandboxes/daytona).

## Termbridge beenden

Drücke `Ctrl+C` in dem Terminal, in dem Termbridge läuft. Dadurch wird Folgendes ausgeführt:

- Der Tunnel wird geschlossen (falls aktiviert)
- Der lokale Server wird beendet
- tmux-Sitzungen bleiben aktiv (sofern du nicht `--kill-on-exit` verwendet hast)

Deine tmux-Sitzungen bleiben standardmäßig bestehen, damit du später wieder eine Verbindung herstellen kannst.