# Référence CLI

## Utilisation de base

Exécutez simplement la commande, sans argument :

```bash
npx termbridge
```

Cela démarre l’ensemble : le serveur local, la session tmux et le tunnel Cloudflare par défaut.

Exécuter `termbridge` sans sous-commande équivaut à `termbridge start`.

Vous pouvez aussi exécuter explicitement `termbridge start` avec toutes les options :

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

## Options

| Option | Fonction | Valeur par défaut |
|------|--------------|---------|
| `--port <port>` | Utiliser un port précis au lieu d’un port aléatoire | Aléatoire |
| `--proxy <port>` | Utiliser un serveur de développement local comme proxy (active les vues Terminal/Aperçu) | - |
| `--session <name>` | Nommer votre session tmux | Généré automatiquement |
| `--kill-on-exit` | Nettoyer les sessions tmux à la fermeture de Termbridge | Désactivé |
| `--no-qr` | Ne pas afficher le code QR (utile pour les scripts) | Désactivé |
| `--no-tunnel` | Désactiver le tunnel (nécessite `--public-url`) | Désactivé |
| `--public-url <url>` | URL public lorsque le tunnel est désactivé | - |
| `--tunnel <provider>` | Fournisseur de tunnel (`cloudflare` ou `none`) | cloudflare |
| `--tunnel-token <token>` | Utiliser un jeton de tunnel Cloudflare nommé (nécessite `--port`) | - |
| `--tunnel-url <url>` | URL public pour le tunnel nommé (requis avec `--tunnel-token`) | - |
| `--backend <backend>` | Backend du terminal (`tmux` ou `sandbox-daytona`) | tmux |
| `--sandbox-repo <url>` | Dépôt URL à cloner dans le bac à sable Daytona | - |
| `--sandbox-branch <branch>` | Branche à extraire dans le bac à sable | - |
| `--sandbox-path <path>` | Chemin du dépôt dans le bac à sable | Dérivé du nom du dépôt |
| `--sandbox-name <name>` | Nom du bac à sable | `termbridge-<hex>` aléatoire |
| `--sandbox-preview-port <port>` | Port d’aperçu dans le bac à sable | - |
| `--sandbox-public` | Créer un bac à sable public | Désactivé (activé en mode direct) |
| `--sandbox-direct` | Exécuter le serveur dans le bac à sable Daytona (sans tunnel) | Désactivé |
| `--dev-proxy-url <url>` | Acheminer le trafic d’aperçu vers ce URL plutôt que vers `localhost:<proxy port>` (utilisé par les scripts de développement) | - |
| `-h`, `--help` | Afficher l’aide | - |

Toute autre option provoque une erreur `unknown option: <flag>`. Il n’existe pas d’option `--version`.

