Skip to content

The open alternative to Salesforce, designed for AI.

9.4 KB
Raw Blame
---
title: CLI
description: Inicia sesión en un espacio de trabajo, explora sus datos y crea aplicaciones desde tu terminal con la CLI de Twenty.
---

import { PageBanner } from "/snippets/page-banner.mdx"

## Ejecutar la CLI

La CLI `twenty` se conecta a espacios de trabajo de Twenty desde tu terminal. Úsala para inspeccionar metadatos, leer registros, enviar solicitudes de API y crear, sincronizar y depurar aplicaciones. La propia CLI requiere **Node.js 24.5+**. El desarrollo de aplicaciones también necesita una versión de Node compatible con el SDK instalado; consulta [Inicio rápido](/es/developers/extend/apps/getting-started/quick-start#before-you-start).

Ejecuta cualquier comando mediante `npx`, sin una instalación global:

```bash filename="Terminal"
npx twenty@latest --version
```

O instálala globalmente una vez y llama a `twenty` directamente:

```bash filename="Terminal"
npm install -g twenty
twenty --version
```

Los ejemplos siguientes usan `twenty`. Sustituye `twenty` por `npx twenty@latest` si no lo instalaste globalmente. Ejecuta `twenty commands` para ver la lista completa de comandos y `twenty \<command> --help` para ver las opciones de un comando.

| Comando         | Qué hace                                                                                        |
| --------------- | ----------------------------------------------------------------------------------------------- |
| `autenticación` | Iniciar sesión, comprobar y eliminar credenciales                                               |
| `remote`        | Enumera, selecciona, cambia el nombre y elimina las conexiones guardadas del espacio de trabajo |
| `metadatos`     | Inspecciona objetos y campos                                                                    |
| `data`          | Enumera y lee registros                                                                         |
| `api`           | Envía solicitudes REST o GraphQL sin procesar                                                   |
| `open`          | Abre el espacio de trabajo en tu navegador                                                      |
| `aplicación`    | Crea, compila, sincroniza, depura y desinstala aplicaciones                                     |
| `local`         | Comienza, inspecciona, para, actualiza y reinicia un entorno de desarrollo local                |
| `doctor`        | Diagnostica la CLI, el SDK de aplicaciones y la conexión del espacio de trabajo                 |

Cada comando que se comunica con un espacio de trabajo acepta `--remote \<name>` para dirigirse a una conexión guardada distinta de la predeterminada y `--json` para obtener una salida estructurada.

## Conectarse a un espacio de trabajo

Inicia sesión con tu navegador. `--use` convierte esta conexión en la predeterminada:

```bash filename="Terminal"
twenty auth login --url https://acme.twenty.com --use
twenty auth status
```

Usa la dirección de tu espacio de trabajo o la dirección del servidor para una configuración local: `http://localhost:2020` para el [entorno de desarrollo local](/es/developers/extend/apps/getting-started/local-server), `http://localhost:3000` para una copia del código fuente. Puedes copiar el comando exacto desde **Configuración > Desarrolladores > CLI**. El inicio de sesión en el navegador requiere Twenty 2.42 o una versión posterior.

Mantén varias conexiones asignándoles nombres:

```bash filename="Terminal"
twenty auth login --url http://localhost:2020 --name local
twenty remote list
twenty remote use local
```

En CI o scripts, redirige una clave de API en lugar de iniciar sesión con el navegador:

```bash filename="Terminal"
printf '%s' "$TWENTY_API_KEY" | twenty auth login --with-token --url https://acme.twenty.com --name ci
```

También puedes configurar `TWENTY_API_URL` y `TWENTY_API_KEY` para una sola ejecución sin guardar nada. Las conexiones guardadas se almacenan en `~/.twenty/config.json`.

Los comandos seleccionan un espacio de trabajo en este orden:

1. Un `--remote \<name>` explícito, que anula las variables de entorno de destino.
2. `TWENTY_REMOTE`, o el par `TWENTY_API_URL` y `TWENTY_API_KEY`. No combines estos dos métodos.
3. El remoto predeterminado guardado.

`auth login --name \<name>` guarda una conexión, pero mantiene un valor predeterminado existente. Añade `--use`, o ejecuta `twenty remote use \<name>`, para cambiar el valor predeterminado.

## Explorar tus datos

```bash filename="Terminal"
# Objects and fields
twenty metadata object list
twenty metadata field list companies

# Records
twenty data list companies --limit 5
twenty data list companies --filter 'employees[gte]:5000' --order-by 'employees[DescNullsLast]'
twenty data get people <id>

# Raw API requests
twenty api rest '/rest/companies?limit=5'
twenty api graphql --query '{ companies(first: 2) { edges { node { name } } } }'

# Open the workspace, or a page inside it
twenty open
twenty open settings/developers
```

Los nombres de los objetos son nombres exactos de API, en singular o plural (`company` o `companies`). Las escrituras de API sin procesar se ejecutan sin un paso de confirmación, y tus permisos en el espacio de trabajo se siguen aplicando.

## Compilar una aplicación

```bash filename="Terminal"
npx twenty@latest app init my-app
cd my-app
yarn install
npx twenty@latest app apply --create
npx twenty@latest app dev
```

* `app init` escribe un proyecto nuevo a partir de la plantilla. No instala dependencias ni se conecta con un espacio de trabajo.
* `app apply --create` compila la aplicación, la registra en el espacio de trabajo, la instala y sincroniza sus metadatos.
* `app dev` supervisa tu código fuente y sincroniza cada compilación correcta.

Otros comandos de la aplicación:

| Comando                       | Qué hace                                                                         |
| ----------------------------- | -------------------------------------------------------------------------------- |
| `app add`                     | Genera la estructura de un objeto, campo, función de lógica u otra entidad       |
| `app build` / `app typecheck` | Compila o verifica los tipos de la aplicación localmente                         |
| `app plan`                    | Obtén una vista previa de los cambios de metadatos que realizaría una aplicación |
| `app apply`                   | Compila, carga y sincroniza la aplicación                                        |
| `app generate-client`         | Regenera el cliente de API tipado sin sincronizar                                |
| `app pull`                    | Restaurar metadatos, traducciones y dependencias almacenadas                     |
| `app translations extract`    | Extraer cadenas traducibles en catálogos de `locales/`                           |
| `app publish`                 | Publica la aplicación en npm o en un registro privado de Twenty                  |
| `app install`                 | Instala un paquete de aplicación ya registrado en el espacio de trabajo          |
| `app uninstall`               | Elimina la aplicación y todo lo que posee del espacio de trabajo                 |

Las definiciones que faltan en tu código fuente se eliminan del espacio de trabajo de forma predeterminada. Pasa `--no-prune` para conservarlos. La aplicación personalizada del espacio de trabajo los conserva a menos que pases `--prune`. Eliminar objetos o campos también elimina sus datos, por lo que requiere confirmación. Consulta [Sincronización y recuperación](/es/developers/extend/apps/operations/sync-and-recovery) para obtener más detalles.

## Ejecutar funciones

Ejecuta una función de lógica implementada sin activarla mediante una ruta, un cron o un evento de base de datos. Primero sincroniza tus cambios locales con `app apply` o `app dev`.

```bash filename="Terminal"
twenty app exec --name create-new-post-card
twenty app exec --name create-new-post-card --payload '{"name": "Hello"}'

# Install and uninstall hooks
twenty app exec --post-install
twenty app exec --pre-install
twenty app exec --uninstall-hook
```

La ejecución de funciones requiere iniciar sesión en el navegador. Las claves de API no pueden ejecutarlas.

## Supervisar los registros de funciones

Transmite la salida de las funciones de lógica de tu aplicación a medida que finalizan las ejecuciones:

```bash filename="Terminal"
twenty app logs
twenty app logs --name create-new-post-card
```

Solo muestra ejecuciones nuevas, no las anteriores.

## Desinstalar una aplicación

```bash filename="Terminal"
twenty app uninstall
twenty app uninstall --yes
```

Esto ejecuta el enlace de desinstalación de la aplicación y elimina todo lo que posee, incluidos sus objetos, campos y sus datos. La aplicación permanece registrada, por lo que `twenty app apply` puede instalarla de nuevo.

## Diagnosticar problemas

```bash filename="Terminal"
twenty doctor
twenty doctor --offline
```

`doctor` comprueba tu versión de Node, qué binario `twenty` está en tu `PATH`, tus conexiones guardadas y el SDK de aplicaciones, y luego informa de lo que debes corregir.

## Scripts y pruebas

La salida de compilación pertenece a la CLI. No lea `.twenty/output/manifest.json` ni importe código de compilación interno; lea `data.manifest` de `twenty app build --json`.

## Referencia completa

La [referencia de comandos](https://github.com/twentyhq/twenty/blob/main/packages/twenty-cli/docs/commands.md) abarca todas las opciones, permisos, formatos de salida y códigos de salida.

<PageBanner illustration="card-page-cli" />