Skip to content

The open alternative to Salesforce, designed for AI.

9.2 KB
Raw Blame
---
title: CLI
description: Accedi a uno spazio di lavoro, esplora i suoi dati e crea app dal tuo terminale con la CLI di Twenty.
---

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

## Esecuzione della CLI

La CLI `twenty` si connette agli spazi di lavoro Twenty dal tuo terminale. Usala per ispezionare i metadati, leggere i record, inviare richieste API e creare, sincronizzare ed eseguire il debug delle app. La CLI stessa richiede **Node.js 24.5+**. Lo sviluppo di app richiede anche una versione di Node supportata dall'SDK installato; consulta [Avvio rapido](/it/developers/extend/apps/getting-started/quick-start#before-you-start).

Esegui qualsiasi comando tramite `npx`, senza un'installazione globale:

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

In alternativa, installala una volta globalmente e richiama direttamente `twenty`:

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

Gli esempi seguenti usano `twenty`. Sostituisci `twenty` con `npx twenty@latest` se non lo hai installato globalmente. Esegui `twenty commands` per l'elenco completo dei comandi e `twenty \<command> --help` per le opzioni di un comando.

| Comando          | Cosa fa                                                                                 |
| ---------------- | --------------------------------------------------------------------------------------- |
| `autenticazione` | Accedi, verifica e rimuovi le credenziali                                               |
| `remote`         | Elenca, seleziona, rinomina e rimuovi le connessioni salvate allo spazio di lavoro      |
| `metadati`       | Ispeziona oggetti e campi                                                               |
| `data`           | Elenca e leggi i record                                                                 |
| `api`            | Invia richieste REST o GraphQL non elaborate                                            |
| `apri`           | Apri lo spazio di lavoro nel browser                                                    |
| `app`            | Crea, compila, sincronizza, esegui il debug e disinstalla app                           |
| `locale`         | Avviare, ispezionare, fermare, aggiornare e ripristinare un ambiente di sviluppo locale |
| `doctor`         | Diagnostica la CLI, l'SDK dell'app e la connessione allo spazio di lavoro               |

Ogni comando che comunica con uno spazio di lavoro accetta `--remote \<name>` per indirizzare una connessione salvata diversa da quella predefinita e `--json` per un output strutturato.

## Connessione a uno spazio di lavoro

Accedi con il browser. `--use` rende questa connessione quella predefinita:

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

Usa l'indirizzo del tuo spazio di lavoro, oppure l'indirizzo del server per una configurazione locale: `http://localhost:2020` per l'[ambiente di sviluppo locale](/it/developers/extend/apps/getting-started/local-server), `http://localhost:3000` per un checkout del codice sorgente. Puoi copiare il comando esatto da **Settings > Developers > CLI**. L'accesso tramite browser richiede Twenty 2.42 o versioni successive.

Mantieni diverse connessioni assegnando loro un nome:

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

Nella CI o negli script, passa una chiave API tramite pipe invece di accedere con il browser:

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

Puoi anche impostare `TWENTY_API_URL` e `TWENTY_API_KEY` per una singola esecuzione senza salvare nulla. Le connessioni salvate si trovano in `~/.twenty/config.json`.

I comandi selezionano un workspace in questo ordine:

1. Un elemento esplicito `--remote \<name>`, che sovrascrive le variabili di ambiente di destinazione.
2. `TWENTY_REMOTE`, oppure la coppia `TWENTY_API_URL` e `TWENTY_API_KEY`. Non combinare questi due metodi.
3. Il remote predefinito salvato.

`auth login --name \<name>` salva una connessione ma mantiene un valore predefinito esistente. Aggiungi `--use` oppure esegui `twenty remote use \<name>` per modificare il valore predefinito.

## Esplorazione dei dati

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

I nomi degli oggetti sono nomi API esatti, al singolare o al plurale (`company` o `companies`). Le scritture API non elaborate vengono eseguite senza un passaggio di conferma e le autorizzazioni nello spazio di lavoro continuano ad applicarsi.

## Compilazione di un'app

```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` scrive un nuovo progetto a partire dal modello. Non installa dipendenze né contatta uno spazio di lavoro.
* `app apply --create` compila l'app, la registra nello spazio di lavoro, la installa e sincronizza i relativi metadati.
* `app dev` monitora il codice sorgente e sincronizza ogni build riuscita.

Altri comandi dell'app:

| Comando                       | Cosa fa                                                                           |
| ----------------------------- | --------------------------------------------------------------------------------- |
| `app add`                     | Genera lo scheletro di un oggetto, campo, funzione logica o altra entità          |
| `app build` / `app typecheck` | Compila l'app o esegui il controllo dei tipi localmente                           |
| `app plan`                    | Visualizza in anteprima le modifiche ai metadati che un'applicazione apporterebbe |
| `app apply`                   | Compila, carica e sincronizza l'app                                               |
| `app generate-client`         | Rigenera il client API tipizzato senza sincronizzare                              |
| `app pull`                    | Ripristina i metadati, le traduzioni e le dipendenze archiviate                   |
| `app translations extract`    | Estrai le stringhe traducibili nei cataloghi in `locales/`                        |
| `app publish`                 | Pubblica l'app su npm o in un registro privato Twenty                             |
| `app install`                 | Installa nello spazio di lavoro un pacchetto dell'app già registrato              |
| `app uninstall`               | Rimuovi l'app e tutto ciò che possiede dallo spazio di lavoro                     |

Per impostazione predefinita, le definizioni mancanti dal codice sorgente vengono eliminate dallo spazio di lavoro. Passa `--no-prune` per mantenerli. L'applicazione Custom dell'area di lavoro li mantiene a meno che non passi `--prune`. L'eliminazione di oggetti o campi elimina anche i relativi dati, quindi richiede conferma. Per i dettagli, consulta [Sincronizzazione e ripristino](/it/developers/extend/apps/operations/sync-and-recovery).

## Esecuzione di funzioni

Esegui una funzione logica distribuita senza attivarla tramite un percorso, un cron o un evento del database. Prima sincronizza le modifiche locali 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
```

L'esecuzione delle funzioni richiede l'accesso tramite browser. Le chiavi API non possono eseguirle.

## Monitoraggio dei log delle funzioni

Trasmetti in streaming l'output delle funzioni logiche dell'app al termine delle esecuzioni:

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

Mostra solo le nuove esecuzioni, non quelle precedenti.

## Disinstallazione di un'app

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

Esegue l'hook di disinstallazione dell'app ed elimina tutto ciò che possiede, inclusi gli oggetti, i campi e i relativi dati. L'app rimane registrata, quindi `twenty app apply` può installarla di nuovo.

## Diagnosi dei problemi

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

`doctor` controlla la versione di Node, quale binario `twenty` si trova nel tuo `PATH`, le connessioni salvate e l'SDK dell'app, quindi segnala cosa correggere.

## Script e test

L'output di build appartiene alla CLI. Non leggere `.twenty/output/manifest.json` né importare codice di build interno; leggi `data.manifest` da `twenty app build --json`.

## Riferimento completo

Il [riferimento dei comandi](https://github.com/twentyhq/twenty/blob/main/packages/twenty-cli/docs/commands.md) descrive ogni flag, autorizzazione, formato di output e codice di uscita.

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