# Daytona

Daytona permet à Termbridge d'exécuter votre terminal et votre aperçu dans un environnement isolé cloud. Utilisez cette option pour disposer d'un environnement reproductible, d'un aperçu cloud ou pour laisser votre ordinateur portable au repos.

## Prérequis

- Une clé Daytona API
- Un dépôt URL que l'environnement isolé peut cloner
- Des identifiants Git si le dépôt est privé

## Démarrage rapide

Définissez le backend sur Daytona et fournissez la configuration du dépôt :

```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
```

Exécutez ensuite Termbridge comme d'habitude :

```bash
npx termbridge
```

Définissez toujours `TERMBRIDGE_SANDBOX_REPO` (ou `--sandbox-repo`). Si cette valeur manque, Termbridge utilise actuellement un dépôt intégré par défaut qui n'est pas accessible au public : l'environnement isolé est créé, mais le clonage échoue ([#2](https://github.com/inline0/termbridge/issues/2)).

## Connexion à Daytona

| Variable | Rôle |
| --- | --- |
| `TERMBRIDGE_DAYTONA_API_KEY` | Votre clé Daytona API |
| `TERMBRIDGE_DAYTONA_API_URL` | Point de terminaison API (par défaut `https://app.daytona.io/api`) |
| `TERMBRIDGE_DAYTONA_TARGET` | Région cible Daytona (facultatif) |

Ces valeurs sont transmises au SDK Daytona. Si l'une d'elles n'est pas définie, le SDK utilise sa propre variable `DAYTONA_API_KEY`, `DAYTONA_API_URL` ou `DAYTONA_TARGET`.

## Mode direct en environnement isolé (sans tunnel)

En mode direct, le serveur Termbridge s'exécute dans l'environnement isolé et Cloudflare est entièrement ignoré. Le URL de partage est le lien d'aperçu Daytona vers le serveur de l'environnement isolé.

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

`TERMBRIDGE_SANDBOX_SERVER_PORT` (ou `--port`) utilise `8080` par défaut. Le mode direct crée un environnement isolé public sauf si vous définissez `TERMBRIDGE_SANDBOX_PUBLIC=false`, et UI masque le sélecteur de terminaux.

Vous pouvez tout de même activer l'aperçu en définissant `TERMBRIDGE_SANDBOX_PREVIEW_PORT` ; en mode direct, cette valeur est transmise comme port `--proxy` du serveur.

## Clonage du dépôt

Termbridge crée un environnement isolé et clone votre dépôt dans son répertoire de travail.

Utilisez ces paramètres :

| Variable | Fonction |
| --- | --- |
| `TERMBRIDGE_SANDBOX_REPO` | Dépôt URL à cloner (à toujours définir, voir le démarrage rapide) |
| `TERMBRIDGE_SANDBOX_BRANCH` | Branche à extraire (facultatif) |
| `TERMBRIDGE_SANDBOX_PATH` | Chemin du dépôt dans le bac à sable (facultatif) |
| `TERMBRIDGE_SANDBOX_NAME` | Nom du bac à sable (facultatif, vaut `termbridge-<random hex>` par défaut) |

Si `TERMBRIDGE_SANDBOX_PATH` n'est pas défini, Termbridge le déduit du nom du dépôt.

## Dépôts privés

Fournissez les identifiants git lors du clonage de dépôts privés :

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

`TERMBRIDGE_SANDBOX_GIT_PASSWORD` est également pris en charge et remplace le jeton s'il est défini.

## Agents de codage

Termbridge peut installer des agents de codage dans le bac à sable et synchroniser votre authentification locale afin qu'ils soient immédiatement prêts.

Consultez le guide [Agents de codage](https://termbridge.inline0.dev/fr/docs/sandboxes/coding-agents) pour connaître la configuration complète, le mode automatique et les détails de sécurité.

## Mode aperçu

Pour afficher la vue d'aperçu, définissez `TERMBRIDGE_SANDBOX_PREVIEW_PORT` sur le port utilisé par votre serveur de développement dans le bac à sable.

Pour Vite, veillez à écouter sur toutes les interfaces :

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

Termbridge récupère le lien d'aperçu de Daytona et le relaie via le serveur Termbridge afin que l'aperçu s'affiche dans le UI.

## Bacs à sable publics ou privés

| Variable | Fonction |
| --- | --- |
| `TERMBRIDGE_SANDBOX_PUBLIC=true` | Crée un bac à sable public |
| `TERMBRIDGE_SANDBOX_PUBLIC=false` | Crée un bac à sable privé |

Lorsque cette variable n'est pas définie, les bacs à sable sont privés, sauf en mode direct, où ils sont publics.

Pour les bacs à sable privés, Termbridge transmet automatiquement le jeton d'aperçu lors du relais de l'aperçu.

## Nettoyage et cycle de vie

Pour supprimer les bacs à sable à la fermeture de Termbridge :

```bash
export TERMBRIDGE_SANDBOX_DELETE_ON_EXIT=true
```

Pour les bacs à sable de courte durée ou de test, utilisez un préfixe :

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

Cela permet de maîtriser l'utilisation des bacs à sable et d'éviter les problèmes de quota disque.

## Options de CLI

Vous pouvez également configurer Daytona avec des options. Une option a priorité sur la variable d'environnement correspondante.

| Option | Variable d'environnement | Fonction |
| --- | --- | --- |
| `--backend sandbox-daytona` | `TERMBRIDGE_BACKEND` | Utiliser le moteur Daytona |
| `--sandbox-repo <url>` | `TERMBRIDGE_SANDBOX_REPO` | Dépôt URL |
| `--sandbox-branch <branch>` | `TERMBRIDGE_SANDBOX_BRANCH` | Branche |
| `--sandbox-path <path>` | `TERMBRIDGE_SANDBOX_PATH` | Chemin du dépôt dans le bac à sable |
| `--sandbox-name <name>` | `TERMBRIDGE_SANDBOX_NAME` | Nom du bac à sable |
| `--sandbox-preview-port <port>` | `TERMBRIDGE_SANDBOX_PREVIEW_PORT` | Port d'aperçu |
| `--sandbox-public` | `TERMBRIDGE_SANDBOX_PUBLIC=true` | Créer un bac à sable public |
| `--sandbox-direct` | `TERMBRIDGE_SANDBOX_DIRECT=true` | Exécuter le serveur dans le bac à sable (sans tunnel) |

Il n'existe pas d'option pour un bac à sable privé ; utilisez `TERMBRIDGE_SANDBOX_PUBLIC=false`. La sortie intégrée de `termbridge --help` affiche toujours les noms `--daytona-*` et `--backend daytona`, qui sont refusés ([#1](https://github.com/inline0/termbridge/issues/1)).

## Dépannage

**La vue d'aperçu est vide**
- Vérifiez que le serveur de développement s'exécute dans le bac à sable.
- Utilisez `--host 0.0.0.0` pour que le port d'aperçu soit accessible.
- Vérifiez que `TERMBRIDGE_SANDBOX_PREVIEW_PORT` correspond au port du serveur de développement.

**La création du bac à sable échoue avec des erreurs de quota**
- Supprimez les anciens bacs à sable dans le tableau de bord Daytona.
- Utilisez `TERMBRIDGE_SANDBOX_DELETE_ON_EXIT=true` pour les sessions de courte durée.

**Le clonage du dépôt échoue**
- Vérifiez le dépôt URL, la branche et les identifiants.
- Vérifiez que le jeton Git dispose d'un accès en lecture au dépôt.