# Daytona

Daytona permite que Termbridge ejecute tu terminal y vista previa en un sandbox en la nube. Úsalo para tener un entorno reproducible, una vista previa en la nube o dejar el portátil inactivo.

## Requisitos

- Una clave Daytona API
- Un repositorio URL que el sandbox pueda clonar
- Credenciales de Git si el repositorio es privado

## Inicio rápido

Establece el backend en Daytona y proporciona la configuración del repositorio:

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

Después ejecuta Termbridge como de costumbre:

```bash
npx termbridge
```

Define siempre `TERMBRIDGE_SANDBOX_REPO` (o `--sandbox-repo`). Si falta, Termbridge recurre actualmente a un repositorio predeterminado integrado que no es de acceso público, por lo que el sandbox se crea, pero falla la clonación ([#2](https://github.com/inline0/termbridge/issues/2)).

## Conexión de Daytona

| Variable | Propósito |
| --- | --- |
| `TERMBRIDGE_DAYTONA_API_KEY` | Tu clave Daytona API |
| `TERMBRIDGE_DAYTONA_API_URL` | Punto de conexión de API (por defecto, `https://app.daytona.io/api`) |
| `TERMBRIDGE_DAYTONA_TARGET` | Región de destino de Daytona (opcional) |

Se pasan al SDK de Daytona. Si alguna no está definida, el SDK recurre a su propia variable `DAYTONA_API_KEY`, `DAYTONA_API_URL` o `DAYTONA_TARGET`.

## Modo sandbox directo (sin túnel)

El modo directo ejecuta el servidor de Termbridge dentro del sandbox y omite por completo Cloudflare. El URL para compartir es el enlace de vista previa de Daytona al servidor del sandbox.

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

`TERMBRIDGE_SANDBOX_SERVER_PORT` (o `--port`) tiene `8080` como valor predeterminado. El modo directo crea un sandbox público, salvo que definas `TERMBRIDGE_SANDBOX_PUBLIC=false`, y UI oculta el selector de terminales.

Puedes habilitar la vista previa igualmente definiendo `TERMBRIDGE_SANDBOX_PREVIEW_PORT`; en modo directo se reenvía como puerto del servidor `--proxy`.

## Clonación del repositorio

Termbridge creará un sandbox y clonará tu repositorio en el directorio de trabajo del sandbox.

Usa estos ajustes:

| Variable | Propósito |
| --- | --- |
| `TERMBRIDGE_SANDBOX_REPO` | Repo URL que se va a clonar (configúrelo siempre; consulte el inicio rápido) |
| `TERMBRIDGE_SANDBOX_BRANCH` | Rama que se va a comprobar (opcional) |
| `TERMBRIDGE_SANDBOX_PATH` | Ruta del repo en el sandbox (opcional) |
| `TERMBRIDGE_SANDBOX_NAME` | Nombre del sandbox (opcional; por defecto, `termbridge-<random hex>`) |

Si no se establece `TERMBRIDGE_SANDBOX_PATH`, Termbridge lo obtiene del nombre del repo.

## Repositorios privados

Proporciona credenciales de git al clonar repositorios privados:

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

`TERMBRIDGE_SANDBOX_GIT_PASSWORD` también es compatible y, si se establece, reemplaza el token.

## Agentes de programación

Termbridge puede instalar agentes de programación en el sandbox y sincronizar su autenticación local para que estén listos de inmediato.

Consulte la guía de [agentes de programación](https://termbridge.inline0.dev/es/docs/sandboxes/coding-agents) para ver la configuración completa, el modo automático y los detalles de seguridad.

## Modo de vista previa

Para mostrar la vista previa, establezca `TERMBRIDGE_SANDBOX_PREVIEW_PORT` en el puerto que usa su servidor de desarrollo dentro del sandbox.

Para Vite, asegúrese de enlazarlo a todas las interfaces:

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

Termbridge obtiene el enlace de vista previa de Daytona y lo redirige a través del servidor Termbridge para que la vista previa se cargue dentro de UI.

## Sandboxes públicos y privados

| Variable | Función |
| --- | --- |
| `TERMBRIDGE_SANDBOX_PUBLIC=true` | Crea un sandbox público |
| `TERMBRIDGE_SANDBOX_PUBLIC=false` | Crea un sandbox privado |

Si no se establece la variable, los sandboxes son privados, excepto en el modo directo, donde son públicos.

En los sandboxes privados, Termbridge reenvía automáticamente el token de vista previa al redirigirla.

## Limpieza y ciclo de vida

Para eliminar los sandboxes cuando Termbridge se cierre:

```bash
export TERMBRIDGE_SANDBOX_DELETE_ON_EXIT=true
```

Para sandboxes de corta duración o de prueba, use un prefijo:

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

Así se mantiene bajo control el uso de sandboxes y se evitan problemas con la cuota de disco.

## Opciones de CLI

También puede configurar Daytona mediante opciones. Una opción tiene prioridad sobre la variable de entorno correspondiente.

| Opción | Variable de entorno | Propósito |
| --- | --- | --- |
| `--backend sandbox-daytona` | `TERMBRIDGE_BACKEND` | Usar el backend Daytona |
| `--sandbox-repo <url>` | `TERMBRIDGE_SANDBOX_REPO` | Repo URL |
| `--sandbox-branch <branch>` | `TERMBRIDGE_SANDBOX_BRANCH` | Rama |
| `--sandbox-path <path>` | `TERMBRIDGE_SANDBOX_PATH` | Ruta del repo en el sandbox |
| `--sandbox-name <name>` | `TERMBRIDGE_SANDBOX_NAME` | Nombre del sandbox |
| `--sandbox-preview-port <port>` | `TERMBRIDGE_SANDBOX_PREVIEW_PORT` | Puerto de vista previa |
| `--sandbox-public` | `TERMBRIDGE_SANDBOX_PUBLIC=true` | Crear un sandbox público |
| `--sandbox-direct` | `TERMBRIDGE_SANDBOX_DIRECT=true` | Ejecutar el servidor dentro del sandbox (sin túnel) |

No hay una opción para un sandbox privado; use `TERMBRIDGE_SANDBOX_PUBLIC=false`. La salida integrada de `termbridge --help` sigue mostrando los nombres `--daytona-*` y `--backend daytona`, que se rechazan ([#1](https://github.com/inline0/termbridge/issues/1)).

## Solución de problemas

**La vista previa aparece en blanco**
- Compruebe que el servidor de desarrollo se esté ejecutando dentro del sandbox.
- Use `--host 0.0.0.0` para que se pueda acceder al puerto de vista previa.
- Confirme que `TERMBRIDGE_SANDBOX_PREVIEW_PORT` coincida con el puerto del servidor de desarrollo.

**La creación del sandbox falla por errores de cuota**
- Elimine los sandboxes antiguos desde el panel de Daytona.
- Use `TERMBRIDGE_SANDBOX_DELETE_ON_EXIT=true` en sesiones de corta duración.

**Falla la clonación del repo**
- Compruebe el repo URL, la rama y las credenciales.
- Asegúrese de que el token Git tenga acceso de lectura al repo.