Skip to content

The open alternative to Salesforce, designed for AI.

9.2 KB
Raw Blame
---
title: CLI
description: Autentifică-te într-un spațiu de lucru, explorează datele acestuia și creează aplicații din terminal folosind CLI-ul Twenty.
---

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

## Rularea CLI-ului

CLI-ul `twenty` se conectează la spațiile de lucru Twenty din terminalul dvs. Folosiți-l pentru a inspecta metadatele, a citi înregistrări, a trimite solicitări API și a crea, sincroniza și depana aplicații. CLI-ul însuși necesită **Node.js 24.5+**. Dezvoltarea aplicațiilor necesită, de asemenea, o versiune Node acceptată de SDK-ul instalat; consultați [Pornire rapidă](/ro/developers/extend/apps/getting-started/quick-start#before-you-start).

Rulați orice comandă prin `npx`, fără o instalare globală:

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

Sau instalați-l o singură dată la nivel global și apelați `twenty` direct:

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

Exemplele de mai jos folosesc `twenty`. Înlocuiți `twenty` cu `npx twenty@latest` dacă nu l-ați instalat global. Rulați `twenty commands` pentru lista completă de comenzi și `twenty \<command> --help` pentru opțiunile unei comenzi.

| Comandă         | Ce face                                                                                |
| --------------- | -------------------------------------------------------------------------------------- |
| `autentificare` | Autentificați-vă, verificați și eliminați acreditările                                 |
| `remote`        | Enumerați, selectați, redenumiți și eliminați conexiunile salvate la spațiile de lucru |
| `metadate`      | Inspectați obiecte și câmpuri                                                          |
| `data`          | Enumerați și citiți înregistrări                                                       |
| `api`           | Trimiteți cereri REST sau GraphQL brute                                                |
| `open`          | Deschideți spațiul de lucru în browser                                                 |
| `aplicație`     | Creați, compilați, sincronizați, depanați și dezinstalați aplicații                    |
| `local`         | Începeți, inspectați, opriți, actualizați și resetați mediul de dezvoltare locală      |
| `doctor`        | Diagnosticați CLI-ul, SDK-ul aplicației și conexiunea la spațiul de lucru              |

Fiecare comandă care comunică cu un spațiu de lucru acceptă `--remote \<name>` pentru a viza o conexiune salvată alta decât cea implicită și `--json` pentru ieșire structurată.

## Conectarea la un spațiu de lucru

Autentificați-vă cu browserul. `--use` face din această conexiune conexiunea implicită:

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

Utilizați adresa spațiului dvs. de lucru sau adresa serverului pentru o configurare locală: `http://localhost:2020` pentru [mediul de dezvoltare local](/ro/developers/extend/apps/getting-started/local-server), `http://localhost:3000` pentru o copie locală a codului sursă. Puteți copia comanda exactă din **Settings > Developers > CLI**. Autentificarea prin browser necesită Twenty 2.42 sau o versiune ulterioară.

Păstrați mai multe conexiuni denumindu-le:

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

În CI sau scripturi, redirecționați o cheie API în loc să vă autentificați cu browserul:

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

De asemenea, puteți seta `TWENTY_API_URL` și `TWENTY_API_KEY` pentru o singură rulare fără a salva nimic. Conexiunile salvate se află în `~/.twenty/config.json`.

Comenzile selectează un spațiu de lucru în această ordine:

1. Un `--remote \<name>` explicit, care suprascrie variabilele de mediu țintă.
2. `TWENTY_REMOTE` sau perechea `TWENTY_API_URL` și `TWENTY_API_KEY`. Nu combinați aceste două metode.
3. Remote-ul implicit salvat.

`auth login --name \<name>` salvează o conexiune, dar păstrează un remote implicit existent. Adăugați `--use` sau rulați `twenty remote use \<name>` pentru a schimba remote-ul implicit.

## Explorarea datelor

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

Numele obiectelor sunt nume API exacte, la singular sau plural (`company` sau `companies`). Scrierile API brute se execută fără un pas de confirmare, iar permisiunile din spațiul de lucru se aplică în continuare.

## Construirea unei aplicații

```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` scrie un proiect nou din șablon. Nu instalează dependențe și nu contactează un spațiu de lucru.
* `app apply --create` compilează aplicația, o înregistrează în spațiul de lucru, o instalează și îi sincronizează metadatele.
* `app dev` monitorizează sursa și sincronizează fiecare compilare reușită.

Alte comenzi pentru aplicații:

| Comandă                       | Ce face                                                                 |
| ----------------------------- | ----------------------------------------------------------------------- |
| `app add`                     | Generează structura unui obiect, câmp, funcții logice sau alte entități |
| `app build` / `app typecheck` | Compilați sau verificați tipurile aplicației local                      |
| `app plan`                    | Previzualizați modificările de metadate pe care le-ar face o aplicare   |
| `app apply`                   | Compilați, încărcați și sincronizați aplicația                          |
| `app generate-client`         | Regenerați clientul API tipizat fără sincronizare                       |
| `app pull`                    | Restaurează metadatele, traducerile și dependențele stocate             |
| `app translations extract`    | Extrage șirurile traducibile în cataloagele din `locales/`              |
| `app publish`                 | Publicați aplicația pe npm sau într-un registru privat Twenty           |
| `app install`                 | Instalați în spațiul de lucru un pachet de aplicație deja înregistrat   |
| `app uninstall`               | Eliminați aplicația și tot ce îi aparține din spațiul de lucru          |

Definițiile care lipsesc din sursă sunt șterse implicit din spațiul de lucru. Transmiteți `--no-prune` pentru a le păstra. Aplicația Personalizată pentru spațiul de lucru le păstrează dacă nu transmiteți `--prune`. Ștergerea obiectelor sau a câmpurilor șterge și datele acestora, deci necesită confirmare. Consultați [Sincronizare și recuperare](/ro/developers/extend/apps/operations/sync-and-recovery) pentru detalii.

## Executarea funcțiilor

Rulați o funcție logică implementată fără a o declanșa printr-o rută, un cron sau un eveniment de bază de date. Sincronizați mai întâi modificările locale cu `app apply` sau `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
```

Executarea funcțiilor necesită autentificare prin browser. Cheile API nu le pot executa.

## Monitorizarea jurnalelor funcțiilor

Transmiteți în flux ieșirea funcțiilor logice ale aplicației pe măsură ce execuțiile se finalizează:

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

Afișează doar execuțiile noi, nu și pe cele anterioare.

## Dezinstalarea unei aplicații

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

Aceasta execută cârligul de dezinstalare al aplicației și șterge tot ce îi aparține, inclusiv obiectele, câmpurile și datele lor. Aplicația rămâne înregistrată, astfel încât `twenty app apply` o poate instala din nou.

## Diagnosticarea problemelor

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

`doctor` verifică versiunea Node, ce binar `twenty` se află în `PATH`, conexiunile salvate și SDK-ul aplicației, apoi raportează ce trebuie remediat.

## Scripturi și teste

Rezultatul compilării aparține CLI-ului. Nu citiți `.twenty/output/manifest.json` și nu importați cod intern de compilare; citiți `data.manifest` din `twenty app build --json`.

## Referință completă

[Referința comenzilor](https://github.com/twentyhq/twenty/blob/main/packages/twenty-cli/docs/commands.md) acoperă fiecare opțiune, permisiune, format de ieșire și cod de ieșire.

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