> ## Documentation Index
> Fetch the complete documentation index at: https://docs.base44.com/llms.txt
> Use this file to discover all available pages before exploring further.

# CLI Base44

> Créez et gérez des applications Base44 (projets) avec l'outil CLI Base44.

<Warning>
  Cette page fait partie d'une compétence d'agent de code IA et est écrite pour les agents, pas pour les humains. Pour la documentation Base44 lisible par un humain, consultez la [documentation développeur](/developers).
</Warning>

# CLI Base44

Créez et gérez des applications Base44 (projets) avec l'outil CLI Base44.

## ⚡ ACTION IMMÉDIATE REQUISE - À lire en premier

Cette compétence s'active à toute mention de « base44 » ou lorsqu'un dossier `base44/` existe. **Ne lisez PAS les fichiers de documentation et ne recherchez PAS sur le web avant d'agir.**

**Votre première action DOIT être :**

1. Vérifier si `base44/config.jsonc` existe dans le répertoire courant
2. Si **OUI** (scénario projet existant) :
   * Transférer à la compétence base44-sdk pour l'implémentation
   * Cette compétence ne gère que les commandes CLI (login, deploy, entities push)
3. Si **NON**, choisir entre deux chemins d'initialisation :
   * **Application provisionnée** — l'application Base44 existe déjà car elle vient d'être provisionnée via un flux Stripe Projects / projects.dev, OU `BASE44_APP_ID` (ou `BASE44_PROJECTS_BASE44_APP_ID`) est présent dans l'environnement ou un fichier `.env`/`.env.local` :
     * Exécutez `npx base44 scaffold` pour configurer les fichiers locaux de cette application **existante**
     * **N'exécutez PAS `npx base44 create`** — cela crée une seconde application en double. Consultez [scaffold.md](https://docs.base44.com/developers/skills/base44-cli/references/scaffold.md).
   * **Nouveau projet** — aucune application n'existe encore et aucune n'a été provisionnée :
     * Cette compétence (base44-cli) traite la requête ; guidez l'utilisateur avec `npx base44 create`
     * N'activez PAS encore base44-sdk

## Critique : installation locale uniquement

N'appelez JAMAIS `base44` directement. Le CLI est installé localement en tant que dépendance de développement et doit être invoqué via un gestionnaire de paquets :

* `npx base44 <command>` (npm - recommandé)
* `yarn base44 <command>` (yarn)
* `pnpm base44 <command>` (pnpm)

MAUVAIS : `base44 login`
BON : `npx base44 login`

## OBLIGATOIRE : vérification d'authentification au démarrage de session

**CRITIQUE** : au tout début de chaque session IA lorsque cette compétence est activée, vous DEVEZ :

1. **Vérifier le statut d'authentification** en exécutant :
   ```bash theme={null}
   npx base44 whoami
   ```

2. **Si l'utilisateur est connecté** (la commande réussit et affiche un e-mail) :
   * Continuez avec la tâche demandée

3. **Si l'utilisateur n'est PAS connecté** (la commande échoue ou affiche une erreur) :
   * **ARRÊTEZ immédiatement**
   * **N'effectuez AUCUNE** opération CLI
   * **Demandez à l'utilisateur de se connecter manuellement** en exécutant :
     ```bash theme={null}
     npx base44 login
     ```
   ```
   - Attendez que l'utilisateur confirme sa connexion avant de continuer
   ```

**Cette vérification est obligatoire et doit avoir lieu avant l'exécution de toute autre commande CLI Base44.**

**Provisionné via Stripe Projects / projects.dev ?** Lorsque l'application a été provisionnée via ce flux, le CLI initialise l'authentification à partir des variables d'environnement `BASE44_ACCESS_TOKEN` / `BASE44_REFRESH_TOKEN` qu'il injecte (les noms préfixés `BASE44_PROJECTS_*` sont normalisés automatiquement). Dans ce cas, `npx base44 whoami` réussit déjà et vous n'avez **pas** besoin d'un `npx base44 login` interactif.

## Aperçu

