# while, pour les agents

while héberge en France les applis de votre utilisateur. Vous envoyez le code ; while le construit, joue ses tests, lui
donne une adresse HTTPS, le surveille et vous prévient quand ça casse. Par MCP, vous mettez en ligne, lisez les
journaux et les erreurs, interrogez la base et revenez en arrière. In English: https://app.while.sh/agents?lang=en

## D'abord, votre utilisateur

Comprenez où il en est, par une question si la conversation ne le dit pas :

- son compte : il a reçu une invitation à while (il l'accepte avec son bouton, puis le 1) ;
  il a un compte (« j'ai un compte while » : le 1) ; ni l'un ni l'autre (l'essai, le 2) ;
- son outil : déjà fait (dans la conversation, sur Lovable, dans un dossier : vous le reprenez et le partagez avec son
  équipe) ; pas encore (faites-lui décrire le besoin, puis construisez une première version) ; des équipes à lancer
  (aidez-le à ajouter ses collègues).

Dans une conversation sans les outils de while, il ajoute le connecteur (le 1). Parlez de son outil et de son équipe,
pas de while.

## 1. Se brancher avec le compte de votre utilisateur

Le serveur MCP : https://app.while.sh/mcp (HTTP, OAuth). Au premier appel d'outil, votre utilisateur se connecte à while dans son
navigateur, puis choisit où vous agissez (une appli ou toute l'organisation) et votre niveau : Lire, Lire et agir, ou
Administrer.

Dans un terminal, vous vous branchez vous-même :

- Tous les agents de la machine : `curl -fsSL https://app.while.sh/install.sh | sh`
- Claude Code : `claude mcp add --transport http --scope user while https://app.while.sh/mcp`
- Codex : `codex mcp add while --url https://app.while.sh/mcp`, puis `codex mcp login while`
- Gemini CLI : `gemini mcp add --scope user --transport http while https://app.while.sh/mcp`
- VS Code : `code --add-mcp '{"name":"while","type":"http","url":"https://app.while.sh/mcp"}'`
- Cursor, dans ~/.cursor/mcp.json : `"while": { "url": "https://app.while.sh/mcp" }`

Puis une nouvelle session et un appel d'outil : while ouvre la page d'autorisation.

Dans une conversation (Claude, Mistral Vibe), votre utilisateur ajoute un connecteur personnalisé à l'adresse https://app.while.sh/mcp
et l'autorise. Le code passe ensuite par les appels d'outils (write_files). Dans ChatGPT, le connecteur personnalisé est
réservé aux offres Business, Enterprise et Edu, et, en Business, aux administrateurs de l'espace. En Plus ou en Pro,
passez par Codex (chatgpt.com/codex) : votre utilisateur lie un dépôt GitHub à son outil dans la console de while
(Lier un dépôt), vous y ouvrez une demande de fusion, il la fusionne, et while met l'outil en ligne à chaque fusion.

Sans navigateur (une CI, un script) : un jeton dans `Authorization: Bearer <jeton>` sur https://app.while.sh/mcp, ou WHILE_TOKEN avant le
script d'installation. create_token le crée ; votre utilisateur le confirme d'un lien.

## 2. Pas de compte : l'essai

L'essai se passe de compte, et son adresse dépend de l'endroit où vous travaillez : une conversation ou un terminal.
Dans une conversation (claude.ai, ChatGPT, une appli de chat qui ne lance aucune commande), votre utilisateur ajoute le
connecteur https://app.while.sh/mcp, la même adresse qu'avec un compte. Tant qu'il ne se connecte pas, ce connecteur sert l'essai, et lui
demande de se connecter quand une action exige son compte. Dans un terminal (Claude Code, Codex, Cursor…), https://app.while.sh/mcp
demande la connexion dès l'ouverture : branchez vous-même le serveur MCP d'essai, https://app.while.sh/essai, sous le nom while-essai.
Les commandes sont les mêmes qu'avec un compte. deploy_app met l'appli en ligne pour un temps limité et rend son
adresse, trial_key et to_say ; la clé va dans l'argument trial de chaque appel. Pour garder l'appli, dites to_say tel
quel à votre utilisateur : ce texte porte le lien de reprise. Votre utilisateur crée son compte, puis vous branchez
https://app.while.sh/mcp, comme au 1.
sign_up { email }, sur le même serveur avec la clé d'essai, lui envoie le lien.

## 3. Mettre en ligne

1. get_catalog : le contrat d'une appli (PORT, un chemin de santé, les tests, Internet fermé par défaut) et les
   briques ; get_catalog { format: "guide" } avant de découper une appli.
2. get_project : une appli existe peut-être déjà pour ce code ; sinon, create_project.
3. Un fichier while.yaml à la racine :

       apiVersion: while/v1
       project: mon-appli
       services:
         - name: web
           port: 3000
           health: { path: /health }

4. Le code : upload_source (une commande curl) ou git push depuis un terminal, write_files sans terminal. Puis
   deploy_app construit, joue les tests, met en ligne et rend l'adresse.

Avec plusieurs environnements, votre utilisateur nomme celui de la mise en ligne.

## 4. Vos outils, et ce qui attend votre utilisateur

Sans groupe chargé, votre liste compte 40 outils ; au niveau Administrer, et dans une conversation, tous. Votre niveau, get_organization le dit (your_level). load_tools { group } ajoute un groupe,
gardé d'une session à l'autre : alerts, feedback_and_docs, environments_and_storage, administer, functions. Claude Code et VS Code
le voient tout de suite ; ailleurs, votre utilisateur reconnecte while.

Certains gestes attendent une personne, et l'outil rend le lien :

- un geste d'administration au niveau Lire et agir (inviter un membre, créer un jeton, donner un rôle) : votre utilisateur
  confirme cet appel-là d'un clic, puis le même appel se fait une fois dans les 15 minutes ;
- un geste sensible (une mise en production, une base supprimée, une API externe, un accès) : une personne approbatrice
  de l'organisation décide. Rappeler l'outil avant sa décision rend le même lien.

## Pour aller plus loin

- La documentation : https://while.sh/docs
- Le schéma de while.yaml : https://app.while.sh/schema/while.v1.json
- L'API : https://app.while.sh/openapi.json
- Le script d'installation, à lire : https://app.while.sh/install.sh
