> ## Documentation Index
> Fetch the complete documentation index at: https://docs.base44.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Base44 CLI

> Crea y gestiona apps de Base44 (proyectos) usando la herramienta CLI de Base44.

<Warning>
  Esta página es parte de una habilidad de agente de codificación con IA y está escrita para agentes, no para humanos. Para la documentación de Base44 legible por humanos, consulta la [documentación para desarrolladores](/developers).
</Warning>

# Base44 CLI

Crea y gestiona apps de Base44 (proyectos) usando la herramienta CLI de Base44.

## ⚡ ACCIÓN INMEDIATA REQUERIDA - Lee esto primero

Esta habilidad se activa ante CUALQUIER mención de "base44" o cuando existe una carpeta `base44/`. **NO leas archivos de documentación ni busques en la web antes de actuar.**

**Tu primera acción DEBE ser:**

1. Comprueba si `base44/config.jsonc` existe en el directorio actual
2. Si **SÍ** (escenario de proyecto existente):
   * Transfiere a la habilidad base44-sdk para la implementación
   * Esta habilidad solo maneja comandos CLI (login, deploy, entities push)
3. Si **NO**, decide entre dos rutas de inicialización:
   * **App aprovisionada** — la app de Base44 ya existe porque acaba de aprovisionarse a través de un flujo Stripe Projects / projects.dev, O `BASE44_APP_ID` (o `BASE44_PROJECTS_BASE44_APP_ID`) está presente en el entorno o en un archivo `.env`/`.env.local`:
     * Ejecuta `npx base44 scaffold` para configurar los archivos locales para esa app **existente**
     * **NO ejecutes `npx base44 create`** — eso crea una segunda app duplicada. Consulta [scaffold.md](https://docs.base44.com/developers/skills/base44-cli/references/scaffold.md).
   * **Nuevo proyecto** — no existe ninguna app aún y ninguna fue aprovisionada:
     * Esta habilidad (base44-cli) maneja la solicitud; guía al usuario a través de `npx base44 create`
     * NO actives base44-sdk aún

## Crítico: solo instalación local

NUNCA llames a `base44` directamente. La CLI se instala localmente como una dependencia de desarrollo y debe accederse mediante un gestor de paquetes:

* `npx base44 <command>` (npm - recomendado)
* `yarn base44 <command>` (yarn)
* `pnpm base44 <command>` (pnpm)

INCORRECTO: `base44 login`
CORRECTO: `npx base44 login`

## OBLIGATORIO: Comprobación de autenticación al inicio de la sesión

**CRÍTICO**: Al principio de cada sesión de IA cuando se activa esta habilidad, DEBES:

1. **Comprobar el estado de autenticación** ejecutando:
   ```bash theme={null}
   npx base44 whoami
   ```

2. **Si el usuario ha iniciado sesión** (el comando tiene éxito y muestra un correo):
   * Continúa con la tarea solicitada

3. **Si el usuario NO ha iniciado sesión** (el comando falla o muestra un error):
   * **DETENTE inmediatamente**
   * **NO procedas** con ninguna operación CLI
   * **Pide al usuario que inicie sesión manualmente** ejecutando:
     ```bash theme={null}
     npx base44 login
     ```
   ```
   - Espera a que el usuario confirme que ha iniciado sesión antes de continuar
   ```

**Esta comprobación es obligatoria y debe suceder antes de ejecutar cualquier otro comando de Base44 CLI.**

**¿Aprovisionado mediante Stripe Projects / projects.dev?** Cuando la app se aprovisionó mediante ese flujo, la CLI inicia la autenticación desde las variables de entorno `BASE44_ACCESS_TOKEN` / `BASE44_REFRESH_TOKEN` que inyecta (los nombres con prefijo `BASE44_PROJECTS_*` se normalizan automáticamente). En ese caso, `npx base44 whoami` ya tiene éxito y **no** necesitas un `npx base44 login` interactivo.

## Descripción general

La CLI de Base44 proporciona herramientas de línea de comandos para autenticación, creación de proyectos, gestión de entidades y despliegue de aplicaciones de Base44. Es agnóstica al framework y funciona con frameworks frontend populares como Vite, Next.js y Create React App, Svelte, Vue y más.

## Cuándo usar esta habilidad vs base44-sdk

**Usa base44-cli cuando:**

* Crees un proyecto de Base44 **NUEVO** desde cero
* Inicialices un proyecto en un directorio vacío
* Configures archivos locales para una app **existente** que se aprovisionó externamente (por ejemplo, a través de un flujo Stripe Projects / projects.dev) → usa `scaffold`
* Al directorio le falta `base44/config.jsonc`
* El usuario menciona: "crear un nuevo proyecto", "inicializar proyecto", "configurar un proyecto", "iniciar una nueva app de Base44"
* Desplegando, enviando entidades o autenticando mediante CLI
* Trabajando con comandos CLI (`npx base44 ...`)

**Usa base44-sdk cuando:**

* Construyas funciones en un proyecto de Base44 **EXISTENTE**
* `base44/config.jsonc` ya existe
* Escribas código JavaScript/TypeScript usando el SDK de Base44
* Implementes funcionalidad, componentes o funciones
* El usuario menciona: "implementar", "construir una función", "añadir funcionalidad", "escribir código"

**Dependencias de habilidad:**

* `base44-cli` es un **requisito previo** para `base44-sdk` en nuevos proyectos
* Si el usuario quiere "crear una app" y no existe un proyecto de Base44, usa `base44-cli` primero
* `base44-sdk` asume que un proyecto de Base44 ya está inicializado

**Lógica de comprobación de estado:**
Antes de seleccionar una habilidad, comprueba:

* SI (el usuario menciona "crear/construir app" O "hacer un proyecto"):
  * SI (`base44/config.jsonc` existe):
    → Usa **base44-sdk** (el proyecto existe, construye funciones)
  * SI NO SI (la app fue aprovisionada externamente — `BASE44_APP_ID`/`BASE44_PROJECTS_BASE44_APP_ID` está establecido, o un flujo Stripe Projects / projects.dev acaba de ejecutarse):
    → Usa **base44-cli** → `npx base44 scaffold` (configura archivos locales para la app existente; NO `create`)
  * SI NO:
    → Usa **base44-cli** → `npx base44 create` (se necesita inicialización de nuevo proyecto)

## Estructura del proyecto

Un proyecto de Base44 combina un proyecto frontend estándar con una carpeta de configuración `base44/`:

```
my-app/
├── base44/                      # Configuración de Base44 (creada por CLI)
│   ├── config.jsonc             # Configuración del proyecto, configuración del sitio
│   ├── .types/                  # Tipos TypeScript autogenerados (creado por `types generate`)
│   │   └── types.d.ts           # Augmentación de módulo para @base44/sdk
│   ├── entities/                # Definiciones de esquemas de entidades
│   │   ├── task.jsonc
│   │   └── board.jsonc
│   ├── functions/               # Funciones de backend (opcional)
│   │   └── my-function/
│   │       └── entry.ts
│   ├── agents/                  # Configuraciones de agentes (opcional)
│   │   └── support_agent.jsonc
│   └── connectors/              # Configuraciones de conectores OAuth (opcional)
│       └── googlecalendar.jsonc
├── src/                         # Código fuente del frontend
│   ├── api/
│   │   └── base44Client.js      # Cliente SDK de Base44
│   ├── pages/
│   ├── components/
│   └── main.jsx
├── index.html                   # Punto de entrada de SPA
├── package.json
└── vite.config.js               # O la configuración de tu framework
```

**Archivos clave:**

* `base44/config.jsonc` - Nombre del proyecto, descripción, configuración de compilación del sitio
* `base44/entities/*.jsonc` - Esquemas de modelo de datos (ver sección Esquema de entidad)
* `base44/functions/*/entry.ts` - Punto de entrada de función de backend
* `base44/agents/*.jsonc` - Configuraciones de agentes (opcional)
* `base44/.types/types.d.ts` - Tipos TypeScript autogenerados para entidades, funciones y agentes (creados por `npx base44 types generate`)
* `base44/connectors/*.jsonc` - Configuraciones de conectores OAuth (opcional)
* `src/api/base44Client.js` - Cliente SDK preconfigurado para uso frontend

**Ejemplo de config.jsonc:**

```jsonc theme={null}
{
  "name": "My App",                    // Requerido: nombre del proyecto
  "description": "App description",    // Opcional: descripción del proyecto
  "entitiesDir": "./entities",         // Opcional: por defecto "entities"
  "functionsDir": "./functions",       // Opcional: por defecto "functions"
  "agentsDir": "./agents",             // Opcional: por defecto "agents"
  "connectorsDir": "./connectors",     // Opcional: por defecto "connectors"
  "site": {                            // Opcional: configuración de despliegue del sitio
    "installCommand": "npm install",   // Opcional: instalar dependencias
    "buildCommand": "npm run build",   // Opcional: comando de compilación
    "serveCommand": "npm run dev",     // Opcional: servidor de desarrollo local
    "outputDirectory": "./dist"        // Opcional: directorio de salida de compilación
  }
}
```

**Propiedades de configuración:**

| Propiedad              | Descripción                                         | Predeterminado |
| ---------------------- | --------------------------------------------------- | -------------- |
| `name`                 | Nombre del proyecto (requerido)                     | -              |
| `description`          | Descripción del proyecto                            | -              |
| `entitiesDir`          | Directorio para esquemas de entidades               | `"entities"`   |
| `functionsDir`         | Directorio para funciones de backend                | `"functions"`  |
| `agentsDir`            | Directorio para configuraciones de agentes          | `"agents"`     |
| `connectorsDir`        | Directorio para configuraciones de conectores       | `"connectors"` |
| `site.installCommand`  | Comando para instalar dependencias                  | -              |
| `site.buildCommand`    | Comando para compilar el proyecto                   | -              |
| `site.serveCommand`    | Comando para ejecutar el servidor de desarrollo     | -              |
| `site.outputDirectory` | Directorio de salida de compilación para despliegue | -              |

## Instalación

Instala la CLI de Base44 como una dependencia de desarrollo en tu proyecto:

```bash theme={null}
npm install --save-dev base44
```

**Importante:** Nunca asumas ni codifiques la versión del paquete `base44`. Instala siempre sin un especificador de versión para obtener la última versión.

Luego ejecuta comandos usando `npx`:

```bash theme={null}
npx base44 <command>
```

**Nota:** Todos los comandos en esta documentación usan `npx base44`. También puedes usar `yarn base44` o `pnpm base44` si lo prefieres.

## Opción global `--app-id`

La CLI tiene una opción global `--app-id <id>` para comandos que solo necesitan un contexto de app, no archivos de proyecto locales.

**Orden de resolución:** bandera `--app-id` → variable de entorno `BASE44_APP_ID` → `base44/.app.jsonc` local

Esto es útil cuando quieres inspeccionar u operar en una app sin cambiar a un directorio de proyecto vinculado. Ejemplos comunes:

```bash theme={null}
# Ejecutar un script único contra una app específica
cat ./script.ts | npx base44 exec --app-id app_123

# Obtener registros para una app desplegada sin un checkout local
npx base44 logs --app-id app_123 --level error
```

Usa `--app-id` para comandos con alcance de app como `exec` y `logs`.

**No** uses `--app-id` para comandos que necesitan archivos de proyecto locales:

* `base44 create` crea una nueva app, por lo que rechaza `--app-id`
* `base44 dev` se ejecuta desde un proyecto local vinculado, por lo que rechaza `--app-id`
* `base44 deploy` aún requiere un directorio de proyecto local porque lee recursos locales

## Comandos disponibles

### Autenticación

| Comando         | Descripción                                                   | Referencia                                                                                       |
| --------------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| `base44 login`  | Autentica con Base44 usando el flujo de código de dispositivo | [auth-login.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-login.md)   |
| `base44 logout` | Cierra sesión del dispositivo actual                          | [auth-logout.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-logout.md) |
| `base44 whoami` | Muestra el usuario autenticado actualmente                    | [auth-whoami.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-whoami.md) |

### Gestión de proyectos

| Comando                 | Descripción                                                                             | Referencia                                                                                                |
| ----------------------- | --------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
| `base44 create`         | Crea un nuevo proyecto de Base44 desde una plantilla                                    | [create.md](https://docs.base44.com/developers/skills/base44-cli/references/create.md) ⚠️ **DEBE LEERSE** |
| `base44 scaffold`       | Genera la estructura de un proyecto local para una app de Base44 existente (por app ID) | [scaffold.md](https://docs.base44.com/developers/skills/base44-cli/references/scaffold.md)                |
| `base44 link`           | Vincula un proyecto local existente a Base44                                            | [link.md](https://docs.base44.com/developers/skills/base44-cli/references/link.md)                        |
| `base44 eject`          | Descarga el código de un proyecto de Base44 existente                                   | [eject.md](https://docs.base44.com/developers/skills/base44-cli/references/eject.md)                      |
| `base44 dashboard open` | Abre el panel de la app en tu navegador                                                 | [dashboard.md](https://docs.base44.com/developers/skills/base44-cli/references/dashboard.md)              |

### Desarrollo

| Comando      | Descripción                                                                                                             | Referencia                                                                       |
| ------------ | ----------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
| `base44 dev` | Inicia el desarrollo local para tu backend de Base44, y tu frontend también cuando `site.serveCommand` está configurado | [dev.md](https://docs.base44.com/developers/skills/base44-cli/references/dev.md) |

### Despliegue

| Comando         | Descripción                                                                                                      | Referencia                                                                             |
| --------------- | ---------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
| `base44 deploy` | Despliega todos los recursos (entidades, funciones, agentes, conectores, configuración de autenticación y sitio) | [deploy.md](https://docs.base44.com/developers/skills/base44-cli/references/deploy.md) |

### Gestión de entidades

| Acción / Comando       | Descripción                                        | Referencia                                                                                                              |
| ---------------------- | -------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| Crear entidades        | Define entidades en la carpeta `base44/entities`   | [entities-create.md](https://docs.base44.com/developers/skills/base44-cli/references/entities-create.md)                |
| `base44 entities push` | Envía entidades locales a Base44                   | [entities-push.md](https://docs.base44.com/developers/skills/base44-cli/references/entities-push.md)                    |
| Patrones RLS           | Ejemplos y operadores de seguridad a nivel de fila | [rls-examples.md](https://docs.base44.com/developers/skills/base44-cli/references/rls-examples.md) ⚠️ **LEER PARA RLS** |

#### Esquema de entidad (referencia rápida)

Sigue SIEMPRE esta estructura exacta al crear archivos de entidad:

**Nomenclatura de archivos:** `base44/entities/{kebab-case-name}.jsonc` (por ejemplo, `team-member.jsonc` para `TeamMember`)

**Plantilla de esquema:**

```jsonc theme={null}
{
  "name": "EntityName",
  "type": "object",
  "properties": {
    "field_name": {
      "type": "string",
      "description": "Field description"
    }
  },
  "required": ["field_name"]
}
```

**Tipos de campo:** `string`, `number`, `integer`, `boolean`, `array`, `object`, `binary`
**Formatos de string:** `date`, `date-time`, `time`, `email`, `uri`, `hostname`, `ipv4`, `ipv6`, `uuid`, `file`, `regex`, `richtext`
**Para enums:** Añade `"enum": ["value1", "value2"]` y opcionalmente `"default": "value1"`
**Nombres de entidad:** Deben ser solo alfanuméricos (patrón: `/^[a-zA-Z0-9]+$/`)

Para documentación completa, consulta [entities-create.md](https://docs.base44.com/developers/skills/base44-cli/references/entities-create.md).

### Gestión de funciones

| Acción / Comando                               | Descripción                                                                                              | Referencia                                                                                                 |
| ---------------------------------------------- | -------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| Crear funciones                                | Define funciones en `base44/functions`                                                                   | [functions-create.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-create.md) |
| `base44 functions deploy [names...] [--force]` | Despliega funciones locales a Base44; opcionalmente apunta a funciones específicas o poda las eliminadas | [functions-deploy.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-deploy.md) |
| `base44 functions delete <names...>`           | Elimina una o más funciones desplegadas de Base44                                                        | [functions-delete.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-delete.md) |
| `base44 functions list`                        | Lista todas las funciones desplegadas en el remoto de Base44                                             | [functions-list.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-list.md)     |
| `base44 functions pull [name]`                 | Extrae funciones desplegadas de Base44 a archivos locales                                                | [functions-pull.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-pull.md)     |

### Gestión de agentes

Los agentes son asistentes de IA conversacionales que pueden interactuar con los usuarios, acceder a las entidades de tu app y llamar a funciones de backend. Usa estos comandos para gestionar las configuraciones de los agentes.

| Acción / Comando     | Descripción                                  | Referencia                                                                                       |
| -------------------- | -------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| Crear agentes        | Define agentes en la carpeta `base44/agents` | Ver Esquema de agente abajo                                                                      |
| `base44 agents pull` | Extrae agentes remotos a archivos locales    | [agents-pull.md](https://docs.base44.com/developers/skills/base44-cli/references/agents-pull.md) |
| `base44 agents push` | Envía agentes locales a Base44               | [agents-push.md](https://docs.base44.com/developers/skills/base44-cli/references/agents-push.md) |

**Nota:** Los comandos de agentes realizan una sincronización completa - enviar reemplaza todos los agentes remotos con los locales, y extraer reemplaza todos los agentes locales con los remotos.

#### Esquema de agente (referencia rápida)

**Nomenclatura de archivos:** `base44/agents/{agent_name}.jsonc` (por ejemplo, `support_agent.jsonc`)

**Plantilla de esquema:**

```jsonc theme={null}
{
  "name": "agent_name",
  "description": "Brief description of what this agent does",
  "instructions": "Detailed instructions for the agent's behavior",
  "tool_configs": [
    // Herramienta de entidad - da al agente acceso a operaciones de entidad
    { "entity_name": "tasks", "allowed_operations": ["read", "create", "update", "delete"] },
    // Herramienta de función de backend - da al agente acceso a una función
    { "function_name": "send_email", "description": "Send an email notification" }
  ],
  "whatsapp_greeting": "Hello! How can I help you today?"
}
```

**Reglas de nombres:**

* Los nombres de agente deben coincidir con el patrón: `/^[a-z0-9_]+$/` (alfanumérico en minúsculas con guiones bajos, 1-100 caracteres)
* Válido: `support_agent`, `order_bot`
* Inválido: `Support-Agent`, `OrderBot`

**Campos requeridos:** `name`, `description`, `instructions`
**Campos opcionales:** `tool_configs` (por defecto `[]`), `whatsapp_greeting`

**Tipos de configuración de herramienta:**

* **Herramientas de entidad**: `entity_name` + `allowed_operations` (array de: `read`, `create`, `update`, `delete`)
* **Herramientas de función de backend**: `function_name` + `description`

### Gestión de conectores

Los conectores permiten a tu app conectarse a servicios externos (Google Calendar, Slack, Stripe, etc.). La mayoría de los conectores usan OAuth para proporcionar tokens de acceso para que las funciones de backend llamen a APIs externas. Stripe es la excepción — se aprovisiona automáticamente del lado del servidor sin un flujo OAuth de navegador.

| Acción / Comando                   | Descripción                                                | Referencia                                                                                                                   |
| ---------------------------------- | ---------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| Crear conectores                   | Define conectores en la carpeta `base44/connectors`        | [connectors-create.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-create.md)                 |
| `base44 connectors list-available` | Lista todos los tipos de integración disponibles de Base44 | [connectors-list-available.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-list-available.md) |
| `base44 connectors pull`           | Extrae conectores remotos a archivos locales               | [connectors-pull.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-pull.md)                     |
| `base44 connectors push`           | Envía conectores locales a Base44                          | [connectors-push.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-push.md)                     |

**Nota:** Los comandos de conectores realizan una sincronización completa - enviar reemplaza todos los conectores remotos con los locales (y activa OAuth para nuevos conectores OAuth), y extraer reemplaza todos los conectores locales con los remotos.

#### Esquema de conector (referencia rápida)

**Nomenclatura de archivos:** `base44/connectors/{type}.jsonc` (por ejemplo, `googlecalendar.jsonc`, `slack.jsonc`)

**Plantilla de esquema:**

```jsonc theme={null}
{
  "type": "googlecalendar",
  "scopes": [
    "https://www.googleapis.com/auth/calendar.readonly",
    "https://www.googleapis.com/auth/calendar.events"
  ]
}
```

**Campos requeridos:** `type`
**Campos opcionales:** `scopes` (por defecto `[]`)

**Tipos de conectores disponibles:** Ejecuta `npx base44 connectors list-available` para ver todos los tipos de integración admitidos.

**Nota:** `stripe` también es un tipo de conector válido pero no lo devuelve `list-available`. Trátalo como un tipo admitido — se aprovisiona automáticamente por Base44 sin un flujo OAuth de navegador. Consulta [connectors-create.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-create.md) para más detalles.

Para documentación completa, consulta [connectors-create.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-create.md).

### Configuración de autenticación

Gestiona la configuración de autenticación de tu app (por ejemplo, inicio de sesión con nombre de usuario y contraseña). La configuración de autenticación se almacena en `base44/auth/` y se sincroniza con Base44 mediante `auth push`/`auth pull`.

| Comando                                                 | Descripción                                                                            | Referencia                                                                                                       |
| ------------------------------------------------------- | -------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| `base44 auth password-login <enable\|disable>`          | Habilita o deshabilita la autenticación con nombre de usuario y contraseña             | [auth-password-login.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-password-login.md) |
| `base44 auth social-login <provider> <enable\|disable>` | Habilita o deshabilita el inicio de sesión social (google, microsoft, facebook, apple) | [auth-social-login.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-social-login.md)     |
| `base44 auth sso <enable\|disable>`                     | Configura el proveedor de identidad SSO (google, microsoft, github, okta, custom)      | [auth-sso.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-sso.md)                       |
| `base44 auth pull`                                      | Extrae la configuración de autenticación de Base44 a archivos locales                  | [auth-pull.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-pull.md)                     |
| `base44 auth push`                                      | Envía la configuración de autenticación local a Base44                                 | [auth-push.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-push.md)                     |

**Nota:** La configuración de autenticación también se despliega como parte de `base44 deploy`.

### Gestión de secretos

Gestiona los secretos del proyecto (variables de entorno almacenadas de forma segura en Base44). Estos comandos están ocultos en la salida de `--help` pero son totalmente funcionales.

| Comando                       | Descripción                                           | Referencia                                                                                             |
| ----------------------------- | ----------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| `base44 secrets list`         | Lista los nombres de todos los secretos               | [secrets-list.md](https://docs.base44.com/developers/skills/base44-cli/references/secrets-list.md)     |
| `base44 secrets set`          | Establece uno o más secretos (KEY=VALUE o --env-file) | [secrets-set.md](https://docs.base44.com/developers/skills/base44-cli/references/secrets-set.md)       |
| `base44 secrets delete <key>` | Elimina un secreto por nombre                         | [secrets-delete.md](https://docs.base44.com/developers/skills/base44-cli/references/secrets-delete.md) |

### Ejecución de scripts

Ejecuta scripts únicos contra tu app con el SDK de Base44 preautenticado. Úsalo para realizar operaciones CRUD en entidades (`base44.entities.MyEntity.list/create/update/delete`), llamar a funciones de backend (`base44.functions.invoke("myFunction", args)`), invocar agentes o acceder a cualquier otro recurso expuesto por el SDK — sin desplegar una función completa. Útil para migraciones de datos, operaciones en masa, depuración y flujos de trabajo con scripts.

| Comando       | Descripción                                                            | Referencia                                                                         |
| ------------- | ---------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| `base44 exec` | Ejecuta un script (mediante stdin) con el SDK de Base44 preautenticado | [exec.md](https://docs.base44.com/developers/skills/base44-cli/references/exec.md) |

### Generación de tipos

| Comando                 | Descripción                                                                             | Referencia                                                                                             |
| ----------------------- | --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| `base44 types generate` | Genera tipos TypeScript (`types.d.ts`) desde entidades, funciones, agentes y conectores | [types-generate.md](https://docs.base44.com/developers/skills/base44-cli/references/types-generate.md) |

**Salida:** `base44/.types/types.d.ts` — aumenta el módulo `@base44/sdk` con registros tipados (`EntityTypeRegistry`, `FunctionNameRegistry`, `AgentNameRegistry`, `ConnectorTypeRegistry`).

**No requiere autenticación.** Se ejecuta completamente localmente. Actualiza automáticamente `tsconfig.json` para incluir los tipos generados.

### Gestión de sitio

| Comando              | Descripción                                                          | Referencia                                                                                       |
| -------------------- | -------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| `base44 site deploy` | Despliega los archivos compilados del sitio al alojamiento de Base44 | [site-deploy.md](https://docs.base44.com/developers/skills/base44-cli/references/site-deploy.md) |
| `base44 site open`   | Abre el sitio desplegado en tu navegador                             | [site-open.md](https://docs.base44.com/developers/skills/base44-cli/references/site-open.md)     |

**Solo SPA**: El alojamiento de Base44 admite aplicaciones de página única (Single Page Applications) con un único punto de entrada `index.html`. Todas las rutas se sirven desde `index.html` (enrutamiento del lado del cliente).

## Inicio rápido

1. Instala la CLI en tu proyecto:
   ```bash theme={null}
   npm install --save-dev base44
   ```

2. Autentícate con Base44:
   ```bash theme={null}
   npx base44 login
   ```

3. Crea un nuevo proyecto (SIEMPRE proporciona el nombre y la bandera `--path`):
   ```bash theme={null}
   npx base44 create my-app --path .
   ```

4. Ejecuta el desarrollo local:
   ```bash theme={null}
   npx base44 dev
   ```

5. Compila y despliega todo:
   ```bash theme={null}
   npm run build
   npx base44 deploy -y
   ```

O despliega recursos individuales:

* `npx base44 entities push` - Envía solo entidades
* `npx base44 functions deploy` - Despliega solo funciones
* `npx base44 functions delete <name>` - Elimina una función desplegada
* `npx base44 functions list` - Lista todas las funciones desplegadas
* `npx base44 functions pull` - Extrae funciones desplegadas a archivos locales
* `npx base44 agents push` - Envía solo agentes
* `npx base44 connectors pull` - Extrae conectores de Base44
* `npx base44 connectors push` - Envía solo conectores
* `npx base44 auth pull` - Extrae la configuración de autenticación de Base44
* `npx base44 auth push` - Envía solo la configuración de autenticación
* `npx base44 site deploy -y` - Despliega solo el sitio

## Flujos de trabajo comunes

### Crear un nuevo proyecto

**⚠️ OBLIGATORIO: Antes de ejecutar `base44 create`, DEBES leer [create.md](https://docs.base44.com/developers/skills/base44-cli/references/create.md) para:**

* **Selección de plantilla** - Elige la plantilla correcta (`backend-and-client` vs `backend-only`)
* **Flujo de trabajo correcto** - Diferentes plantillas requieren diferentes pasos de configuración
* **Errores comunes** - Evita errores de creación de carpetas que causen fallos

No seguir las instrucciones de create.md dará como resultado una estructura de proyecto rota.

### Vincular un proyecto existente

```bash theme={null}
# Si tienes base44/config.jsonc pero no .app.jsonc
npx base44 link --create --name my-app
```

### Ejecutar desarrollo local

```bash theme={null}
# Inicia el backend de Base44 localmente
npx base44 dev
```

Si quieres que `base44 dev` ejecute también tu frontend, verifica que `base44/config.jsonc` tenga `site.serveCommand` establecido correctamente (por ejemplo, `"serveCommand": "npm run dev"`). Cuando ese campo está presente, `base44 dev` ejecuta tanto el backend como el frontend juntos.

### Desplegar todos los cambios

```bash theme={null}
# Genera tipos (opcional, para proyectos TypeScript)
npx base44 types generate

# Compila tu proyecto primero
npm run build

# Despliega todo (entidades, funciones y sitio)
npx base44 deploy -y
```

### Generar tipos TypeScript

```bash theme={null}
# Genera tipos desde entidades, funciones, agentes y conectores
npx base44 types generate
```

Esto crea `base44/.types/types.d.ts` con registros tipados para el módulo `@base44/sdk`. Ejecuta esto después de cambiar entidades, funciones, agentes o conectores para mantener tus tipos sincronizados. No requiere autenticación.

### Desplegar recursos individuales

```bash theme={null}
# Enviar solo entidades
npx base44 entities push

# Desplegar solo funciones (todas)
npx base44 functions deploy
# Desplegar funciones específicas
npx base44 functions deploy my-function other-function
# Desplegar y podar funciones eliminadas
npx base44 functions deploy --force

# Enviar solo agentes
npx base44 agents push

# Extraer conectores de Base44
npx base44 connectors pull

# Enviar solo conectores
npx base44 connectors push

# Desplegar solo sitio
npx base44 site deploy -y
```

### Abrir el panel

```bash theme={null}
# Abrir el panel de la app en el navegador
npx base44 dashboard
```

## Autenticación

La mayoría de los comandos requieren autenticación. Si no has iniciado sesión, la CLI te pedirá automáticamente iniciar sesión. Tu sesión se almacena localmente y persiste entre sesiones de CLI.

## Solución de problemas

| Error                                                | Solución                                                                                                           |
| ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
| No autenticado                                       | Ejecuta `npx base44 login` primero                                                                                 |
| No se encontraron entidades                          | Asegúrate de que las entidades existen en el directorio `base44/entities/`                                         |
| Entidad no reconocida                                | Asegúrate de que el archivo usa nomenclatura kebab-case (por ejemplo, `team-member.jsonc` no `TeamMember.jsonc`)   |
| No se encontraron funciones                          | Asegúrate de que las funciones existen en `base44/functions/` con `entry.ts` o `entry.js`                          |
| No se encontraron agentes                            | Asegúrate de que los agentes existen en el directorio `base44/agents/` con configuraciones `.jsonc` válidas        |
| Nombre de agente inválido                            | Los nombres de agente deben ser alfanuméricos en minúsculas solo con guiones bajos                                 |
| No se encontraron conectores                         | Asegúrate de que los conectores existen en el directorio `base44/connectors/` con configuraciones `.jsonc` válidas |
| Tipo de conector inválido                            | Ejecuta `npx base44 connectors list-available` para ver los tipos válidos                                          |
| Tipo de conector duplicado                           | Cada tipo de conector solo puede definirse una vez por proyecto                                                    |
| Tiempo de espera de autorización de conector agotado | Vuelve a ejecutar `npx base44 connectors push` y completa el flujo OAuth en tu navegador                           |
| No se encontró configuración del sitio               | Comprueba que `site.outputDirectory` está configurado en la configuración del proyecto                             |
| Falla el despliegue del sitio                        | Asegúrate de haber ejecutado `npm run build` primero y de que la compilación tuvo éxito                            |
| Mensaje de actualización disponible                  | Si se te pide actualizar, ejecuta `npm install -g base44@latest` (o usa npx para instalaciones locales)            |

<Note>Esta página fue traducida usando IA. Para obtener la información más precisa y actualizada, consulta la [versión en inglés](/).</Note>