snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-docs/l/ro/developers/extend/apps/getting-started/concepts.mdx

@@ -0,0 +1,102 @@
+---
+title: Concepte
+description: Cum funcționează aplicațiile Twenty — modelul de entități, izolarea (sandboxing) și ciclul de viață al instalării.
+icon: sitemap
+---
+
+Aplicațiile Twenty sunt pachete TypeScript care vă extind spațiul de lucru cu obiecte personalizate, logică, componente UI și capabilități AI. Acestea rulează pe platforma Twenty, cu izolare completă (sandboxing) și controale de permisiuni.
+
+## Cum funcționează aplicațiile
+
+O aplicație este o colecție de **entități** declarate folosind funcțiile `defineEntity()` din pachetul `twenty-sdk`. SDK-ul detectează aceste declarații prin analiză AST în timpul construirii și produce un **manifest** — o descriere completă a ceea ce aplicația dvs. adaugă unui spațiu de lucru. Aceste funcții validează configurația în timpul build-ului și oferă completare automată în IDE și siguranța tipurilor.
+
+```
+your-app/
+├── src/
+│   ├── application-config.ts    ← defineApplication (required, one per app)
+│   ├── roles/                   ← defineRole
+│   ├── objects/                 ← defineObject
+│   ├── fields/                  ← defineField
+│   ├── logic-functions/         ← defineLogicFunction
+│   ├── front-components/        ← defineFrontComponent
+│   ├── skills/                  ← defineSkill
+│   ├── agents/                  ← defineAgent
+│   ├── views/                   ← defineView
+│   ├── navigation-menu-items/   ← defineNavigationMenuItem
+│   └── page-layouts/            ← definePageLayout
+├── public/                      ← Static assets (images, icons)
+└── package.json
+```
+
+<Note>
+  **Organizarea fișierelor ține de dvs.** Detectarea entităților este bazată pe AST — SDK-ul găsește apelurile `export default defineEntity(...)` indiferent unde se află fișierul. Structura de foldere de mai sus este o convenție, nu o cerință.
+</Note>
+
+## Tipuri de entități
+
+| Entitate                          | Scop                                                                                       | Documentație                                                                                                         |
+| --------------------------------- | ------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------- |
+| **Aplicație**                     | Identitatea aplicației, rolul implicit, variabile                                          | [Application Config](/l/ro/developers/extend/apps/config/application)                                                     |
+| **Rol**                           | Seturi de permisiuni pentru obiecte și câmpuri                                             | [Roles & Permissions](/l/ro/developers/extend/apps/config/roles)                                                          |
+| **Obiect**                        | Tipuri de înregistrări personalizate cu câmpuri                                            | [Objects](/l/ro/developers/extend/apps/data/objects)                                                                      |
+| **Câmp**                          | Adăugați câmpuri la obiecte din alte aplicații                                             | [Extending Objects](/l/ro/developers/extend/apps/data/extending-objects)                                                  |
+| **Relație**                       | Legături bidirecționale între obiecte                                                      | [Relations](/l/ro/developers/extend/apps/data/relations)                                                                  |
+| **Funcție logică**                | TypeScript pe partea de server cu declanșatoare                                            | [Funcții logice](/l/ro/developers/extend/apps/logic/logic-functions)                                                      |
+| **Abilitate**                     | Instrucțiuni reutilizabile pentru agenți AI                                                | [Abilități și agenți](/l/ro/developers/extend/apps/logic/skills-and-agents)                                               |
+| **Agent**                         | Agenți AI cu prompturi personalizate                                                       | [Abilități și agenți](/l/ro/developers/extend/apps/logic/skills-and-agents)                                               |
+| **Furnizor de conexiune**         | Date de autentificare OAuth pentru API-uri terțe                                           | [Connections](/l/ro/developers/extend/apps/logic/connections)                                                             |
+| **Vizualizare**                   | Vizualizări preconfigurate ale listelor de înregistrări                                    | [Views](/l/ro/developers/extend/apps/layout/views)                                                                        |
+| **Element de meniu de navigare**  | Intrări personalizate în bara laterală                                                     | [Navigation Menu Items](/l/ro/developers/extend/apps/layout/navigation-menu-items)                                        |
+| **Layout pagină**                 | File și widgeturi pe pagina de detalii a unei înregistrări                                 | [Page Layouts](/l/ro/developers/extend/apps/layout/page-layouts)                                                          |
+| **Componentă front-end**          | Interfață React izolată (sandboxed) în Twenty                                              | [Componente front-end](/l/ro/developers/extend/apps/layout/front-components)                                              |
+| **Dependențe partajate**          | Dependențele partajate de componentele front-end ale aplicației, declarate în package.json | [Dependențe partajate](/l/ro/developers/extend/apps/layout/front-components#sharing-dependencies-across-front-components) |
+| **Element din meniul de comenzi** | Acțiuni rapide și intrări Cmd+K                                                            | [Command Menu Items](/l/ro/developers/extend/apps/layout/command-menu-items)                                              |
+
+## Izolare (sandboxing)
+
+* **Funcțiile logice** rulează în procese Node.js izolate pe server. Acestea accesează datele numai prin clientul API tipizat, care acționează fie ca persoana care a declanșat execuția, fie ca aplicația în sine. Consultați [Ce acces utilizează un apel](/l/ro/developers/extend/apps/logic/logic-functions#whose-access-a-call-uses).
+* **Componentele front-end** rulează în Web Workers folosind Remote DOM — izolate de pagina principală, dar randând elemente DOM native (nu iframes). Acestea comunică cu Twenty printr-un API al gazdei bazat pe transmiterea de mesaje.
+* **Permisiunile** sunt aplicate la nivelul API-ului. Sunt injectate două tokenuri de execuție, ambele derivate din rolul declarat cu `defineApplicationRole()`; cel implicit este restrâns suplimentar la ceea ce poate face persoana care a declanșat execuția, ori de câte ori o persoană se află în spatele execuției.
+
+## Ciclul de viață al aplicației
+
+```
+┌─────────────────────────────────────────────────────────┐
+│ Development                                             │
+│   npx create-twenty-app → yarn twenty dev (live sync)   │
+├─────────────────────────────────────────────────────────┤
+│ Build & Deploy                                          │
+│   yarn twenty dev:build → yarn twenty app:publish        │
+├─────────────────────────────────────────────────────────┤
+│ Install flow                                            │
+│   upload → [pre-install] → metadata migration →         │
+│   generate SDK → [post-install] → … → [uninstall]       │
+├─────────────────────────────────────────────────────────┤
+│ Publish                                                 │
+│   npm publish → appears in Twenty marketplace           │
+└─────────────────────────────────────────────────────────┘
+```
+
+* **`yarn twenty dev`** — monitorizează fișierele sursă și sincronizează în timp real modificările către un server Twenty conectat. Clientul API tipizat este regenerat automat atunci când schema se schimbă.
+* **`yarn twenty dev:build`** — compilează TypeScript, împachetează funcțiile logice și componentele front-end cu esbuild și produce un manifest.
+* **Hook-uri pre/post-instalare și dezinstalare** — funcții opționale care rulează în timpul instalării sau chiar înainte de eliminare. Vezi [Install Hooks](/l/ro/developers/extend/apps/config/install-hooks) pentru detalii.
+
+## Pașii următori
+
+<CardGroup cols={2}>
+  <Card title="Configurare" icon="screwdriver-wrench" href="/l/ro/developers/extend/apps/config/overview">
+    Identitatea aplicației, rolul implicit și hook-urile de instalare și dezinstalare.
+  </Card>
+  <Card title="Date" icon="database" href="/l/ro/developers/extend/apps/data/overview">
+    Obiecte, câmpuri și relații bidirecționale.
+  </Card>
+  <Card title="Logică" icon="bolt" href="/l/ro/developers/extend/apps/logic/overview">
+    Funcții logice, abilități, agenți și conexiuni OAuth.
+  </Card>
+  <Card title="Aspect" icon="table-columns" href="/l/ro/developers/extend/apps/layout/overview">
+    Vizualizări, navigare, layouturi de pagină, componente front-end.
+  </Card>
+  <Card title="Operațiuni" icon="rocket" href="/l/ro/developers/extend/apps/operations/overview">
+    CLI, testare, remote-uri, CI și publicarea aplicației.
+  </Card>
+</CardGroup>

packages/twenty-docs/l/ro/developers/extend/apps/getting-started/local-server.mdx

@@ -0,0 +1,87 @@
+---
+title: Server local
+description: Gestionează serverul Twenty Docker local — pornește, oprește, actualizează, rulează o instanță de testare în paralel și configurează manual SDK-ul.
+icon: server
+---
+
+## Gestionarea serverului local
+
+Folosiți `yarn twenty docker:*` pentru a controla containerul Twenty local:
+
+| Comandă                                | Ce face                                                      |
+| -------------------------------------- | ------------------------------------------------------------ |
+| `yarn twenty docker:start`             | Pornește serverul (descarcă imaginea dacă este necesar)      |
+| `yarn twenty docker:start 2.2.0`       | Pornește o anumită versiune a serverului                     |
+| `yarn twenty docker:start --port 3030` | Pornește pe un port personalizat                             |
+| `yarn twenty docker:stop`              | Oprește serverul (păstrează datele)                          |
+| `yarn twenty docker:status`            | Afișează URL-ul, versiunea și credențialele de autentificare |
+| `yarn twenty docker:logs`              | Transmite în flux jurnalele serverului                       |
+| `yarn twenty docker:reset`             | Șterge datele și pornește de la zero                         |
+| `yarn twenty docker:upgrade`           | Descarcă cea mai recentă imagine `twenty-app-dev`            |
+| `yarn twenty docker:upgrade 2.2.0`     | Actualizează la o versiune specifică                         |
+
+Datele persistă între reporniri în două volume Docker (`twenty-app-dev-data` pentru PostgreSQL, `twenty-app-dev-storage` pentru fișiere). Folosiți `reset` pentru a șterge totul.
+
+## Fixarea versiunii serverului
+
+Când nu este transmisă nicio versiune, `docker:start` rezolvă versiunea din intervalul `engines.twenty` al aplicației tale din `package.json` — același interval față de care serverul validează când aplicația ta este instalată. Pornește cea mai nouă imagine publicată `twenty-app-dev` care satisface intervalul, revenind la `latest` atunci când câmpul lipsește sau nicio versiune publicată nu se potrivește:
+
+```json filename="package.json"
+{
+  "engines": {
+    "twenty": ">=2.2.0"
+  }
+}
+```
+
+Transmite explicit o versiune pentru a suprascrie intervalul pentru o singură rulare: `yarn twenty docker:start 2.3.0`. Dacă un container există deja pe o versiune diferită, `docker:start` îl actualizează pe loc (recreând containerul, dar păstrând volumele tale de date).
+
+## Actualizarea imaginii serverului
+
+`yarn twenty docker:upgrade` descarcă cea mai recentă imagine, compară digest-urile și recreează containerul doar dacă s-a schimbat ceva. Volumele de date sunt păstrate — doar containerul este înlocuit. Dacă a fost descărcată o imagine nouă și containerul rula, actualizarea pornește automat un container nou; rulați apoi `yarn twenty docker:start` pentru a aștepta până când devine funcțional.
+
+```bash filename="Terminal"
+yarn twenty docker:upgrade            # Latest
+yarn twenty docker:upgrade 2.2.0      # Specific version
+```
+
+Puteți verifica versiunea care rulează cu `yarn twenty docker:status` (aceasta afișează `APP_VERSION` încorporat în container).
+
+## Rularea unei instanțe de test în paralel
+
+Adăugați `--test` la orice comandă `docker:*` pentru a gestiona o a doua instanță, complet izolată — utilă pentru teste de integrare sau pentru a experimenta fără a atinge datele principale de dezvoltare:
+
+| Comandă                             | Ce face                                             |
+| ----------------------------------- | --------------------------------------------------- |
+| `yarn twenty docker:start --test`   | Pornește instanța de test (implicit pe portul 2021) |
+| `yarn twenty docker:stop --test`    | Oprește-o                                           |
+| `yarn twenty docker:status --test`  | Afișează-i starea                                   |
+| `yarn twenty docker:logs --test`    | Transmite în flux jurnalele sale                    |
+| `yarn twenty docker:reset --test`   | Șterge-i datele                                     |
+| `yarn twenty docker:upgrade --test` | Actualizează-i imaginea                             |
+
+Instanța de test are propriul container (`twenty-app-dev-test`), propriile volume (`twenty-app-dev-test-data`, `twenty-app-dev-test-storage`) și propria configurație — rulează alături de instanța principală, fără conflicte. Combinați `--test` cu `--port` pentru a înlocui portul 2021.
+
+## Configurare manuală (fără generator)
+
+Săriți peste generatorul de schelet dacă adăugați SDK-ul într-un proiect existent:
+
+```bash filename="Terminal"
+yarn add twenty-sdk twenty-client-sdk
+```
+
+Adăugați scriptul în `package.json`:
+
+```json filename="package.json"
+{
+  "scripts": {
+    "twenty": "twenty"
+  }
+}
+```
+
+Acum puteți rula `yarn twenty dev`, `yarn twenty docker:start` și restul.
+
+<Note>
+Nu instalați `twenty-sdk` global — fixați-l per proiect astfel încât fiecare aplicație să folosească propria versiune.
+</Note>

packages/twenty-docs/l/ro/developers/extend/apps/getting-started/project-structure.mdx

@@ -0,0 +1,79 @@
+---
+title: Structura proiectului
+description: Ce conține o aplicație Twenty generată — fișiere, foldere și ce face fiecare.
+icon: folder-tree
+---
+
+O aplicație nouă generată de `npx create-twenty-app` arată astfel:
+
+```text filename="my-twenty-app/"
+my-twenty-app/
+  package.json
+  src/
+    application-config.ts                   # Required — your app's entry point
+    default-role.ts                         # Permissions for logic functions
+    constants/
+      universal-identifiers.ts              # Auto-generated UUIDs and metadata
+    front-components/
+      main-page.tsx                         # Welcome page component
+    navigation-menu-items/
+      main-page.navigation-menu-item.ts     # Sidebar entry for the welcome page
+    page-layouts/
+      main-page.page-layout.ts              # Standalone page hosting the component
+    __tests__/
+      application-config.test.ts            # Unit test
+      global-setup.ts                       # Integration test setup (sync + uninstall)
+      schema.integration-test.ts            # Integration test against a live server
+  .github/workflows/
+    ci.yml                                  # Lint, typecheck, unit + integration tests
+    cd.yml                                  # Deploy + install on push to main
+    publish.yml                             # Publish to npm on version tags (with provenance)
+  public/
+    logo.svg                                # Static assets
+  vitest.config.ts                          # Integration test runner config
+  vitest.unit.config.ts                     # Unit test runner config
+  tsconfig.json, tsconfig.spec.json
+  .nvmrc, .yarnrc.yml, .oxlintrc.json
+  README.md, AGENTS.md, CLAUDE.md, CHANGELOG.md, SETUP.md
+```
+
+## Fișiere cheie
+
+| Fișier / Folder                                                            | Scop                                                                                                                            |
+| -------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| `src/application-config.ts`                                                | **Necesar.** Fișierul principal de configurare pentru aplicație.                                                                |
+| `src/default-role.ts`                                                      | Rol implicit care controlează la ce pot avea acces funcțiile logice.                                                            |
+| `src/constants/universal-identifiers.ts`                                   | UUID-uri generate automat și metadate (nume afișat, descriere).                                                                 |
+| `src/front-components/`, `src/navigation-menu-items/`, `src/page-layouts/` | O pagină de bun venit inițială: o componentă de interfață randată de un layout de pagină autonom, accesibilă din bara laterală. |
+| `src/__tests__/`                                                           | Un test unitar plus un test de integrare (cu configurarea sa globală) care sincronizează aplicația cu un server real.           |
+| `public/`                                                                  | Resurse statice (imagini, fonturi) servite împreună cu aplicația.                                                               |
+| `AGENTS.md` / `CLAUDE.md`                                                  | Ghid pentru agenții AI de programare care lucrează la aplicație.                                                                |
+| `CHANGELOG.md` / `SETUP.md`                                                | Jurnal de modificări notabile și instrucțiuni de configurare pentru dezvoltare locală.                                          |
+
+<Note>
+**Organizarea fișierelor ține de dvs.** Folderele de mai sus sunt convenții — SDK-ul detectează entitățile prin analiză AST pe apelurile `export default defineEntity(...)`, indiferent unde se află fișierul.
+</Note>
+
+## Dependențe
+
+Ambele pachete Twenty SDK trebuie plasate sub `devDependencies`, nu sub `dependencies`:
+
+```json filename="package.json"
+{
+  "dependencies": {},
+  "devDependencies": {
+    "twenty-client-sdk": "2.20.0",
+    "twenty-sdk": "2.20.0",
+    "twenty-ui": "1.0.0-alpha.1"
+  }
+}
+```
+
+Generatorul de schelete fixează versiunile `twenty-sdk` și `twenty-client-sdk` la propria sa versiune — păstrează-le sincronizate când faci upgrade.
+
+* **`twenty-sdk`** livrează CLI-ul `twenty` și uneltele de build/scaffolding. Acesta rulează doar în timpul dezvoltării și al build-ului și nu este niciodată importat de runtime-ul aplicației tale publicate.
+* **`twenty-client-sdk`** este importat de codul aplicației tale (`CoreApiClient`, `MetadataApiClient`, `RestApiClient`), dar Twenty îl furnizează la runtime — funcțiile de logică îl obțin dintr-un strat SDK generat, iar componentele de interfață îl rezolvă din module livrate de server. Copia instalată local este folosită doar pentru verificarea tipurilor și pentru build-ul la momentul de deploy, astfel că nu trebuie niciodată inclusă în bundle-ul livrat.
+
+Păstrarea oricărui pachet sub `dependencies` îl include în bundle-ul de runtime al aplicației instalate, unde reprezintă o încărcătură inutilă. `twenty dev:build` emite un avertisment atunci când oricare dintre ele este încă listat sub `dependencies`.
+
+Adaugă dependențele de runtime proprii ale aplicației tale (bibliotecile pe care funcțiile tale de logică chiar le importă la runtime) sub `dependencies`, ca de obicei. Menține arborele suplu: `dependencies` sunt instalate într-un strat de execuție limitat la 250 MB necomprimat, iar o operațiune de sync sau install eșuează cu o eroare privind dimensiunea dependințelor dacă se depășește această limită — bibliotecile de UI și uneltele de dezvoltare trebuie să fie în `devDependencies`.

packages/twenty-docs/l/ro/developers/extend/apps/getting-started/quick-start.mdx

@@ -0,0 +1,166 @@
+---
+title: Pornire rapidă
+icon: rocket
+description: Creați prima dvs. aplicație Twenty în câteva minute.
+---
+
+## Cerințe
+
+* **Node.js 24.5+** — [Descărcați](https://nodejs.org/)
+* **Yarn 4** — vine împreună cu Node prin Corepack. Activați-l: `corepack enable`
+* **Docker** — [Descărcați](https://www.docker.com/products/docker-desktop/). Necesar pentru a rula un server Twenty local. Omiteți dacă rulați deja Twenty în altă parte.
+
+Crearea unei aplicații Twenty are trei faze. Generatorul le reunește într-o singură comandă pe calea optimă, dar fiecare fază este un concept separat — când ceva eșuează, dacă știți în ce fază sunteți, știți ce trebuie să corectați.
+
+| Fază                    | Ce faceți                                        | Instrument                          | Rezultat                       |
+| ----------------------- | ------------------------------------------------ | ----------------------------------- | ------------------------------ |
+| **1. Creați scheletul** | Generați codul sursă al aplicației               | `npx create-twenty-app`             | Un proiect TypeScript pe disc  |
+| **2. Rulați un server** | Porniți un server Twenty cu care să sincronizați | Docker + `yarn twenty docker:start` | O instanță Twenty care rulează |
+| **3. Sincronizați**     | Sincronizați în timp real codul cu serverul      | `yarn twenty dev`                   | Modificările apar în UI        |
+
+---
+
+## Faza 1 — Creați scheletul proiectului
+
+Creați o nouă aplicație din șablon:
+
+```bash filename="Terminal"
+npx create-twenty-app@latest my-twenty-app
+```
+
+Generatorul este neinteractiv: numele directorului devine numele aplicației. Transmite `--display-name` și `--description` pentru a personaliza metadatele generate (le poți edita și mai târziu în `src/constants/universal-identifiers.ts`). Aceasta generează un proiect TypeScript în `my-twenty-app/` cu un fișier inițial `application-config.ts`, un rol implicit, fluxuri de lucru CI/CD și un test de integrare.
+
+**După această fază:** aveți codul sursă al aplicației pe mașina dvs. Încă nu rulează — aceasta este Faza 2.
+
+---
+
+## Faza 2 — Rulați un server Twenty local
+
+Aplicația are nevoie de un server Twenty cu care să se sincronizeze. Serverul este o instanță Twenty completă — UI, API GraphQL, PostgreSQL — care rulează local în Docker. Codul local încarcă definițiile pe acel server, făcându-le să apară în UI.
+
+Generatorul de proiecte pornește unul pentru tine: cu Docker rulând, descarcă imaginea `twentycrm/twenty-app-dev`, o pornește pe portul `2020` și autentifică CLI-ul față de spațiul de lucru demo preconfigurat (`tim@apple.dev`) — fără a fi necesară autentificarea.
+
+Pentru a te conecta în schimb la un server Twenty existent, treci argumentul `--url \<your-server-url>`. Serverele la distanță se autentifică prin OAuth: se deschide un browser astfel încât să te poți autentifica și să dai clic pe **Authorize**, ceea ce oferă CLI-ului acces la spațiul tău de lucru. (Poți opta pentru OAuth și local cu `--authentication-method oauth` — autentifică-te cu `tim@apple.dev` / `tim@apple.dev`.)
+
+<div style={{textAlign: 'center'}}>
+  <img src="/images/docs/developers/extends/apps/login.png" alt="Ecranul de autentificare Twenty" />
+</div>
+
+<div style={{textAlign: 'center'}}>
+  <img src="/images/docs/developers/extends/apps/authorize.png" alt="Ecranul de autorizare Twenty CLI" />
+</div>
+
+Terminalul va confirma că totul este configurat.
+
+<div style={{textAlign: 'center'}}>
+  <img src="/images/docs/developers/extends/apps/scaffolded.png" alt="Aplicația a fost creată cu succes" />
+</div>
+
+**După această fază:** aveți un server Twenty care rulează la [http://localhost:2020](http://localhost:2020), iar CLI-ul dvs. este autorizat să sincronizeze cu acesta.
+
+<Note>
+Dacă Docker nu este instalat sau nu rulează, generatorul de schelet vă va indica comanda corectă de pornire pentru sistemul dvs. de operare. După ce Docker rulează, puteți continua cu `yarn twenty docker:start` — nu este nevoie să recreați scheletul.
+</Note>
+
+---
+
+## Faza 3 — Sincronizați modificările
+
+Aceasta este bucla internă în care veți petrece cea mai mare parte a timpului.
+
+```bash filename="Terminal"
+cd my-twenty-app
+yarn twenty dev
+```
+
+Aceasta monitorizează `src/`, reconstruiește la fiecare modificare și sincronizează rezultatul pe server. Editați un fișier, salvați, iar în câteva secunde serverul reflectă modificarea. Veți vedea în terminal un panou de stare în timp real.
+
+Pentru o ieșire mai detaliată (jurnale de build, cereri de sincronizare, urme ale erorilor), adăugați `--verbose`.
+
+<div style={{textAlign: 'center'}}>
+  <img src="/images/docs/developers/extends/apps/dev.png" alt="Ieșirea terminalului în modul de dezvoltare" />
+</div>
+
+Deschideți [http://localhost:2020/settings/applications#developer](http://localhost:2020/settings/applications#developer). Ar trebui să vedeți aplicația dvs. listată la **Your Apps**.
+
+<div style={{textAlign: 'center'}}>
+  <img src="/images/docs/developers/extends/apps/app-in-ui-1.png" alt="Lista Your Apps care afișează My twenty app" />
+</div>
+
+Faceți clic pe **My twenty app** pentru a vedea **înregistrarea aplicației** — o înregistrare la nivel de server care descrie aplicația dvs. (nume, identificator, credențiale OAuth, sursă). O singură înregistrare poate fi instalată în mai multe spații de lucru pe același server.
+
+<div style={{textAlign: 'center'}}>
+  <img src="/images/docs/developers/extends/apps/app-in-ui-2.png" alt="Detalii despre înregistrarea aplicației" />
+</div>
+
+Faceți clic pe **View installed app** pentru a vedea instalarea în spațiul de lucru. Fila **About** afișează versiunea și opțiunile de administrare.
+
+<div style={{textAlign: 'center'}}>
+  <img src="/images/docs/developers/extends/apps/app-in-ui-3.png" alt="Aplicație instalată" />
+</div>
+
+**După această fază:** aveți o buclă de dezvoltare în timp real. Editați orice fișier în `src/` și acesta apare în UI.
+
+### Sincronizare unică pentru CI și scripturi
+
+Folosește `plan` și `apply` pentru a rula același pipeline o singură dată, fără watcher:
+
+```bash filename="Terminal"
+yarn twenty plan   # preview the metadata changes without applying them
+yarn twenty apply  # show the plan, then apply it
+```
+
+| Comandă             | Comportament                                                                                                                                                              | Când se folosește                                                                     |
+| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
+| `yarn twenty dev`   | Monitorizează și resincronizează la fiecare modificare. Rulează până când îl opriți.                                                                                      | Dezvoltare locală interactivă.                                                        |
+| `yarn twenty apply` | Un singur build + sync, iese cu `0` la succes, `1` la eșec. Solicită confirmare pentru modificările distructive (treci argumentul `--force` pentru a sări peste aceasta). | CI, hook-uri pre-commit, agenți AI, fluxuri de lucru scriptate.                       |
+| `yarn twenty plan`  | Construiește și afișează modificările de metadate **fără a le aplica**.                                                                                                   | Inspectarea modificărilor pe care le-ar face o sincronizare înainte de a le confirma. |
+
+Toate modurile necesită o conexiune la distanță autentificată. Vezi [Sincronizare și recuperare](/l/ro/developers/extend/apps/operations/sync-and-recovery#previewing-changes-plan) pentru mai multe detalii despre `plan`.
+
+<Note>
+`yarn twenty dev --once` și `yarn twenty dev --once --dry-run` sunt aliasuri depreciate pentru `yarn twenty apply` și `yarn twenty plan`.
+</Note>
+
+### Opțiuni pentru modul de dezvoltare
+
+| Opțiune                               | Descriere                                                                                        |
+| ------------------------------------- | ------------------------------------------------------------------------------------------------ |
+| `--force`                             | Aplică modificările distructive (ștergeri) fără confirmare.                                      |
+| `--debounceMs \<ms>` | Setează întârzierea de debounce pentru modificarea fișierului în milisecunde (implicit: `1000`). |
+| `--verbose` / `--debug`               | Afișează jurnale detaliate de construire, cereri de sincronizare și urme ale erorilor.           |
+
+## Ce puteți construi
+
+Aplicațiile sunt compuse din **entități** — fiecare definită într-un fișier TypeScript cu un singur `export default`:
+
+| Entitate                    | Ce face                                                                                         |
+| --------------------------- | ----------------------------------------------------------------------------------------------- |
+| **Obiecte și câmpuri**      | Modele de date personalizate (carte poștală, factură etc.) cu câmpuri tipizate                  |
+| **Funcții logice**          | TypeScript pe server declanșat de rute HTTP, programări cron sau evenimente din baza de date    |
+| **Componente front-end**    | Componente React care se afișează în UI-ul Twenty (panou lateral, widgeturi, meniul de comenzi) |
+| **Abilități și agenți**     | Capabilități AI — instrucțiuni reutilizabile și asistenți autonomi                              |
+| **Vizualizări și navigare** | Vizualizări de listă preconfigurate și elemente de meniu în bara laterală                       |
+| **Layouturi de pagină**     | Pagini personalizate de detalii ale înregistrărilor cu file și widgeturi                        |
+
+Referință completă: [Concepte](/l/ro/developers/extend/apps/getting-started/concepts).
+
+## Pașii următori
+
+<CardGroup cols={2}>
+  <Card title="Configurare" icon="screwdriver-wrench" href="/l/ro/developers/extend/apps/config/overview">
+    Identitatea aplicației, rolul implicit, hook-urile de instalare și dezinstalare, resursele publice.
+  </Card>
+  <Card title="Date" icon="database" href="/l/ro/developers/extend/apps/data/overview">
+    Obiecte, câmpuri și relații bidirecționale.
+  </Card>
+  <Card title="Logică" icon="bolt" href="/l/ro/developers/extend/apps/logic/overview">
+    Funcții logice, abilități, agenți și conexiuni OAuth.
+  </Card>
+  <Card title="Aspect" icon="table-columns" href="/l/ro/developers/extend/apps/layout/overview">
+    Vizualizări, navigare, layouturi de pagină, componente front-end.
+  </Card>
+  <Card title="Operațiuni" icon="rocket" href="/l/ro/developers/extend/apps/operations/overview">
+    CLI, testare, remote-uri, CI și publicarea aplicației.
+  </Card>
+</CardGroup>

packages/twenty-docs/l/ro/developers/extend/apps/getting-started/scaffolding.mdx

@@ -0,0 +1,63 @@
+---
+title: Generare automată
+description: Generați fișiere de entități în mod interactiv cu yarn twenty dev:add — obiecte, câmpuri, vizualizări, funcții logice și altele.
+icon: wand-magic-sparkles
+---
+
+În loc să creați manual fișiere de entități, folosiți generatorul interactiv (scaffolder):
+
+```bash filename="Terminal"
+yarn twenty dev:add
+```
+
+Vă cere să alegeți un tip de entitate și vă ghidează prin câmpurile necesare, apoi scrie un fișier gata de utilizare cu un `universalIdentifier` stabil și apelul corect `defineEntity()`.
+
+Puteți de asemenea să transmiteți direct tipul de entitate pentru a sări peste primul prompt:
+
+```bash filename="Terminal"
+yarn twenty dev:add object
+yarn twenty dev:add logicFunction
+yarn twenty dev:add frontComponent
+```
+
+## Tipuri de entități disponibile
+
+| Tipul entității                 | Comandă                                    | Fișier generat                                            |
+| ------------------------------- | ------------------------------------------ | --------------------------------------------------------- |
+| Obiect                          | `yarn twenty dev:add object`               | `src/objects/\<name>.ts`                 |
+| Câmp                            | `yarn twenty dev:add field`                | `src/fields/\<name>.ts`                  |
+| Funcție logică                  | `yarn twenty dev:add logicFunction`        | `src/logic-functions/\<name>.ts`         |
+| Componentă frontend             | `yarn twenty dev:add frontComponent`       | `src/front-components/\<name>.tsx`       |
+| Rol                             | `yarn twenty dev:add role`                 | `src/roles/\<name>.ts`                   |
+| Abilitate                       | `yarn twenty dev:add skill`                | `src/skills/\<name>.ts`                  |
+| Agent                           | `yarn twenty dev:add agent`                | `src/agents/\<name>.ts`                  |
+| Vizualizare                     | `yarn twenty dev:add view`                 | `src/views/\<name>.ts`                   |
+| Element de meniu de navigare    | `yarn twenty dev:add navigationMenuItem`   | `src/navigation-menu-items/\<name>.ts`   |
+| Machetă de pagină               | `yarn twenty dev:add pageLayout`           | `src/page-layouts/\<name>.ts`            |
+| Fila "Aspect pagină"            | `yarn twenty dev:add pageLayoutTab`        | `src/page-layout-tabs/\<name>.ts`        |
+| Element din meniul de comenzi   | `yarn twenty dev:add commandMenuItem`      | `src/command-menu-items/\<name>.ts`      |
+| Câmpul vizualizării             | `yarn twenty dev:add viewField`            | `src/view-fields/\<name>.ts`             |
+| Furnizor de conexiune           | `yarn twenty dev:add connectionProvider`   | `src/connection-providers/\<name>.ts`    |
+| Tip de activitate în cronologie | `yarn twenty dev:add timelineActivityType` | `src/timeline-activity-types/\<name>.ts` |
+
+## Ce generează scaffolder-ul
+
+Fiecare tip de entitate are propriul său șablon. De exemplu, `yarn twenty dev:add object` solicită:
+
+1. **Nume (singular)** — de ex., `invoice`
+2. **Nume (plural)** — de ex., `invoices`
+3. **Etichetă (singular)** — completată automat din nume (de ex., `Invoice`)
+4. **Etichetă (plural)** — completată automat (de ex., `Invoices`)
+5. **Creați o vizualizare și un element de navigare?** — dacă răspundeți afirmativ, scaffolder-ul generează, de asemenea, o vizualizare corespunzătoare și un link în bara laterală pentru noul obiect.
+
+Alte tipuri de entități au prompturi mai simple — majoritatea cer doar un nume.
+
+Tipul de entitate `field` este mai detaliat: solicită numele câmpului, eticheta, tipul (dintr-o listă cu toate tipurile de câmp disponibile precum `TEXT`, `NUMBER`, `SELECT`, `RELATION` etc.) și `universalIdentifier` al obiectului țintă.
+
+## Cale de output personalizată
+
+Utilizați opțiunea `--path` pentru a plasa fișierul generat într-o locație personalizată:
+
+```bash filename="Terminal"
+yarn twenty dev:add logicFunction --path src/custom-folder
+```

packages/twenty-docs/l/ro/developers/extend/apps/getting-started/troubleshooting.mdx

@@ -0,0 +1,14 @@
+---
+title: Depanare
+description: Probleme comune la prima rulare — Docker, versiunea Node, Yarn, dependențe.
+icon: wrench
+---
+
+* **Erori Docker** — Asigurați-vă că Docker Desktop (sau daemonul) rulează înainte de `yarn twenty docker:start`. Mesajul de eroare va afișa comanda corectă de pornire pentru sistemul dvs. de operare.
+* **Versiune Node greșită** — Este nevoie de 24.5+ (`engines.node: ^24.5.0`). Verificați cu `node -v`.
+* **Lipsește Yarn 4** — Rulați `corepack enable`.
+* **Dependențe nefuncționale** — `rm -rf node_modules && yarn install`.
+* **Erori ale `twenty-sdk` după actualizarea la v2.8.0** — A fost mutat din `dependencies` în `devDependencies` în v2.8.0. Vezi [Structura proiectului → Dependințe](/l/ro/developers/extend/apps/getting-started/project-structure#dependencies).
+* **`twenty dev:build` afișează un avertisment despre `twenty-client-sdk` aflat în `dependencies`** — Este furnizat în timpul execuției de către Twenty, așa că ar trebui mutat în `devDependencies` alături de `twenty-sdk`. Vezi [Structura proiectului → Dependințe](/l/ro/developers/extend/apps/getting-started/project-structure#dependencies).
+
+Blocat? Întrebați pe [Discordul Twenty](https://discord.com/channels/1130383047699738754/1130386664812982322).