Le CLI Base44 fournit des outils en ligne de commande pour l'authentification, la création de projets, la gestion des entités et le déploiement d'applications Base44. Il est agnostique du framework et fonctionne avec les frameworks front-end populaires comme Vite, Next.js et Create React App, Svelte, Vue, etc.

## Quand utiliser cette compétence par rapport à base44-sdk

**Utilisez base44-cli quand :**

* Créer un **NOUVEAU** projet Base44 à partir de zéro
* Initialiser un projet dans un répertoire vide
* Configurer les fichiers locaux d'une application **existante** provisionnée en externe (par exemple, via un flux Stripe Projects / projects.dev) → utilisez `scaffold`
* Le répertoire ne contient pas `base44/config.jsonc`
* L'utilisateur mentionne : « créer un nouveau projet », « initialiser un projet », « configurer un projet », « démarrer une nouvelle application Base44 »
* Déployer, pousser des entités ou s'authentifier via le CLI
* Travailler avec des commandes CLI (`npx base44 ...`)

**Utilisez base44-sdk quand :**

* Construire des fonctionnalités dans un projet Base44 **EXISTANT**
* `base44/config.jsonc` existe déjà
* Écrire du code JavaScript/TypeScript utilisant le SDK Base44
* Implémenter des fonctionnalités, composants ou features
* L'utilisateur mentionne : « implémenter », « construire une fonctionnalité », « ajouter une fonctionnalité », « écrire du code »

**Dépendances entre compétences :**

* `base44-cli` est un **prérequis** de `base44-sdk` pour les nouveaux projets
* Si l'utilisateur veut « créer une application » et qu'aucun projet Base44 n'existe, utilisez d'abord `base44-cli`
* `base44-sdk` suppose qu'un projet Base44 est déjà initialisé

**Logique de vérification d'état :**
Avant de sélectionner une compétence, vérifiez :

