---
title: "CLI"
description: "La ligne de commande beeuni, son modèle d’authentification, la boucle de développement et chaque commande."
---

L’interface en ligne de commande (CLI) `beeuni` permet de contrôler Beeuni depuis un terminal — sur votre ordinateur ou dans un environnement de session isolé. Cette page présente le cycle de développement habituel, puis répertorie chaque commande stable et chaque option.

<a id="install"></a>

## Installation

```sh
curl -fsSL https://beeuni.ai/install | bash
```

Le programme d’installation télécharge un binaire précompilé pour macOS et Linux. Windows n’est pas pris en charge.

| Commande | Effet |
| --- | --- |
| `beeuni update` | Relancer le script d’installation et récupérer le dernier binaire. |
| `beeuni uninstall [-y\|--yes] [--keep-auth] [--keep-home]` | Supprimer le binaire, le shim `/usr/local/bin` et le jeton enregistré. `--keep-auth` conserve le jeton. `--keep-home` conserve `~/.beeuni`. |
| `beeuni version` | Afficher la version de la CLI. |

<a id="auth-model"></a>

## Modèle d’authentification

Beeuni stocke l’authentification par hôte, et non de façon globale. Un hôte correspond à un point de terminaison de l’API Beeuni. Utilisez `cloud` pour vous connecter à Beeuni.

Le fichier de configuration se trouve à l’emplacement `~/.config/beeuni/config.json`, avec le mode `0600`. Remplacez son chemin avec `BEEUNI_CONFIG_FILE`.

La CLI suit une hiérarchie : hôte → compte → projet → session. Vous vous connectez à un hôte, choisissez un compte dans cet hôte, choisissez un projet dans ce compte, puis ouvrez des sessions dans ce projet. `beeuni hosts login` exécute les trois premières étapes dans l’ordre : il vous connecte, choisit le compte, puis définit un projet par défaut.

