# Daytona

Mit Daytona kann Termbridge dein Terminal und deine Vorschau in einer Cloud-Sandbox ausführen. Nutze das für eine reproduzierbare Umgebung, eine Cloud-Vorschau oder wenn dein Laptop ausgeschaltet bleiben soll.

## Voraussetzungen

- Ein Daytona-API-Schlüssel
- Ein Repository-URL, das die Sandbox klonen kann
- Git-Zugangsdaten, falls das Repository privat ist

## Schnellstart

Lege das Backend auf Daytona fest und gib die Repository-Konfiguration an:

```bash
export TERMBRIDGE_BACKEND=sandbox-daytona
export TERMBRIDGE_DAYTONA_API_KEY=your_key
export TERMBRIDGE_SANDBOX_REPO=https://github.com/you/your-repo.git
export TERMBRIDGE_SANDBOX_BRANCH=main
export TERMBRIDGE_SANDBOX_PATH=your-repo
export TERMBRIDGE_SANDBOX_NAME=termbridge-sandbox
export TERMBRIDGE_SANDBOX_PUBLIC=true
export TERMBRIDGE_SANDBOX_PREVIEW_PORT=5173
export TERMBRIDGE_SANDBOX_DELETE_ON_EXIT=true
```

Führe Termbridge anschließend wie gewohnt aus:

```bash
npx termbridge
```