* SI (l'utilisateur mentionne « créer/construire une application » OU « faire un projet ») :
  * SI (`base44/config.jsonc` existe) :
    → Utilisez **base44-sdk** (le projet existe, construisez des fonctionnalités)
  * SINON SI (l'application a été provisionnée en externe — `BASE44_APP_ID`/`BASE44_PROJECTS_BASE44_APP_ID` défini, ou un flux Stripe Projects / projects.dev vient de s'exécuter) :
    → Utilisez **base44-cli** → `npx base44 scaffold` (configurez les fichiers locaux pour l'application existante ; ne faites PAS `create`)
  * SINON :
    → Utilisez **base44-cli** → `npx base44 create` (initialisation d'un nouveau projet nécessaire)

## Structure du projet

Un projet Base44 combine un projet front-end standard avec un dossier de configuration `base44/` :

```
my-app/
├── base44/                      # Configuration Base44 (créée par le CLI)
│   ├── config.jsonc             # Paramètres du projet, config du site
│   ├── .types/                  # Types TypeScript auto-générés (créés par `types generate`)
│   │   └── types.d.ts           # Augmentation de module pour @base44/sdk
│   ├── entities/                # Définitions de schémas d'entités
│   │   ├── task.jsonc
│   │   └── board.jsonc
│   ├── functions/               # Fonctions backend (facultatif)
│   │   └── my-function/
│   │       └── entry.ts
│   ├── agents/                  # Configurations d'agents (facultatif)
│   │   └── support_agent.jsonc
│   └── connectors/              # Configurations de connecteurs OAuth (facultatif)
│       └── googlecalendar.jsonc
├── src/                         # Code source du front-end
│   ├── api/
│   │   └── base44Client.js      # Client SDK Base44
│   ├── pages/
│   ├── components/
│   └── main.jsx
├── index.html                   # Point d'entrée SPA
├── package.json
└── vite.config.js               # Ou la config de votre framework
```

**Fichiers clés :**

* `base44/config.jsonc` - Nom du projet, description, paramètres de build du site
* `base44/entities/*.jsonc` - Schémas de modèle de données (voir la section Schéma d'entité)
* `base44/functions/*/entry.ts` - Point d'entrée d'une fonction backend
* `base44/agents/*.jsonc` - Configurations d'agents (facultatif)
* `base44/.types/types.d.ts` - Types TypeScript auto-générés pour les entités, fonctions et agents (créés par `npx base44 types generate`)
* `base44/connectors/*.jsonc` - Configurations de connecteurs OAuth (facultatif)
* `src/api/base44Client.js` - Client SDK préconfiguré pour l'usage front-end

**Exemple de config.jsonc :**

```jsonc theme={null}
{
  "name": "My App",                    // Requis : nom du projet
  "description": "App description",    // Facultatif : description du projet
  "entitiesDir": "./entities",         // Facultatif : par défaut "entities"
  "functionsDir": "./functions",       // Facultatif : par défaut "functions"
  "agentsDir": "./agents",             // Facultatif : par défaut "agents"
  "connectorsDir": "./connectors",     // Facultatif : par défaut "connectors"
  "site": {                            // Facultatif : config de déploiement du site
    "installCommand": "npm install",   // Facultatif : installer les dépendances
    "buildCommand": "npm run build",   // Facultatif : commande de build
    "serveCommand": "npm run dev",     // Facultatif : serveur de dev local
    "outputDirectory": "./dist"        // Facultatif : répertoire de sortie du build
  }
}
```

**Propriétés de config :**

| Propriété              | Description                                       | Défaut         |
| ---------------------- | ------------------------------------------------- | -------------- |
| `name`                 | Nom du projet (requis)                            | -              |
| `description`          | Description du projet                             | -              |
| `entitiesDir`          | Répertoire des schémas d'entités                  | `"entities"`   |
| `functionsDir`         | Répertoire des fonctions backend                  | `"functions"`  |
| `agentsDir`            | Répertoire des configs d'agents                   | `"agents"`     |
| `connectorsDir`        | Répertoire des configs de connecteurs             | `"connectors"` |
| `site.installCommand`  | Commande d'installation des dépendances           | -              |
| `site.buildCommand`    | Commande de build du projet                       | -              |
| `site.serveCommand`    | Commande du serveur de dev                        | -              |
| `site.outputDirectory` | Répertoire de sortie du build pour le déploiement | -              |

## Installation

Installez le CLI Base44 comme dépendance de développement dans votre projet :

```bash theme={null}
npm install --save-dev base44
```

**Important :** ne supposez ni ne codez en dur la version du paquet `base44`. Installez toujours sans spécification de version pour obtenir la dernière.

Puis exécutez les commandes avec `npx` :

```bash theme={null}
npx base44 <command>
```

**Note :** toutes les commandes de cette documentation utilisent `npx base44`. Vous pouvez aussi utiliser `yarn base44` ou `pnpm base44` si vous préférez.

## Option globale `--app-id`

Le CLI dispose d'une option globale `--app-id <id>` pour les commandes qui n'ont besoin que d'un contexte d'application, pas des fichiers de projet locaux.

**Ordre de résolution :** flag `--app-id` → variable d'environnement `BASE44_APP_ID` → `base44/.app.jsonc` local

C'est utile pour inspecter une application ou opérer dessus sans passer dans un répertoire de projet lié. Exemples courants :

```bash theme={null}
# Exécuter un script ponctuel sur une application spécifique
cat ./script.ts | npx base44 exec --app-id app_123

# Récupérer les journaux d'une application déployée sans checkout local
npx base44 logs --app-id app_123 --level error
```

Utilisez `--app-id` pour les commandes à portée application comme `exec` et `logs`.

N'utilisez **pas** `--app-id` pour les commandes qui ont besoin de fichiers de projet locaux :

* `base44 create` crée une nouvelle application, elle rejette donc `--app-id`
* `base44 dev` s'exécute depuis un projet local lié, elle rejette donc `--app-id`
* `base44 deploy` nécessite toujours un répertoire de projet local car elle lit les ressources locales

## Commandes disponibles

### Authentification

| Commande        | Description                                             | Référence                                                                                        |
| --------------- | ------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| `base44 login`  | S'authentifier auprès de Base44 via le flux device code | [auth-login.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-login.md)   |
| `base44 logout` | Se déconnecter de l'appareil actuel                     | [auth-logout.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-logout.md) |
| `base44 whoami` | Afficher l'utilisateur authentifié actuel               | [auth-whoami.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-whoami.md) |

### Gestion de projet

| Commande                | Description                                                                          | Référence                                                                                                            |
| ----------------------- | ------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------- |
| `base44 create`         | Créer un nouveau projet Base44 à partir d'un modèle                                  | [create.md](https://docs.base44.com/developers/skills/base44-cli/references/create.md) ⚠️ **À LIRE OBLIGATOIREMENT** |
| `base44 scaffold`       | Générer un projet local pour une application Base44 existante (par ID d'application) | [scaffold.md](https://docs.base44.com/developers/skills/base44-cli/references/scaffold.md)                           |
| `base44 link`           | Lier un projet local existant à Base44                                               | [link.md](https://docs.base44.com/developers/skills/base44-cli/references/link.md)                                   |
| `base44 eject`          | Télécharger le code d'un projet Base44 existant                                      | [eject.md](https://docs.base44.com/developers/skills/base44-cli/references/eject.md)                                 |
| `base44 dashboard open` | Ouvrir le tableau de bord de l'application dans votre navigateur                     | [dashboard.md](https://docs.base44.com/developers/skills/base44-cli/references/dashboard.md)                         |

### Développement

| Commande     | Description                                                                                                               | Référence                                                                        |
| ------------ | ------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
| `base44 dev` | Démarrer le développement local pour votre backend Base44, ainsi que votre front-end si `site.serveCommand` est configuré | [dev.md](https://docs.base44.com/developers/skills/base44-cli/references/dev.md) |

### Déploiement

| Commande        | Description                                                                                                 | Référence                                                                              |
| --------------- | ----------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
| `base44 deploy` | Déployer toutes les ressources (entités, fonctions, agents, connecteurs, config d'authentification et site) | [deploy.md](https://docs.base44.com/developers/skills/base44-cli/references/deploy.md) |

### Gestion des entités

| Action / Commande      | Description                                           | Référence                                                                                                                 |
| ---------------------- | ----------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| Créer des entités      | Définir des entités dans le dossier `base44/entities` | [entities-create.md](https://docs.base44.com/developers/skills/base44-cli/references/entities-create.md)                  |
| `base44 entities push` | Pousser les entités locales vers Base44               | [entities-push.md](https://docs.base44.com/developers/skills/base44-cli/references/entities-push.md)                      |
| Modèles RLS            | Exemples et opérateurs de sécurité au niveau ligne    | [rls-examples.md](https://docs.base44.com/developers/skills/base44-cli/references/rls-examples.md) ⚠️ **À LIRE POUR RLS** |

#### Schéma d'entité (référence rapide)

Suivez TOUJOURS exactement cette structure lors de la création de fichiers d'entités :

**Nommage des fichiers :** `base44/entities/{kebab-case-name}.jsonc` (par exemple, `team-member.jsonc` pour `TeamMember`)

**Modèle de schéma :**

```jsonc theme={null}
{
  "name": "EntityName",
  "type": "object",
  "properties": {
    "field_name": {
      "type": "string",
      "description": "Field description"
    }
  },
  "required": ["field_name"]
}
```

**Types de champs :** `string`, `number`, `integer`, `boolean`, `array`, `object`, `binary`
**Formats de chaîne :** `date`, `date-time`, `time`, `email`, `uri`, `hostname`, `ipv4`, `ipv6`, `uuid`, `file`, `regex`, `richtext`
**Pour les enums :** ajoutez `"enum": ["value1", "value2"]` et éventuellement `"default": "value1"`
**Noms d'entités :** doivent être alphanumériques uniquement (motif : `/^[a-zA-Z0-9]+$/`)

Pour la documentation complète, consultez [entities-create.md](https://docs.base44.com/developers/skills/base44-cli/references/entities-create.md).

### Gestion des fonctions

| Action / Commande                              | Description                                                                                                               | Référence                                                                                                  |
| ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| Créer des fonctions                            | Définir des fonctions dans `base44/functions`                                                                             | [functions-create.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-create.md) |
| `base44 functions deploy [names...] [--force]` | Déployer les fonctions locales vers Base44 ; cibler éventuellement des fonctions spécifiques ou élaguer celles supprimées | [functions-deploy.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-deploy.md) |
| `base44 functions delete <names...>`           | Supprimer une ou plusieurs fonctions déployées de Base44                                                                  | [functions-delete.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-delete.md) |
| `base44 functions list`                        | Lister toutes les fonctions déployées sur le distant Base44                                                               | [functions-list.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-list.md)     |
| `base44 functions pull [name]`                 | Récupérer les fonctions déployées de Base44 vers des fichiers locaux                                                      | [functions-pull.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-pull.md)     |

### Gestion des agents

Les agents sont des assistants IA conversationnels qui peuvent interagir avec les utilisateurs, accéder aux entités de votre application et appeler des fonctions backend. Utilisez ces commandes pour gérer les configurations d'agents.

| Action / Commande    | Description                                            | Référence                                                                                        |
| -------------------- | ------------------------------------------------------ | ------------------------------------------------------------------------------------------------ |
| Créer des agents     | Définir des agents dans le dossier `base44/agents`     | Voir Schéma d'agent ci-dessous                                                                   |
| `base44 agents pull` | Récupérer les agents distants vers des fichiers locaux | [agents-pull.md](https://docs.base44.com/developers/skills/base44-cli/references/agents-pull.md) |
| `base44 agents push` | Pousser les agents locaux vers Base44                  | [agents-push.md](https://docs.base44.com/developers/skills/base44-cli/references/agents-push.md) |

**Note :** les commandes d'agents effectuent une synchronisation complète — pousser remplace tous les agents distants par les locaux, et récupérer remplace tous les agents locaux par les distants.

#### Schéma d'agent (référence rapide)

**Nommage des fichiers :** `base44/agents/{agent_name}.jsonc` (par exemple, `support_agent.jsonc`)

**Modèle de schéma :**

```jsonc theme={null}
{
  "name": "agent_name",
  "description": "Brief description of what this agent does",
  "instructions": "Detailed instructions for the agent's behavior",
  "tool_configs": [
    // Entity tool - gives agent access to entity operations
    { "entity_name": "tasks", "allowed_operations": ["read", "create", "update", "delete"] },
    // Backend function tool - gives agent access to a function
    { "function_name": "send_email", "description": "Send an email notification" }
  ],
  "whatsapp_greeting": "Hello! How can I help you today?"
}
```

**Règles de nommage :**

* Les noms d'agents doivent correspondre au motif : `/^[a-z0-9_]+$/` (alphanumérique en minuscules avec underscores, 1 à 100 caractères)
* Valides : `support_agent`, `order_bot`
* Invalides : `Support-Agent`, `OrderBot`

**Champs requis :** `name`, `description`, `instructions`
**Champs facultatifs :** `tool_configs` (par défaut `[]`), `whatsapp_greeting`

**Types de configs d'outils :**

* **Outils d'entité** : `entity_name` + `allowed_operations` (tableau parmi : `read`, `create`, `update`, `delete`)
* **Outils de fonction backend** : `function_name` + `description`

### Gestion des connecteurs

Les connecteurs permettent à votre application de se connecter à des services externes (Google Calendar, Slack, Stripe, etc.). La plupart utilisent OAuth pour fournir aux fonctions backend des jetons d'accès leur permettant d'appeler des API externes. Stripe fait exception — il est provisionné automatiquement côté serveur sans flux OAuth dans le navigateur.

| Action / Commande                  | Description                                                 | Référence                                                                                                                    |
| ---------------------------------- | ----------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| Créer des connecteurs              | Définir des connecteurs dans le dossier `base44/connectors` | [connectors-create.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-create.md)                 |
| `base44 connectors list-available` | Lister tous les types d'intégration disponibles chez Base44 | [connectors-list-available.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-list-available.md) |
| `base44 connectors pull`           | Récupérer les connecteurs distants vers des fichiers locaux | [connectors-pull.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-pull.md)                     |
| `base44 connectors push`           | Pousser les connecteurs locaux vers Base44                  | [connectors-push.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-push.md)                     |

**Note :** les commandes de connecteurs effectuent une synchronisation complète — pousser remplace tous les connecteurs distants par les locaux (et déclenche OAuth pour les nouveaux connecteurs OAuth), et récupérer remplace tous les connecteurs locaux par les distants.

#### Schéma de connecteur (référence rapide)

**Nommage des fichiers :** `base44/connectors/{type}.jsonc` (par exemple, `googlecalendar.jsonc`, `slack.jsonc`)

**Modèle de schéma :**

```jsonc theme={null}
{
  "type": "googlecalendar",
  "scopes": [
    "https://www.googleapis.com/auth/calendar.readonly",
    "https://www.googleapis.com/auth/calendar.events"
  ]
}
```

**Champs requis :** `type`
**Champs facultatifs :** `scopes` (par défaut `[]`)

**Types de connecteurs disponibles :** exécutez `npx base44 connectors list-available` pour voir tous les types d'intégration pris en charge.

**Note :** `stripe` est aussi un type de connecteur valide mais n'est pas renvoyé par `list-available`. Traitez-le comme un type pris en charge — il est provisionné automatiquement par Base44 sans flux OAuth dans le navigateur. Consultez [connectors-create.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-create.md) pour plus de détails.

Pour la documentation complète, consultez [connectors-create.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-create.md).

### Configuration d'authentification

Gérez les paramètres d'authentification de votre application (par exemple, connexion par nom d'utilisateur et mot de passe). La configuration d'authentification est stockée dans `base44/auth/` et synchronisée avec Base44 via `auth push`/`auth pull`.

| Commande                                                | Description                                                                        | Référence                                                                                                        |
| ------------------------------------------------------- | ---------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| `base44 auth password-login <enable\|disable>`          | Activer ou désactiver l'authentification par nom d'utilisateur et mot de passe     | [auth-password-login.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-password-login.md) |
| `base44 auth social-login <provider> <enable\|disable>` | Activer ou désactiver la connexion sociale (google, microsoft, facebook, apple)    | [auth-social-login.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-social-login.md)     |
| `base44 auth sso <enable\|disable>`                     | Configurer le fournisseur d'identité SSO (google, microsoft, github, okta, custom) | [auth-sso.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-sso.md)                       |
| `base44 auth pull`                                      | Récupérer la config d'authentification de Base44 vers des fichiers locaux          | [auth-pull.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-pull.md)                     |
| `base44 auth push`                                      | Pousser la config d'authentification locale vers Base44                            | [auth-push.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-push.md)                     |

**Note :** la config d'authentification est aussi déployée dans le cadre de `base44 deploy`.

### Gestion des secrets

Gérez les secrets du projet (variables d'environnement stockées de manière sécurisée dans Base44). Ces commandes sont masquées de la sortie `--help` mais sont pleinement fonctionnelles.

| Commande                      | Description                                               | Référence                                                                                              |
| ----------------------------- | --------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| `base44 secrets list`         | Lister les noms de tous les secrets                       | [secrets-list.md](https://docs.base44.com/developers/skills/base44-cli/references/secrets-list.md)     |
| `base44 secrets set`          | Définir un ou plusieurs secrets (KEY=VALUE ou --env-file) | [secrets-set.md](https://docs.base44.com/developers/skills/base44-cli/references/secrets-set.md)       |
| `base44 secrets delete <key>` | Supprimer un secret par nom                               | [secrets-delete.md](https://docs.base44.com/developers/skills/base44-cli/references/secrets-delete.md) |

### Exécution de scripts

Exécutez des scripts ponctuels sur votre application avec le SDK Base44 préauthentifié. Utilisez-la pour effectuer des opérations CRUD sur des entités (`base44.entities.MyEntity.list/create/update/delete`), appeler des fonctions backend (`base44.functions.invoke("myFunction", args)`), invoquer des agents, ou accéder à toute autre ressource exposée par le SDK — sans déployer de fonction complète. Utile pour les migrations de données, opérations en masse, débogage et workflows scriptés.

| Commande      | Description                                                      | Référence                                                                          |
| ------------- | ---------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| `base44 exec` | Exécuter un script (via stdin) avec le SDK Base44 préauthentifié | [exec.md](https://docs.base44.com/developers/skills/base44-cli/references/exec.md) |

### Génération de types

| Commande                | Description                                                                                        | Référence                                                                                              |
| ----------------------- | -------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| `base44 types generate` | Générer les types TypeScript (`types.d.ts`) à partir des entités, fonctions, agents et connecteurs | [types-generate.md](https://docs.base44.com/developers/skills/base44-cli/references/types-generate.md) |

**Sortie :** `base44/.types/types.d.ts` — augmente le module `@base44/sdk` avec des registres typés (`EntityTypeRegistry`, `FunctionNameRegistry`, `AgentNameRegistry`, `ConnectorTypeRegistry`).

**Aucune authentification requise.** S'exécute entièrement en local. Met automatiquement à jour `tsconfig.json` pour inclure les types générés.

### Gestion du site

| Commande             | Description                                                    | Référence                                                                                        |
| -------------------- | -------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| `base44 site deploy` | Déployer les fichiers du site buildé vers l'hébergement Base44 | [site-deploy.md](https://docs.base44.com/developers/skills/base44-cli/references/site-deploy.md) |
| `base44 site open`   | Ouvrir le site déployé dans votre navigateur                   | [site-open.md](https://docs.base44.com/developers/skills/base44-cli/references/site-open.md)     |

**SPA uniquement** : l'hébergement Base44 prend en charge les Single Page Applications avec un unique point d'entrée `index.html`. Toutes les routes sont servies depuis `index.html` (routage côté client).

## Démarrage rapide

1. Installez le CLI dans votre projet :
   ```bash theme={null}
   npm install --save-dev base44
   ```

2. Authentifiez-vous auprès de Base44 :
   ```bash theme={null}
   npx base44 login
   ```

3. Créez un nouveau projet (fournissez TOUJOURS un nom et le flag `--path`) :
   ```bash theme={null}
   npx base44 create my-app --path .
   ```

4. Lancez le développement local :
   ```bash theme={null}
   npx base44 dev
   ```

5. Buildez et déployez tout :
   ```bash theme={null}
   npm run build
   npx base44 deploy -y
   ```

Ou déployez des ressources individuelles :

* `npx base44 entities push` - Pousser uniquement les entités
* `npx base44 functions deploy` - Déployer uniquement les fonctions
* `npx base44 functions delete <name>` - Supprimer une fonction déployée
* `npx base44 functions list` - Lister toutes les fonctions déployées
* `npx base44 functions pull` - Récupérer les fonctions déployées vers des fichiers locaux
* `npx base44 agents push` - Pousser uniquement les agents
* `npx base44 connectors pull` - Récupérer les connecteurs de Base44
* `npx base44 connectors push` - Pousser uniquement les connecteurs
* `npx base44 auth pull` - Récupérer la config d'authentification de Base44
* `npx base44 auth push` - Pousser uniquement la config d'authentification
* `npx base44 site deploy -y` - Déployer uniquement le site

## Workflows courants

### Créer un nouveau projet

**⚠️ OBLIGATOIRE : avant d'exécuter `base44 create`, vous DEVEZ lire [create.md](https://docs.base44.com/developers/skills/base44-cli/references/create.md) pour :**

* **Sélection de modèle** - Choisir le bon modèle (`backend-and-client` vs `backend-only`)
* **Workflow correct** - Chaque modèle requiert des étapes de configuration différentes
* **Pièges courants** - Éviter les erreurs de création de dossier qui causent des échecs

Ne pas suivre les instructions de create.md entraînera une génération de projet cassée.

### Lier un projet existant

```bash theme={null}
# Si vous avez base44/config.jsonc mais pas .app.jsonc
npx base44 link --create --name my-app
```

### Lancer le développement local

```bash theme={null}
# Démarre le backend Base44 en local
npx base44 dev
```

Si vous voulez que `base44 dev` lance aussi votre front-end, vérifiez que `base44/config.jsonc` a bien `site.serveCommand` défini (par exemple, `"serveCommand": "npm run dev"`). Lorsque ce champ est présent, `base44 dev` lance le backend et le front-end ensemble.

### Déployer tous les changements

```bash theme={null}
# Générer les types (facultatif, pour les projets TypeScript)
npx base44 types generate

# Buildez d'abord votre projet
npm run build

# Déployez tout (entités, fonctions et site)
npx base44 deploy -y
```

### Générer les types TypeScript

```bash theme={null}
# Générer les types à partir des entités, fonctions, agents et connecteurs
npx base44 types generate
```

Cela crée `base44/.types/types.d.ts` avec des registres typés pour le module `@base44/sdk`. Exécutez-la après avoir modifié entités, fonctions, agents ou connecteurs pour garder vos types synchronisés. Aucune authentification requise.

### Déployer des ressources individuelles

```bash theme={null}
# Pousser uniquement les entités
npx base44 entities push

# Déployer uniquement les fonctions (toutes)
npx base44 functions deploy
# Déployer des fonctions spécifiques
npx base44 functions deploy my-function other-function
# Déployer et élaguer les fonctions supprimées
npx base44 functions deploy --force

# Pousser uniquement les agents
npx base44 agents push

# Récupérer les connecteurs de Base44
npx base44 connectors pull

# Pousser uniquement les connecteurs
npx base44 connectors push

# Déployer uniquement le site
npx base44 site deploy -y
```

### Ouvrir le tableau de bord

```bash theme={null}
# Ouvrir le tableau de bord de l'application dans le navigateur
npx base44 dashboard
```

## Authentification

La plupart des commandes nécessitent une authentification. Si vous n'êtes pas connecté, le CLI vous invitera automatiquement à vous connecter. Votre session est stockée localement et persiste entre les sessions CLI.

## Dépannage

| Erreur                               | Solution                                                                                                                      |
| ------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------- |
| Non authentifié                      | Exécutez d'abord `npx base44 login`                                                                                           |
| Aucune entité trouvée                | Assurez-vous que des entités existent dans le répertoire `base44/entities/`                                                   |
| Entité non reconnue                  | Assurez-vous que le fichier utilise le nommage kebab-case (par exemple, `team-member.jsonc` et non `TeamMember.jsonc`)        |
| Aucune fonction trouvée              | Assurez-vous que des fonctions existent dans `base44/functions/` avec `entry.ts` ou `entry.js`                                |
| Aucun agent trouvé                   | Assurez-vous que des agents existent dans `base44/agents/` avec des configs `.jsonc` valides                                  |
| Nom d'agent invalide                 | Les noms d'agents doivent être alphanumériques en minuscules avec underscores uniquement                                      |
| Aucun connecteur trouvé              | Assurez-vous que des connecteurs existent dans `base44/connectors/` avec des configs `.jsonc` valides                         |
| Type de connecteur invalide          | Exécutez `npx base44 connectors list-available` pour voir les types valides                                                   |
| Type de connecteur en double         | Chaque type de connecteur ne peut être défini qu'une fois par projet                                                          |
| Timeout d'autorisation de connecteur | Réexécutez `npx base44 connectors push` et terminez le flux OAuth dans votre navigateur                                       |
| Aucune configuration de site trouvée | Vérifiez que `site.outputDirectory` est configuré dans la config du projet                                                    |
| Le déploiement du site échoue        | Assurez-vous d'avoir exécuté `npm run build` d'abord et que le build a réussi                                                 |
| Message de mise à jour disponible    | Si vous êtes invité à mettre à jour, exécutez `npm install -g base44@latest` (ou utilisez npx pour les installations locales) |

<Note>Cette page a été traduite à l'aide de l'IA. Pour les informations les plus précises et à jour, consultez la [version anglaise](/). </Note>