---
title: "CLI ThunderPhone"
description: "Connectez-vous, gérez les agents vocaux et les appels, configurez les clients MCP et initialisez des projets depuis le terminal."
---

La CLI nécessite Node.js 18.18 ou une version ultérieure. Exécutez-la avec `npx`, ou installez-la globalement :

```bash
npm install -g thunderphone
thunderphone --help
```

## Se connecter

```bash
npx thunderphone login
thunderphone whoami --json
```

La connexion affiche un code de vérification, ouvre le navigateur et attend l'autorisation.
Utilisez `--no-browser` sur une machine sans interface graphique et ouvrez l'URL affichée ailleurs.
La connexion par appareil nécessite le déploiement du flux OAuth pour appareils de l'API. Une clé API d'organisation
dans `THUNDERPHONE_API_KEY` peut également authentifier les commandes et prévaut sur
les identifiants de connexion enregistrés.

Les identifiants sont stockés par profil dans `~/.config/thunderphone/credentials.json`
avec le mode de fichier `0600`. `XDG_CONFIG_HOME` et `THUNDERPHONE_CONFIG_DIR` remplacent le
répertoire. Les jetons d'accès sont actualisés automatiquement et les jetons d'actualisation rotatifs sont
enregistrés de manière atomique. Les jetons ne sont jamais affichés par la commande de connexion.

```bash
thunderphone login --profile work
thunderphone agents list --profile work --json
thunderphone logout --profile work
```

`THUNDERPHONE_PROFILE` définit le profil par défaut. La déconnexion supprime les identifiants locaux ;
elle ne révoque pas l'autorisation côté serveur. L'API par défaut est `https://api.thunderphone.com`.
Utilisez `--api-base-url` ou `THUNDERPHONE_API_BASE_URL` pour une autre API. Le jeton d'un profil
ne peut pas être envoyé à une autre URL d'API configurée ; connectez-vous à cette URL avec un profil distinct.

## Commandes

Chaque commande accepte `--json`. Les données renvoyées avec succès sont envoyées vers stdout ; les erreurs vers stderr
avec un code de sortie non nul. Sans `--json`, la sortie est un tableau compact ou une liste de champs.
Le format JSON conserve la structure de réponse de l’API, avec les champs d’identifiants masqués. Le service MCP
réserve stdout au protocole MCP.

| Commande | Objectif |
| --- | --- |
| `login [--no-browser] [--scope "scopes"]` | Autoriser via un code d’appareil |
| `logout`, `whoami` | Supprimer les identifiants locaux ; lister les organisations accessibles |
| `agents list`, `agents get ID` | Lire les agents |
| `agents create --file agent.json` | Créer un agent |
| `agents update ID --file agent.json` | Enregistrer un brouillon d’agent |
| `agents deploy ID`, `agents delete ID` | Déployer le brouillon ; supprimer un agent |
| `numbers list` | Lire les numéros de téléphone |
| `numbers provision --country US --area-code 415` | Provisionner un numéro entrant américain |
| `numbers assign NUMBER_ID --agent ID` | Attribuer un agent entrant |
| `sms send TO --from FROM --body TEXT --idempotency-key KEY` | Envoyer un SMS via un numéro d’opérateur connecté par le client, avec répétition sécurisée |
| `sms list [--limit N]`, `sms get UUID` | Lister ou consulter les enregistrements SMS |
| `call TO --agent ID --from FROM [--wait]` | Passer un appel sortant ; attendre éventuellement sa transcription |
| `calls list [--limit N] [--agent ID]` | Lister les appels (limite de 1 à 200) |
| `calls get ID`, `calls transcript ID` | Lire un appel ou sa transcription |
| `test run AGENT_ID [--scenario ID] --consent-to-charge` | Exécuter des scénarios enregistrés facturables via le canal web |
| `test status RUN_ID [--agent ID]` | Consulter un lot, avec les détails des scénarios lorsqu’un agent est fourni |
| `import VENDOR export.json` | Préparer une importation JSON d’un fournisseur pour révision |
| `imports get UUID`, `imports commit UUID` | Consulter une importation ; valider les agents sélectionnés après révision |
| `mcp setup`, `mcp serve` | Configurer un client ; démarrer le pont stdio |
| `init [directory]` | Initialiser la structure d’un projet |

