The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
---
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" />