Tous les jetons commencent par `beeuni_pat_`. Un jeton utilisateur, obtenu avec `beeuni login`, donne accès à tous les comptes et projets auxquels vous appartenez. Un jeton de projet est créé automatiquement pour un environnement de session isolé et limité à un seul projet. Consultez [Portée des jetons](#token-scope).

<a id="the-dev-loop"></a>

## Le cycle de développement

Ce cycle suppose que la CLI est installée et que vous avez exécuté `beeuni login`. Consultez [Démarrage rapide](/docs/fr/quickstart) pour la configuration.

1. **Associer un dépôt**

    Créez un projet ou associez-y un dossier de dépôt existant.

    Pour créer un nouveau projet à partir d’un modèle :

    ```sh
    beeuni init my-app
    cd my-app
    ```

    `beeuni init` crée un répertoire de projet avec le modèle généraliste. Son fichier
    `beeuni.yaml` déclare `beeuni_version: 2` et lance le
    [harness du moteur d’agent par défaut](/docs/fr/work/harnesses).

    Pour associer un dépôt cloné existant à un projet que vous avez déjà créé :

    ```sh
    beeuni projects link <project-id>
    ```

    Cette commande écrit `.beeuni/link.json` dans le répertoire actuel. Beeuni lit ce fichier pour retrouver votre projet à chaque exécution d’une commande depuis ce dossier. Si vous comptez d’abord exécuter `beeuni ship`, ignorez cette étape. Cette commande associe un nouveau projet pour vous si aucun n’existe.

2. **Envoyer votre code**

    ```sh
    beeuni ship
    ```

    `beeuni ship` vérifie votre `beeuni.yaml`, valide les modifications locales, pousse votre branche et vous invite à fournir tout secret ou toute connexion manquants. Exécutez cette commande chaque fois que vous souhaitez envoyer vos modifications locales vers le projet cloud. Lors de la première exécution, elle crée aussi le projet cloud et le dépôt si vous n’en avez pas encore associé.

3. **Lancer des sessions et s’y connecter**

    Démarrez une session avec une invite :

    ```sh
    beeuni sessions new --prompt "Build the login page" --wait
    ```

    Chaque session s’exécute dans son propre environnement isolé et sur sa propre branche. `--wait` attend que la session soit prête.

    Connectez-vous à une session depuis votre terminal :

    ```sh
    beeuni connect
    ```

    Sans identifiant de session, `beeuni connect` (alias : `attach`) ouvre un sélecteur de session
    pour le projet associé — les sessions en cours s’ouvrent immédiatement, celles qui sont arrêtées démarrent d’abord, et `+ New session` lance un nouvel environnement isolé — puis ouvre l’interface TUI complète du moteur d’agent par défaut connectée à cette session. Indiquez un identifiant pour ignorer le sélecteur :
    `beeuni connect <session-id>`.

    La CLI gère le binaire `opencode` pour vous : lors de la première connexion, elle télécharge
    la version exacte utilisée par le serveur de la session et la met en cache dans
    `~/.beeuni/opencode/<version>/`, afin que la TUI et le serveur utilisent toujours la même version. Définissez
    `BEEUNI_OPENCODE_BIN` pour utiliser votre propre binaire.

    Une session utilisant le [harness pi](/docs/fr/work/harnesses) ne dispose pas de serveur du moteur d’agent par défaut.
    `beeuni connect` renvoie le code de sortie 1 pour cette session, avec le message `This session's runtime does
    not support attaching a terminal client.`

    Pour une conversation plus légère, sous forme de lignes, plutôt que l’interface TUI complète, exécutez :

    ```sh
    beeuni sessions chat
    ```

    Cette commande ouvre une conversation interactive avec votre session la plus récente. Ajoutez un identifiant pour cibler une session précise : `beeuni sessions chat <id>`.

    Pour utiliser l’ensemble du produit dans votre terminal — liste des sessions, transcription et zone de saisie, shell dans l’environnement isolé, ainsi que les écrans Files, Review, Apps, Customize et Account — lancez le client terminal expérimental :

    ```sh
    beeuni tui        # or: beeuni t, or beeunit
    beeunit --project <id> --new --terminal   # new session + sandbox shell, one command
    ```

    Il se connecte à l’hôte que vous utilisez déjà. Consultez [la page de la TUI](/docs/fr/cli#sessions).

    Pour ouvrir un shell brut dans l’environnement isolé, sans agent, exécutez :

    ```sh
    beeuni sessions shell
    ```

    Affichez vos sessions en cours à tout moment :

    ```sh
    beeuni sessions ls
    ```

4. **Examiner les demandes de modification**

    Un agent ouvre une demande de modification (CR) lorsque sa session comporte des commits prêts à être fusionnés. Affichez, examinez et fusionnez-les depuis la CLI.

    ```sh
    beeuni cr ls
    beeuni cr diff 1
    beeuni cr merge 1
    ```

    `beeuni cr ls` affiche les demandes de modification du projet associé. `beeuni cr diff <cr>` affiche le correctif unifié. `beeuni cr merge <cr>` le fusionne dans la branche par défaut du projet. Indiquez le numéro de la CR ou son identifiant complet.

<a id="reference"></a>

## Référence

<a id="auth-commands"></a>

### Commandes d’authentification

| Commande | Effet |
| --- | --- |
| `beeuni login [--host <name>] [--api <url>] [--token <pat>] [--account <slug>] [--no-project]` | Se connecter à l’hôte actif ou à celui indiqué. Ouvre un navigateur par défaut ; `--token` permet de se connecter sans interface. `--no-project` ignore le choix du projet par défaut. |
| `beeuni logout [--host <name>]` | Supprimer le jeton de l’hôte actif ou de celui indiqué. |
| `beeuni whoami [--host <name>] [--json] [--token-only]` | Afficher l’utilisateur connecté et le compte actif. |
| `beeuni token [--host <name>]` | Raccourci pour `beeuni whoami --token-only`. |

`beeuni hosts login` / `hosts logout` / `hosts whoami` sont les formes canoniques. `login` / `logout` / `whoami` sont des raccourcis qui agissent sur l’hôte actif.

<a id="hosts"></a>

### Hôtes

| Commande | Effet |
| --- | --- |
| `beeuni hosts ls [--json]` | Lister tous les hôtes et leur état d’authentification. |
| `beeuni hosts login [<name>] [--token <pat>] [--api <url>] [--account <slug>] [--no-project]` | Se connecter à un hôte. Si le nom est inconnu, l’hôte est d’abord enregistré. |
| `beeuni hosts logout [<name>]` | Supprimer le jeton d’un hôte. |
| `beeuni hosts use <name>` | Changer d’hôte actif. |
| `beeuni hosts add <name> --url <url> [--dashboard-url <url>] [--login]` | Enregistrer un nouvel hôte. `--login` connecte ensuite à cet hôte. |
| `beeuni hosts rm <name> [--force]` | Supprimer un hôte. |
| `beeuni hosts info [<name>] [--json]` | Afficher les détails d’un hôte. |
| `beeuni hosts current [--json]` | Afficher le nom de l’hôte actif. |

L’URL d’un hôte distant qui commence par `http://` est normalisée en `https://`. La CLI n’envoie jamais de jeton à un hôte distant via HTTP non chiffré. `localhost` fait exception.

<a id="accounts"></a>

### Comptes

| Commande | Effet |
| --- | --- |
| `beeuni accounts ls [--json]` | Lister les comptes auxquels vous appartenez sur l’hôte actif. |
| `beeuni accounts use [<slug-or-id>]` | Changer de compte actif. |
| `beeuni accounts current [--json]` | Afficher le compte actif. |
| `beeuni accounts info [<slug-or-id>] [--json]` | Afficher un compte. |

<a id="members"></a>

### Membres

Qui appartient au compte et quel est son rôle dans celui-ci. Les rôles sont `owner`,
`admin` et `member`. Les propriétaires et les administrateurs disposent implicitement du rôle Manager dans chaque projet. `member` est donc le seul rôle qui nécessite des autorisations propres à chaque projet.

| Commande | Effet |
| --- | --- |
| `beeuni members ls [--json]` | Lister les membres, leurs rôles et le nombre de projets. |
| `beeuni members invite <email> --role admin\|member [--project <id>:<role>]` | Inviter par e-mail. Un utilisateur Beeuni existant est ajouté immédiatement ; toute autre personne reçoit un lien d’invitation par e-mail. `--project` peut être répété et s’applique lorsque l’invitation est acceptée. Nécessite `member.invite`. |
| `beeuni members set-role <user\|email> --role owner\|admin\|member` | Modifier le rôle d’un compte. Nécessite `member.update` ; le rôle `owner` est réservé au propriétaire. |
| `beeuni members rm <user\|email> [-y\|--yes]` | Supprimer un membre et révoquer ses jetons. Nécessite `member.remove`. |
| `beeuni members super-admin <user\|email> on\|off` | Accorder ou révoquer l’accès de contournement super-admin. Nécessite `member.super_admin.grant`. |
| `beeuni members invites ls [--json]` | Lister les invitations en attente que vous avez envoyées. |
| `beeuni members invites cancel <invite-id>` | Annuler une invitation en attente. |
| `beeuni members invites resend <invite-id>` | Renvoyer l’e-mail et réinitialiser l’expiration de 14 jours. |

Un `<user>` est un identifiant utilisateur ou l’adresse e-mail d’une personne déjà membre du compte.
Options : `--account <id>`, `--host <name>`, `--json`, `-y`.

<a id="groups"></a>

### Groupes

Un groupe de comptes est un ensemble nommé de personnes auxquelles vous attribuez un rôle en une seule fois. Associez un groupe à une portée avec `beeuni access grant --group <id> --role <key>` ; révoquez cette association avec `beeuni access revoke <assignment-id>`.

| Commande | Effet |
| --- | --- |
| `beeuni groups ls [--json]` | Liste les groupes avec le nombre de membres et de projets. |
| `beeuni groups create <name> [--description <t>]` | Crée un groupe. |
| `beeuni groups set <group> [--name <n>] [--description <t>\|--no-description]` | Renomme ou modifie la description d'un groupe. |
| `beeuni groups rm <group> [-y\|--yes]` | Supprime un groupe. Ses autorisations sont également supprimées. |
| `beeuni groups members <group> [--json]` | Liste les membres d'un groupe. |
| `beeuni groups add <group> <user>...` | Ajoute une ou plusieurs personnes. |
| `beeuni groups remove <group> <user>` | Retire une personne. |
| `beeuni groups projects <group> [--json]` | Indique les projets accessibles au groupe et le rôle associé. |

Un `<group>` est un identifiant de groupe ou son nom exact. Les lectures nécessitent `group.read`.
`create`, `set` et `add` nécessitent `group.update` ou `group.members.manage`, ainsi que le droit `rbac` de l'entreprise. `rm` et `remove` servent au nettoyage et ne sont jamais soumis à des droits.

<a id="tokens"></a>

### Jetons

Identifiants non interactifs du compte. Les lectures nécessitent `token.read`. Chaque membre du compte peut créer et révoquer ses propres clés personnelles (`token.personal.create`, `token.personal.revoke`) ; une clé personnelle agit en votre nom et ne possède jamais plus de vos propres rôles. Les comptes de service et les clés d'autres personnes nécessitent `token.create` / `token.revoke` (propriétaire et administrateur).

| Commande | Effet |
| --- | --- |
| `beeuni tokens ls [--mine] [--json]` | Liste les clés API personnelles du compte. `--mine` limite la liste à celles que vous avez créées. |
| `beeuni tokens new <name> [--expires <when>] [--project <id>]` | Crée une clé. Le secret n'est affiché qu'une fois. `--project` l'associe à un seul projet, qu'elle ne peut jamais quitter. |
| `beeuni tokens rm <token-id> [-y\|--yes]` | Révoque immédiatement une clé. |
| `beeuni tokens apps ls [--json]` | Liste vos applications connectées : les applications et clients MCP que vous avez approuvés avec Sign in with Beeuni, pour tous les comptes. |
| `beeuni tokens apps rm <client-id> [-y\|--yes] [--json]` | Révoque une application connectée : ses jetons cessent immédiatement de fonctionner et elle doit vous redemander l'autorisation. |
| `beeuni tokens service-accounts ls [--json]` | Liste les comptes de service. |
| `beeuni tokens service-accounts new <name> [--description <t>] [--expires <when>]` | En crée un. Le bearer n'est affiché qu'une fois. |
| `beeuni tokens service-accounts disable <id>` | Désactive un compte de service : il ne peut plus s'authentifier ; supprimez-le et recréez-le pour le réactiver. |
| `beeuni tokens service-accounts rm <id> [-y\|--yes]` | Supprime définitivement un compte de service. |

Une clé API personnelle agit en votre nom et expire avec votre adhésion. Un compte de service agit en son propre nom et n'hérite d'aucun accès : un nouveau compte ne possède aucune autorisation. Accordez-lui-en une avec `beeuni access grant --service-account <id> --role <key>`.
`--expires <when>` accepte une date ISO-8601 ou une durée à partir de maintenant : `30d`, `12h`, `6w`, `1y`.

<a id="billing"></a>

### Facturation

Lisez le forfait, les crédits et les dépenses du compte actif. Lecture seule : les changements de forfait, les recharges et les moyens de paiement se font dans le tableau de bord.

| Commande | Effet |
| --- | --- |
| `beeuni billing status [--json]` | Forfait, crédits, sièges et abonnement. |
| `beeuni billing transactions [--limit <n>] [--offset <n>] [--type <a,b>] [--json]` | Registre des crédits, du plus récent au plus ancien. Taille de page par défaut : 50. |
| `beeuni billing transactions --summary\|--breakdown\|--usage [--days <n>]` | Crédits entrants/sortants, répartition du solde (expirants/non expirants/quotidiens) ou résumé de l'utilisation des crédits. `--days` définit la fenêtre pour `--summary` et `--usage` ; valeur par défaut : 30. |
| `beeuni billing costs [--since <iso>] [--until <iso>] [--json]` | Dépenses du compte sur une période, avec ventilation par modèle. Fenêtre par défaut : 30 jours, demi-ouverte `[from, to)` UTC. |
| `beeuni billing costs --by project\|session [--sort <k>] [--limit <n>] [--offset <n>] [--csv <file>]` | Regroupe les dépenses par projet ou par session. `--sort` accepte `total_desc` (par défaut), `total_asc`, `recent` ou `name_asc` (`--by project` uniquement). `--csv` nécessite `--by`. |

Filtres : `--project <id>`, `--session <id>` et `--owner <id>` (sessions, avec `--by session`). Options : `--account <id>`, `--host <name>`, `--json`.

<a id="projects"></a>

### Projets

Une commande détermine « le projet » dans cet ordre :

1. L'option `--project`.
2. La variable d'environnement `BEEUNI_PROJECT_ID`.
3. `.beeuni/link.json` dans le répertoire de travail exact.
4. La valeur par défaut globale définie par `beeuni projects use`.

| Commande | Effet |
| --- | --- |
| `beeuni projects ls [--all] [--query <text>] [--json]` | Liste les projets du compte actif. `--all` couvre tous les comptes auxquels vous appartenez. `--query` (alias `-q`) filtre par nom, identifiant ou dépôt. |
| `beeuni projects info [<id>] [--json]` | Affiche un projet. Par défaut : le projet associé ou le projet par défaut. |
| `beeuni projects use [<id>]` | Définit le projet par défaut global. Change de compte actif si le projet se trouve ailleurs. |
| `beeuni projects unset` | Efface le projet par défaut global. |
| `beeuni projects link [<id>]` | Associe le répertoire actuel à un projet. Écrit `.beeuni/link.json`. |
| `beeuni projects unlink` | Supprime `.beeuni/link.json`. |
| `beeuni projects open [<id>]` | Ouvre la page du tableau de bord d'un projet dans votre navigateur. |
| `beeuni projects clone [<id>] [dir]` | Clone le dépôt d'un projet via le proxy git Beeuni authentifié. |
| `beeuni projects rm [<id>] [-y\|--yes]` | Supprime un projet et son dépôt git géré par Beeuni. Les dépôts que vous avez connectés vous-même ne sont jamais modifiés. |
| `beeuni projects set [<id>] [--name <n>] [--branch <b>] [--manifest <path>] [--json]` | Met à jour les paramètres d'un projet. Seuls les champs transmis sont écrits. Si aucun champ n'est transmis, quitte `2`. Alias : `update`. |
| `beeuni projects set [<id>] --icon <emoji>\|--no-icon\|--glyph <name>:<color>\|--no-glyph` | Définit ou supprime l'icône du projet. |
| `beeuni projects rename [<id>] <name>` | Alias de `beeuni projects set --name <name>`. |
| `beeuni projects features [ls] [--json]` | Liste chaque indicateur de fonctionnalité avec sa clé, son état, son origine et sa stabilité. |
| `beeuni projects features enable\|disable\|reset <flag>` | Active ou désactive la surcharge du projet, ou l'efface afin que l'indicateur suive la valeur par défaut de la plateforme. |
| `beeuni projects cli-tokens ls [--json]` | Liste les jetons CLI du projet. |
| `beeuni projects cli-tokens new [--name <name>] [--expires-at <iso>]` | Crée un jeton CLI limité au projet. Le secret n'est affiché qu'une fois. |
| `beeuni projects cli-tokens rm <token-id> [-y\|--yes]` | Révoque un jeton CLI du projet. |
| `beeuni projects upgrade [<id>] [--json]` | Démarre la session de l'agent qui migre un `beeuni.toml` v1 vers un `beeuni.yaml` v2 et ouvre une demande de modification. |

Un projet n'affiche qu'une seule icône : écrire `--icon` efface le glyphe et écrire `--glyph` efface l'emoji ; transmettre les deux est refusé. Couleurs des glyphes : `grey`, `red`, `orange`, `yellow`, `lime`, `blue`, `purple`, `magenta`. `set` et `features` nécessitent `project.settings.write`. Un indicateur que la plateforme marque comme indisponible reste désactivé, quelle que soit la surcharge du projet.

Un jeton CLI de projet est associé à un seul projet — l'API le rejette partout ailleurs. Un bac à sable de session utilise son `BEEUNI_TOKEN` associé à la session. `cli-tokens ls` nécessite l'accès en lecture au projet ; `new` et `rm` nécessitent `project.credentials.issue`. Un jeton associé à une session ne peut ni créer ni révoquer de jetons de projet (`403`), que le projet déclare ou non des agents. Un jeton CLI de projet suit la politique PAT du compte : lorsque le compte exige une expiration, transmettez `--expires-at` ; une expiration dépassant la durée de vie maximale renvoie `400`.

`beeuni projects upgrade` nécessite l'accès en écriture au projet. L'agent par défaut actualise la référence du marketplace, réécrit le manifeste, exécute `beeuni validate` et ouvre une demande de modification. Il ne fusionne jamais les modifications : un humain examine le diff.

<a id="project-scaffold"></a>

### Structure du projet

`beeuni init [project-name] [options]` crée un nouveau répertoire de projet. Le modèle initial écrit un `beeuni.yaml` v2, `agents/`, `skills/`, `memory/` et `harnesses/opencode/`. La commande peut configurer la détection des outils de codage locaux sans modifier le moteur d’agent par défaut. Elle n'écrit pas `.beeuni/link.json`. `beeuni ship` ou `beeuni projects link` créent ce fichier.

| Option | Signification |
| --- | --- |
| `--name <project>` | Nom du projet. |
| `--primary <agent>` | Agent principal. |
| `--agents <csv>` | Intégrations d'agents de codage locaux à configurer. |
| `--force` | Configure le répertoire actuel sur place au lieu d'en créer un nouveau. |
| `--overwrite` | Écrase les fichiers existants. |
| `--no-git` | Ignore l'initialisation de git. |
| `-y, --yes` | Ne demande pas de confirmation. |

La sélection de l'outil de codage local ne modifie pas le moteur d’agent par défaut.

`beeuni init` n'inclut pas de sélecteur de marketplace. Ajouter une compétence de marketplace est une importation d'agent : démarrez une session et demandez à l'agent d'en importer une.

<a id="ship"></a>

### Livraison

`beeuni ship` prépare, valide et pousse votre branche actuelle vers le dépôt git du projet. Exécutez-la une fois pour créer le projet, puis à nouveau à tout moment pour le synchroniser. Alias : `beeuni deploy`.

À chaque exécution :
- Exécute les vérifications [`beeuni validate`](#manifest-validation) : `beeuni.yaml` fusionné avec tous les fichiers qu’il répertorie sous [`imports:`](/docs/fr/project/manifest#imports), les Dockerfiles du bac à sable, le câblage de l’agent et la taille du dépôt (ignorer avec `--no-verify`). Une erreur bloque la publication. Un avertissement ne la bloque jamais.
- Valide toute modification non validée de l’arborescence de travail (ignorer avec `--no-commit`).
- Demande tout secret `env` manquant (ignorer avec `--no-env`).
- Pousse la branche actuelle vers la branche distante du même nom.
- Connecte tout connecteur déclaré qui nécessite encore une authentification (ignorer avec `--no-connect`).

Un `origin` GitHub existant est associé via l’application Beeuni GitHub. Tout autre `origin` existant est enregistré tel quel. Sans `origin`, un dépôt git Beeuni géré est créé.

| Option | Effet |
| --- | --- |
| `--name <project>` | Nom d’affichage d’un nouveau projet. |
| `--account <id\|slug>` | Compte sous lequel créer le projet (uniquement lors de la première publication). |
| `--origin <managed\|git-url>` | Remplace le choix de source déduit automatiquement. |
| `--github-token <pat>` | Associe une source GitHub avec ce jeton plutôt qu’avec l’application GitHub. |
| `-m, --message <text>` | Message de commit. |
| `--no-commit` / `--no-verify` / `--no-env` / `--no-connect` | Ignorer cette étape. |
| `-y, --yes` | Ne pas demander de confirmation. |
| `-n, --dry-run` | Afficher ce qui se passerait, sans rien modifier. |
| `--project <id>` / `--host <name>` | Cibler un projet ou un hôte autre que celui par défaut. |

<a id="apps"></a>

### Applications

Apps héberge des sites statiques, serveurs, tâches et bases de données. Chaque App possède une URL stable. Une version contient le code et la configuration ; un déploiement échoué ne remplace pas la version active.

```bash
beeuni apps list
beeuni apps show main
beeuni apps connect main
beeuni apps launch --template convex --slug main
beeuni apps deploy dist --type static --spa
beeuni apps machines main
beeuni apps volumes main
```

Reliez les Apps avec `uses` et les exemples de `beeuni apps connect`. Ne placez pas les identifiants administratifs dans le code client.

Les ressources actives consomment les crédits du compte. Consultez Billing et Usage. Apps ne possède pas de budget mensuel distinct.

[Apps](/docs/feature-flags/apps)

### Sessions

Chaque session s’exécute dans un bac à sable sur sa propre branche.

| Commande | Effet |
| --- | --- |
| `beeuni sessions ls [--mine\|--shared\|--automated] [--search <q>] [--label <label>]... [--json]` | Liste les sessions. `--label` peut être répété ; une session doit porter toutes les étiquettes indiquées. Une colonne LABELS apparaît si une session listée possède des étiquettes. |
| `beeuni sessions status [--all] [--json]` | Toutes les sessions et l’activité actuelle de leur agent. Alias : `overview`, `ps`. |
| `beeuni sessions info <id> [--json]` | Vue détaillée : état, branche, agent, URL du sandbox. |
| `beeuni sessions new [--prompt "<text>"] [--agent <name>] [--model <id>] [--wait] [--connect] [--json]` | Démarre une session. `--connect` ouvre l’interface TUI du moteur d’agent par défaut dès qu’elle est prête (implique `--wait`) ; dans un terminal interactif sans cette option, l’interface demande si vous souhaitez vous connecter après la création. `--model <id>` remplace le modèle par défaut du projet ; un modèle utilisant une clé API ou un abonnement ChatGPT utilise toutes les clés disponibles pour ce modèle, qui alternent. `--wait` attend que la session soit en cours d’exécution (jusqu’à ~5 minutes). Utilisez `--secret <id>` ou `--no-secrets` pour limiter l’accès aux Secrets. Ces options Secret nécessitent un jeton de backend. Utilisez `--connector <alias>=<authorization-id>` ou `--no-connectors` pour définir l’accès aux Connectors. Utilisez `--require-connector <alias>` pour exiger une autorisation avant le provisionnement. Les options de portée peuvent être répétées. Utilisez `--context <key>=<value>` pour le contexte d’exécution non secret. `--label <label>` (répétable) catégorise la session ; `--meta <key>=<value>` (répétable) stocke une chaîne dans ses métadonnées. |
| `beeuni sessions chat [<id>] [--prompt "<text>"] [--queue \| --steer] [--new] [--agent <name>] [--json]` | Discute avec l’agent d’une session. Mode interactif par défaut. Alias : `talk`. La commande de premier niveau `beeuni chat` fonctionne aussi. `--queue` est réservé à un seul envoi : il stocke l’invite dans la boîte de réception persistante de la session et retourne dès qu’elle est enregistrée, au lieu de la transmettre à l’environnement d’exécution. `--steer` la stocke de la même façon, et le tour en cours la lit à l’étape suivante sans s’arrêter. Si aucun tour n’est en cours, il en démarre un. Une session qui ne peut pas être pilotée l’exécute comme `--queue`. |
| `beeuni sessions connect [<id>] [-- <opencode args>]` | Ouvre l’interface TUI du moteur d’agent par défaut sur le serveur du moteur d’agent par défaut de la session. Également disponible au premier niveau : `beeuni connect` / `beeuni attach`. Sans identifiant, ouvre un sélecteur de session (en cours d’exécution, arrêtée avec redémarrage possible, ou nouvelle). L’interface télécharge automatiquement le binaire `opencode` correspondant à la version (cache : `~/.beeuni/opencode/<version>/` ; remplacement : `BEEUNI_OPENCODE_BIN`). Une session pi n’a pas de serveur opencode : la commande quitte avec le code `1` et indique plutôt `beeuni sessions shell` et `beeuni sessions chat`. |
| `beeuni tui [--host <name>] [--project <id>] [--session <id>] [--new] [--agent <name>] [--terminal] [--no-sidebar] [--mouse] [--install] [--uninstall]` | **Expérimental.** Ouvre le client terminal Beeuni : sessions, transcription, zone de saisie, shell du sandbox, Files, Review, Apps, Customize et Account. Alias `beeuni t` et `beeunit`. `--new` crée une session dans le projet au démarrage (`--agent` choisit l’agent), `--terminal` ouvre le shell du sandbox avec le focus, `--no-sidebar` démarre sans la barre latérale (`Alt+B` l’affiche ou la masque), `--mouse` confie le contrôle de la souris à l’application (désactivé par défaut pour que la sélection, la copie et les clics sur les liens de votre terminal continuent de fonctionner). L’interface TUI est un binaire distinct d’environ 80 Mo ; au premier lancement, une confirmation est demandée, puis le binaire `beeuni-tui` correspondant à la version est installé dans `~/.beeuni/tui/<version>/` ; les mises à jour ultérieures de l’interface actualisent le binaire sans demander confirmation et réutilisent un binaire inchangé. `--install` effectue l’installation sans demander confirmation, `--uninstall` le supprime. Utilise l’hôte actif, sauf si `--host` en indique un autre ; si aucun hôte n’est connecté, l’interface ouvre son propre écran de connexion. `?` affiche toutes les combinaisons de touches. Voir [/docs/cli#sessions](/docs/fr/cli#sessions). |
| `beeuni sessions shell [<id>] [--new]` | Ouvre un terminal interactif brut dans le sandbox, sans agent. Se rattache au terminal existant de la session ; `--new` en démarre toujours un nouveau. Alias : `terminal`, `ssh`. |
| `beeuni sessions shell <id> ls [--json]` | Liste les terminaux de la session : identifiant, état, commande. Ne nécessite pas de TTY. |
| `beeuni sessions shell <id> kill <pty-id>` | Ferme un terminal. Le shell ambiant est recréé au prochain rattachement ; les processus qui y sont exécutés ne le sont pas. |
| `beeuni sessions forward <id> --port <sandbox>[:<local>]` | Transfère un port du sandbox vers votre machine, comme dans VS Code, afin que `http://localhost:3000` imprimée par un agent fonctionne dans votre navigateur. `--port` peut être répétée ; si aucun port local n’est indiqué, le même numéro est utilisé s’il est libre, sinon le prochain port libre ; `:0` demande un port éphémère attribué par le système d’exploitation. Le transfert prend en charge HTTP et WebSocket (le rechargement à chaud du serveur de développement fonctionne). Affiche une ligne `⇄ localhost:N → sandbox:M` par transfert et reste au premier plan jusqu’à Ctrl+C. Ne démarre pas une session arrêtée : affiche plutôt la solution `beeuni sessions restart`. Alias : `ports`. |
| `beeuni sessions log [<id>] [--limit <n>] [--json]` | Affiche les messages récents en lecture seule. Une session en cours d’exécution est lue en direct ; une session arrêtée est lue à partir de la transcription enregistrée à la fin de chaque tour. Elle n’est donc jamais réactivée uniquement pour être lue. La source est indiquée sur stderr, afin que la sortie `--json` reste inchangée. Alias : `messages`, `history`. |
| `beeuni sessions attachments <id> [--download <attachment-id>\|--all] [--out <dir>] [--json]` | Liste les fichiers stockés pour une session — pièces jointes des utilisateurs et copies des fichiers présentés par l’agent — et les télécharge. Fonctionne lorsque la session est arrêtée : ni la liste ni les fichiers ne nécessitent son sandbox. Les téléchargements n’écrasent jamais un fichier existant ; un nom déjà utilisé devient `name (1).ext`. |
| `beeuni sessions pending <id> [--json]` | Liste les demandes d’autorisation d’outil ou les questions en attente. Alias : `prompts`. |
| `beeuni sessions approve <id> [<req-id>] [--always] [--reject] [--message "<text>"]` | Répond à une demande d’autorisation. |
| `beeuni sessions answer <id> [<req-id>] [--option <v>]... [--text "<text>"] [--reject]` | Répond à une question. |
| `beeuni sessions digest [--since <7d>] [--json]` | Vue compacte pour examiner plusieurs sessions. La transcription d’une session arrêtée provient de sa copie enregistrée et porte la mention `saved` (et `partial` si cette copie ne remonte pas jusqu’au premier message). Alias : `review`, `summary`. |
| `beeuni sessions scope <id> [scope options] [--json]` | Consulte ou remplace l’accès aux Secrets et aux Connectors. Alias : `access`. Utilisez `--secret <id>`, `--no-secrets` ou `--inherit-secrets` pour les Secrets. Utilisez `--connector <alias>=<authorization-id>` ou `--no-connectors` pour les associations de Connectors. Utilisez `--require-connector <alias>` ou `--no-required-connectors` pour les Connectors obligatoires. Les catégories indiquées remplacent leurs valeurs actuelles. Les catégories omises restent inchangées. Les modifications s’appliquent à la prochaine invite. Les valeurs de Secret supprimées restent dans le contexte existant si la session les a déjà lues. |
| `beeuni sessions preview <id> [port] [--port <n>] [--list] [--json]` | Affiche une URL d’aperçu cliquable pour un port du sandbox. Port par défaut : `3000`. `--list` affiche plutôt les candidats indiqués. |
| `beeuni sessions restart <id>` | Redémarre le sandbox de la session. |
| `beeuni sessions rename <id> <name>` | Définit le nom d’une session. Indiquez `""` pour l’effacer. |
| `beeuni sessions update [<id>] [--label <l>]... [--unlabel <l>]... [--clear-labels] [--meta <key>=<value>]... [--unmeta <key>]... [--json]` | Modifie les étiquettes et les métadonnées d’une session. `--label` ajoute, `--unlabel` supprime, `--clear-labels` vide d’abord la liste ; `--meta` définit une clé chaîne, `--unmeta` supprime une clé. Sans identifiant, modifie `$BEEUNI_SESSION_ID`, afin qu’un agent puisse étiqueter la session dans laquelle il s’exécute. Alias : `label`. |
| `beeuni sessions rm <id>...` | Arrête et supprime une ou plusieurs sessions. |
| `beeuni sessions open <id>` | Ouvre la page du tableau de bord d’une session dans votre navigateur. |
| `beeuni sessions stop <id> [--json]` | Met une session en pause. Le sandbox s’arrête sur place et le disque est conservé. Alias : `pause`. Nécessite `project.session.stop`. |
| `beeuni sessions start <id> [--wait] [--json]` | Réactive une session : provisionne un sandbox manquant, reprend une session arrêtée et résout son environnement d’exécution. L’opération est idempotente. Alias : `wake`. `--wait` attend que la session soit prête (jusqu’à ~5 min) et quitte avec le code `1` si la session finit en échec ou à l’arrêt. |
| `beeuni sessions warm [--exclude <id>] [--json]` | Crée à l’avance la session que vous allez utiliser, afin que le sandbox soit déjà démarré. Réutilise une session préchauffée existante et inutilisée. Une session préchauffée reste masquée dans `sessions ls` jusqu’à sa première invite. |
| `beeuni sessions model <id> <model-id> [--json]` | Modifie le modèle utilisé par une session en cours. Un sandbox actif est redirigé vers le nouveau modèle et son environnement d’exécution redémarre, ce qui met fin au tour en cours ; une session arrêtée enregistre la valeur pour son prochain démarrage. Une session pour laquelle aucune clé n’est sélectionnée chez le fournisseur du nouveau modèle reçoit toutes les clés disponibles pour ce fournisseur. |
| `beeuni sessions compact <id> [--json]` | Résumer la conversation jusqu’ici et continuer à partir du résumé. Une session dont l’environnement d’exécution ne répertorie pas `session.compact` se termine avec `1` comme motif. |
| `beeuni sessions queue <id> [ls] [--json]` | Lister les invites encore en attente dans la boîte de réception persistante de la session. |
| `beeuni sessions queue <id> rm <prompt-id>` | Supprimer une invite mise en file d’attente. Refusé (`409`) dès qu’une étape du modèle a commencé à y répondre. |
| `beeuni sessions queue <id> now <prompt-id>` | Exécuter ensuite une invite en attente : la remettre en file avant les autres selon la règle de priorité et lever la suspension de la session. |
| `beeuni sessions queue <id> hold\|release` | Suspendre toutes les invites en attente — ce que fait le bouton Stop — ou lever la suspension. |
| `beeuni sessions approvals <id> [ls] [--json]` | Lister les appels de connecteur soumis à approbation et en attente d’un humain dans cette session. |
| `beeuni sessions approvals <id> approve\|deny <execution-id>` | Autoriser l’exécution d’un appel de connecteur soumis à approbation, ou le refuser. L’agent en est informé et continue sans cet appel. |
| `beeuni sessions files <id> <subcommand> [--json]` | Lire et modifier l’espace de travail actif du bac à sable : `ls [<path>]`, `status`, `find <query>`, `write <path>`, `touch <path>`, `mkdir <path>`, `mv <from> <to>`, `rm <path>`. |
| `beeuni sessions share <id> [--mode private\|project\|members] [--member <id\|email>] [--group <id>] [--show] [--json]` | Définir qui, au sein de Beeuni, peut ouvrir cette session. Sans `--mode`, affiche le paramètre actuel et ne le modifie pas. `--member` et `--group` peuvent être répétés. |
| `beeuni sessions links <id> ls [--json]` | Lister tous les liens publics créés pour la session, du plus récent au plus ancien. |
| `beeuni sessions links <id> create [options]` | Créer un lien public sans authentification vers un port d’aperçu ou un fichier de l’espace de travail. |
| `beeuni sessions links <id> revoke <share-id>` | Révoquer un lien public. |

`sessions queue` nécessite `project.session.start` — la même autorisation que pour envoyer
un message. Une invite mise en file d’attente persiste à la fermeture du terminal et est transmise lorsque la
session peut la recevoir. Ajoutez-en une avec
`beeuni sessions chat <id> -p "…" --queue`, ou orientez le tour en cours avec
`--steer`. `sessions queue ls` affiche l’`DELIVERY` de chaque invite (`steer`,
`queue` ou `interrupt`) et, pour une invite d’orientation exécutée comme `queue`, le
motif : `unsupported` (la session ne peut pas recevoir de messages pendant un tour),
`not_prompter` (le tour d’un autre membre est en cours) ou `turn_ended`.

Les `sessions approvals` sont persistantes : contrairement aux `sessions pending`, elles survivent au
redémarrage du bac à sable. Il faut `project.members.manage`, ou être l’humain qui
a lancé la session. Un agent ne peut jamais résoudre sa propre demande d’approbation.

`sessions attachments` lit le stockage de fichiers privé de la session, et non son
espace de travail. Les fichiers y sont déposés au moment de l’envoi, et chaque fichier présenté par l’agent y est
déposé à la fin du tour.

`sessions files` lit l’arborescence de travail que l’agent modifie en ce moment, avant
que quoi que ce soit soit validé ; `beeuni files` lit plutôt le dépôt validé. Les chemins
sont résolus sous `/workspace`, sauf s’ils commencent par `/workspace`, `/tmp`,
`/home` ou `/opt`. La commande réveille le bac à sable s’il est en veille. Options :
`--from <local path>` (`write` lit ce fichier au lieu de stdin), `--content`
(`find` recherche dans le contenu avec ripgrep plutôt que dans les noms de fichiers), `--limit <N>`
(limite de fichiers `find`) et `-y` pour ignorer la confirmation `rm`.

`sessions share` est soumis au contrôle du propriétaire : l’API refuse les demandes d’un responsable de projet
qui ne peut pas déjà lire la session. Une session partagée s’exécute uniquement avec les clés du fournisseur
partagées avec l’ensemble du projet : un modèle exécuté avec vos propres clés passe aux clés du projet pour ce fournisseur ; si aucune clé de ce fournisseur n’est disponible, le partage est refusé (`409 SHARED_SESSION_NEEDS_PROJECT_KEY`).

Options de `sessions links create` : `--port <n>` (par défaut `3000` ; `22`, `8000`
et les ports opencode sont refusés), `--path <p>` (par défaut `/`),
`--preview <id>` (un candidat nommé — `web`, `vite`, `dev-server`, `api-docs` —
au lieu de `--port`/`--path`), `--file <path>` (partager un fichier de l’espace de travail
au lieu d’un aperçu ; toujours en lecture seule), `--mode view\|interactive` (par défaut `view` ;
`interactive` autorise les écritures et les websockets, et est ignoré pour `--file`),
`--label <text>` et `--expires <iso>`. La création d’un lien nécessite l’accord du propriétaire de la session,
car le lien lui-même ne nécessite aucune connexion ; la liste et la révocation sont également accessibles à un responsable de projet.

Dans un bac à sable, `BEEUNI_SESSION_ID` est l’identifiant de votre propre session.

<a id="change-requests"></a>

### Demandes de modification

Une demande de modification (CR) fusionne une branche dans une autre sur n’importe quel hébergeur Git. C’est le seul moyen pour un agent d’intégrer le travail de sa session dans la branche par défaut. Voir [Demandes de modification](/docs/fr/work/change-requests).

| Commande | Effet |
| --- | --- |
| `beeuni cr ls [--status open\|merged\|closed\|all] [--project <id>]` | Lister les CR. Par défaut : `--status open`. |
| `beeuni cr show <cr> [--project <id>]` | Afficher une CR, y compris son aperçu de fusion. Alias : `info`. |
| `beeuni cr diff <cr> [--no-color] [--json]` | Afficher le diff unifié d’une CR. |
| `beeuni cr open --title "<text>" [--description "<text>"] [--head <ref>] [--session <id>] [--base <ref>]` | Ouvrir une CR. Alias : `new`, `create`. Dans un bac à sable, `--head` et `--session` sont renseignés automatiquement par défaut. `--base` utilise par défaut la branche par défaut du projet. |
| `beeuni cr merge <cr> [--message "<text>"]` | Fusionner une CR ouverte. Avance rapide si possible, fusion à trois voies sinon. |
| `beeuni cr close <cr>` | Fermer une CR ouverte sans la fusionner. |
| `beeuni cr reopen <cr>` | Rouvrir une CR fermée. Les CR fusionnées sont définitives. |
| `beeuni cr merge-preview <cr> [--json]` | Indiquer si la CR peut être fusionnée et lister tous les chemins en conflit. Alias : `preview`. |
| `beeuni cr request-changes <cr> --message "<text>"` | Demander à l’agent qui a ouvert la CR de la réviser. Alias : `changes`. |
| `beeuni cr version-diff --from <ver> --into <ver> [--json]` | Résumer une version par rapport à une autre avant d’ouvrir une CR. |

`request-changes` ajoute une note à la CR et la transmet à la session d’origine, en démarrant son bac à sable s’il est en veille. Nécessite `project.review.act` —
la même autorisation terminale que celle utilisée par le Centre de révision, et non `gitops.push`.

`<cr>` accepte un numéro propre au projet (`3`) ou l’identifiant complet. Dans un bac à sable, l’interface en ligne de commande lit automatiquement son jeton — aucune connexion ni aucun lien ne sont nécessaires.

<a id="review"></a>

### Révision

La boîte de réception de révision du projet — tout ce qui attend une décision humaine : demandes de modification, appels d’outils de connecteur dont la politique exige une approbation, ainsi que les résultats, décisions et lots soumis par les agents pour approbation. Elle reflète le Centre de révision du tableau de bord. Activée pour tous les projets ; `project.review.read` et
`project.review.act` contrôlent la lecture et les actions.

| Commande | Effet |
| --- | --- |
| `beeuni review ls [--segment <s>] [--kind <k>] [--json]` | Lister les éléments de la boîte de réception. Par défaut : tous les segments. |
| `beeuni review show <item-id> [--json]` | Afficher un élément en entier. |
| `beeuni review act <item-id> <verdict> [--message <text>]` | Décider du sort d’un élément. `--message` contient la note. |
| `beeuni review bulk <verdict> <id> [<id> …]` | Décider du sort de plusieurs éléments natifs en un seul appel. |
| `beeuni review submit --kind <k> --title <t> [options]` | Soumettre un résultat, une décision ou un lot pour révision. |

Verdicts : `approve`, `reject`, `changes`, `answer`, `dismiss`. Segments :
`needs_you`, `waiting`, `done`. Types : `change`, `approval`, `output`,
`decision`, `batch`.

La destination d’un verdict dépend de l’identifiant de l’élément. Pour `cr:<id>`, `approve` fusionne
la modification, `reject` la ferme et `changes` renvoie la note à l’agent
qui l’a ouverte (`--message` requis). Pour `call:<id>`, `approve` autorise l’exécution de l’appel
et `reject` le refuse ; une approbation de connecteur n’accepte aucun autre verdict —
consultez d’abord ses arguments avec `beeuni review show`. Tous les autres identifiants sont traités par le point de terminaison d’action natif, qui accepte tous les verdicts.

`bulk` agit uniquement sur les identifiants natifs. Une approbation de connecteur nécessite l’examen de ses paramètres et une demande de modification nécessite de consulter son diff ; les deux sont signalées et ignorées — même règle que pour la sélection multiple du tableau de bord.

Options de `submit` : `--kind output\|decision\|batch` (obligatoire), `--title <text>`
(obligatoire), `--summary <text>`, `--risk none\|low\|medium\|high` (par défaut
`none`), `--detail <json>` (un objet JSON), `--agent <name>` et
`--session <id>` (ignoré si la session ne fait pas partie de ce projet).

La lecture nécessite `project.review.read`, les verdicts nécessitent `project.review.act` et
`submit` nécessite `project.review.submit`.

### Secrets

Valeurs chiffrées stockées sur le projet. Par défaut, un secret est injecté comme variable d’environnement en clair dans chaque sandbox de session au démarrage (exposition via l’environnement). La livraison renforcée — où la sandbox conserve un handle et où Beeuni substitue la valeur réelle à l’extérieur (exposition renforcée par la sortie, et `beeuni secrets call`) — est expérimentale. Activez l’indicateur de fonctionnalité `secrets_egress` (Settings → Feature flags) pour l’utiliser ; lorsqu’il est désactivé, `beeuni secrets delivery … egress` renvoie `403` `feature_disabled`. Voir [Secrets](/docs/fr/project/secrets).

| Commande | Effet |
| --- | --- |
| `beeuni secrets ls` | Répertorie les secrets par identifiant et spécification de manifeste `env`, avec les personnes pouvant utiliser chaque valeur. Marque les valeurs requises mais manquantes. |
| `beeuni secrets set NAME=VALUE ... [--identifier <id>] [--scope runtime\|connector] [--only-me]` | Crée ou met à jour un ou plusieurs secrets. `NAME=-` lit la valeur depuis stdin. `--scope connector` conserve la valeur côté serveur pour la passerelle de connecteurs. `--only-me` rend la nouvelle valeur utilisable uniquement par vous. |
| `beeuni secrets share IDENTIFIER --user <email\|id\|me> --group <id> --agent <name> \| --everyone` | Définit qui peut utiliser la valeur. Les personnes y accèdent directement ou dans leurs propres sessions privées ; un agent y accède dans chacune de ses sessions, déclencheurs compris. Voir [Qui peut utiliser un secret](/docs/fr/project/secrets#who-can-use-a-secret). |
| `beeuni secrets request NAME ... [--scope runtime\|connector] [--expires <min>]` | Génère un lien permettant à une personne de saisir une valeur que vous ne possédez pas. |
| `beeuni secrets unset NAME ...` | Supprime des secrets. |
| `beeuni secrets grant IDENTIFIER --agent <name>` | Permet à un agent de recevoir ce secret : fusionne l’identifiant dans la liste `secrets` de cet agent dans `beeuni.yaml`, en ajoutant l’entrée de l’agent si le manifeste l’omet. |

`grant` corrige une ligne que `ls` signale comme impossible à livrer. Il élargit uniquement la liste d’un agent ; pour la réduire ou la remplacer, réécrivez l’ensemble avec `beeuni
agents scope`. There is no `secrets revoke` — l’API ne propose aucune route supprimant un seul identifiant d’une autorisation. La première autorisation accordée sur un projet sans agent lance la gouvernance : dès lors, un agent absent du manifeste ne reçoit aucun secret du projet, et la commande l’indique lorsque cela se produit.

<a id="env"></a>

### Environnement

| Commande | Effet |
| --- | --- |
| `beeuni env pull [--out <path>] [--force]` | Écrit une structure `.env` — noms uniquement. Les valeurs ne quittent jamais le cloud. |
| `beeuni env push --from <path>` | Téléverse chaque `NAME=VALUE` d’un fichier dotenv comme secret. |

### Agents

Paramètres de modèle par agent sur le projet associé.

| Commande | Effet |
| --- | --- |
| `beeuni agents ls [--json]` | Affiche le modèle défini pour chaque agent et la valeur par défaut de secours. Alias : `models`. |
| `beeuni agents model <agent> <provider/model>` | Définit le modèle d’un agent. |
| `beeuni agents model <agent> --clear` | Supprime la définition — l’agent suit de nouveau la valeur par défaut. |
| `beeuni agents default <agent>` | Définit cet agent comme agent par défaut du projet. |
| `beeuni agents default --show [--json]` | Affiche l’agent par défaut actuel. |
| `beeuni agents scope <agent> [--secrets all\|none\|A,B] [--connectors all\|none\|a,b] [--apps all\|none\|a,b] [--require-connector <slug>]` | Remplace les secrets, connecteurs et Beeuni Apps que l’agent peut utiliser. `--apps` accepte des slugs d’Apps et nécessite un `beeuni.yaml` v2 ; l’agent nécessite également `project.app.read`. `--require-connector` peut être répété et doit être résolu avant le démarrage d’une session. |
| `beeuni agents scope <agent> --show [--json]` | Affiche la portée actuelle de l’agent. |
| `beeuni agents config <agent> [--json]` | Affiche le bloc de configuration complet de l’agent. |
| `beeuni agents config <agent> --file <path>` | Remplace le bloc par le contenu d’un fichier JSON. `-` lit stdin. |
| `beeuni agents config <agent> --set <key>=<value> ...` | Modifie des clés pointées individuelles, en les fusionnant. Peut être répété, par exemple `behavior.model=glm-5.3-flash`, `enabled=false`, `connectors=["slack"]`. |

Chaque option de portée remplace ; aucune ne fusionne. Une valeur `--set` est analysée comme JSON lorsqu’elle peut l’être, et conservée comme chaîne dans le cas contraire. Les définitions de modèles et `scope` s’appliquent instantanément, sans commit `beeuni.yaml` ; `default` et `config` effectuent un commit vers `beeuni.yaml` sur la branche par défaut du projet. `scope` nécessite `project.agent.write`, tout comme `default` et `config`.

<a id="tools"></a>

### Outils

Les outils dont disposent les sessions de ce projet, lus depuis le fichier `beeuni.yaml` local et ses [imports](/docs/fr/project/manifest#imports). Exécutez depuis la racine du projet. Voir [Outils](/docs/fr/project/tools).

| Commande | Effet |
| --- | --- |
| `beeuni tools ls [--json]` | Répertorie chaque outil disponible pour les sessions : nom, type (`beeuni`, `beeuni (overridden)`, `project`) et source (`beeuni:<name>` ou chemin du module). Répertorie également les outils Beeuni supprimés par le projet. `--json` affiche `{ manifest, tools_key, tools, removed }`. |
| `beeuni tools eject <name> [--force]` | Copie l’outil Beeuni `<name>` vers `tools/<name>.ts` et définit `tools.<name>: tools/<name>.ts` dans `beeuni.yaml`, dans le fichier qui le déclare. La ligne modifiée se termine par `# ejected from beeuni:<name>` ; tous les autres commentaires sont conservés. Sans clé `tools:`, répertorie également les quatre autres outils Beeuni afin que l’éjection ne supprime rien. Refuse l’opération lorsque `tools/<name>.ts` existe ou lorsque l’outil pointe déjà vers un autre module, sauf si `--force`. Refuse un nom qui n’est pas un outil Beeuni. |

Sans clé `tools:`, chaque session reçoit les cinq outils Beeuni (`web_search`, `image_search`, `scrape_webpage`, `memory`, `show`). Avec une clé `tools:`, les sessions reçoivent uniquement les outils Beeuni qu’elle répertorie. Pour supprimer un outil Beeuni, supprimez sa ligne sous `tools:`, puis exécutez `beeuni validate`. Pour limiter les outils d’un agent, utilisez `agents.<name>.tools`. Codes de sortie : `0` terminé, `1` refusé (un fichier existe, un manifeste ou un import ne peut pas être analysé), `2` aucun manifeste, option inconnue ou nom qui n’est pas un outil Beeuni.

<a id="models"></a>

### Modèles

Les modèles proposés par le projet et celui avec lequel il démarre. Même interface que la section Customize → Models du tableau de bord. Un projet ne stocke que ses exceptions à la valeur par défaut du catalogue (le modèle le plus récent de chaque famille). L’activation est uniquement visuelle : elle détermine ce que proposent les sélecteurs, jamais ce que la passerelle fournit.

| Commande | Effet |
| --- | --- |
| `beeuni models ls [--json]` | Répertorie chaque modèle que vous pouvez exécuter : état, origine, mode de paiement (`VIA` : Beeuni, clé API ou ChatGPT — le vôtre, partagé avec vous ou partagé avec le projet), fournisseur. |
| `beeuni models enable <model-id>...` | Propose ces modèles. |
| `beeuni models disable <model-id>...` | Cesse de les proposer. La valeur par défaut du projet est refusée avec `409` — modifiez d’abord la valeur par défaut. |
| `beeuni models reset` | Supprime toutes les exceptions et revient à la valeur par défaut du catalogue. |
| `beeuni models default [--json]` | Affiche la chaîne des valeurs par défaut (projet → compte → plateforme) et sa résolution. |
| `beeuni models default <model-id> [--account]` | Définit la valeur par défaut du projet, ou celle du compte avec `--account`. |
| `beeuni models default --clear [--account]` | Supprime la valeur par défaut du projet ou du compte. |

Les identifiants de modèles sont des identifiants filaires de la passerelle — un identifiant géré nu (`glm-5.3-flash`) ou un `provider/model` BYOK. Copiez-en un depuis `beeuni models ls --json`. Les définitions par agent se trouvent sur `beeuni agents model <agent> <model-id>`. Les écritures nécessitent `project.model.write`.

<a id="channels"></a>

### Canaux

Gère la connexion du projet à une plateforme de discussion. Les jetons sont stockés chiffrés dans les secrets du projet et résolus côté serveur — ils ne sont jamais injectés dans la sandbox.

| Commande | Effet |
| --- | --- |
| `beeuni channels status [--json]` | Affiche la connexion actuelle. |
| `beeuni channels connect [--wait] [--timeout <sec>]` | Se connecte en une étape : affiche un lien d’installation. `--wait` interroge jusqu’à ce que l’installation soit effectuée. |
| `beeuni channels connect --manual [--bot-token <token>] [--signing-secret <secret>]` | Mode d’utilisation de votre propre application : enregistre directement un jeton de bot et un secret de signature. |
| `beeuni channels disconnect [--platform slack\|teams]` | Supprime la connexion du projet — celle de Slack, ou celle de Teams avec `--platform teams`. |
| `beeuni channels manifest` | Affiche le JSON du manifeste d’application pour le parcours d’utilisation de votre propre application. |
| `beeuni channels email status [--json]` | Boîte de réception et mode de livraison pour un connecteur e-mail. |
| `beeuni channels email connect [options]` | Crée une boîte de réception gérée ou associe une boîte AgentMail existante. |
| `beeuni channels email disconnect` | Supprime la connexion de la boîte de réception. |
| `beeuni channels email policy [--allow <email\|@domain>] [--allow-regex <re>] [--allow-all]` | Remplace les personnes autorisées à envoyer des e-mails à l’agent. |
| `beeuni channels bindings [ls] [--json]` | Répertorie chaque canal associé ainsi que l’agent, le modèle et la politique d’adhésion auxquels il est résolu. |
| `beeuni channels bind <bindingId> [--agent <name>\|--no-agent] [--model <id>\|--no-model] [--policy <p>]` | Modifie une association. `--policy` accepte `owner_approval`, `owner_only` ou `project_open`. |

`--platform slack|teams` sélectionne la plateforme ; par défaut `slack`. Teams
`connect` affiche l’URL de consentement de l’administrateur Microsoft ; l’octroi du consentement à l’échelle du tenant
publie automatiquement l’application dans le catalogue Teams. Voir [Connectors](/docs/fr/connect/connectors).

Le canal e-mail repose sur AgentMail et nécessite le feature flag `agentmail_email`.
Options `email connect` : `--connector <slug>` (par défaut `beeuni_email`),
`--api-key <k>` (utilisez votre propre clé AgentMail ; `-` lit depuis stdin),
`--display-name <n>` (nom affiché comme expéditeur des e-mails sortants ; par défaut, le nom du projet),
`--username <u>` et `--domain <d>` (nouvelle boîte de réception gérée), et
`--inbox-id <id>` avec `--email <addr>` (associer une boîte de réception existante — les deux sont
obligatoires ensemble). `--allow` peut être répété et active le mode restreint ; une
valeur seule sans `@`, ou précédée de `@`, est interprétée comme un domaine.
`--allow-all` vide la liste et accepte à nouveau tous les expéditeurs.

Les écritures e-mail et `bind` nécessitent `project.connector.write`.

<a id="connectors"></a>

### Connecteurs

Les connecteurs sont des outils qu’un agent peut appeler. `add`, `rm` et `policy set` modifient le fichier local `beeuni.yaml` ; exécutez `beeuni ship` pour appliquer les changements, sauf si vous transmettez `--apply` pour modifier immédiatement le projet cloud.

| Commande | Effet |
| --- | --- |
| `beeuni connectors ls [--json]` | Lister les connecteurs et leur état. |
| `beeuni connectors show <slug> [--json]` | Afficher les outils d’un connecteur. |
| `beeuni connectors add <slug> --provider <p> [options] [--apply]` | Ajouter un connecteur. |
| `beeuni connectors rm <slug> [--apply]` | Supprimer un connecteur. |
| `beeuni connectors rename <slug> <name>` | Définir le nom d’affichage d’un connecteur. |
| `beeuni connectors sync` | Réconcilier le catalogue à partir de `beeuni.yaml` fourni. |
| `beeuni connectors credential <slug> [value]` | Définir les identifiants d’un connecteur. |
| `beeuni connectors connect <slug>` | Lancer un flux de connexion en un clic. |
| `beeuni connectors link <slug> [--expires <min>]` | Créer un lien de connexion partageable pour une personne. |
| `beeuni connectors types [--connector <a,b>] [--out <file>]` | Écrire les types TypeScript de chaque action appelable : un fichier `declare module '@beeuni/sdk'` qui type les arguments `connectors.callAction(slug, action, args)` et `output`. Les connecteurs gérés ne publient aucun schéma de sortie ; leur résultat est donc `unknown`. Sans `--out`, le résultat s’affiche dans stdout. |
| `beeuni connectors accounts <slug> [--default <label\|id>] [--json]` | Lister les comptes que vos appels peuvent utiliser, avec l’identité associée à chacun. `--default` en définit un comme compte fixe. |
| `beeuni connectors connections ls [--all] [--json]` | Lister les connexions avec leur libellé, `CONNECTED AS`, propriétaire, `WHO CAN USE` (`owner only`, `everyone` ou les libellés des autorisations, avec `(not you)` lorsque vous la listez uniquement pour la gérer), état et statut par défaut. |
| `beeuni connectors connections rename <id> <label…>` | Renommer une connexion. Seul le libellé change ; aucune nouvelle autorisation n’est demandée. |
| `beeuni connectors connections share <id> [--group <id>]… [--user <email\|id>]… [--everyone]` | Partager votre compte privé : il devient un compte partagé que seule cette personne peut utiliser (`--everyone` : tout le projet). Nécessite le droit de gérer les connexions du projet. |
| `beeuni connectors apps [<query>] [--category <c>] [--cursor <c>] [--limit <n>] [--json]` | Rechercher dans le catalogue des boîtes à outils gérées — les identifiants que `add --provider composio --app <slug>` accepte. Alias : `beeuni connectors toolkits`. Ajoutez `--pipedream` pour le catalogue hérité. |
| `beeuni connectors catalog [<query>] [--cursor <c>] [--json]` | Parcourir le catalogue des connecteurs directs. Nécessite le flag `connectors_api_discover`. |
| `beeuni connectors catalog show <id> [--json]` | Afficher les surfaces d’une fiche du catalogue. |
| `beeuni connectors sensitive <slug> on\|off` | Soumettre également les lectures de ce connecteur à un contrôle : chaque appel nécessite alors une approbation. Prend effet immédiatement. |
| `beeuni connectors owner <slug> project\|user` | Définir qui autorise : une connexion du projet ou chaque membre individuellement. Prend effet immédiatement. |
| `beeuni connectors authorize <slug> [--status] [--scope "<a b>"] [--client-id <id>] [--client-secret <s>] [--success-redirect <url>] [--error-redirect <url>] [--json]` | Configurer OAuth 2.1 de bout en bout pour un connecteur : découvrir les métadonnées d’autorisation du serveur, inscrire Beeuni comme client (RFC 7591) si le serveur le permet, puis afficher l’URL d’approbation. `--status` affiche le résultat à la place. |
| `beeuni connectors authorize <slug> --device` | Même chose, avec le flux OAuth 2.0 pour les appareils (RFC 8628) : afficher un code et une URL, puis vérifier jusqu’à l’approbation, au refus ou à l’expiration. |
| `beeuni connectors policy ls [--json]` | Afficher la politique d’exécution à l’échelle du projet. Alias : `show`. |
| `beeuni connectors policy set --default <risk\|allow_all> [--apply]` | Définir le mode d’exécution par défaut dans `beeuni.yaml`. `--apply` le définit directement. |
| `beeuni connectors policy add <match> <allow\|ask\|block> [--condition <k=v>]` | Ajouter une règle à l’échelle du projet. Prend effet immédiatement. `--condition` la limite à un argument correspondant et peut être répété ; `k!=v` inverse la correspondance, et `k` est un chemin en notation pointée dans les arguments de l’appel. |
| `beeuni connectors policy rm <match>` | Supprimer une règle à l’échelle du projet. Prend effet immédiatement. |
| `beeuni connectors policy <slug> ls\|set <match> <allow\|ask\|block>\|rm <match>\|clear` | Gérer les règles d’appel d’outils d’un connecteur. |

`policy ls`, `show`, `set`, `add` et `rm` constituent la surface à l’échelle du projet. Un connecteur portant l’un de ces noms de verbes doit donc être désigné par `policy <slug> ls`. Un `<match>` peut être un nom d’outil, un motif glob (`send_*`) ou un `/regex/`.

Options `add` : `--name <label>`, `--provider <pipedream\|mcp\|openapi\|postman\|graphql\|http>`, `--app <slug>`, `--url <url>`, `--transport <http\|sse>`, `--endpoint <url>`, `--base-url <url>`, `--spec <url\|path>`, `--auth-type <none\|bearer\|basic\|custom>`, `--credential shared`.

<a id="sandboxes"></a>

### Environnements de test

Gère les images d’environnement de test du projet. Un modèle définit une image ou un Dockerfile, ainsi que des ressources ; une compilation produit l’instantané à partir duquel les sessions démarrent.

| Commande | Effet |
| --- | --- |
| `beeuni sandboxes ls [--json]` | Lister les modèles et l’état actuel du fournisseur. |
| `beeuni sandboxes builds [--json]` | Afficher le journal de compilation récent. |
| `beeuni sandboxes health [--json]` | Vérifier que le modèle principal est prêt. |
| `beeuni sandboxes add <slug> (--image <i>\|--dockerfile <p>) [options]` | Créer un modèle personnalisé et lancer une compilation. |
| `beeuni sandboxes update <slug> [options]` | Mettre à jour un modèle. |
| `beeuni sandboxes build <slug>` | Lancer une nouvelle compilation. |
| `beeuni sandboxes rebuild <slug>` | Forcer une nouvelle compilation : supprimer d’abord l’instantané existant. |
| `beeuni sandboxes rm <slug>` | Supprimer un modèle. |
| `beeuni sandboxes fix` | Démarrer une session avec le journal de la dernière compilation échouée pour la réparer. |
| `beeuni sandboxes provider [--json]` | Afficher le fournisseur d’environnement de test défini pour le projet et les fournisseurs proposés par cet hôte. |
| `beeuni sandboxes provider <name> [--timeout <sec>]` | Affecter un seul fournisseur à chaque nouvelle session. Si la cible nécessite d’abord la compilation de son instantané, l’API renvoie une préparation et la commande attend qu’elle soit terminée. Valeur par défaut de `--timeout` : 600s. |
| `beeuni sandboxes provider --clear` | Supprimer l’affectation et utiliser le fournisseur par défaut de la plateforme. Alias : `--unpin`. |
| `beeuni sandboxes provider status [--json]` | Afficher la dernière transition de fournisseur et son historique. Alias : `transition`. |

L’affectation d’un fournisseur nécessite `project.settings.write`.

Options `add`/`update` : `--name <label>`, `--cpu <n>`, `--memory <n>` (GiB), `--disk <n>` (GiB).

### Backends

Les bases de données sont des Apps avec des volumes persistants. Gérez-les et connectez-les via Apps.

[Apps](/docs/feature-flags/apps)

### Marketplace

Parcourez la marketplace Beeuni et installez un élément dans un projet.

| Commande | Effet |
| --- | --- |
| `beeuni marketplace search [query]` | Recherche des éléments dans la marketplace. |
| `beeuni marketplace list` | Liste les éléments de la marketplace. |
| `beeuni marketplace show <id-or-name>` | Affiche un élément de la marketplace. |
| `beeuni marketplace install <id-or-name>` | Démarre une session d’agent qui importe l’élément. |

Options : `--query <text>`, `--type <type>`, `--source <source>`, `--host <name>`, `--project <id>`, `--json`.

L’installation est pilotée par un agent : il démarre une session de projet qui clone l’élément,
l’examine, fusionne ce qui convient et ouvre une demande de modification. Il n’existe pas de
mécanisme d’installation, de mise à jour ou de suppression déterministe.

<a id="system-skills"></a>

### Compétences système

Les compétences système de Beeuni constituent la référence opérationnelle de la plateforme, pour les personnes comme pour les agents. Elles couvrent les sessions, les environnements isolés, le moteur d’agent par défaut, les connecteurs, la mémoire et les canaux. Cette page publique en est le point d’entrée ; la CLI authentifiée récupère les compétences depuis l’hôte en cours d’exécution. Utilisez `beeuni system-skills list` pour découvrir les compétences disponibles, puis `get` pour celle dont vous avez besoin. L’API les fournit en direct, elles correspondent donc à la version déployée de l’hôte. Ne considérez pas une copie locale comme à jour.

| Commande | Effet |
| --- | --- |
| `beeuni system-skills list` | Liste les compétences système Beeuni. Sous-commande par défaut. |
| `beeuni system-skills get <name> [--full]` | Affiche le `SKILL.md` actuel d’une compétence. `--full` ajoute les fichiers référencés. |
| `beeuni system-skills path [name]` | Affiche le répertoire d’une compétence sur le disque du projet. |

Options : `--host <name>`, `--json`.

`beeuni skills` est un alias permanent pour la même commande. Connectez-vous d’abord à l’hôte avec `beeuni login` ; l’API des compétences exige une authentification. Utilisez `--host <name>` pour travailler avec un autre hôte. Une page de documentation publique ne peut pas remplacer ces instructions en direct, propres à l’hôte.

Cette liste contient toujours les compétences système, jamais un mélange. Les compétences facultatives se trouvent dans la marketplace : `beeuni marketplace list --type skill`. Pour la syntaxe des commandes, utilisez `beeuni <command> --help` ; pour la référence complète de la plateforme, consultez `beeuni system-skills get beeuni-system --full`.

<a id="connector"></a>

### Connecteur

L’interface de l’agent dans l’environnement isolé avec tous les connecteurs. Chaque appel est vérifié, résolu et audité côté serveur ; la CLI ne détient jamais d’identifiants tiers. Authentification : `BEEUNI_TOKEN`. La sortie est au format JSON.

| Commande | Effet |
| --- | --- |
| `beeuni connectors discover "<intent>"` | Recherche des outils selon une intention exprimée en langage naturel. |
| `beeuni connectors show <connector>.<action>` | Affiche le schéma d’entrée d’une action. |
| `beeuni connectors call <connector>.<action> '<json-args>'` | Exécute un outil. Un appel soumis à gouvernance renvoie immédiatement son `approval_url` authentifié. Le serveur reprend la session après une décision d’approbation ou de refus. Passez les arguments volumineux avec `@file.json` ou `-` (entrée standard). |
| `beeuni connectors call <connector>.<action> '<json-args>' --reason "<text>"` | Décrit l’appel à l’attention de la personne chargée de l’approuver lorsque la politique le bloque. La carte de demande d’approbation affiche cette description de l’agent à côté des arguments. |
| `beeuni connectors call <connector>.<action> @args.json --attach <file>` | Prépare un fichier et ajoute sa référence au tableau des pièces jointes de l’action. La passerelle écrit les octets dans l’élément de pièce jointe du fournisseur. `--attach` peut être répété ; `--attach-path <a.b.c>` indique le nom du tableau. Voir [Joindre des fichiers](/docs/fr/connect/connectors#attach-files). |
| `beeuni connectors call <connector>.<action> '<json-args>' --out <file>` | Écrit le résultat JSON complet dans `<file>` et n’affiche qu’un résumé : `saved_to`, `bytes` et `shape` (clés, longueurs des tableaux, `pageInfo`). Voir [Résultats volumineux](/docs/fr/connect/connectors#large-results). |
| `beeuni connectors upload <file> --connector <slug>` | Prépare un fichier. Affiche `ref`, `{"$beeuni_attachment":"<id>"}`, à placer dans les arguments de l’appel. |
| `beeuni connectors add <slug> --provider pipedream --app <app>` | Ajoute immédiatement un connecteur, puis le connecte. |
| `beeuni connectors rm <slug>` | Supprime un connecteur du projet. |
| `beeuni connectors connect <slug> [--owner me\|project] [--label <name>]` | Crée un lien de connexion destiné à une personne. `--label` propose un nom pour un nouveau compte, par exemple un deuxième compte Gmail. |

<a id="files"></a>

### Fichiers

Vue en lecture seule du dépôt git du projet. Agit sur la branche par défaut, sauf si `--ref` indique une autre branche, une balise ou un commit.

| Commande | Effet |
| --- | --- |
| `beeuni files ls [<path>]` | Répertorie récursivement les fichiers sous un chemin. La liste s’arrête à 1 000 fichiers et l’indique ; précisez le chemin pour la réduire ou utilisez `files search`. |
| `beeuni files cat <path>` | Affiche le contenu d’un fichier. |
| `beeuni files search <query> [--content]` | Recherche des noms de fichiers ou le contenu des fichiers avec `--content`. |
| `beeuni files history <path>` | Historique des commits d’un fichier. |
| `beeuni files branches` | Répertorie les branches. |
| `beeuni files commits [--path <p>]` | Répertorie les commits sur `--ref`. |
| `beeuni files show <sha>` | Affiche un commit et les fichiers qu’il a modifiés. |
| `beeuni files diff <sha> [--path <p>]` | Affiche le patch unifié d’un commit. |
| `beeuni files compare <from> <into>` | Résume le diff entre deux références. |
| `beeuni files download -o <out.zip>` | Télécharge le dépôt, ou le sous-arbre `--path`, à `--ref` au format zip. Alias : `archive`. |

Options disponibles pour chaque sous-commande : `--ref <ref>`, `--path <p>`, `--limit <n>`, `--json`.
`download` accepte également `-o, --out <file>`, obligatoire.

Chaque sous-commande nécessite `project.file.read`. `download` refuse aussi tout sous-arbre qui inclurait un agent ou une compétence auxquels vous n’avez pas accès — un zip ne peut pas être filtré pendant son téléchargement — ; dans ce cas, archivez un `--path` plus restreint.

<a id="triggers"></a>

### Déclencheurs

Un déclencheur démarre une session selon un calendrier, un webhook, un événement d’application ou un moniteur (expérimental). `add`, `rm`, `enable`, `disable` modifient le manifeste local — exécutez `beeuni ship` pour appliquer les changements. `pause`/`resume` actionnent un interrupteur distinct côté serveur. Voir [Déclencheurs](/docs/fr/connect/triggers).

| Commande | Effet |
| --- | --- |
| `beeuni triggers ls [--json]` | Répertorie les déclencheurs et leur état d’exécution. |
| `beeuni triggers add <slug> [options] [--apply]` | Ajoute un déclencheur au manifeste. `--apply` le crée directement sur le projet cloud : la commande l’enregistre dans `beeuni.yaml` sur `main`, puis effectue la réconciliation. |
| `beeuni triggers set <slug> [options]` | Modifie un déclencheur actif. Seuls les indicateurs fournis sont écrits. La modification est toujours appliquée immédiatement — il n’existe pas de version locale. Alias : `update`. |
| `beeuni triggers rm <slug> [--apply]` | Supprime un déclencheur de `beeuni.yaml` ou, avec `--apply`, du projet cloud immédiatement. |
| `beeuni triggers info <slug> [--json]` | Affiche un déclencheur. |
| `beeuni triggers events --connector <slug> [--json]` | Répertorie les événements proposés par un connecteur, avec les paramètres de chaque événement. |
| `beeuni triggers fire <slug>` | Déclenche manuellement un déclencheur et attend le résultat de l’exécution : une exécution échouée renvoie un code de sortie non nul avec son erreur, et la nouvelle session du déclenchement est nettoyée (une exécution ajoutée à une session existante reste en place). `--wait <dur>` limite l’attente (par défaut `90s` ; `0` renvoie la réponse dès que le déclenchement est accepté). |
| `beeuni triggers enable <slug> [--apply]` / `disable <slug> [--apply]` | Active ou désactive un déclencheur. |
| `beeuni triggers pause` / `resume` | Désactive ou réactive tous les déclencheurs du projet, côté serveur. |

Options de `add` : `--type <cron\|webhook\|event\|monitor>` (par défaut `cron`), `--prompt <text>` (obligatoire), `--agent <name>`, `--cron <expr>` (6 champs, p. ex. `"0 0 9 * * 1-5"`), `--run-at <iso>` (exécution unique à cet instant au lieu d’une expression cron), `--timezone <tz>` (UTC par défaut), `--secret-env <NAME>`, `--name <label>`, `--disabled`.

Options réservées aux déclencheurs actifs — valides avec `add --apply` et chaque `set` : `--model <provider/model>`, `--session-mode <fresh\|keyed\|pinned\|reuse>`, `--session-key <tmpl>` (regroupe une session par clé, p. ex. `"{{ body.data.chat_jid }}"` ; implique `keyed`), `--session-id <id>` (la session dans laquelle boucle un déclencheur `pinned` ; doit être une session de ce projet), `--session-access <private\|project\|members>` (par défaut `private`), `--member <uuid>` et `--group <uuid>` (répétables ; chacun implique `members`), et `--filter <path=value>` (répétable ; tous doivent correspondre, p. ex. `--filter body.type=push`).

`set` accepte toutes les options réservées aux déclencheurs actifs, ainsi que `--name`, `--prompt`, `--cron`, `--run-at`, `--timezone`, `--secret-env`, `--agent` et `--enabled true|false`. `--cron` et `--run-at` sont exclusifs : définir l’un efface l’autre. Les champs du moniteur sont uniquement ajoutés.

<a id="reminders"></a>

### Rappels

Un rappel relance une session ultérieurement, une fois ou de manière répétée. Il est stocké dans la base de données, et non dans `beeuni.yaml`. Dans une session, `--session` vaut `$BEEUNI_SESSION_ID` par défaut. Voir [Rappels](/docs/fr/connect/reminders).

| Commande | Effet |
| --- | --- |
| `beeuni remind "<text>" [schedule]` | Crée un rappel. Identique à `beeuni reminders add`. |
| `beeuni reminders add "<text>" [schedule]` | Crée un rappel. Affiche son identifiant et sa prochaine exécution. |
| `beeuni reminders ls [--json]` | Répertorie les rappels de la session. |
| `beeuni reminders pause <id>` / `resume <id>` | Désactive ou active un rappel. `resume` le réarme à partir de maintenant. |
| `beeuni reminders rm <id>` | Supprime un rappel. Alias : `stop`, `delete`. |

Options de planification : `--in <duration>` ou `--at <iso>` (première exécution ; utilisé seul, déclenche une seule exécution), `--every <duration>` (répétition, minimum `5m`), `--cron "<expr>"` avec `--timezone <tz>`. Autres options : `--name <label>`, `--session <id>` (un préfixe unique suffit), `--project <id>`, `--host <name>`, `--json`.

Options d’événement (`--type event`) : `--connector <slug>` et `--event <TYPE>` (toutes deux obligatoires), `--config key=value` (répétable, valeurs de type chaîne) et `--config-json '{...}'` (valeurs typées). `set` accepte les mêmes indicateurs. Un déclencheur d’événement rejette `--cron`, `--run-at`, `--timezone`, `--secret-env` et les options de moniteur. L’invite lit `{{ event.data.<field> }}` ; voir [Déclencheurs d’événements d’application](/docs/fr/connect/triggers#app-event-triggers).

Options de moniteur (`--type monitor`) : `--run <cmd>` (commande relative au dépôt à superviser ; obligatoire), `--mode <poll\|stream>` (obligatoire ; `poll` relance la commande sur `--interval`, `stream` la maintient en vie), `--interval <dur>` (`mode=poll` uniquement, minimum 30 s, p. ex. `60s`, `5m`) et `--expect-event-within <dur>` (surveillance du silence ; en l’absence d’événement dans le délai, déclenche plutôt un événement de cycle de vie, minimum 5 min, p. ex. `24h`). Un moniteur est une commande du dépôt que la plateforme exécute 24 h/24, et chaque ligne de sortie standard déclenche l’événement. Cette fonctionnalité est expérimentale : la plateforme n’exécute les moniteurs que lorsque le flag de fonctionnalité `monitors` est activé.

<a id="access"></a>

### Accès

L’interface CLI de la table unique des autorisations. Chaque ligne est une **attribution** : un principal, un rôle, une portée, éventuellement limitée à un objet. Voir [Comptes et accès](/docs/fr/accounts#one-access-model) pour le modèle. Rôles de compte : `owner`, `admin`, `member`. Rôles de projet : `manager`, `member`.

| Commande | Effet |
| --- | --- |
| `beeuni access assignments [--project <id>\|--account\|--all] [--json]` | Répertorie les attributions d’un projet, du compte ou de tous les projets. |
| `beeuni access grant --user <id\|email>\|--group <id>\|--service-account <id> --role <key\|id> [opts]` | Crée une attribution. Affiche son identifiant. |
| `beeuni access revoke <assignment-id>` | Révoque une attribution. |

Options d’autorisation : `--project <id>` (par défaut : le projet associé), `--account` (tout le compte), `--agent <name>` (limite l’autorisation à un agent — attribution à un objet), `--connection <id>` (limite l’utilisation d’un compte de connecteur partagé ; la première autorisation réserve le compte à ses bénéficiaires, et la révocation de la dernière le rend de nouveau accessible à tout le projet), `--everyone` (accorde l’accès à toutes les personnes ayant accès au projet ; cette option attend un `--agent` ou un `--connection`, jamais un rôle) et `--expires <iso>` (horodatage de révocation automatique). `--principal` filtre une liste et accepte `user:<id>`, `group:<id>`, `service_account:<id>`, `project:<id>` ou `pending:<email>` ; un identifiant seul est interprété comme celui d’un utilisateur. Une autorisation accordée à tout le monde apparaît sous la forme `everyone`. L’identité d’un agent est un `service_account` ; `--service-account <id>` permet donc d’attribuer un rôle à un agent. `--user` accepte une adresse e-mail et la résout à l’aide de l’annuaire des membres du compte.

```bash
beeuni access grant --user alice@corp.com --role manager
beeuni access grant --user alice@corp.com --role admin --account
beeuni access grant --group 8f3c… --role member --project 1a2b…
beeuni access grant --user alice@corp.com --agent support-bot
beeuni access grant --everyone --agent support-bot
beeuni access grant --group 8f3c… --connection 2b7e…
beeuni access revoke 4d5e…
```

Les verbes de membre du projet sont une vue de lecture des mêmes attributions :

| Commande | Effet |
| --- | --- |
| `beeuni access ls [--json]` | Lister les personnes ayant accès au projet, leur rôle de compte et leur rôle effectif dans le projet. |
| `beeuni access invite <email> --role <r>` | Inviter quelqu’un dans le projet. Crée une attribution `pending`. |
| `beeuni access grant <user-id> --role <r>` | Définir le rôle d’un utilisateur dans le projet. |
| `beeuni access revoke <user-id>` | Supprimer l’accès d’un utilisateur au projet. |
| `beeuni access pending [--json]` | Lister les invitations en attente. |
| `beeuni access resend <invite-id>` | Renvoyer un e-mail d’invitation et réinitialiser son expiration à 14 jours. Affiche aussi le lien. |
| `beeuni access cancel <invite-id>` | Annuler une invitation en attente. |
| `beeuni access requests ls [--json]` | Lister les demandes en attente des personnes souhaitant rejoindre ce projet. |
| `beeuni access requests approve <req-id> [--role <r>]` | Approuver une demande et attribuer le rôle dans le projet. Rôle par défaut : `member`. |
| `beeuni access requests reject <req-id>` | Rejeter une demande. Alias : `deny`. |

Chaque verbe des deux blocs ci-dessus nécessite `project.members.manage`.

Une personne, un groupe ou un agent reçoit des rôles de Beeuni ; un agent
possède également des permissions Beeuni dans `beeuni.yaml`, et une session ne peut
faire que ce que les deux autorisent. Voir [Un vocabulaire, deux liaisons](/docs/fr/accounts#one-vocabulary-two-bindings).

### Audit

Les commandes d’audit lisent le journal centralisé de reconstruction. Les listes de comptes et de projets sont triées de la plus récente à la plus ancienne. La chronologie d’une session est ordonnée par heure de création
(`session_sequence` n’est défini que sur les lignes écrites avant 2026-10, qui apparaissent
en premier). `--all` suit chaque curseur de continuation. `ls` répertorie les 90 derniers jours ; `export` remonte jusqu’à 365 jours, et les événements de plus de 90 jours proviennent des archives (voir [Conservation des audits](/docs/fr/accounts#retention)). Le tableau affiche
le titre de chaque ligne (`EVENT`, par exemple « Clé de passerelle LLM révoquée ») à côté de son
`ACTION` (`gateway.key.revoke`) ; `--action` filtre par préfixe d’action. Toutes les
actions et tous les titres : [Actions du journal d’audit](/docs/fr/audit-actions).

| Commande | Effet |
| --- | --- |
| `beeuni audit ls [filters] [--all] [--json]` | Lister les événements du compte. |
| `beeuni audit project <project-id> [filters] [--all] [--json]` | Lister les événements d’un projet. |
| `beeuni audit session <session-id> --project <project-id> [--all] [--json]` | Reconstituer une session dans l’ordre. |
| `beeuni audit export [filters] --format csv\|jsonl --out <file>` | Reprendre chaque page d’export dans un seul fichier. |
| `beeuni audit webhooks ls [--json]` | Lister les webhooks d’audit du compte. |
| `beeuni audit webhooks add --name <n> --url <u> [--action-prefix <p>]` | En créer un. Le secret de signature ne s’affiche qu’une fois et un envoi de test est déclenché immédiatement. `--action-prefix` ne transmet que les actions correspondant à ce préfixe. |
| `beeuni audit webhooks enable <webhook-id>` | Reprendre la transmission. |
| `beeuni audit webhooks disable <webhook-id>` | Suspendre la transmission tout en conservant le point de terminaison. |
| `beeuni audit webhooks rm <webhook-id>` | Supprimer définitivement un webhook. |

Les webhooks d’audit transmettent la piste à un SIEM. Chaque verbe nécessite `account.write` ;
`add` et `enable` nécessitent également le droit d’accès Enterprise. `disable` et `rm`
ne le nécessitent jamais.

Filtres : `--actor`, `--actor-type`, `--project`, `--session`, `--source`,
`--phase`, `--outcome`, `--action`, `--resource-type`, `--request-id`,
`--correlation-id`, `--query`, `--since`, `--until`, `--cursor` et `--limit`.
Les listes et les exports de comptes nécessitent `audit.read` et le droit d’accès `auditAccess`
du compte. Les listes de l’ensemble du projet nécessitent `project.members.manage`, car elles peuvent
inclure des métadonnées de sessions privées. La reconstitution d’une session nécessite
`project.session.read` et la visibilité de cette session.

<a id="roles"></a>

### Rôles

Un rôle est un ensemble nommé de permissions. Les rôles système (`owner`, `admin`, `member`
au niveau du compte ; `manager`, `member` au niveau du projet ; ainsi que `agent-user`, le
marqueur porté par une attribution d’objet) sont des références en lecture seule. Vous pouvez créer et modifier vos rôles personnalisés, qui nécessitent le droit d’accès Enterprise `rbac`.

| Commande | Effet |
| --- | --- |
| `beeuni roles ls [--json]` | Lister les rôles système et personnalisés. |
| `beeuni roles show <role> [--json]` | Afficher les permissions et les utilisations d’un rôle. |
| `beeuni roles permissions <role> [--json]` | Lister les permissions d’un rôle. |
| `beeuni roles create <key> --name <n> [options]` | Créer un rôle personnalisé. |
| `beeuni roles edit <role> [--name <n>] [--desc <t>\|--no-desc]` | Renommer un rôle personnalisé ou modifier sa description. Sa clé ne change jamais. Nécessite `role.update` et refuse les rôles système. |
| `beeuni roles set-actions <role> --actions a,b` | Remplacer les permissions d’un rôle personnalisé. |
| `beeuni roles rm <role>` | Supprimer un rôle personnalisé. |
| `beeuni roles export [--project <id>] [--out <file>] [--format toml\|json]` | Exporter les rôles et les attributions dans un fichier. |
| `beeuni roles import <file>` | Appliquer un fichier de rôles et d’attributions. |

Associez un rôle à un principal avec `beeuni access grant`. Les anciens verbes `beeuni roles
assign` / `unassign` / `assignments` fonctionnent toujours et écrivent dans la même table,
mais `beeuni access` est la méthode documentée. `beeuni roles actions` est remplacé
par `beeuni permissions ls`.

Un rôle personnalisé ne fait qu’ajouter des permissions. Beeuni ne dispose d’aucune règle de refus : un rôle ne peut donc pas retirer une permission à un gestionnaire.

### Permissions

Le catalogue des permissions, sous forme de données. Une ligne par action terminale, avec la portée à laquelle elle est évaluée, son caractère délégable et les permissions qu’elle implique. Les rôles sont construits à partir de ces clés — `beeuni roles create --actions` et `beeuni roles set-actions` les utilisent
exactement. Alias : `beeuni perms`.

| Commande | Effet |
| --- | --- |
| `beeuni permissions ls [--scope account\|project] [--area <a>] [--json]` | Lister le catalogue. |
| `beeuni permissions show <action> [--json]` | Afficher tous les détails d’une action. |

<a id="grants"></a>

### Attributions

Attribue un objet de projet à un principal — une **attribution d’objet**. Les secrets et
les connecteurs résident sur les agents ; attribuer un agent à une personne lui accorde donc tout ce que cet agent déclare. Par défaut, un agent est fermé : un membre ne peut y accéder que si une attribution le désigne ou désigne l’un de ses groupes. `beeuni access grant --agent
<name>` écrit dans la même ligne.

| Commande | Effet |
| --- | --- |
| `beeuni grants ls [--json]` | Lister les attributions d’objets et les agents pouvant être attribués. |
| `beeuni grants assign <agent-name> --to <who> [--group]` | Attribuer un agent à un utilisateur ou à un groupe avec `--group`. |
| `beeuni grants revoke <grant-id>` | Révoquer une attribution d’objet. |

<a id="manifest-validation"></a>

### Validation du manifeste

| Commande | Effet |
| --- | --- |
| `beeuni validate [--file <path>] [--json] [--scopes] [--no-dockerfile-lint]` | Valider le manifeste par rapport au schéma canonique, analyser statiquement chaque Dockerfile de sandbox et le câblage des agents, et vérifier la taille du dépôt. Résout d’abord `beeuni.yaml`, puis `beeuni.toml`. Codes de sortie : `0` si le manifeste est valide (des avertissements peuvent être présents), `1` en cas d’erreurs, `2` si le fichier est introuvable. `beeuni ship` exécute les mêmes vérifications. |
| `beeuni schema [--version 1\|2] [--url]` | Afficher le schéma JSON du manifeste. `--url` affiche plutôt l’URL du schéma. |

Voir [Référence du manifeste](/docs/fr/project/manifest).

<a id="repository-size"></a>

#### Taille du dépôt

Une session construit sa [configuration d’agent](/docs/fr/work/runtime#where-a-box-gets-the-release) à partir de tous les fichiers suivis par Git au commit de base. Une nouvelle session récupère ces fichiers depuis sa propre copie de travail, quelle que soit leur taille. Une session en cours prend en compte les modifications de la branche de base via l’instantané du projet, que Beeuni Cloud génère jusqu’à 512 MiB compressés ; au-delà, la session conserve sa configuration en cours jusqu’au démarrage d’une nouvelle session. Chaque session télécharge également tous les fichiers. `beeuni validate` compte les fichiers stockés par Git, ainsi que les fichiers non suivis que `beeuni ship` ajoute ensuite, et affiche un avertissement lorsqu’un fichier atteint 10 MiB ou plus, ou que le total dépasse 512 MiB. Un fichier Git LFS est compté comme son pointeur, car la version ne contient que le pointeur. L’avertissement indique les fichiers les plus volumineux. La commande n’échoue jamais.

Pour supprimer l’avertissement :
- Déplacez les ressources statiques volumineuses (vidéos, images, jeux de données, poids de modèles) vers un stockage objet comme S3, R2 ou GCS, ou vers un CDN, et téléchargez-les au moment de l’exécution.
- Ajoutez les fichiers générés lors de la compilation (`dist/`, `out/`) à `.gitignore`.
- Pour un chemin qui doit rester dans Git mais qu’aucun agent ne lit, ajoutez `<path> export-ignore` à `.gitattributes`. La version le laisse de côté, tout comme la vérification ; une règle de répertoire s’applique à tout son contenu. Le répertoire de configuration de l’agent et `beeuni.yaml` sont toujours inclus en entier.

<a id="token-scope"></a>

### Portée des jetons

Chaque jeton commence par `beeuni_pat_`. Un jeton utilisateur s’applique à tous les projets de vos comptes. Un jeton de projet s’applique à un seul projet et est injecté automatiquement dans les environnements de test de ce projet. Consultez la référence complète des familles de jetons dans [Session runtime](/docs/fr/work/runtime).

<a id="exit-codes"></a>

### Codes de sortie

| Code | Signification |
| --- | --- |
| `0` | Réussite. |
| `1` | Échec de l’opération. Les diagnostics sont affichés sur stderr. |
| `2` | Indicateur incorrect, sous-commande inconnue ou argument obligatoire manquant. |