Lege immer `TERMBRIDGE_SANDBOX_REPO` (oder `--sandbox-repo`) fest. Fehlt der Wert, greift Termbridge derzeit auf ein integriertes Standard-Repository zurück, das nicht öffentlich zugänglich ist. Daher wird die Sandbox erstellt, aber das Klonen schlägt fehl ([#2](https://github.com/inline0/termbridge/issues/2)).

## Daytona-Verbindung

| Variable | Zweck |
| --- | --- |
| `TERMBRIDGE_DAYTONA_API_KEY` | Dein Daytona-API-Schlüssel |
| `TERMBRIDGE_DAYTONA_API_URL` | API-Endpunkt (Standard: `https://app.daytona.io/api`) |
| `TERMBRIDGE_DAYTONA_TARGET` | Zielregion von Daytona (optional) |

Diese Werte werden an das Daytona-SDK übergeben. Wenn einer davon nicht festgelegt ist, greift das SDK auf seine eigene Variable `DAYTONA_API_KEY`, `DAYTONA_API_URL` oder `DAYTONA_TARGET` zurück.

## Direkter Sandbox-Modus (ohne Tunnel)

Im direkten Modus läuft der Termbridge-Server in der Sandbox; Cloudflare wird vollständig umgangen. Der Freigabe-URL ist der Daytona-Vorschaulink zum Server in der Sandbox.

```bash
export TERMBRIDGE_BACKEND=sandbox-daytona
export TERMBRIDGE_SANDBOX_DIRECT=true
export TERMBRIDGE_SANDBOX_SERVER_PORT=8080
```

`TERMBRIDGE_SANDBOX_SERVER_PORT` (oder `--port`) verwendet standardmäßig `8080`. Im direkten Modus wird eine öffentliche Sandbox erstellt, sofern du `TERMBRIDGE_SANDBOX_PUBLIC=false` nicht festlegst; UI blendet den Terminal-Umschalter aus.

Du kannst die Vorschau weiterhin aktivieren, indem du `TERMBRIDGE_SANDBOX_PREVIEW_PORT` festlegst. Im direkten Modus wird der Wert als Server-`--proxy` weitergegeben.

## Repository klonen

Termbridge erstellt eine Sandbox und klont dein Repository in das Arbeitsverzeichnis der Sandbox.

Verwende diese Einstellungen:

| Variable | Zweck |
| --- | --- |
| `TERMBRIDGE_SANDBOX_REPO` | Repo URL zum Klonen (immer festlegen, siehe Schnellstart) |
| `TERMBRIDGE_SANDBOX_BRANCH` | Auszucheckender Branch (optional) |
| `TERMBRIDGE_SANDBOX_PATH` | Pfad zum Repo in der Sandbox (optional) |
| `TERMBRIDGE_SANDBOX_NAME` | Sandbox-Name (optional, Standardwert: `termbridge-<random hex>`) |

Wenn `TERMBRIDGE_SANDBOX_PATH` nicht festgelegt ist, leitet Termbridge den Wert aus dem Repo-Namen ab.

## Private Repositories

Gib git-Zugangsdaten an, wenn du private Repositories klonst:

```bash
export TERMBRIDGE_SANDBOX_GIT_USERNAME=your_github_username
export TERMBRIDGE_SANDBOX_GIT_TOKEN=your_github_token
```

`TERMBRIDGE_SANDBOX_GIT_PASSWORD` wird ebenfalls unterstützt und überschreibt das Token, wenn es festgelegt ist.

## Programmieragenten

Termbridge kann Programmieragenten in der Sandbox installieren und deine lokale Authentifizierung synchronisieren, damit sie sofort einsatzbereit sind.

Im Leitfaden zu [Programmieragenten](https://termbridge.inline0.dev/de/docs/sandboxes/coding-agents) findest du alle Infos zur Einrichtung, zum Automatikmodus und zur Sicherheit.

## Vorschaumodus

Damit die Vorschau angezeigt wird, setze `TERMBRIDGE_SANDBOX_PREVIEW_PORT` auf den Port, den dein Dev-Server in der Sandbox verwendet.

Stelle bei Vite sicher, dass der Server an alle Schnittstellen gebunden ist:

```bash
npm run dev -- --host 0.0.0.0 --port 5173
```

Termbridge ruft den Daytona-Vorschau-Link ab und leitet ihn über den Termbridge-Server weiter, damit die Vorschau im UI geladen wird.

## Öffentliche und private Sandboxes

| Variable | Funktion |
| --- | --- |
| `TERMBRIDGE_SANDBOX_PUBLIC=true` | Erstellt eine öffentliche Sandbox |
| `TERMBRIDGE_SANDBOX_PUBLIC=false` | Erstellt eine private Sandbox |

Wenn die Variable nicht festgelegt ist, sind Sandboxes privat. Im Direktmodus sind sie öffentlich.

Bei privaten Sandboxes leitet Termbridge das Vorschau-Token beim Weiterleiten der Vorschau automatisch mit.

## Bereinigung und Lebenszyklus

So löschst du Sandboxes, wenn Termbridge beendet wird:

```bash
export TERMBRIDGE_SANDBOX_DELETE_ON_EXIT=true
```

Verwende für kurzlebige oder Test-Sandboxes ein Präfix:

```bash
export TERMBRIDGE_SANDBOX_NAME=termbridge-test-$(date +%s)
export TERMBRIDGE_SANDBOX_DELETE_ON_EXIT=true
```

So behältst du die Sandbox-Nutzung im Griff und vermeidest Probleme mit dem Speicherplatzkontingent.

## CLI-Optionen

Du kannst Daytona auch über Optionen konfigurieren. Eine Option hat Vorrang vor der entsprechenden Umgebungsvariable.

| Option | Umgebungsvariable | Zweck |
| --- | --- | --- |
| `--backend sandbox-daytona` | `TERMBRIDGE_BACKEND` | Daytona-Backend verwenden |
| `--sandbox-repo <url>` | `TERMBRIDGE_SANDBOX_REPO` | Repo URL |
| `--sandbox-branch <branch>` | `TERMBRIDGE_SANDBOX_BRANCH` | Branch |
| `--sandbox-path <path>` | `TERMBRIDGE_SANDBOX_PATH` | Repo-Pfad in der Sandbox |
| `--sandbox-name <name>` | `TERMBRIDGE_SANDBOX_NAME` | Sandbox-Name |
| `--sandbox-preview-port <port>` | `TERMBRIDGE_SANDBOX_PREVIEW_PORT` | Vorschau-Port |
| `--sandbox-public` | `TERMBRIDGE_SANDBOX_PUBLIC=true` | Öffentliche Sandbox erstellen |
| `--sandbox-direct` | `TERMBRIDGE_SANDBOX_DIRECT=true` | Server in der Sandbox ausführen (ohne Tunnel) |

Für eine private Sandbox gibt es keine Option; verwende `TERMBRIDGE_SANDBOX_PUBLIC=false`. Die integrierte `termbridge --help`-Ausgabe zeigt weiterhin `--daytona-*`-Namen und `--backend daytona` an, die abgelehnt werden ([#1](https://github.com/inline0/termbridge/issues/1)).

## Fehlerbehebung

**Vorschau bleibt leer**
- Stelle sicher, dass der Dev-Server in der Sandbox läuft.
- Verwende `--host 0.0.0.0`, damit der Vorschau-Port erreichbar ist.
- Prüfe, ob `TERMBRIDGE_SANDBOX_PREVIEW_PORT` dem Port des Dev-Servers entspricht.

**Sandbox-Erstellung schlägt wegen Kontingentfehlern fehl**
- Lösche alte Sandboxes im Daytona-Dashboard.
- Verwende `TERMBRIDGE_SANDBOX_DELETE_ON_EXIT=true` für kurzlebige Sitzungen.

**Repo-Klonen schlägt fehl**
- Prüfe Repo URL, Branch und Zugangsdaten.
- Stelle sicher, dass das Git-Token Lesezugriff auf das Repo hat.