Les appels sortants nécessitent un numéro autorisé pour les appels sortants. `THUNDERPHONE_FROM_NUMBER` peut
fournir `--from`. Les numéros VoIP des clients prennent toujours en charge les appels sortants.
Les numéros provisionnés par ThunderPhone sont initialement limités aux appels entrants ; un administrateur de l’organisation peut
demander l’activation des appels sortants depuis la page Numéros de téléphone, où chaque demande est
examinée manuellement. `--wait` utilise par défaut un délai d’expiration d’une heure ; définissez
`--timeout SECONDS` pour le modifier. Un délai d’expiration arrête l’attente sans mettre fin à l’appel.

Les SMS nécessitent également un numéro compatible SMS sur votre compte Twilio ou Telnyx
connecté. Ils ne sont jamais envoyés depuis un numéro appartenant à ThunderPhone. Réutilisez une clé d’idempotence
uniquement lorsque vous réessayez avec exactement le même expéditeur, destinataire et contenu.

Les importations prennent en charge `vapi`, `retell`, `elevenlabs` et `bland`. Le second argument est un
chemin vers une exportation JSON d’un fournisseur, et non un ID de fournisseur distant. L’API prépare un mappage
de manière asynchrone ; consultez-le avec `imports get UUID` et validez uniquement lorsqu’il est prêt
et après avoir vérifié les champs mappés et les avertissements. Consultez [les importations d’agents](/fr/guides/import-agents).

## Configuration MCP

```bash
thunderphone mcp setup --client cursor --api-key-env THUNDERPHONE_API_KEY
thunderphone mcp setup --client codex --scope user --api-key-env THUNDERPHONE_API_KEY
thunderphone mcp setup --client claude-desktop --scope user
```

Clients : `claude-code`, `codex`, `cursor`, `vscode`, `gemini`, `claude-desktop` et
`windsurf`. La portée projet est utilisée par défaut. Desktop et Windsurf nécessitent la portée utilisateur.
Omettez `--client` pour détecter un client unique dans le projet ; une détection ambiguë
demande une sélection interactive ou échoue avec des instructions dans une session non interactive.
La configuration affiche le fichier qu'elle a écrit et préserve les serveurs non liés. Le JSON existant
doit être un JSON strict valide ; les valeurs TOML de Codex sont préservées, mais les commentaires peuvent être reformatés.

La configuration privilégie HTTP distant direct. Avec `--api-key-env`, elle écrit une référence
à une variable, jamais la clé. Sans cette option, HTTP direct s'appuie sur la prise en charge
OAuth du client ; il n'utilise pas le fichier d'identifiants de la CLI. Pour réutiliser les identifiants de `thunderphone login`
dans tout client compatible stdio, utilisez :

```json
{
  "mcpServers": {
    "thunderphone": {
      "command": "npx",
      "args": ["-y", "@thunderphone/mcp"]
    }
  }
}
```

Le wrapper vérifie `THUNDERPHONE_API_KEY`, puis le profil CLI actuel (en l'actualisant
si nécessaire), puis délègue OAuth à `mcp-remote`. `THUNDERPHONE_MCP_URL` remplace
le point de terminaison. Il n'émet aucune télémétrie. La configuration autonome est également disponible via
`npx -y @thunderphone/mcp setup --client cursor` ou `thunderphone-mcp setup` après
avoir installé `@thunderphone/mcp` globalement.

## Créer un projet

```bash
npx create-thunderphone-agent my-receptionist
npx create-thunderphone-agent my-outbound --template python --agent-type outbound
# Equivalent:
thunderphone init my-receptionist --template node --agent-type receptionist
```

Les templates sont `node` et `python` ; les types d'agent sont `receptionist`, `outbound` et
`custom`. L'agent par défaut est un réceptionniste dentaire anglais/espagnol avec des
faits de démonstration explicites. Les projets incluent `agent.json`, des scripts de déploiement,
des configurations MCP pour Claude Code, Cursor et VS Code, des instructions d'agent,
`.env.example` et un README. La génération de squelette fonctionne hors ligne et refuse d'écraser un répertoire non vide.

Modifiez les informations de l'entreprise avant le déploiement. Exportez la clé API, le numéro d'appelant
connecté et votre destinataire de test comme indiqué dans le README généré. `npm run deploy`
ou `python deploy.py` crée ou met à jour l'agent, déploie son brouillon et effectue un
appel de test facturable. Les scripts utilisent l'authentification par clé API ; la CLI et le wrapper MCP stdio
prennent également en charge la connexion par appareil. Les scripts Python nécessitent Python 3.9 ou une version ultérieure.