Une option prévaut sur la variable d’environnement correspondante, à une exception près : `TERMBRIDGE_TUNNEL` remplace actuellement `--tunnel` et `--no-tunnel` ([#5](https://github.com/inline0/termbridge/issues/5)).

> **Remarque**
> La sortie `termbridge --help` intégrée affiche encore les options `--daytona-*` et les `--backend tmux | daytona`. Ces noms sont refusés ; utilisez les options `--sandbox-*` et les `--backend sandbox-daytona` du tableau ci-dessus ([#1](https://github.com/inline0/termbridge/issues/1)).

## Exemples

### Se connecter à une session tmux existante

Si une session tmux est déjà en cours :

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

### Port fixe et session personnalisée

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

### Fermeture propre (aucune session restante)

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

### Scripts (sans sortie QR)

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

### Utiliser un serveur de développement Vite comme proxy

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

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

Utilisez le bouton **Views** pour basculer entre Terminal et Aperçu. L’aperçu charge votre application via le proxy, avec la prise en charge de HMR.

### Tunnel Cloudflare nommé (basé sur un jeton)

Si vous avez un compte Cloudflare et souhaitez éviter les limites de débit de trycloudflare :

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

### Désactiver le tunnel (fournir votre propre URL public)

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

## Variables d’environnement

Termbridge lit les variables d’environnement du shell et celles d’un fichier `.env` dans le répertoire d’où vous l’exécutez. Les variables déjà définies dans le shell prévalent sur celles du fichier `.env`.

### Paramètres principaux

| Variable | Fonction |
|----------|--------------|
| `TERMBRIDGE_SESSIONS=2` | Créer plusieurs sessions tmux au démarrage |
| `TERMBRIDGE_TMUX_CWD=/path` | Répertoire de travail des nouvelles sessions tmux |
| `TERMBRIDGE_PUBLIC_URL=https://example.com` | URL public lorsque le tunnel est désactivé |
| `TERMBRIDGE_TUNNEL=none` | Désactiver le tunnel |
| `TERMBRIDGE_TUNNEL_TOKEN=<token>` | Jeton de tunnel nommé (nécessite `TERMBRIDGE_TUNNEL_URL`) |
| `TERMBRIDGE_TUNNEL_URL=https://term.example.com` | URL public pour le tunnel nommé |

### Paramètres avancés

Daytona définit ces variables pour le serveur qu’il exécute dans le bac à sable. Vous pouvez également les définir vous-même.

| Variable | Fonction |
|----------|--------------|
| `TERMBRIDGE_HOST=0.0.0.0` | Adresse à laquelle le serveur se lie (par défaut `127.0.0.1`). L'URL local affiché indique toujours `127.0.0.1`. |
| `TERMBRIDGE_COOKIE_SAMESITE=lax` | `SameSite` valeur du cookie de session : `lax`, `strict` ou `none` (par défaut `Lax`, ou `None` en mode direct) |
| `TERMBRIDGE_SHARE_FILE=/path/share-url.txt` | Écrit également le URL de partage dans ce fichier |
| `TERMBRIDGE_HIDE_TERMINAL_SWITCHER=1` | Masque le sélecteur de terminaux dans UI |
| `TERMBRIDGE_TMUX_PATH_PREFIX=/path/bin` | Ajoute ce texte au début de `PATH` dans chaque session tmux démarrée ou rejointe par Termbridge (saisi dans la session comme une commande `export`) |

### Développement

| Variable | Fonction |
|----------|--------------|
| `TERMBRIDGE_INSECURE_COOKIE=1` | Autorise les cookies HTTP (développement local uniquement) |
| `TERMBRIDGE_PROXY_PORT=5173` | Port du proxy pour le script dev:beam:proxy |
| `TERMBRIDGE_DEV_UI=http://127.0.0.1:5000` | Remplace Vite dev UI URL |
| `TERMBRIDGE_DEV_PORT=3000` | Remplace le port du serveur Termbridge en développement (par défaut `8787`) |
| `TERMBRIDGE_DEV_SESSION=codex` | Nom de session tmux pour `dev:beam` (par défaut `codex`) |
| `TERMBRIDGE_SKIP_BUILD=1` | Ignore la compilation CLI dans `dev:beam` |

### Environnement isolé (Daytona)

| Variable | Fonction |
|----------|--------------|
| `TERMBRIDGE_BACKEND=sandbox-daytona` | Utilise le backend d'environnement isolé Daytona |
| `TERMBRIDGE_SANDBOX_DIRECT=true` | Exécute Termbridge dans l'environnement isolé |
| `TERMBRIDGE_SANDBOX_SERVER_PORT=8080` | Port du serveur dans l'environnement isolé |
| `TERMBRIDGE_SANDBOX_AGENTS=claude-code,codex` | Installe automatiquement et synchronise l'authentification des agents |
| `TERMBRIDGE_SANDBOX_AGENT_ENV=...` | Variables d'environnement supplémentaires à transférer |
| `TERMBRIDGE_SANDBOX_AGENT_AUTH_PATHS=...` | Fichiers d'authentification locaux à synchroniser |

Pour la configuration complète de Daytona, consultez le [guide Daytona](https://termbridge.inline0.dev/fr/docs/sandboxes/daytona).

## Arrêter Termbridge

Appuyez sur `Ctrl+C` dans le terminal où Termbridge est en cours d'exécution. Cette action :

- Ferme le tunnel (s'il est activé)
- Arrête le serveur local
- Laisse les sessions tmux actives (sauf si vous avez utilisé `--kill-on-exit`)

Par défaut, vos sessions tmux persistent, vous pouvez donc vous reconnecter plus tard.