plugins-reference.md 2026-09-24 22:57 UTC to 2026-09-25 23:58 UTC

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

4 

5# Référence des plugins

6 

7> Référence technique complète pour le système de plugins Claude Code, incluant les schémas, les commandes CLI et les spécifications des composants.

8 

9<Tip>

10 Vous cherchez à installer des plugins ? Consultez [Découvrir et installer des plugins](/docs/fr/discover-plugins). Pour créer des plugins, consultez [Plugins](/docs/fr/plugins). Pour distribuer des plugins, consultez [Marchés de plugins](/docs/fr/plugin-marketplaces).

11</Tip>

12 

13Un **plugin** est un répertoire autonome de composants qui étend Claude Code avec des fonctionnalités personnalisées. Les composants de plugin incluent skills, agents, hooks, serveurs MCP, serveurs LSP et moniteurs.

14 

15<h2 id="plugin-components-reference">

16 Référence des composants de plugin

17</h2>

18 

19<h3 id="skills">

20 Skills

21</h3>

22 

23Les plugins ajoutent des skills à Claude Code, créant des raccourcis `/name` que vous ou Claude pouvez invoquer.

24 

25**Emplacement** : répertoire `skills/` ou `commands/` à la racine du plugin, ou un seul fichier `SKILL.md` à la racine du plugin

26 

27**Format de fichier** : Les skills sont des répertoires avec `SKILL.md` ; les commandes sont de simples fichiers markdown

28 

29**Structure du skill** :

30 

31```text theme={null}

32skills/

33├── pdf-processor/

34│ ├── SKILL.md

35│ ├── reference.md (optional)

36│ └── scripts/ (optional)

37└── code-reviewer/

38 └── SKILL.md

39```

40 

41Les skills et les commandes sont automatiquement découverts lors de l'installation du plugin.

42 

43Si un plugin n'a pas de répertoire `skills/` et pas de champ manifest `skills`, un `SKILL.md` à la racine du plugin est chargé comme un skill unique. Définissez le champ frontmatter `name` pour contrôler le nom d'invocation du skill. Sans cela, Claude Code revient au nom du répertoire d'installation. Pour un plugin [copié dans le cache](#plugin-caching-and-file-resolution), ce nom est une chaîne de version qui change à chaque mise à jour. Pour les plugins qui fournissent plus d'un skill, utilisez la disposition du répertoire `skills/` montrée ci-dessus.

44 

45Dans les skills et commandes de plugin, les champs frontmatter booléens tels que `disable-model-invocation` acceptent `yes`, `no`, `on`, `off`, `1` et `0` dans n'importe quelle casse de lettre, en plus de `true` et `false`. Avant v2.1.218, Claude Code ne reconnaissait que `true` et `false`.

46 

47Pour plus de détails, consultez [Skills](/docs/fr/skills).

48 

49<h3 id="agents">

50 Agents

51</h3>

52 

53Les plugins peuvent fournir des sous-agents spécialisés pour des tâches spécifiques que Claude peut invoquer automatiquement si approprié.

54 

55**Emplacement** : répertoire `agents/` à la racine du plugin

56 

57**Format de fichier** : Fichiers markdown décrivant les capacités de l'agent

58 

59**Structure de l'agent** :

60 

61```markdown theme={null}

62name: agent-name

63description: What this agent specializes in and when Claude should invoke it

64model: sonnet

65effort: medium

66maxTurns: 20

67disallowedTools: Write, Edit

68 

69Detailed system prompt for the agent describing its role, expertise, and behavior.

70```

71 

72<h4 id="plugin-agent-frontmatter">

73 Frontmatter d'agent de plugin

74</h4>

75 

76Un fichier d'agent de plugin utilise les mêmes [champs frontmatter qu'un fichier de sous-agent](/docs/fr/sub-agents#supported-frontmatter-fields), sauf que Claude Code honore seulement certains d'entre eux quand l'agent provient d'un plugin :

77 

78* **Supportés** : `name`, `description`, `model`, `effort`, `maxTurns`, `tools`, `disallowedTools`, `skills`, `memory`, `background`, `omitClaudeMd`, `isolation`, `color` et `experimental`. La seule valeur `isolation` valide est `"worktree"`.

79* **Non supportés, pour des raisons de sécurité** : `hooks`, `mcpServers` et `permissionMode`. Claude Code ignore ces champs lors du chargement d'un agent depuis un plugin. Pour les utiliser, copiez le fichier d'agent dans `.claude/agents/` ou `~/.claude/agents/`.

80* **Non supportés** : `initialPrompt`.

81 

82Vous pouvez placer les fichiers d'agent de plugin dans des sous-dossiers de `agents/`. Claude Code [les charge récursivement](/docs/fr/sub-agents#choose-the-subagent-scope) et joint le nom du plugin, chaque nom de sous-dossier et le nom du fichier avec des deux-points pour former le nom scopé de l'agent. Par exemple, `agents/review/security.md` dans un plugin nommé `my-plugin` se charge comme `my-plugin:review:security`. Deux paramètres changent ce nom :

83 

84* Frontmatter `name` : il remplace uniquement le nom du fichier, donc `name: audit` dans `agents/review/security.md` se charge comme `my-plugin:review:audit`

85* Champ manifest [`agents`](#component-path-fields) : un fichier que vous listez là se charge sans noms de sous-dossier, donc `"agents": "./custom/review/security.md"` se charge comme `my-plugin:security`

86 

87Claude Code charge un agent de plugin même quand son frontmatter n'a pas de `name` ou ne s'analyse pas :

88 

89* Pas de `name` : Claude Code nomme l'agent d'après le fichier, donc `agents/reviewer.md` dans un plugin nommé `my-plugin` se charge comme `my-plugin:reviewer`

90* Frontmatter qui ne s'analyse pas : Claude Code nomme l'agent d'après le fichier, utilise `Agent from my-plugin plugin` comme sa description, et ignore tous les champs du fichier

91 

92En contraste, Claude Code ignore un fichier d'agent de projet, utilisateur ou géré dont le frontmatter n'a pas de `name` ou ne s'analyse pas.

93 

94Pour trouver les fichiers dans le répertoire `agents/` par défaut d'un plugin dont le frontmatter ne s'analyse pas, exécutez `claude plugin validate`. Le chemin que vous passez dépend de si le plugin a un manifest, et les deux exemples utilisent `./my-plugin` comme répertoire du plugin :

95 

96* Un plugin avec un manifest : `claude plugin validate ./my-plugin`

97* Un plugin sans manifest : `claude plugin validate ./my-plugin/agents`. Nécessite Claude Code v2.1.233 ou ultérieur.

98 

99Les agents apparaissent dans la [typeahead @-mention](/docs/fr/sub-agents#invoke-subagents-explicitly) sous leur nom scopé, tel que `my-plugin:code-reviewer`, une fois que le plugin est activé.

100 

101Pour plus de détails, consultez [Sous-agents](/docs/fr/sub-agents).

102 

103<h3 id="hooks">

104 Hooks

105</h3>

106 

107Les plugins peuvent fournir des gestionnaires d'événements qui répondent automatiquement aux événements de Claude Code.

108 

109**Emplacement** : `hooks/hooks.json` à la racine du plugin, ou en ligne dans plugin.json

110 

111**Format** : Configuration JSON avec des matchers d'événements et des actions

112 

113`hooks/hooks.json` peut porter une clé `$schema` de niveau supérieur qui nomme une URL JSON Schema pour l'autocomplétion et la validation de l'éditeur. Claude Code ignore la clé au moment du chargement.

114 

115**Configuration du hook** :

116 

117```json theme={null}

118{

119 "hooks": {

120 "PostToolUse": [

121 {

122 "matcher": "Write|Edit",

123 "hooks": [

124 {

125 "type": "command",

126 "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/format-code.sh"

127 }

128 ]

129 }

130 ]

131 }

132}

133```

134 

135Les hooks de plugin répondent aux mêmes événements de cycle de vie que les [hooks définis par l'utilisateur](/docs/fr/hooks) :

136 

137| Événement | Quand il se déclenche |

138| :-------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

139| `SessionStart` | Quand une session commence ou reprend |

140| `Setup` | Quand vous démarrez Claude Code avec `--init-only`, ou avec `--init` ou `--maintenance` en mode `-p`. Pour une préparation unique en CI ou dans les scripts |

141| `UserPromptSubmit` | Quand vous soumettez une invite, avant que Claude la traite |

142| `UserPromptExpansion` | Quand une commande tapée par l'utilisateur se développe en une invite, avant qu'elle n'atteigne Claude. Peut bloquer l'expansion |

143| `PreToolUse` | Avant qu'un appel d'outil s'exécute. Peut le bloquer |

144| `PermissionRequest` | Quand un appel d'outil nécessite une décision de permission |

145| `PermissionDenied` | Quand le mode automatique refuse un appel d'outil, y compris les refus sans verdict du classificateur. Utilisez la sortie JSON `hookSpecificOutput.retry: true` pour indiquer au modèle qu'il peut réessayer l'appel d'outil refusé. Claude Code ignore `retry` quand le classificateur n'a produit aucun verdict |

146| `PostToolUse` | Après qu'un appel d'outil réussisse |

147| `PostToolUseFailure` | Après qu'un appel d'outil échoue |

148| `PostToolBatch` | Après qu'un lot complet d'appels d'outils parallèles se résout, avant l'appel du modèle suivant |

149| `Notification` | Quand Claude Code envoie une notification |

150| `MessageDisplay` | Pendant que le texte du message assistant s'affiche |

151| `SubagentStart` | Quand un sous-agent est généré |

152| `SubagentStop` | Quand un sous-agent se termine |

153| `TaskCreated` | Quand une tâche est en cours de création via `TaskCreate` |

154| `TaskCompleted` | Quand une tâche est marquée comme complétée |

155| `Stop` | Quand Claude finit de répondre |

156| `StopFailure` | Quand le tour se termine en raison d'une erreur API |

157| `TeammateIdle` | Quand un coéquipier d'une [équipe d'agents](/docs/fr/agent-teams) est sur le point de devenir inactif |

158| `InstructionsLoaded` | Quand un fichier CLAUDE.md ou `.claude/rules/*.md` est chargé dans le contexte. Se déclenche au démarrage de la session et quand les fichiers sont chargés paresseusement pendant une session |

159| `ConfigChange` | Quand un fichier de configuration change pendant une session |

160| `CwdChanged` | Quand le répertoire de travail change, par exemple quand Claude exécute une commande `cd`. Utile pour la gestion réactive de l'environnement avec des outils comme direnv |

161| `DirectoryAdded` | Quand un répertoire de travail est ajouté en milieu de session via `/add-dir` ou la demande de contrôle SDK `register_repo_root` |

162| `FileChanged` | Quand un fichier surveillé change sur le disque. Le champ `matcher` spécifie les noms de fichiers à surveiller |

163| `WorktreeCreate` | Quand un worktree est en cours de création via `--worktree`, `isolation: "worktree"`, ou pour une session en arrière-plan. Remplace le comportement git par défaut |

164| `WorktreeRemove` | Quand un worktree est supprimé à la sortie de la session, quand un sous-agent se termine, ou quand vous supprimez une session en arrière-plan |

165| `PreCompact` | Avant la compaction du contexte |

166| `PostCompact` | Après la compaction du contexte est complétée |

167| `PreModelSwitch` | Avant que Claude Code applique un changement de modèle que vous ou un client avez demandé. Peut bloquer le changement |

168| `PostModelSwitch` | Après que le modèle de la session change, y compris les changements que Claude Code effectue de lui-même, comme la restauration du modèle quand vous reprenez une session |

169| `Elicitation` | Quand un serveur MCP demande une entrée utilisateur pendant un appel d'outil |

170| `ElicitationResult` | Après qu'un utilisateur réponde à une élicitation MCP, avant que la réponse soit renvoyée au serveur |

171| `SessionEnd` | Quand une session se termine |

172 

173**Types de hook** :

174 

175* `command` : exécuter des commandes shell ou des scripts

176* `http` : envoyer l'événement JSON comme une requête POST à une URL

177* `mcp_tool` : appeler un outil sur un [serveur MCP](/docs/fr/mcp) configuré

178* `prompt` : évaluer un prompt avec un LLM (utilise le placeholder `$ARGUMENTS` pour le contexte)

179* `agent` : exécuter un vérificateur agentic avec des outils pour les tâches de vérification complexes

180 

181Les hooks qui ciblent le [serveur MCP bundlé](#mcp-servers) du plugin doivent utiliser ses noms scopés. Les matchers d'outils et les champs `if` prennent le nom d'outil scopé `mcp__plugin_<plugin-name>_<server-name>__<tool>`, et le champ `server` d'un hook `mcp_tool` prend `plugin:<plugin-name>:<server-name>`. Un matcher écrit contre la clé de serveur nue ne se déclenche jamais. Consultez [Match MCP tools](/docs/fr/hooks#match-mcp-tools) et [Plugin-provided MCP servers](/docs/fr/mcp#plugin-provided-mcp-servers).

182 

183<h3 id="mcp-servers">

184 MCP servers

185</h3>

186 

187Les plugins peuvent bundler des serveurs Model Context Protocol (MCP) pour connecter Claude Code avec des outils et services externes.

188 

189**Emplacement** : `.mcp.json` à la racine du plugin, ou en ligne dans plugin.json

190 

191**Format** : Configuration standard du serveur MCP

192 

193**Configuration du serveur MCP** :

194 

195```json theme={null}

196{

197 "mcpServers": {

198 "plugin-database": {

199 "command": "${CLAUDE_PLUGIN_ROOT}/servers/db-server",

200 "args": ["--config", "${CLAUDE_PLUGIN_ROOT}/config.json"],

201 "env": {

202 "DB_PATH": "${CLAUDE_PLUGIN_ROOT}/data"

203 }

204 },

205 "plugin-api-client": {

206 "command": "npx",

207 "args": ["@company/mcp-server", "--plugin-mode"]

208 }

209 }

210}

211```

212 

213**Comportement d'intégration** :

214 

215* Les serveurs MCP de plugin démarrent automatiquement quand le plugin est activé

216* Les serveurs apparaissent comme des outils MCP standard dans la boîte à outils de Claude

217* Les serveurs de plugin peuvent être configurés indépendamment des serveurs MCP utilisateur

218* Si vous exécutez [`/reload-plugins`](/docs/fr/discover-plugins#apply-plugin-changes-without-restarting) en milieu de session, Claude Code maintient les connexions actives des serveurs dont la configuration est inchangée

219 

220<h3 id="lsp-servers">

221 LSP servers

222</h3>

223 

224<Tip>

225 Vous cherchez à utiliser des plugins LSP ? Installez-les depuis la marketplace officielle : recherchez « lsp » dans l'onglet Discover `/plugin`. Cette section documente comment créer des plugins LSP pour les langages non couverts par la marketplace officielle.

226</Tip>

227 

228Les plugins peuvent fournir des serveurs [Language Server Protocol](https://microsoft.github.io/language-server-protocol/) (LSP) pour donner à Claude une [intelligence de code en temps réel](/docs/fr/discover-plugins#code-intelligence) en travaillant sur votre base de code.

229 

230**Emplacement** : `.lsp.json` à la racine du plugin, ou en ligne dans `plugin.json`

231 

232**Format** : Configuration JSON mappant les noms de serveurs de langage à leurs configurations

233 

234**Format du fichier `.lsp.json`** :

235 

236```json theme={null}

237{

238 "go": {

239 "command": "gopls",

240 "args": ["serve"],

241 "extensionToLanguage": {

242 ".go": "go"

243 }

244 }

245}

246```

247 

248**En ligne dans `plugin.json`** :

249 

250```json theme={null}

251{

252 "name": "my-plugin",

253 "lspServers": {

254 "go": {

255 "command": "gopls",

256 "args": ["serve"],

257 "extensionToLanguage": {

258 ".go": "go"

259 }

260 }

261 }

262}

263```

264 

265**Champs obligatoires :**

266 

267| Field | Description |

268| :-------------------- | :---------------------------------------------------------- |

269| `command` | Le binaire LSP à exécuter (doit être dans PATH) |

270| `extensionToLanguage` | Mappe les extensions de fichier aux identifiants de langage |

271 

272**Champs optionnels :**

273 

274| Field | Description |

275| :---------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

276| `args` | Arguments de ligne de commande pour le serveur LSP |

277| `transport` | Transport de communication : `stdio` (par défaut) ou `socket`. Claude Code accepte `socket` mais exécute chaque serveur sur stdio, donc les règles du protocole stdout s'appliquent à tous les serveurs |

278| `env` | Variables d'environnement à définir au démarrage du serveur |

279| `initializationOptions` | Options passées au serveur lors de l'initialisation |

280| `settings` | Paramètres passés via `workspace/didChangeConfiguration` |

281| `workspaceFolder` | Chemin du dossier d'espace de travail pour le serveur |

282| `startupTimeout` | Temps maximum d'attente du démarrage du serveur (millisecondes) |

283| `shutdownTimeout` | Temps maximum d'attente de l'arrêt gracieux (millisecondes). Quand le délai d'attente s'écoule, Claude Code termine le processus du serveur. Quand non défini, aucun délai d'attente ne s'applique |

284| `restartOnCrash` | Si le serveur doit redémarrer après un crash. Par défaut `true`. Définissez à `false` pour laisser un serveur crashé arrêté au lieu de le redémarrer |

285| `maxRestarts` | Nombre maximum de tentatives de redémarrage avant d'abandonner |

286| `diagnostics` | Si les diagnostics doivent être poussés dans le contexte de Claude après les éditions (par défaut `true`). Définissez à `false` pour garder la navigation de code mais supprimer l'injection automatique de diagnostics. |

287 

288`restartOnCrash` et `shutdownTimeout` nécessitent Claude Code v2.1.205 ou ultérieur. Avant v2.1.205, le schéma de configuration acceptait les deux options mais définir l'une d'elles causait à Claude Code de sauter ce serveur LSP entièrement au démarrage, avec la raison visible uniquement dans la sortie `claude --debug`.

289 

290**Plusieurs serveurs pour la même extension** : quand plus d'un serveur LSP activé déclare la même extension de fichier dans `extensionToLanguage`, que les serveurs proviennent d'un plugin ou de différents plugins, le premier serveur enregistré gère les fichiers avec cette extension et les autres ne démarrent jamais. L'interface `/plugin` affiche un avertissement nommant le plugin dont le serveur est actif.

291 

292**Serveurs qui échouent à initialiser** : Claude Code ignore un serveur dont la configuration est invalide, par exemple un manquant `command` ou `extensionToLanguage`, et les autres serveurs configurés démarrent toujours. Exécutez `claude --debug` pour voir pourquoi un serveur a été ignoré.

293 

294Un serveur ignoré ne réclame pas ses extensions de fichier, donc un autre serveur valide qui déclare la même extension, du même plugin ou d'un plugin différent, gère toujours ces fichiers.

295 

296**Envoyez la sortie de log à stderr, pas stdout** : Claude Code lit le stdout d'un serveur comme des messages de protocole uniquement, et accepte les en-têtes de message jusqu'à 64 KiB et un corps de message jusqu'à 32 MiB. Claude Code déconnecte un serveur qui dépasse l'une ou l'autre limite ou écrit une sortie non-protocole à stdout, et compte la déconnexion comme un crash pour `restartOnCrash` et `maxRestarts`. Quand vous exécutez avec `--debug`, Claude Code écrit une erreur nommant la cause au journal de débogage.

297 

298<Warning>

299 **Vous devez installer le binaire du serveur de langage séparément.** Les plugins LSP configurent comment Claude Code se connecte à un serveur de langage, mais ils n'incluent pas le serveur lui-même. Si vous voyez `Executable not found in $PATH` dans l'onglet Errors `/plugin`, installez le binaire requis pour votre langage.

300</Warning>

301 

302**Plugins LSP disponibles :**

303 

304| Plugin | Language server | Install command |

305| :------------------ | :------------------------- | :----------------------------------------------------------------------------------------------- |

306| `pyright-lsp` | Pyright (Python) | `pip install pyright` ou `npm install -g pyright` |

307| `typescript-lsp` | TypeScript Language Server | `npm install -g typescript-language-server typescript` |

308| `rust-analyzer-lsp` | rust-analyzer | [Voir l'installation de rust-analyzer](https://rust-analyzer.github.io/manual.html#installation) |

309 

310Installez d'abord le serveur de langage, puis installez le plugin depuis la marketplace.

311 

312<h3 id="monitors">

313 Monitors

314</h3>

315 

316Les plugins peuvent déclarer des moniteurs de fond que Claude Code démarre automatiquement quand le plugin est actif. Chaque moniteur exécute une commande shell pour la durée de vie de la session et livre chaque ligne stdout à Claude comme une notification, donc Claude peut réagir aux entrées de log, changements de statut, ou événements sondés sans être demandé de démarrer la montre lui-même.

317 

318Les moniteurs de plugin utilisent le même mécanisme que l'[outil Monitor](/docs/fr/tools-reference#monitor-tool) et partagent ses contraintes de disponibilité. Ils s'exécutent uniquement dans les sessions CLI interactives, s'exécutent non-sandboxés au même niveau de confiance que les [hooks](#hooks), et sont ignorés sur les hôtes où l'outil Monitor est indisponible.

319 

320**Emplacement** : `monitors/monitors.json` à la racine du plugin, ou en ligne dans `plugin.json`

321 

322**Format** : Tableau JSON d'entrées de moniteur

323 

324Le `monitors/monitors.json` suivant surveille un point de terminaison de statut de déploiement et un journal d'erreurs local :

325 

326```json theme={null}

327[

328 {

329 "name": "deploy-status",

330 "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/poll-deploy.sh",

331 "description": "Deployment status changes"

332 },

333 {

334 "name": "error-log",

335 "command": "tail -F ./logs/error.log",

336 "description": "Application error log",

337 "when": "on-skill-invoke:debug"

338 }

339]

340```

341 

342Pour déclarer les moniteurs en ligne, définissez `experimental.monitors` dans `plugin.json` au même tableau. Pour charger depuis un chemin non-par défaut, définissez `experimental.monitors` à une chaîne de chemin relatif telle que `"./config/monitors.json"`. Les moniteurs sont un [composant expérimental](#experimental-components).

343 

344**Champs obligatoires :**

345 

346| Field | Description |

347| :------------ | :---------------------------------------------------------------------------------------------------------------------------------- |

348| `name` | Identifiant unique au sein du plugin. Empêche les processus dupliqués quand le plugin se recharge ou un skill est invoqué à nouveau |

349| `command` | Commande shell exécutée comme un processus de fond persistant dans le répertoire de travail de la session |

350| `description` | Résumé court de ce qui est surveillé. Affiché dans le panneau de tâches et dans les résumés de notification |

351 

352**Champs optionnels :**

353 

354| Field | Description |

355| :----- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

356| `when` | Contrôle quand le moniteur démarre. `"always"` le démarre au démarrage de la session et au rechargement du plugin, et est la valeur par défaut. `"on-skill-invoke:<skill-name>"` le démarre la première fois que le skill nommé dans ce plugin est dispatché |

357 

358La valeur `command` supporte les [substitutions de chemin](#environment-variables) `${CLAUDE_PLUGIN_ROOT}`, `${CLAUDE_PLUGIN_DATA}` et `${CLAUDE_PROJECT_DIR}`, plus n'importe quel `${ENV_VAR}` de l'environnement. Préfixez la commande avec `cd "${CLAUDE_PLUGIN_ROOT}" && ` si le script doit s'exécuter depuis le répertoire du plugin lui-même.

359 

360Une `command` de moniteur ne peut pas référencer les valeurs [`${user_config.*}`](#user-configuration). La commande s'exécute via un shell, donc Claude Code rejette le moniteur avec une [erreur](/docs/fr/errors#plugin-command-references-user-config) au lieu de substituer la valeur. Les processus de moniteur ne reçoivent pas les variables d'environnement `CLAUDE_PLUGIN_OPTION_<KEY>`, donc faites en sorte que le script de moniteur lise la valeur depuis un fichier de configuration qu'il possède.

361 

362Si vous désactivez un plugin en milieu de session, Claude Code n'arrête pas les moniteurs qui sont déjà en cours d'exécution ; ils s'arrêtent quand la session se termine.

363 

364<h3 id="themes">

365 Themes

366</h3>

367 

368Les plugins peuvent fournir des thèmes de couleur qui apparaissent dans `/theme` aux côtés des présets intégrés et des thèmes locaux de l'utilisateur. Un thème est un fichier JSON dans `themes/` avec un préset `base` et une carte `overrides` clairsemée de jetons de couleur. Les thèmes sont un [composant expérimental](#experimental-components).

369 

370```json theme={null}

371{

372 "name": "Dracula",

373 "base": "dark",

374 "overrides": {

375 "claude": "#bd93f9",

376 "error": "#ff5555",

377 "success": "#50fa7b"

378 }

379}

380```

381 

382Quand un utilisateur sélectionne un thème de plugin, Claude Code enregistre `custom:<plugin-name>:<slug>` dans sa configuration. Les thèmes de plugin sont en lecture seule : quand un utilisateur appuie sur `Ctrl+E` sur l'un d'eux dans `/theme`, Claude Code le copie dans `~/.claude/themes/` pour qu'ils puissent éditer la copie.

383 

384***

385 

386<h2 id="plugin-installation-scopes">

387 Portées d'installation des plugins

388</h2>

389 

390Lorsque vous installez un plugin, vous choisissez une **portée** qui détermine où le plugin est disponible et qui d'autre peut l'utiliser :

391 

392| Portée | Fichier de paramètres | Cas d'usage |

393| :-------- | :--------------------------------------- | :----------------------------------------------------------------------------------------- |

394| `user` | `~/.claude/settings.json` | Plugins personnels disponibles dans tous les projets (par défaut) |

395| `project` | `.claude/settings.json` | Plugins d'équipe partagés via le contrôle de version |

396| `local` | `.claude/settings.local.json` | Plugins spécifiques au projet, ignorés par git lorsque Claude Code enregistre un paramètre |

397| `managed` | [Paramètres gérés](/docs/fr/managed-settings) | Plugins gérés (lecture seule, mise à jour uniquement) |

398 

399Les plugins utilisent le même système de portée que les autres configurations de Claude Code. Pour les instructions d'installation et les drapeaux de portée, consultez [Installer des plugins](/docs/fr/discover-plugins#install-plugins). Pour une explication complète des portées, consultez [Portées de configuration](/docs/fr/settings#where-settings-live).

400 

401***

402 

403<h2 id="skills-directory-plugins">

404 Plugins du répertoire de compétences

405</h2>

406 

407Tout dossier situé sous un répertoire de compétences qui contient un manifeste `.claude-plugin/plugin.json` est chargé en tant que plugin nommé `<name>@skills-dir` lors de la session suivante, sans marketplace et sans étape d'installation. Générez-en un avec [`plugin init`](#plugin-init). Contrairement à une installation marketplace copiée, le plugin est découvert sur place plutôt que copié dans le cache des plugins.

408 

409Un arborescence de répertoire de compétences prend en charge trois choses distinctes :

410 

411| Ce que vous avez | Ce que c'est |

412| :-------------------------------------------- | :------------------------------------------------------------------------------------------------- |

413| `<skills-dir>/foo/SKILL.md` sans manifeste | Une simple [compétence](/docs/fr/skills) nommée `foo` |

414| `<skills-dir>/foo/.claude-plugin/plugin.json` | Un plugin `foo@skills-dir`, qui peut regrouper ses propres compétences, agents, hooks et bien plus |

415| `<plugin>/skills/bar/SKILL.md` | Une compétence `bar` empaquetée à l'intérieur d'un plugin |

416 

417<h3 id="choose-where-the-plugin-loads-from">

418 Choisir d'où le plugin se charge

419</h3>

420 

421| Répertoire de compétences | Portée | Charge |

422| :------------------------ | :-------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------ |

423| `~/.claude/skills/` | personnel | Dans chaque projet, puisque l'emplacement vous appartient uniquement |

424| `<cwd>/.claude/skills/` | projet | Uniquement après que vous acceptiez la [boîte de dialogue de confiance](/docs/fr/permissions#what-runs-before-you-trust-a-folder) de l'espace de travail pour ce dossier |

425 

426Un plugin de portée projet est archivé dans le référentiel et atteint chaque collaborateur qui le clone. Parce que ce contenu provient du référentiel plutôt que de vous, il se charge uniquement après la même barrière de confiance qui régit les règles d'autorisation du projet dans `.claude/settings.json`, donc faire confiance à un dossier parent ou exécuter avec `-p` ne suffit pas, et les composants qui exécutent du code sont davantage restreints :

427 

428* Les serveurs MCP qu'il déclare passent par la [même approbation par serveur](/docs/fr/mcp) qu'un `.mcp.json` de projet

429* Les serveurs LSP ne démarrent qu'après que vous fassiez confiance à l'espace de travail

430* Les [moniteurs en arrière-plan](#monitors) ne se chargent pas

431 

432Les plugins de portée personnelle n'ont aucune de ces restrictions.

433 

434<Warning>

435 Les plugins `@skills-dir` de portée projet se chargent uniquement à partir du `.claude/skills/` du [répertoire de travail principal](/docs/fr/permissions#working-directories) de la session. Ils ne [remontent pas jusqu'à la racine du référentiel](/docs/fr/skills#discovery-from-parent-and-nested-directories) comme le font les compétences et commandes simples, donc lancer depuis un sous-répertoire manque un plugin qui se trouve à la racine du référentiel. Lancez depuis la racine du référentiel, ou [déplacez la session là-bas avec `/cd`](/docs/fr/permissions#move-the-session-to-another-directory) sur v2.1.246 ou ultérieur.

436</Warning>

437 

438<h3 id="edit-reload-and-disable-a-skills-directory-plugin">

439 Modifier, recharger et désactiver un plugin du répertoire de compétences

440</h3>

441 

442Les modifications que vous apportez au `SKILL.md` d'une compétence prennent effet immédiatement dans la session actuelle. Les modifications apportées aux autres composants du plugin, tels que `hooks/`, `.mcp.json`, `agents/` et `output-styles/`, ne le font pas. Exécutez `/reload-plugins` ou redémarrez Claude Code pour les récupérer. Voir [Détection des changements en direct](/docs/fr/skills#live-change-detection).

443 

444Pour arrêter le chargement d'un plugin du répertoire de compétences, supprimez son dossier ou désactivez-le par nom. Il n'y a pas d'étape `uninstall` car rien n'a été installé à partir d'une marketplace.

445 

446```bash theme={null}

447claude plugin disable my-tool@skills-dir

448```

449 

450***

451 

452<h2 id="synced-plugins">

453 Plugins synchronisés depuis claude.ai

454</h2>

455 

456Claude Code charge les plugins activés pour votre compte claude.ai, y compris les plugins que votre organisation active pour ses membres, aux côtés des plugins que vous installez à partir des marketplaces. Il télécharge chacun d'eux dans `~/.claude/plugins/synced/` et le charge en tant que `<name>@synced`, sans marketplace et sans enregistrement d'installation. Un plugin synchronisé s'exécute avec la même confiance qu'un plugin marketplace que vous avez installé : ses skills, agents, hooks, serveurs MCP et serveurs LSP se chargent tous.

457 

458L'endroit où Claude Code synchronise ces plugins dépend de la session :

459 

460* Dans [Cowork](https://claude.com/product/cowork) et les [sessions cloud](/docs/fr/cloud-environments#what-carries-over-from-your-setup), Claude Code les télécharge dans l'environnement propre de la session au démarrage de la session. Avant la v2.1.239, Claude Code chargeait ces plugins en tant que `<name>@inline`, l'identité que les plugins `--plugin-dir` utilisent.

461* Dans les sessions de terminal où vous vous connectez avec votre compte claude.ai, Claude Code vérifie votre compte une fois à chaque démarrage, puis télécharge les nouveaux plugins et les plugins mis à jour et supprime ceux que vous ou votre organisation avez désactivés, le tout en arrière-plan. La synchronisation dans les sessions de terminal nécessite Claude Code v2.1.273 ou version ultérieure.

462 

463La vérification au lancement s'exécute en arrière-plan, elle peut donc se terminer après le démarrage de votre session. Lorsqu'elle ajoute, met à jour ou supprime un plugin synchronisé dans une session interactive, Claude Code affiche `Plugins changed. Run /reload-plugins to activate.` Exécutez [`/reload-plugins`](/docs/fr/discover-plugins#apply-plugin-changes-without-restarting) pour charger la modification dans cette session, ou laissez-la pour la prochaine fois que vous démarrez Claude Code. Si vous activez un plugin sur claude.ai pendant qu'une session est en cours d'exécution, Claude Code le télécharge la prochaine fois qu'il démarre.

464 

465La synchronisation des plugins dans les sessions de terminal s'exécute dans les mêmes conditions de connexion que les [skills synchronisés depuis claude.ai](/docs/fr/skills#where-synced-skills-load). Elle nécessite également une connexion qui accorde à Claude Code l'accès aux plugins de votre compte.

466 

467Une connexion à partir d'une version antérieure de Claude Code récupère l'accès aux plugins la prochaine fois que Claude Code renouvelle cette connexion en arrière-plan, dans quelques heures, ou immédiatement si vous exécutez `/login` à nouveau. La synchronisation des plugins commence la prochaine fois que vous démarrez Claude Code après cela.

468 

469`claude plugin list` affiche les plugins synchronisés sous un en-tête `Synced from claude.ai`, et l'onglet **Installed** de `/plugin` les répertorie avec `synced` comme source. Gérez un plugin synchronisé par l'ID `<name>@synced` que `claude plugin list` affiche :

470 

471* **Désactiver un plugin** : exécutez `claude plugin disable <name>@synced`, ou désactivez-le à partir de l'onglet **Installed** de `/plugin`. Claude Code enregistre le choix en tant que `"<name>@synced": false` dans votre [`enabledPlugins`](/docs/fr/settings-reference#enabledplugins) au niveau utilisateur. Pour réactiver le plugin, exécutez `claude plugin enable <name>@synced`.

472* **Exclure un plugin partout** : [désactivez le plugin pour votre compte claude.ai](/docs/fr/desktop#extend-claude-code). Pour l'exclure d'un projet dans chaque environnement, définissez `"<name>@synced": false` sous `enabledPlugins` dans le `.claude/settings.json` engagé de ce projet.

473* **Gérer le plugin lui-même sur claude.ai** : `claude plugin install`, `update` et `uninstall` ne s'appliquent pas à un plugin synchronisé. Claude Code télécharge les mises à jour d'un plugin à la prochaine synchronisation. Pour en supprimer un, désactivez le plugin pour votre compte claude.ai, et Claude Code le supprime à la prochaine synchronisation.

474* **Arrêter la synchronisation sur une machine** : définissez [`syncClaudeAiPlugins`](/docs/fr/settings-reference#syncclaudeaiplugins) sur `false` dans vos paramètres utilisateur. Claude Code arrête le téléchargement, et la prochaine fois qu'il démarre, il déplace les plugins qu'il a déjà synchronisés vers `~/.claude/plugins/.trash/` et ne les charge plus. Votre organisation peut définir la même clé dans les [paramètres gérés](/docs/fr/managed-settings), ou désactiver les Skills sur claude.ai, ce qui arrête également la synchronisation des plugins.

475 

476Vous ne pouvez pas désactiver un plugin que votre organisation marque comme requis sur claude.ai. Claude Code le charge même si vous l'avez désactivé précédemment, et `claude plugin disable` refuse avec `Plugin "<name>@synced" is required by your organization and can't be disabled here. Contact your admin to change it.` Dans `claude plugin list`, ces plugins sont marqués `required by your org`.

477 

478Lorsqu'un plugin activé provenant de toute autre source correspond au nom d'un plugin synchronisé, Claude Code charge ce plugin et signale que la copie synchronisée n'est pas chargée. Les autres sources incluent les installations marketplace, les [plugins du répertoire de skills](#skills-directory-plugins), les plugins `--plugin-dir` et les plugins intégrés à Claude Code. Pour utiliser la copie claude.ai à la place, désactivez votre propre copie. Avant la v2.1.239, Claude Code chargeait la copie synchronisée à la place d'une installation marketplace portant le même nom.

479 

480***

481 

482<h2 id="plugin-manifest-schema">

483 Schéma du manifeste du plugin

484</h2>

485 

486Le fichier `.claude-plugin/plugin.json` définit les métadonnées et la configuration de votre plugin.

487 

488Le manifeste est facultatif. S'il est omis, Claude Code découvre automatiquement les composants dans les [emplacements par défaut](#file-locations-reference) et dérive le nom du plugin du nom du répertoire. Utilisez un manifeste lorsque vous devez fournir des métadonnées ou des chemins de composants personnalisés.

489 

490<h3 id="complete-schema">

491 Schéma complet

492</h3>

493 

494```json theme={null}

495{

496 "name": "plugin-name",

497 "displayName": "Plugin Name",

498 "version": "1.2.0",

499 "description": "Brief plugin description",

500 "author": {

501 "name": "Author Name",

502 "email": "author@example.com",

503 "url": "https://github.com/author"

504 },

505 "homepage": "https://docs.example.com/plugin",

506 "repository": "https://github.com/author/plugin",

507 "license": "MIT",

508 "keywords": ["keyword1", "keyword2"],

509 "metadata": { "catalogId": "cat-123", "tier": "pro" },

510 "skills": "./custom/skills/",

511 "commands": ["./custom/commands/special.md"],

512 "agents": ["./custom/agents/reviewer.md"],

513 "hooks": "./config/hooks.json",

514 "mcpServers": "./mcp-config.json",

515 "outputStyles": "./styles/",

516 "lspServers": "./.lsp.json",

517 "experimental": {

518 "themes": "./themes/",

519 "monitors": "./monitors.json",

520 "evals": "quality/evals"

521 },

522 "dependencies": [

523 "helper-lib",

524 { "name": "secrets-vault", "version": "~2.1.0" }

525 ]

526}

527```

528 

529<h3 id="required-fields">

530 Champs obligatoires

531</h3>

532 

533Si vous incluez un manifeste, `name` est le seul champ obligatoire.

534 

535| Champ | Type | Description | Exemple |

536| :----- | :----- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------- |

537| `name` | string | Identifiant unique en kebab-case, sans espaces, caractères de contrôle ou caractères de formatage bidirectionnel. Lorsqu'une [entrée de marketplace](/docs/fr/plugin-marketplaces#plugin-entries) répertorie le plugin sous un nom différent, le nom de l'entrée marketplace est celui utilisé par les clés `enabledPlugins` et `/plugin` | `"deployment-tools"` |

538 

539Ce nom est utilisé pour l'espace de noms des composants. Par exemple, dans l'interface utilisateur, l'agent `agent-creator` pour le plugin nommé `plugin-dev` apparaîtra comme `plugin-dev:agent-creator`.

540 

541<h3 id="unrecognized-fields">

542 Champs non reconnus

543</h3>

544 

545Claude Code ignore les champs de niveau supérieur qu'il ne reconnaît pas. Vous pouvez conserver les métadonnées d'un autre écosystème dans `plugin.json` et le plugin se charge toujours. Cela rend pratique de maintenir un seul manifeste qui sert également de manifeste d'extension VS Code ou Cursor, d'un `package.json` npm, ou d'un manifeste de bundle MCPB/DXT.

546 

547`claude plugin validate` signale les champs non reconnus comme des avertissements, pas des erreurs. Si un champ est décalé d'un ou deux caractères par rapport à un champ reconnu, l'avertissement suggère le nom probablement prévu. Un plugin avec uniquement des avertissements de champs non reconnus réussit toujours la validation et se charge au moment de l'exécution.

548 

549La façon dont Claude Code gère un champ reconnu dont la valeur a le mauvais type dépend du champ :

550 

551* **La plupart des champs** : le plugin ne se charge pas. Par exemple, une valeur `keywords` qui est une chaîne au lieu d'un tableau est une erreur de chargement, et `claude plugin validate` la signale comme telle.

552* **`experimental` et `metadata`** : Claude Code ignore une valeur non-objet, et `claude plugin validate` signale un avertissement.

553 

554Passez `--strict` pour traiter les avertissements comme des erreurs. Utilisez-le dans CI pour détecter un nom de champ mal orthographié ou un champ laissé par l'outil de manifeste d'un autre avant la publication, même si le plugin se chargerait au moment de l'exécution.

555 

556```bash theme={null}

557claude plugin validate ./my-plugin --strict

558```

559 

560<h3 id="metadata-fields">

561 Champs de métadonnées

562</h3>

563 

564| Champ | Type | Description | Exemple |

565| :--------------- | :------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |

566| `$schema` | string | URL du schéma JSON pour l'autocomplétion et la validation de l'éditeur. Claude Code ignore ce champ au moment du chargement. | `"https://json.schemastore.org/claude-code-plugin-manifest.json"` |

567| `displayName` | string | Nom lisible par l'homme affiché dans le sélecteur `/plugin` et autres surfaces d'interface utilisateur. Pour un plugin installé depuis le marketplace, un `displayName` sur l'[entrée marketplace](/docs/fr/plugin-marketplaces#optional-plugin-fields) a la priorité sur cette valeur. Lorsqu'aucun nom d'affichage n'est défini dans l'un ou l'autre endroit, les utilisateurs voient `name`. Contrairement à `name`, peut contenir des espaces et n'importe quelle casse. Non utilisé pour l'espace de noms ou la recherche. | `"Deployment Tools"` |

568| `version` | string | Optionnel. Version sémantique. La définition de ceci épingle le plugin à cette chaîne de version, de sorte que les utilisateurs ne reçoivent des mises à jour que lorsque vous la modifiez, sauf pour une [`command` source](/docs/fr/plugin-marketplaces#command-sources) ou un plugin [chargé en place](#plugin-caching-and-file-resolution) ; voir [Gestion des versions](#version-management). S'il est également défini dans l'entrée marketplace, `plugin.json` gagne. S'il est omis, la version provient de la source suivante dans [Gestion des versions](#version-management). | `"2.1.0"` |

569| `description` | string | Brève explication de l'objectif du plugin | `"Deployment automation tools"` |

570| `author` | object | Informations sur l'auteur | `{"name": "Dev Team", "email": "dev@company.com"}` |

571| `homepage` | string | URL de la documentation | `"https://docs.example.com"` |

572| `repository` | string | URL du code source | `"https://github.com/user/plugin"` |

573| `license` | string | Identifiant de licence | `"MIT"`, `"Apache-2.0"` |

574| `keywords` | array | Balises de découverte | `["deployment", "ci-cd"]` |

575| `metadata` | object | Objet de forme libre pour vos propres données, telles que les champs d'habilitation ou de catalogue. Claude Code ne le lit pas, donc les valeurs n'affectent jamais le comportement du plugin. Claude Code ignore une valeur non-objet, et `claude plugin validate` la signale comme un avertissement. Avant v2.1.222, Claude Code traitait la clé comme un [champ non reconnu](#unrecognized-fields). | `{"catalogId": "cat-123"}` |

576| `defaultEnabled` | boolean | Si le plugin démarre dans un état activé lorsque l'utilisateur n'en a pas défini un. Par défaut `true`. Voir [Activation par défaut](#default-enablement). | `false` |

577 

578<h3 id="default-enablement">

579 Activation par défaut

580</h3>

581 

582Définissez `defaultEnabled: false` dans `plugin.json` pour livrer un plugin qui s'installe désactivé. L'utilisateur l'active avec `claude plugin enable <plugin>` ou l'interface `/plugin`. Utilisez ceci pour les plugins qui ajoutent un coût ou une portée auquel un utilisateur devrait s'inscrire, comme celui qui se connecte à un service externe.

583 

584`defaultEnabled` est le fallback lorsque rien d'autre n'a décidé l'état du plugin. Le paramètre de l'utilisateur et une exigence de dépendance ont la priorité sur celui-ci :

585 

586* **Le paramètre de l'utilisateur** : une entrée pour le plugin dans `enabledPlugins` à n'importe quelle portée de paramètres. Une fois écrit, il persiste à travers les mises à jour et réinstallations de plugins, donc changer `defaultEnabled` dans une version ultérieure ne bascule pas un utilisateur existant.

587* **Une exigence de dépendance** : lorsqu'un plugin est requis par un autre qui est actif, Claude Code écrit `true` pour lui au moment de l'installation ou de l'activation. Cela lui donne un paramètre explicite, donc sa propre valeur par défaut ne s'applique plus. Voir [Activer ou désactiver un plugin avec des dépendances](/docs/fr/plugin-dependencies#enable-or-disable-a-plugin-with-dependencies).

588 

589Le même champ peut apparaître dans l'entrée marketplace d'un plugin, où il a la priorité sur la valeur dans `plugin.json`. Voir [Champs de plugin optionnels](/docs/fr/plugin-marketplaces#optional-plugin-fields).

590 

591<h3 id="component-path-fields">

592 Champs de chemin de composant

593</h3>

594 

595| Champ | Type | Description | Exemple |

596| :---------------------- | :-------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------- |

597| `skills` | string\|array | Répertoires de compétences personnalisés contenant `<name>/SKILL.md`. S'ajoute à l'analyse par défaut `skills/`. Voir [Règles de comportement des chemins](#path-behavior-rules) pour l'exception de racine marketplace | `"./custom/skills/"` |

598| `commands` | string\|array | Fichiers de compétences `.md` plats personnalisés ou répertoires (remplace `commands/` par défaut) | `"./custom/cmd.md"` ou `["./cmd1.md"]` |

599| `agents` | string\|array | Fichiers d'agent personnalisés (remplace `agents/` par défaut) | `"./custom/agents/reviewer.md"` |

600| `workflows` | string\|array | Fichiers ou répertoires de scripts [workflow](/docs/fr/workflows) personnalisés (remplace `workflows/` par défaut) | `"./custom/workflows/"` |

601| `hooks` | string\|array\|object | Chemins de configuration de hook ou configuration en ligne | `"./my-extra-hooks.json"` |

602| `mcpServers` | string\|array\|object | Chemins de configuration MCP ou configuration en ligne | `"./my-extra-mcp-config.json"` |

603| `outputStyles` | string\|array | Fichiers/répertoires de style de sortie personnalisés (remplace `output-styles/` par défaut) | `"./styles/"` |

604| `lspServers` | string\|array\|object | Configurations [Language Server Protocol](https://microsoft.github.io/language-server-protocol/) pour l'intelligence du code (aller à la définition, trouver les références, etc.) | `"./.lsp.json"` |

605| `experimental.themes` | string\|array | Fichiers/répertoires de thème de couleur (remplace `themes/` par défaut). Voir [Thèmes](#themes) | `"./themes/"` |

606| `experimental.monitors` | string\|array | Configurations [Monitor](/docs/fr/tools-reference#monitor-tool) de fond qui démarrent automatiquement lorsque le plugin est actif. Voir [Moniteurs](#monitors) | `"./monitors.json"` |

607| `experimental.evals` | string\|array | Répertoire sous la racine du plugin qui contient les [cas d'évaluation](/docs/fr/plugin-evals#use-a-different-eval-directory) du plugin, lorsqu'il n'est pas le répertoire par défaut `evals/`. `claude plugin eval --eval-dir` le remplace | `"quality/evals"` |

608| `userConfig` | object | Valeurs configurables par l'utilisateur demandées au moment de l'activation. Voir [Configuration utilisateur](#user-configuration) | |

609| `channels` | array | Déclarations de canal pour l'injection de messages (style Telegram, Slack, Discord). Voir [Canaux](#channels) | |

610| `dependencies` | array | Autres plugins que ce plugin nécessite, optionnellement avec des contraintes de version semver. Voir [Contraindre les versions de dépendance du plugin](/docs/fr/plugin-dependencies) | `[{ "name": "secrets-vault", "version": "~2.1.0" }]` |

611 

612<h3 id="experimental-components">

613 Composants expérimentaux

614</h3>

615 

616Les composants sous la clé `experimental`, `themes` et `monitors`, ont un schéma de manifeste qui peut changer entre les versions pendant qu'ils se stabilisent. L'endroit où vous les déclarez est une migration séparée : le niveau supérieur fonctionne toujours, `claude plugin validate` avertit, et une version future exigera `experimental.*`.

617 

618<h3 id="user-configuration">

619 Configuration utilisateur

620</h3>

621 

622Le champ `userConfig` déclare les valeurs pour lesquelles Claude Code invite l'utilisateur lorsque le plugin est activé. Utilisez ceci au lieu d'exiger que les utilisateurs modifient manuellement `settings.json`.

623 

624```json theme={null}

625{

626 "userConfig": {

627 "api_endpoint": {

628 "type": "string",

629 "title": "API endpoint",

630 "description": "Your team's API endpoint"

631 },

632 "api_token": {

633 "type": "string",

634 "title": "API token",

635 "description": "API authentication token",

636 "sensitive": true

637 }

638 }

639}

640```

641 

642Les clés doivent être des identifiants valides. Chaque option supporte ces champs :

643 

644| Champ | Obligatoire | Description |

645| :------------ | :---------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

646| `type` | Oui | L'un de `string`, `number`, `boolean`, `directory`, ou `file` |

647| `title` | Oui | Étiquette affichée dans la boîte de dialogue de configuration |

648| `description` | Oui | Texte d'aide affiché sous le champ |

649| `sensitive` | Non | Si `true`, masque l'entrée et stocke la valeur dans le stockage sécurisé au lieu de `settings.json` |

650| `required` | Non | Si `true`, la validation échoue lorsque le champ est vide |

651| `default` | Non | Valeur utilisée lorsque l'utilisateur ne fournit rien |

652| `options` | Non | Pour le type `string`, les valeurs que le champ accepte, affichées dans `/config` comme un sélecteur sur celles-ci. Voir [Limiter un champ à des options fixes](#limit-a-field-to-fixed-options). Nécessite Claude Code v2.1.271 ou ultérieur |

653| `multiple` | Non | Pour le type `string`, autoriser un tableau de chaînes |

654| `min` / `max` | Non | Limites pour le type `number` |

655 

656À l'exception des champs `sensitive` et des listes `multiple`, chaque champ de chaque plugin activé apparaît également comme une ligne dans le panneau `/config`. Les lignes nécessitent Claude Code v2.1.269 ou ultérieur.

657 

658Chaque valeur est disponible pour la substitution comme `${user_config.KEY}` dans les configurations de serveur MCP et LSP et les commandes de hook. Les valeurs non sensibles peuvent également être substituées dans le contenu des compétences et des agents. Toutes les valeurs sont exportées vers les processus de hook en tant que variables d'environnement `CLAUDE_PLUGIN_OPTION_<KEY>`, où `<KEY>` est la clé d'option en majuscules.

659 

660Les champs qui s'exécutent dans un shell rejettent `${user_config.*}` : substituer une valeur configurée dans une commande shell permettrait au shell d'exécuter tout ce que cette valeur contient, donc le composant échoue avec une [erreur](/docs/fr/errors#plugin-command-references-user-config) à la place. Chaque champ rejeté a une autre façon de passer la valeur :

661 

662| Champ rejeté | Comment passer la valeur |

663| :--------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------- |

664| Commandes de hook en forme shell | Utilisez la [forme exec](/docs/fr/hooks#exec-form-and-shell-form) avec `args`, ou lisez `CLAUDE_PLUGIN_OPTION_<KEY>` à partir de l'environnement du hook |

665| Commandes [Monitor](#monitors) | Lisez la valeur à partir d'un fichier de configuration dans le script |

666| MCP [`headersHelper`](/docs/fr/mcp#use-dynamic-headers-for-custom-authentication) | Lisez la valeur à partir d'un fichier de configuration dans le script |

667 

668Avant v2.1.207, ces champs substituaient les valeurs `${user_config.KEY}` ; mettez à jour les plugins qui en dépendaient.

669 

670Les valeurs non sensibles sont stockées sous la clé [`pluginConfigs`](/docs/fr/settings-reference#pluginconfigs) dans votre `settings.json` utilisateur comme `pluginConfigs[<plugin-id>].options`.

671 

672Sur macOS, Claude Code stocke les valeurs sensibles dans le Keychain macOS, en revenant à `~/.claude/.credentials.json` lorsque le Keychain rejette l'écriture. Sur les plates-formes sans un trousseau supporté, il les stocke dans `~/.claude/.credentials.json`. Le stockage du trousseau est partagé avec les jetons OAuth et a une limite totale d'environ 2 KB, donc gardez les valeurs sensibles petites.

673 

674Claude Code lit toutes les valeurs `pluginConfigs` à partir de seulement trois sources de paramètres :

675 

676* **Paramètres utilisateur** : `~/.claude/settings.json`, le fichier que l'invite au moment de l'activation écrit

677* **`--settings`** : l'indicateur CLI ou les paramètres en ligne du SDK

678* **Paramètres gérés** : [politique contrôlée par l'organisation](/docs/fr/permissions#managed-settings)

679 

680Lorsque plusieurs sources définissent la même clé, les paramètres gérés ont la priorité, puis `--settings`, puis les paramètres utilisateur. La seule source que vous pouvez supprimer de cette liste est les paramètres utilisateur : passez [`--setting-sources`](/docs/fr/cli-reference#cli-flags) sans `user` et Claude Code les ignore. Les paramètres gérés et `--settings` restent quels que soient les paramètres que vous passez. L'option [`settingSources`](/docs/fr/agent-sdk/claude-code-features#what-settingsources-does-not-control) du SDK définit la même liste.

681 

682Les entrées dans le `.claude/settings.json` ou `.claude/settings.local.json` d'un projet sont ignorées. Les deux fichiers vivent dans l'espace de travail, donc un référentiel cloné pourrait fournir des valeurs là, et ces valeurs s'écouleraient dans les commandes de hook de plugin, les configurations de serveur MCP, les commandes LSP et les commandes de moniteur. Avant v2.1.207, ces entrées étaient lues. La restriction est spécifique à `pluginConfigs` : [`enabledPlugins`](/docs/fr/settings-reference#enabledplugins) honore toujours les paramètres de projet et locaux.

683 

684<h4 id="limit-a-field-to-fixed-options">

685 Limiter un champ à des options fixes

686</h4>

687 

688Définissez `options` sur un champ `userConfig` pour que les utilisateurs choisissent sa valeur dans une liste fixe.

689 

690Pour limiter un champ `tone` à trois options, listez-les dans `options` et définissez `default` sur l'une d'elles :

691 

692```json theme={null}

693{

694 "userConfig": {

695 "tone": {

696 "type": "string",

697 "title": "Tone",

698 "description": "Voice for generated replies",

699 "options": ["neutral", "warm", "formal"],

700 "default": "neutral"

701 }

702 }

703}

704```

705 

706Si vous déclarez `options` sur n'importe quel champ, les utilisateurs sur les versions de Claude Code antérieures à v2.1.271 ne peuvent pas charger le plugin.

707 

708Lorsque vous définissez `options` sur un champ, suivez ces règles :

709 

710* Définissez `type` sur `string`

711* Ne définissez pas `multiple` ou `sensitive` sur `true`

712* Définissez `default` sur l'une des options

713* Si vous laissez `default` non défini, définissez `required` sur `true`

714* Listez au moins une option, chacune de 1 à 64 caractères de long

715* Ne commencez pas ou ne terminez pas une option par un espace

716* N'utilisez pas de caractères de contrôle, de caractères invisibles, de caractères qui changent la direction du texte, ou d'espaces autres qu'un espace régulier dans une option

717* Ne listez pas la même option deux fois, même dans une casse de lettre différente

718 

719Si vous enfreignez l'une de ces règles, le plugin ne se charge pas. Exécutez `claude plugin validate` pour voir quel champ enfreint quelle règle.

720 

721<h3 id="channels">

722 Canaux

723</h3>

724 

725Le champ `channels` permet à un plugin de déclarer un ou plusieurs canaux de message qui injectent du contenu dans la conversation. Chaque canal se lie à un serveur MCP que le plugin fournit.

726 

727```json theme={null}

728{

729 "channels": [

730 {

731 "server": "telegram",

732 "userConfig": {

733 "bot_token": {

734 "type": "string",

735 "title": "Bot token",

736 "description": "Telegram bot token",

737 "sensitive": true

738 },

739 "owner_id": {

740 "type": "string",

741 "title": "Owner ID",

742 "description": "Your Telegram user ID"

743 }

744 }

745 }

746 ]

747}

748```

749 

750Le champ `server` est obligatoire et doit correspondre à une clé dans les `mcpServers` du plugin. Le `userConfig` optionnel par canal utilise le même schéma que le champ de niveau supérieur, permettant au plugin de demander des jetons de bot ou des ID de propriétaire lorsque le plugin est activé.

751 

752<h3 id="path-behavior-rules">

753 Règles de comportement des chemins

754</h3>

755 

756Si un chemin personnalisé remplace ou étend le répertoire par défaut du plugin dépend du champ :

757 

758* **Remplace le défaut** : `commands`, `agents`, `workflows`, `outputStyles`, `experimental.themes`, `experimental.monitors`. Par exemple, lorsque le manifeste spécifie `commands`, le répertoire par défaut `commands/` n'est pas analysé. Pour conserver le défaut et en ajouter plus, listez-le explicitement : `"commands": ["./commands/", "./extras/"]`

759* **S'ajoute au défaut** : `skills`. Le répertoire par défaut `skills/` est toujours analysé, et les répertoires listés dans `skills` sont chargés à côté de lui. Exception : pour une [entrée marketplace dont la `source` se résout à la racine marketplace](/docs/fr/plugin-marketplaces#advanced-plugin-entries), déclarer des sous-répertoires spécifiques remplace l'analyse par défaut `skills/`

760* **Règles de fusion propres** : [hooks](#hooks), [serveurs MCP](#mcp-servers), et [serveurs LSP](#lsp-servers). Voir chaque section pour savoir comment plusieurs sources se combinent

761 

762Lorsqu'un plugin a à la fois un dossier par défaut et la clé de manifeste correspondante, Claude Code avertit du dossier ignoré dans `claude plugin list` et la vue de détail `/plugin`. Le plugin se charge toujours en utilisant les chemins du manifeste. Claude Code n'avertit pas lorsque la clé de manifeste pointe dans le dossier par défaut, par exemple `"commands": ["./commands/deploy.md"]`, car ce chemin nomme le dossier explicitement.

763 

764Pour tous les champs de chemin :

765 

766* Tous les chemins doivent être relatifs à la racine du plugin et commencer par `./`, sauf que le champ `skills` accepte également `"."`

767 * À la fois `"."` et `"./"` désignent la racine du plugin elle-même

768 * Avant v2.1.221, `"."` échouait la validation du manifeste et le plugin ne se chargeait pas, donc utilisez `"./"` pour supporter les versions antérieures

769* Les composants des chemins personnalisés utilisent les mêmes règles de nommage et d'espace de noms, sauf les fichiers d'agent. Voir [Agents](#agents) pour savoir comment fonctionnent les noms d'agent

770* Plusieurs chemins peuvent être spécifiés comme des tableaux

771* Un chemin de compétence peut pointer vers un répertoire qui contient directement un `SKILL.md`, par exemple `"skills": ["."]` pour la racine du plugin

772 * Claude Code prend le nom d'invocation de la compétence à partir du champ `name` du frontmatter dans `SKILL.md`, donc le nom reste stable quel que soit le nom du répertoire d'installation

773 * Si `name` n'est pas défini dans le frontmatter, Claude Code revient au nom de base du répertoire

774 

775Un plugin qui a un `SKILL.md` à sa racine, aucun sous-répertoire `skills/`, et aucun champ de manifeste `skills` est automatiquement chargé comme un plugin à compétence unique. Vous n'avez pas besoin de définir `"skills": ["./"]` dans `plugin.json` pour cette disposition.

776 

777**Exemples de chemins** :

778 

779```json theme={null}

780{

781 "commands": [

782 "./specialized/deploy.md",

783 "./utilities/batch-process.md"

784 ],

785 "agents": [

786 "./custom-agents/reviewer.md",

787 "./custom-agents/tester.md"

788 ]

789}

790```

791 

792<h3 id="environment-variables">

793 Variables d'environnement

794</h3>

795 

796Claude Code fournit trois variables pour référencer les chemins :

797 

798| Variable | Se résout à | Utilisez-la pour |

799| :---------------------- | :---------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------- |

800| `${CLAUDE_PLUGIN_ROOT}` | Chemin absolu vers le répertoire d'installation du plugin | Scripts, binaires et fichiers de configuration fournis avec le plugin |

801| `${CLAUDE_PLUGIN_DATA}` | [Répertoire persistant](#persistent-data-directory) qui survit aux mises à jour du plugin, créé à la première référence | Dépendances installées telles que `node_modules` ou environnements virtuels Python, code généré et caches |

802| `${CLAUDE_PROJECT_DIR}` | La racine du projet | Scripts et fichiers de configuration locaux au projet |

803 

804Les trois sont exportés en tant que variables d'environnement vers les processus de hook et vers les sous-processus de serveur MCP et LSP. Ils ne sont pas présents dans l'environnement des commandes que Claude exécute via l'outil Bash, dans la session principale ou dans un sous-agent. Dans le contenu du plugin, écrivez l'espace réservé à la place, et Claude Code substitue le chemin en ligne lorsqu'il charge le contenu. Les champs qui les substituent en ligne dépendent du composant du plugin :

805 

806| Composant du plugin | Champs où les espaces réservés se résolvent |

807| :------------------------------------ | :------------------------------------------ |

808| Contenu des compétences et des agents | N'importe où l'espace réservé apparaît |

809| Commandes de hook et de moniteur | N'importe où l'espace réservé apparaît |

810| Serveurs MCP `stdio` | `command`, `args`, `env` |

811| Serveurs MCP `http`, `sse`, `ws` | `url`, `headers`, `headersHelper` |

812| Serveurs LSP | `command`, `args`, `env`, `workspaceFolder` |

813 

814Dans les commandes de hook, utilisez la [forme exec](/docs/fr/hooks#exec-form-and-shell-form) avec `args` afin que chaque chemin soit passé comme un argument sans guillemets. Dans les hooks en forme shell et les commandes de moniteur, enveloppez les variables entre guillemets doubles, comme dans `"${CLAUDE_PROJECT_DIR}/scripts/server.sh"`. Ce hook en forme shell exécute un script fourni avec un plugin :

815 

816```json theme={null}

817{

818 "hooks": {

819 "PostToolUse": [

820 {

821 "hooks": [

822 {

823 "type": "command",

824 "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/process.sh"

825 }

826 ]

827 }

828 ]

829 }

830}

831```

832 

833Pour un plugin copié, `${CLAUDE_PLUGIN_ROOT}` change lorsque le plugin se met à jour. Le répertoire de la version précédente reste sur le disque pendant une période de grâce après une mise à jour, mais traitez-le comme éphémère et n'écrivez pas d'état là. Pour un plugin chargé en place à partir d'un marketplace de répertoire local, la variable pointe vers le répertoire source stable. Voir [mise en cache du plugin](#plugin-caching-and-file-resolution) pour savoir quels plugins sont copiés et pour la sémantique de nettoyage.

834 

835Lorsqu'un plugin copié se met à jour en milieu de session, les commandes de hook, les moniteurs, les serveurs MCP et les serveurs LSP continuent d'utiliser le chemin de la version précédente. Exécutez `/reload-plugins` pour basculer les hooks, les serveurs MCP et les serveurs LSP vers le nouveau chemin ; les moniteurs nécessitent un redémarrage de session. Dans une session sans terminal interactif, le rechargement laisse les serveurs MCP du plugin sur l'ancien chemin jusqu'à la session suivante.

836 

837Pour un plugin avec une `command` source, Claude Code [peut recharger le plugin lui-même](/docs/fr/plugin-marketplaces#when-claude-code-re-runs-the-command).

838 

839Les serveurs MCP peuvent également appeler la demande `roots/list` pour lire les répertoires de travail de la session au moment de l'exécution. Voir [ce que `roots/list` retourne et quand Claude Code notifie le serveur des changements](/docs/fr/mcp#option-3-add-a-local-stdio-server).

840 

841<h4 id="persistent-data-directory">

842 Répertoire de données persistant

843</h4>

844 

845Le répertoire `${CLAUDE_PLUGIN_DATA}` se résout à `~/.claude/plugins/data/{id}/`, où `{id}` est l'identifiant du plugin avec les caractères en dehors de `a-z`, `A-Z`, `0-9`, `_`, et `-` remplacés par `-`. Pour un plugin installé comme `formatter@my-marketplace`, le répertoire est `~/.claude/plugins/data/formatter-my-marketplace/`.

846 

847Un usage courant est d'installer les dépendances de langage une fois et de les réutiliser à travers les sessions et les mises à jour de plugins. Utilisez-le pour les dépendances Python, les dépendances verrouillées avec Yarn ou pnpm, et les packages dont les scripts de cycle de vie doivent s'exécuter. Pour un plugin installé depuis le marketplace, vous n'en aurez peut-être pas besoin du tout : Claude Code installe automatiquement les [dépendances de package Node.js éligibles](#node-js-package-dependencies) lorsqu'il met en cache le plugin.

848 

849Parce que le répertoire de données survit à n'importe quelle version de plugin unique, une vérification de l'existence du répertoire seule ne peut pas détecter lorsqu'une mise à jour change le manifeste de dépendance du plugin. Le modèle recommandé compare le manifeste fourni par rapport à une copie dans le répertoire de données et réinstalle lorsqu'ils diffèrent.

850 

851Ce hook `SessionStart` installe `node_modules` à la première exécution et à nouveau chaque fois qu'une mise à jour de plugin inclut un `package.json` modifié :

852 

853```json theme={null}

854{

855 "hooks": {

856 "SessionStart": [

857 {

858 "hooks": [

859 {

860 "type": "command",

861 "command": "diff -q \"${CLAUDE_PLUGIN_ROOT}/package.json\" \"${CLAUDE_PLUGIN_DATA}/package.json\" >/dev/null 2>&1 || (cd \"${CLAUDE_PLUGIN_DATA}\" && cp \"${CLAUDE_PLUGIN_ROOT}/package.json\" . && npm install) || rm -f \"${CLAUDE_PLUGIN_DATA}/package.json\""

862 }

863 ]

864 }

865 ]

866 }

867}

868```

869 

870Le `diff` sort nonzero lorsque la copie stockée est manquante ou diffère de celle fournie, couvrant à la fois la première exécution et les mises à jour changeant les dépendances. Si `npm install` échoue, le `rm` final supprime le manifeste copié afin que la session suivante réessaye.

871 

872Les scripts fournis dans `${CLAUDE_PLUGIN_ROOT}` peuvent ensuite s'exécuter contre les `node_modules` persistants :

873 

874```json theme={null}

875{

876 "mcpServers": {

877 "routines": {

878 "command": "node",

879 "args": ["${CLAUDE_PLUGIN_ROOT}/server.js"],

880 "env": {

881 "NODE_PATH": "${CLAUDE_PLUGIN_DATA}/node_modules"

882 }

883 }

884 }

885}

886```

887 

888Le répertoire de données est supprimé automatiquement lorsque vous désinstallez le plugin de la dernière portée où il est installé. L'interface `/plugin` affiche la taille du répertoire et demande avant de supprimer. Le CLI supprime par défaut ; passez [`--keep-data`](#plugin-uninstall) pour le conserver.

889 

890***

891 

892<h2 id="plugin-caching-and-file-resolution">

893 Mise en cache des plugins et résolution des fichiers

894</h2>

895 

896Les plugins sont spécifiés de trois façons :

897 

898* Via `claude --plugin-dir` ou `claude --plugin-url`, pour la durée d'une session.

899* Via une marketplace, installés pour les sessions futures.

900* Via votre compte claude.ai, [synchronisés](#synced-plugins) dans `~/.claude/plugins/synced/`.

901 

902À des fins de sécurité et de vérification, Claude Code copie les plugins de *marketplace* dans le **cache de plugins** local de l'utilisateur (`~/.claude/plugins/cache`), sauf si le plugin se charge sur place. Une [source `command` en mode lien](/docs/fr/plugin-marketplaces#copy-mode-and-link-mode) se charge sur place via des liens dans l'entrée du cache. Une [source de chemin relatif](/docs/fr/plugin-marketplaces#relative-paths) dans une marketplace ajoutée à partir d'un répertoire local se charge sur place à partir du dossier de la marketplace.

903 

904Pour un plugin chargé sur place à partir d'une marketplace de répertoire local, vos modifications du répertoire source prennent effet au prochain démarrage de session ou `/reload-plugins`. Vous n'avez pas besoin d'une augmentation de version. Les processus de hook du plugin et les serveurs MCP et LSP reçoivent un `CLAUDE_PLUGIN_ROOT` qui pointe vers le répertoire source. Claude Code n'installe pas les [dépendances de packages Node.js](#node-js-package-dependencies) du plugin dans le répertoire source. Installez-les vous-même, ou à partir d'un hook dans le [répertoire de données persistantes](#persistent-data-directory).

905 

906Pour les plugins copiés, chaque version installée est un répertoire distinct dans le cache, regroupé par marketplace et plugin et nommé pour la version résolue, avec sa propre copie des fichiers du plugin et des [dépendances de packages Node.js](#node-js-package-dependencies). Une dépendance résolue à partir d'une [balise de version](/docs/fr/plugin-dependencies#tag-plugin-releases-for-version-resolution) obtient un nom de répertoire avec un suffixe de commit-SHA.

907 

908Lorsque vous mettez à jour ou désinstallez un plugin, Claude Code marque le répertoire de la version précédente comme orphelin et le supprime lors d'un balayage en arrière-plan environ 14 jours plus tard. La période de grâce permet aux sessions Claude Code concurrentes qui ont déjà chargé l'ancienne version de continuer à fonctionner sans erreurs. Claude Code exécute le balayage uniquement si au moins un plugin est installé ; après avoir désinstallé votre dernier plugin, les répertoires orphelins restent sur le disque jusqu'à ce que vous installiez à nouveau un plugin.

909 

910Claude Code supprime un dossier de plugin ou de marketplace du cache uniquement lorsqu'il ne contient plus aucun répertoire ou lien symbolique. Si vous créez un lien symbolique vers une extraction de développement dans le cache en tant qu'entrée de version d'un plugin, Claude Code ne marque jamais le lien comme orphelin et ne le supprime jamais, ni les dossiers qui le contiennent. Claude Code n'écrit jamais non plus ses fichiers de suivi de version à l'intérieur de l'extraction liée.

911 

912Les outils Glob et Grep de Claude ignorent les répertoires de version orphelins lors des recherches, de sorte que les résultats de fichiers n'incluent pas le code de plugin obsolète.

913 

914<h3 id="node-js-package-dependencies">

915 Dépendances de packages Node.js

916</h3>

917 

918Lorsque Claude Code copie un plugin dans le cache, il installe également les dépendances de packages Node.js du plugin à cet endroit, afin que les hooks et serveurs MCP du plugin puissent les charger. Cette section couvre les packages npm et Bun qu'un plugin déclare dans son propre `package.json`. Pour les plugins qui dépendent d'autres plugins, voir [versions de dépendances de plugins](/docs/fr/plugin-dependencies).

919 

920Claude Code exécute l'installation dans le répertoire de version copié chaque fois qu'il en crée un : lorsque vous installez un plugin, lorsque Claude Code met à jour un plugin vers une nouvelle version, et au démarrage de la session lorsqu'un plugin activé n'est pas encore en cache, par exemple sur une nouvelle machine. L'installation s'exécute uniquement lorsque le répertoire racine du plugin contient à la fois un `package.json` et un fichier de verrouillage pris en charge :

921 

922| Fichier de verrouillage | Commande |

923| :------------------------------------------- | :----------------------------------------------- |

924| `bun.lock` ou `bun.lockb` | `bun install --frozen-lockfile --ignore-scripts` |

925| `npm-shrinkwrap.json` ou `package-lock.json` | `npm ci --ignore-scripts` |

926 

927Si un plugin contient plus d'un de ces fichiers de verrouillage, Claude Code utilise la première correspondance, en vérifiant dans l'ordre : `bun.lock`, `bun.lockb`, `npm-shrinkwrap.json`, `package-lock.json`.

928 

929Claude Code ignore `yarn.lock` et `pnpm-lock.yaml` car Yarn et pnpm prennent en charge les hooks de configuration au moment de la résolution qui contournent `--ignore-scripts`. Lorsqu'un `bunfig.toml` se trouve à côté du fichier de verrouillage bun correspondant, Claude Code ignore complètement l'installation, car le fichier peut configurer un scanner de sécurité que Bun charge et exécute pendant l'installation. La correspondance du nom de fichier ignore la casse. Supprimez le `bunfig.toml`, ou fournissez un fichier de verrouillage npm à la place du fichier de verrouillage bun.

930 

931Livrez un fichier de verrouillage npm pour la plus large portée. Claude Code exécute le gestionnaire de packages du fichier de verrouillage correspondant à partir du PATH de l'utilisateur et ne revient pas au fichier de verrouillage alternatif s'il est manquant. Pour un plugin distribué via une source npm, utilisez `npm-shrinkwrap.json` ; npm exclut `package-lock.json` des packages publiés.

932 

933Claude Code contraint cette installation de dépendances de sorte qu'aucun code du plugin ou de ses packages ne s'exécute pendant celle-ci, et limite la durée pendant laquelle elle peut s'exécuter :

934 

935* **Résolution figée :** Bun et npm installent exactement ce que le fichier de verrouillage épingle, et échouent plutôt que de re-résoudre les versions lorsque `package.json` et le fichier de verrouillage ne sont pas d'accord.

936* **Pas de scripts de cycle de vie :** `--ignore-scripts` empêche les scripts `preinstall`, `install` et `postinstall` de s'exécuter, de sorte que les dépendances qui construisent des modules natifs dans ces scripts téléchargent mais ne se compilent pas pendant cette installation.

937* **Délai d'expiration de 60 secondes :** Claude Code arrête une installation qui s'exécute plus longtemps et la traite comme échouée.

938 

939Claude Code récupère un plugin de source npm avant cette installation de dépendances, et aucun des scripts d'installation propres du package ne s'exécute pendant la récupération. Voir [packages npm](/docs/fr/plugin-marketplaces#npm-packages).

940 

941Une installation échouée ou ignorée ne bloque jamais le plugin. Lorsque l'installation échoue, ou que Claude Code ignore un fichier de verrouillage yarn ou pnpm ou un fichier de verrouillage bun avec un `bunfig.toml` à côté, il enregistre la raison comme un avertissement dans la [sortie de débogage](#debugging-commands). Un plugin avec un `package.json` et aucun fichier de verrouillage est ignoré sans entrée de journal. Une installation qui expire peut laisser un arbre `node_modules` partiel dans la copie en cache.

942 

943Vous ne pouvez pas désactiver l'installation automatique ; aucun paramètre ou variable d'environnement ne la désactive. Dans les réseaux restreints, voir les [exigences d'accès réseau](/docs/fr/network-config#network-access-requirements) pour les hôtes à autoriser.

944 

945Pour les dépendances que l'installation automatique ne peut pas fournir, telles que les packages qui ont besoin de leurs scripts de cycle de vie pour se construire, les dépendances Python, ou un plugin verrouillé avec Yarn ou pnpm, installez-les à partir d'un hook dans le [répertoire de données persistantes](#persistent-data-directory).

946 

947<h3 id="path-traversal-limitations">

948 Limitations de traversée de chemin

949</h3>

950 

951Claude Code ne permet pas à un plugin de référencer des fichiers en dehors de son propre répertoire. Il rejette un chemin de composant qui se résout en dehors de la racine du plugin, que le chemin soit déclaré dans `plugin.json` ou dans une [entrée de marketplace](/docs/fr/plugin-marketplaces#plugin-entries). Cela couvre un chemin qui pointe en dehors du plugin tel qu'écrit, comme `../shared-utils`, et un lien symbolique qui mène en dehors du plugin, autre que les [liens au sein d'une marketplace](#share-files-within-a-marketplace-with-symlinks).

952 

953Sur macOS et Linux, Claude Code rejette également un chemin de composant qui contient une barre oblique inverse n'importe où dedans, même lorsque le chemin reste à l'intérieur du plugin. Les composants déclarés avec des chemins de barre oblique inverse se chargent donc uniquement sous Windows. Écrivez les chemins de composant avec des barres obliques avant, comme `./commands/deploy.md`.

954 

955Lorsque Claude Code rejette un chemin, il signale une erreur [`path escapes plugin directory`](/docs/fr/errors#path-escapes-plugin-directory) et charge le plugin sans ce composant.

956 

957Claude Code ne copie pas non plus les fichiers en dehors du répertoire du plugin dans le cache lorsqu'il installe le plugin, de sorte que lorsqu'un script à l'intérieur d'un plugin copié lit un chemin au-dessus de la racine du plugin, il ne trouve pas non plus ces fichiers.

958 

959<h3 id="share-files-within-a-marketplace-with-symlinks">

960 Partager des fichiers au sein d'une marketplace avec des liens symboliques

961</h3>

962 

963Si votre plugin doit partager des fichiers avec d'autres parties de la même marketplace, vous pouvez créer des liens symboliques à l'intérieur de votre répertoire de plugin. La façon dont un lien symbolique est traité lorsque le plugin est copié dans le cache dépend de l'endroit où sa cible se résout :

964 

965* **Au sein du propre répertoire du plugin :** le lien symbolique est préservé en tant que lien symbolique relatif dans le cache, de sorte qu'il continue de se résoudre à la cible copiée au moment de l'exécution.

966* **Ailleurs au sein de la même marketplace :** le lien symbolique est déréférencé. Le contenu de la cible est copié dans le cache à sa place. Cela permet au répertoire `skills/` d'un meta-plugin de créer un lien vers les compétences définies par d'autres plugins de la marketplace.

967* **En dehors de la marketplace :** le lien symbolique est ignoré pour des raisons de sécurité. Cela empêche les plugins de tirer des fichiers hôtes arbitraires tels que les chemins système dans le cache.

968 

969Pour les plugins installés avec `--plugin-dir`, à partir d'un chemin local, ou à partir d'une [source `command`](/docs/fr/plugin-marketplaces#copy-mode-and-link-mode) en mode copie, seuls les liens symboliques qui se résolvent au sein du propre répertoire du plugin sont préservés. Tous les autres sont ignorés.

970 

971La commande suivante crée un lien à partir d'un plugin de marketplace vers une compétence partagée définie par un plugin frère. Sous Windows, utilisez `mklink /D` à partir d'une invite de commande élevée ou activez le mode développeur :

972 

973```bash theme={null}

974ln -s ../../shared-plugin/skills/foo ./skills/foo

975```

976 

977***

978 

979<h2 id="plugin-directory-structure">

980 Structure du répertoire des plugins

981</h2>

982 

983<h3 id="standard-plugin-layout">

984 Disposition standard des plugins

985</h3>

986 

987Un plugin complet suit cette structure :

988 

989```text theme={null}

990enterprise-plugin/

991├── .claude-plugin/ # Répertoire de métadonnées (optionnel)

992│ └── plugin.json # manifeste du plugin

993├── skills/ # Skills

994│ ├── code-reviewer/

995│ │ └── SKILL.md

996│ └── pdf-processor/

997│ ├── SKILL.md

998│ └── scripts/

999├── commands/ # Skills en tant que fichiers .md plats

1000│ ├── status.md

1001│ └── logs.md

1002├── agents/ # Définitions de sous-agents

1003│ ├── security-reviewer.md

1004│ ├── performance-tester.md

1005│ ├── compliance-checker.md

1006│ └── review/ # Les agents ici se chargent en tant que enterprise-plugin:review:<name>

1007│ └── accessibility.md

1008├── workflows/ # Scripts de flux de travail

1009│ └── release-audit.js

1010├── output-styles/ # Définitions de style de sortie

1011│ └── terse.md

1012├── themes/ # Définitions de thème de couleur

1013│ └── dracula.json

1014├── monitors/ # Configurations de moniteur en arrière-plan

1015│ └── monitors.json

1016├── hooks/ # Configurations de hooks

1017│ ├── hooks.json # Configuration principale des hooks

1018│ └── security-hooks.json # Hooks supplémentaires

1019├── bin/ # Exécutables du plugin ajoutés à PATH

1020│ └── my-tool # Invocable en tant que commande nue dans l'outil Bash

1021├── settings.json # Paramètres par défaut du plugin

1022├── .mcp.json # Définitions du serveur MCP

1023├── .lsp.json # Configurations du serveur LSP

1024├── scripts/ # Scripts de hooks et utilitaires

1025│ ├── security-scan.sh

1026│ ├── format-code.py

1027│ └── deploy.js

1028├── LICENSE # Fichier de licence

1029└── CHANGELOG.md # Historique des versions

1030```

1031 

1032<Warning>

1033 Le répertoire `.claude-plugin/` contient le fichier `plugin.json`. Tous les autres répertoires (commands/, agents/, skills/, workflows/, output-styles/, themes/, monitors/, hooks/) doivent être à la racine du plugin, pas à l'intérieur de `.claude-plugin/`.

1034</Warning>

1035 

1036Un fichier `CLAUDE.md` à la racine du plugin n'est pas chargé en tant que contexte de projet. Les plugins contribuent au contexte par le biais de skills, d'agents et de hooks plutôt que par CLAUDE.md. Pour livrer des instructions qui se chargent dans le contexte de Claude, mettez-les dans un [skill](#skills).

1037 

1038<h3 id="file-locations-reference">

1039 Référence des emplacements de fichiers

1040</h3>

1041 

1042| Composant | Emplacement par défaut | Objectif |

1043| :------------------- | :--------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

1044| **Manifeste** | `.claude-plugin/plugin.json` | Métadonnées et configuration du plugin (optionnel) |

1045| **Skills** | `skills/` | Skills avec la structure `<name>/SKILL.md` |

1046| **Commandes** | `commands/` | Skills en tant que fichiers Markdown plats. Utilisez `skills/` pour les nouveaux plugins |

1047| **Agents** | `agents/` | Fichiers Markdown de sous-agents. Les sous-dossiers font partie du [nom de l'agent](#agents) |

1048| **Flux de travail** | `workflows/` | Fichiers de script de [flux de travail](/docs/fr/workflows) |

1049| **Styles de sortie** | `output-styles/` | Définitions de style de sortie |

1050| **Thèmes** | `themes/` | Définitions de thème de couleur |

1051| **Hooks** | `hooks/hooks.json` | Configuration des hooks |

1052| **Serveurs MCP** | `.mcp.json` | Définitions du serveur MCP |

1053| **Serveurs LSP** | `.lsp.json` | Configurations du serveur de langage |

1054| **Moniteurs** | `monitors/monitors.json` | Configurations de moniteur en arrière-plan |

1055| **Exécutables** | `bin/` | Exécutables ajoutés au `PATH` de l'outil Bash et invocables en tant que commandes nues tandis que le plugin est activé. Vous ne pouvez pas inclure ce répertoire dans un plugin que vous [distribuez via les paramètres de l'organisation claude.ai](/docs/fr/plugin-marketplaces#keep-executables-out-of-the-top-level-bin-directory) |

1056| **Paramètres** | `settings.json` | Configuration par défaut appliquée lorsque le plugin est activé. Seules les clés [`agent`](/docs/fr/sub-agents) et [`subagentStatusLine`](/docs/fr/statusline#subagent-status-lines) sont prises en charge |

1057 

1058***

1059 

1060<h2 id="cli-commands-reference">

1061 Référence des commandes CLI

1062</h2>

1063 

1064Claude Code fournit des commandes CLI pour la gestion non-interactive des plugins, utiles pour les scripts et l'automatisation.

1065 

1066<h3 id="plugin-init">

1067 plugin init

1068</h3>

1069 

1070Créez un nouveau plugin dans `~/.claude/skills/<name>/`. À la prochaine session Claude Code, il se charge automatiquement en tant que `<name>@skills-dir` et apparaît dans `/plugin` et `claude plugin list` sans étape d'installation.

1071 

1072Consultez [Plugins du répertoire de compétences](#skills-directory-plugins) pour les exigences de portée et de confiance.

1073 

1074```bash theme={null}

1075claude plugin init <name> [options]

1076```

1077 

1078La commande prend ces arguments :

1079 

1080* `<name>` : Nom du plugin. Devient l'espace de noms de la compétence et le nom du répertoire sous `~/.claude/skills/`, il ne peut donc pas contenir d'espaces ou de séparateurs de chemin.

1081 

1082La commande accepte ces options :

1083 

1084| Option | Description | Par défaut |

1085| :----------------------- | :--------------------------------------------------------------------------------------------------------------------------------- | :---------------------- |

1086| `--description <text>` | Description du manifeste | |

1087| `--author <name>` | Nom de l'auteur | `git config user.name` |

1088| `--author-email <email>` | E-mail de l'auteur | `git config user.email` |

1089| `--with <components...>` | Créez également des dossiers de composants. Valeurs valides : `skills`, `agents`, `hooks`, `mcp`, `lsp`, `output-style`, `channel` | |

1090| `-f, --force` | Remplacez un `.claude-plugin/` existant à la cible | |

1091| `-h, --help` | Afficher l'aide pour la commande | |

1092 

1093`claude plugin new` est un alias pour cette commande.

1094 

1095Chaque valeur `--with` ajoute un fichier de démarrage pour ce composant, prêt à être modifié :

1096 

1097| Composant | Ce qu'il crée |

1098| :------------- | :------------------------------------------------------------------------------------------------------------ |

1099| `skills` | Une compétence supplémentaire nommée `<name>:example` à côté de celle par défaut |

1100| `agents` | Une définition de sous-agent `agents/` |

1101| `hooks` | Un `hooks/hooks.json` avec un gestionnaire d'événements exemple |

1102| `mcp` | Un `.mcp.json` avec des exemples de serveur HTTP et stdio |

1103| `lsp` | Un exemple `.lsp.json` de serveur de langage |

1104| `output-style` | Un `output-styles/<name>.md` qui s'applique automatiquement lorsque le plugin est activé |

1105| `channel` | Un [canal](/docs/fr/channels) basé sur MCP : un serveur stdio (`server.ts`), son `.mcp.json`, et un `package.json` |

1106 

1107Le plugin créé utilise la source `@skills-dir` plutôt qu'une marketplace. Les administrateurs peuvent bloquer cette source avec `strictKnownMarketplaces` ou en ajoutant `{"source": "skills-dir"}` à `blockedMarketplaces` dans les [paramètres gérés](/docs/fr/plugin-marketplaces#managed-marketplace-restrictions). Lorsqu'elle est bloquée, `plugin init` échoue avant d'écrire.

1108 

1109Ces exemples montrent les invocations courantes :

1110 

1111```bash theme={null}

1112# Créer un plugin minimal

1113claude plugin init my-helper

1114 

1115# Créer avec des dossiers de compétences et de hooks

1116claude plugin init my-helper --with skills hooks

1117 

1118# Remplacer un scaffold existant

1119claude plugin init my-helper --force

1120```

1121 

1122<h3 id="plugin-install">

1123 plugin install

1124</h3>

1125 

1126Installez un plugin à partir des marketplaces disponibles.

1127 

1128```bash theme={null}

1129claude plugin install <plugin> [options]

1130```

1131 

1132La commande prend ces arguments :

1133 

1134* `<plugin>` : Nom du plugin ou `plugin-name@marketplace-name` pour une marketplace spécifique

1135 

1136La commande accepte ces options :

1137 

1138| Option | Description | Par défaut |

1139| :-------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :--------- |

1140| `-s, --scope <scope>` | Portée d'installation : `user`, `project`, ou `local` | `user` |

1141| `--config <key=value>` | Définissez une option [`userConfig`](#user-configuration) déclarée dans le manifeste du plugin. Répétez le drapeau pour définir plusieurs options | |

1142| `-y, --yes` | Acceptez une commande que la marketplace du plugin déclare, sans l'invite de confirmation : la commande qui produit un plugin avec une [`command` source](/docs/fr/plugin-marketplaces#command-sources), ou le [`headersHelper`](/docs/fr/plugin-marketplaces#authenticate-archive-downloads) qui authentifie un téléchargement d'archive. Accepter un `headersHelper` nécessite Claude Code v2.1.238 ou ultérieur. Claude Code imprime toujours la commande en premier. Requis lorsque stdin ou stdout n'est pas un TTY, sauf si vous passez `--accept-command`. N'a aucun effet dans une session Claude Code, exécutez donc la commande depuis votre propre terminal | |

1143| `--accept-command <sha256>` | Acceptez la commande déclarée par la marketplace dont le `sha256` qu'une exécution [`--json`](#plugin-json-result) précédente a rapporté dans `shownCommand`, à la place de `-y`. L'acceptation compte pour exactement cette commande, ce plugin, et ce catalogue de marketplace. Si l'un d'eux a changé depuis que la commande a été affichée, y compris par l'actualisation de la marketplace de l'exécution elle-même, Claude Code n'accepte pas le digest et affiche la commande à nouveau. Ne peut pas être combiné avec `-y`. N'a aucun effet dans une session Claude Code, exécutez donc la commande depuis votre propre terminal. Nécessite Claude Code v2.1.271 ou ultérieur | |

1144| `--json` | Imprimez le résultat en tant qu'un objet JSON sur la dernière ligne de stdout au lieu du message lisible par l'homme, pour une utilisation dans les scripts. Consultez [Format de résultat JSON](#plugin-json-result). Nécessite Claude Code v2.1.268 ou ultérieur | |

1145| `-h, --help` | Afficher l'aide pour la commande | |

1146 

1147La portée détermine quel fichier de paramètres le plugin installé est ajouté à. Par exemple, `--scope project` écrit dans `enabledPlugins` dans .claude/settings.json, rendant le plugin disponible pour tous ceux qui clonent le référentiel du projet.

1148 

1149<span id="plugin-json-result" />Avec `--json`, la dernière ligne de stdout est un objet JSON. Analysez uniquement cette ligne, car Claude Code imprime toute commande que la marketplace déclare avant elle. Trois champs sont toujours présents :

1150 

1151* `command` : la sous-commande qui a été exécutée, comme `install`

1152* `outcome` : `ok` ou `failed`

1153* `message` : une description lisible par l'homme du résultat

1154 

1155D'autres champs, tels que `pluginId`, `scope`, et `failureCode`, n'apparaissent que lorsqu'ils s'appliquent. L'option `--json` sur `plugin uninstall`, `plugin update`, `plugin enable`, et `plugin disable` imprime le même objet avec les propres champs de cette sous-commande. Une erreur d'utilisation, comme un `--scope` invalide, n'imprime aucune ligne de résultat et quitte 1 avec la raison sur stderr.

1156 

1157Lorsqu'une exécution affiche une commande déclarée par la marketplace et ne l'exécute pas, le résultat `failed` porte également un objet `shownCommand` dont les champs incluent la commande telle qu'affichée, le plugin auquel elle appartient, et le `sha256` de la commande. Pour accepter exactement cette commande, réexécutez avec ce `sha256` en tant que `--accept-command`. Nécessite Claude Code v2.1.271 ou ultérieur.

1158 

1159Si `shownCommand.acceptCommandMatched` est `false`, le digest que vous avez passé ne correspond pas à la commande maintenant affichée. Montrez cette commande à une personne avant de passer son `sha256`.

1160 

1161Ces exemples montrent les invocations courantes :

1162 

1163```bash theme={null}

1164# Installer dans la portée utilisateur (par défaut)

1165claude plugin install formatter@my-marketplace

1166 

1167# Installer dans la portée du projet (partagé avec l'équipe)

1168claude plugin install formatter@my-marketplace --scope project

1169 

1170# Installer dans la portée locale (non partagé avec l'équipe)

1171claude plugin install formatter@my-marketplace --scope local

1172```

1173 

1174<h3 id="plugin-uninstall">

1175 plugin uninstall

1176</h3>

1177 

1178Supprimez un plugin installé.

1179 

1180```bash theme={null}

1181claude plugin uninstall <plugin> [options]

1182```

1183 

1184La commande prend ces arguments :

1185 

1186* `<plugin>` : Nom du plugin ou `plugin-name@marketplace-name`

1187 

1188La commande accepte ces options :

1189 

1190| Option | Description | Par défaut |

1191| :-------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------- |

1192| `-s, --scope <scope>` | Désinstaller de la portée : `user`, `project`, ou `local` | `user` |

1193| `--keep-data` | Préservez le [répertoire de données persistantes](#persistent-data-directory) du plugin | |

1194| `--prune` | Supprimez également les dépendances auto-installées qu'aucun autre plugin ne nécessite. Consultez [plugin prune](#plugin-prune) | |

1195| `-y, --yes` | Ignorez l'invite de confirmation `--prune`. Requis lorsque stdin ou stdout n'est pas un TTY | |

1196| `--json` | Imprimez le résultat en tant qu'un objet JSON sur la dernière ligne de stdout, au [même format que `plugin install --json`](#plugin-json-result). Ne peut pas être combiné avec `--prune`. Nécessite Claude Code v2.1.268 ou ultérieur | |

1197| `-h, --help` | Afficher l'aide pour la commande | |

1198 

1199`claude plugin remove` et `claude plugin rm` sont des alias pour cette commande.

1200 

1201Par défaut, la désinstallation de la dernière portée restante supprime également le répertoire `${CLAUDE_PLUGIN_DATA}` du plugin. Utilisez `--keep-data` pour le préserver, par exemple lors de la réinstallation après avoir testé une nouvelle version.

1202 

1203<Note>

1204 Lorsque les plugins installés de différentes marketplaces partagent un nom, la forme `plugin-name@marketplace-name` désinstalle uniquement le plugin de la marketplace nommée. Avant v2.1.212, la forme qualifiée pouvait correspondre et désinstaller le plugin du même nom d'une marketplace différente.

1205</Note>

1206 

1207<h3 id="plugin-prune">

1208 plugin prune

1209</h3>

1210 

1211Supprimez les dépendances de plugin auto-installées qui ne sont plus requises par aucun plugin installé. Les dépendances que Claude Code a intégrées pour satisfaire le champ [`dependencies`](/docs/fr/plugin-dependencies) d'un autre plugin sont supprimées ; les plugins que vous avez installés directement ne sont jamais touchés.

1212 

1213```bash theme={null}

1214claude plugin prune [options]

1215```

1216 

1217La commande accepte ces options :

1218 

1219| Option | Description | Par défaut |

1220| :-------------------- | :-------------------------------------------------------------------------------- | :--------- |

1221| `-s, --scope <scope>` | Élaguer à la portée : `user`, `project`, ou `local` | `user` |

1222| `--dry-run` | Listez ce qui serait supprimé sans rien supprimer | |

1223| `-y, --yes` | Ignorez l'invite de confirmation. Requis lorsque stdin ou stdout n'est pas un TTY | |

1224| `-h, --help` | Afficher l'aide pour la commande | |

1225 

1226`claude plugin autoremove` est un alias pour cette commande.

1227 

1228La commande liste les dépendances orphelines et demande une confirmation avant de les supprimer. Pour supprimer un plugin et nettoyer ses dépendances en une seule étape, exécutez `claude plugin uninstall <plugin> --prune`.

1229 

1230<h3 id="plugin-enable">

1231 plugin enable

1232</h3>

1233 

1234Activez un plugin désactivé. Lorsque la cible est installée à partir d'une marketplace et déclare des [dépendances](/docs/fr/plugin-dependencies), Claude Code les active transitivement à la même portée. La commande échoue dans les conditions que [Activer ou désactiver un plugin avec des dépendances](/docs/fr/plugin-dependencies#enable-or-disable-a-plugin-with-dependencies) énumère.

1235 

1236```bash theme={null}

1237claude plugin enable <plugin> [options]

1238```

1239 

1240La commande prend ces arguments :

1241 

1242* `<plugin>` : Nom du plugin, `plugin-name@marketplace-name`, ou `plugin-name@synced` pour un [plugin synchronisé depuis claude.ai](#synced-plugins)

1243 

1244La commande accepte ces options :

1245 

1246| Option | Description | Par défaut |

1247| :-------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------- |

1248| `-s, --scope <scope>` | Portée à activer : `user`, `project`, ou `local`. Lorsqu'elle est omise, Claude Code détecte la portée où le plugin est installé | Détection automatique |

1249| `--json` | Imprimez le résultat en tant qu'un objet JSON sur la dernière ligne de stdout, au [même format que `plugin install --json`](#plugin-json-result). Nécessite Claude Code v2.1.268 ou ultérieur | |

1250| `-h, --help` | Afficher l'aide pour la commande | |

1251 

1252<h3 id="plugin-disable">

1253 plugin disable

1254</h3>

1255 

1256Désactivez un plugin sans le désinstaller.

1257 

1258Lorsque la cible est installée à partir d'une marketplace, la commande échoue si un autre plugin activé [en dépend](/docs/fr/plugin-dependencies#enable-or-disable-a-plugin-with-dependencies). Le message d'erreur inclut une commande chaînée qui désactive d'abord chaque dépendant.

1259 

1260Pour un [plugin synchronisé](#synced-plugins) que votre organisation exige, la commande échoue et ne sauvegarde rien.

1261 

1262```bash theme={null}

1263claude plugin disable [plugin] [options]

1264```

1265 

1266La commande prend ces arguments :

1267 

1268* `[plugin]` : Nom du plugin, `plugin-name@marketplace-name`, ou `plugin-name@synced` pour un [plugin synchronisé depuis claude.ai](#synced-plugins). Optionnel lors de l'utilisation de `--all`

1269 

1270La commande accepte ces options :

1271 

1272| Option | Description | Par défaut |

1273| :-------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------- |

1274| `-a, --all` | Désactivez tous les plugins activés. Ne peut pas être combiné avec `--scope` | |

1275| `-s, --scope <scope>` | Portée à désactiver : `user`, `project`, ou `local`. Lorsqu'elle est omise, Claude Code détecte la portée où le plugin est installé | Détection automatique |

1276| `--json` | Imprimez le résultat en tant qu'un objet JSON sur la dernière ligne de stdout, au [même format que `plugin install --json`](#plugin-json-result). Nécessite Claude Code v2.1.268 ou ultérieur | |

1277| `-h, --help` | Afficher l'aide pour la commande | |

1278 

1279<h3 id="plugin-update">

1280 plugin update

1281</h3>

1282 

1283Mettez à jour un plugin vers la dernière version.

1284 

1285```bash theme={null}

1286claude plugin update <plugin> [options]

1287```

1288 

1289La commande prend ces arguments :

1290 

1291* `<plugin>` : Nom du plugin ou `plugin-name@marketplace-name`

1292 

1293La commande accepte ces options :

1294 

1295| Option | Description | Par défaut |

1296| :-------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :--------- |

1297| `-s, --scope <scope>` | Portée à mettre à jour : `user`, `project`, `local`, ou `managed` | `user` |

1298| `-y, --yes` | Acceptez une commande que la marketplace du plugin déclare, sans l'invite de confirmation : la commande qui produit un plugin avec une [`command` source](/docs/fr/plugin-marketplaces#command-sources), ou le [`headersHelper`](/docs/fr/plugin-marketplaces#authenticate-archive-downloads) qui authentifie un téléchargement d'archive. Accepter un `headersHelper` nécessite Claude Code v2.1.238 ou ultérieur. Claude Code imprime toujours la commande en premier. Requis lorsque stdin ou stdout n'est pas un TTY, sauf si vous passez `--accept-command`. N'a aucun effet dans une session Claude Code, exécutez donc la commande depuis votre propre terminal | |

1299| `--accept-command <sha256>` | Acceptez la commande déclarée par la marketplace dont le `sha256` qu'une exécution [`--json`](#plugin-json-result) précédente a rapporté dans `shownCommand`, à la place de `-y`. L'acceptation compte pour exactement cette commande, ce plugin, et ce catalogue de marketplace. Si l'un d'eux a changé depuis que la commande a été affichée, y compris par l'actualisation de la marketplace de l'exécution elle-même, Claude Code n'accepte pas le digest et affiche la commande à nouveau. Ne peut pas être combiné avec `-y`. N'a aucun effet dans une session Claude Code, exécutez donc la commande depuis votre propre terminal. Nécessite Claude Code v2.1.271 ou ultérieur | |

1300| `--json` | Imprimez le résultat en tant qu'un objet JSON sur la dernière ligne de stdout, au [même format que `plugin install --json`](#plugin-json-result). Nécessite Claude Code v2.1.268 ou ultérieur | |

1301| `-h, --help` | Afficher l'aide pour la commande | |

1302 

1303<Note>

1304 Claude Code résout un nom de plugin nu par rapport à vos plugins installés. Lorsque les plugins installés de différentes marketplaces partagent le nom, Claude Code refuse la mise à jour et énumère les commandes `plugin-name@marketplace-name` qualifiées à exécuter à la place. Avant v2.1.246, Claude Code acceptait uniquement la forme qualifiée et rejetait un nom nu comme non trouvé.

1305</Note>

1306 

1307***

1308 

1309<h3 id="plugin-list">

1310 plugin list

1311</h3>

1312 

1313Listez les plugins installés avec leur version, leur marketplace source et leur statut d'activation.

1314 

1315```bash theme={null}

1316claude plugin list [options]

1317```

1318 

1319La commande accepte ces options :

1320 

1321| Option | Description | Par défaut |

1322| :------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------- |

1323| `--json` | Sortie en JSON. Une ligne de plugin avec des problèmes de chargement ou des avertissements de création porte des tableaux de chaînes `errors` ou `notes`. Sur Claude Code v2.1.268 ou ultérieur, les tableaux parallèles `errorDetails` et `noteDetails` donnent à chaque entrée son `type` de diagnostic et les noms auxquels elle se réfère, comme le plugin, la marketplace, le serveur ou le fichier | |

1324| `--available` | Incluez les plugins disponibles des marketplaces. Nécessite `--json` | |

1325| `-h, --help` | Afficher l'aide pour la commande | |

1326 

1327Dans une session interactive, `/plugin list` imprime un listage similaire en ligne, mais il couvre uniquement les plugins installés depuis une marketplace :

1328 

1329* Les plugins chargés à partir des répertoires de compétences apparaissent dans l'interface `/plugin` et dans `claude plugin list`, mais pas dans la sortie en ligne `/plugin list`.

1330* [Les plugins synchronisés depuis claude.ai](#synced-plugins) apparaissent dans `claude plugin list` sur Claude Code v2.1.239 ou ultérieur et dans l'interface `/plugin`, mais pas dans la sortie en ligne `/plugin list`.

1331* Les plugins chargés pour la session avec `--plugin-dir` ou `--plugin-url` apparaissent dans l'interface `/plugin`, et dans `claude plugin list` uniquement lorsque le même drapeau précède la sous-commande, comme dans `claude --plugin-dir <dir> plugin list`. Seul le nom du drapeau indique leur emplacement, donc un `claude plugin list` nu ne peut pas les trouver, contrairement aux plugins synchronisés et aux plugins du répertoire de compétences, dont les répertoires fixes sont analysés par Claude Code.

1332 

1333La forme interactive accepte `--enabled` ou `--disabled` pour afficher uniquement les plugins dans cet état, et `ls` comme raccourci pour `list`.

1334 

1335<h3 id="plugin-details">

1336 plugin details

1337</h3>

1338 

1339Affichez l'inventaire des composants d'un plugin et le coût en jetons projeté. La sortie énumère tous les composants que le plugin contribue, regroupés en tant que Compétences, Agents, Hooks, serveurs MCP et serveurs LSP, ainsi qu'une estimation du nombre de jetons qu'il ajoute à chaque session. Le groupe Compétences inclut à la fois les entrées `skills/` et `commands/`.

1340 

1341```bash theme={null}

1342claude plugin details <name>

1343```

1344 

1345La commande prend ces arguments :

1346 

1347* `<name>` : Nom du plugin ou `plugin-name@marketplace-name`

1348 

1349La commande accepte ces options :

1350 

1351| Option | Description | Par défaut |

1352| :----------- | :------------------------------- | :--------- |

1353| `-h, --help` | Afficher l'aide pour la commande | |

1354 

1355La sortie affiche deux chiffres de coût pour chaque composant :

1356 

1357* **Toujours actif :** jetons ajoutés à chaque session par le texte de listage du plugin, comme les descriptions de compétences, les descriptions d'agents et les noms de commandes, indépendamment du fait qu'un composant se déclenche ou non.

1358* **À l'invocation :** jetons qu'un composant coûte lorsqu'il se déclenche. Affiché par composant, pas comme un total de plugin, car une session typique n'invoque qu'un sous-ensemble de composants.

1359 

1360Cet exemple montre à quoi ressemble la sortie pour un plugin avec deux compétences :

1361 

1362```

1363dependency-guard 1.2.0

1364 Dependency analysis for Claude Code sessions

1365 Source: dependency-guard@example-marketplace

1366 

1367Component inventory

1368 Skills (2) scan-dependencies, review-changes

1369 Agents (0)

1370 Hooks (1) SessionStart (harness-only — no model context cost)

1371 MCP servers (0)

1372 LSP servers (0)

1373 

1374Projected token cost

1375 Always-on: ~180 tok added to every session

1376 

1377Per-component (rounded)

1378 component always-on on-invoke

1379 scan-dependencies ~100 ~2400

1380 review-changes ~80 ~1800

1381 

1382 On-invoke cost is paid each time a skill or agent fires.

1383 Token counts are estimates and may differ from actual usage.

1384```

1385 

1386Le total toujours actif est calculé via l'API `count_tokens` pour votre modèle actif. Les nombres par composant sont proportionnellement mis à l'échelle à partir de ce total. Si l'API est inaccessible, la commande revient à une estimation basée sur les caractères.

1387 

1388<h3 id="plugin-validate">

1389 plugin validate

1390</h3>

1391 

1392Vérifiez un plugin ou une marketplace pour les erreurs de syntaxe et de schéma avant la publication.

1393 

1394La commande quitte 0 lorsque la validation réussit, 1 lorsqu'elle échoue, et 2 lorsque l'exécution de la validation elle-même échoue, par exemple lorsque le chemin que vous transmettez est illisible.

1395 

1396```bash theme={null}

1397claude plugin validate <path> [options]

1398```

1399 

1400La commande prend ces arguments :

1401 

1402* `<path>` : Chemin vers un répertoire de plugin ou un répertoire de marketplace. Consultez [Valider un plugin ou un répertoire sans manifeste](/docs/fr/plugin-marketplaces#validate-a-plugin-or-a-directory-without-a-manifest) pour savoir quels fichiers une exécution de plugin couvre.

1403 

1404La commande accepte ces options :

1405 

1406| Option | Description | Par défaut |

1407| :----------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------- |

1408| `--strict` | Traitez les avertissements comme des erreurs et quittez 1 sur eux. Utilisez dans CI pour détecter les problèmes que le runtime tolère, comme les [champs non reconnus](#unrecognized-fields) | |

1409| `--json` | Sortez le rapport de validation en tant qu'un objet JSON avec les mêmes codes de sortie. Nécessite Claude Code v2.1.259 ou ultérieur | |

1410| `-h, --help` | Afficher l'aide pour la commande | |

1411 

1412Avec `--json`, Claude Code écrit le rapport sur stdout en tant qu'un objet JSON avec ces champs de niveau supérieur :

1413 

1414* `success` : le même verdict que le code de sortie donne

1415* `strict` : si l'exécution a traité les avertissements comme des erreurs

1416* `target` : le chemin résolu que Claude Code a validé

1417* `manifest` : le propre résultat du manifeste, ou `null` pour une [exécution sans manifeste](/docs/fr/plugin-marketplaces#validate-a-plugin-or-a-directory-without-a-manifest)

1418* `contents` : résultats par fichier, chacun nommant son `file` et portant des tableaux `errors`, `warnings`, et `notes`

1419 

1420À la sortie 2, la commande n'écrit rien sur stdout ; le message d'erreur va à stderr.

1421 

1422Dans une session interactive, `/plugin validate <path>` exécute les mêmes vérifications en ligne.

1423 

1424<h3 id="plugin-eval">

1425 plugin eval

1426</h3>

1427 

1428Exécutez les [cas d'évaluation](/docs/fr/plugin-evals) d'un plugin et rapportez les résultats notés. Nécessite Claude Code v2.1.269 ou ultérieur. Chaque cas est une invite plus des évaluateurs ; Claude Code l'exécute plusieurs fois dans une session isolée avec uniquement le plugin cible chargé, et par défaut aussi sans le plugin afin que le rapport montre la différence. Consultez [Tester les plugins avec des évaluations](/docs/fr/plugin-evals) pour le format des cas, les évaluateurs, les résultats et l'utilisation en CI.

1429 

1430```bash theme={null}

1431claude plugin eval [target] [options]

1432```

1433 

1434La `target` optionnelle est un répertoire de plugin, un seul fichier `prompt.md` ou `case.yaml`, un plugin installé en tant que `name` ou `name@marketplace`, ou `name@skills-dir`, et par défaut le répertoire courant. Mettez-le avant `--tag`, `--allow-tools`, et `--json`.

1435 

1436Ce tableau énumère les options que la plupart des exécutions utilisent. Exécutez `claude plugin eval --help` pour l'ensemble complet, y compris `--case`, `--tag`, `--output-dir`, `--report`, `--allow-real-servers`, `--keep-temp`, et `--verbose`.

1437 

1438| Option | Description | Par défaut |

1439| :------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :-------------------------------------------------------------------------------------------------------- |

1440| `--runs <n>` | Exécutions par cas par bras | `runs` de chaque cas, sinon 3 |

1441| `-j, --concurrency <n>` | Sessions d'agent à exécuter à la fois, 1 à 8. Elles partagent votre limite de débit | `1` |

1442| `--model <model>` | Modèle pour l'agent en test | `model` de chaque cas, sinon `ANTHROPIC_MODEL` s'il est défini, sinon la valeur par défaut de Claude Code |

1443| `--judge-model <model>` | Modèle pour les évaluateurs `llm` et `baseline` | Un petit modèle rapide |

1444| `--ablation <mode>` | `none` ou `with-without`. Consultez [Comparer par rapport à une ligne de base sans plugin](/docs/fr/plugin-evals#compare-against-a-no-plugin-baseline) | `with-without` lorsqu'un plugin se résout, sinon `none` |

1445| `--threshold <0..1>` | Quittez 1 si un cas quelconque note en dessous de ceci | `1.0` |

1446| `--max-cost-usd <usd>` | Arrêtez avant la prochaine exécution une fois que les dépenses atteignent ceci, quittez 2, et rapportez les résultats partiels | Pas de plafond |

1447| `--allow-tools <tools...>` | Accordez des outils au-delà de l'ensemble en lecture seule, comme `Bash`, `Write`, `Edit`, ou `"mcp__plugin_<plugin>_<server>__*"`. Consultez [Accorder des outils](/docs/fr/plugin-evals#grant-tools) | |

1448| `--scaffold` | Exécutez le [`scaffold_script`](/docs/fr/plugin-evals#add-setup-or-history-with-case-yaml) de chaque cas | Désactivé |

1449| `--trust-plugin` | Ignorez l'invite de confiance à la première exécution, pour CI. Consultez [Ce qu'une exécution peut accéder](/docs/fr/plugin-evals#security) | Désactivé |

1450| `--mocks <mode>` | `record` ou `off`. Consultez [Serveurs MCP fictifs](/docs/fr/plugin-evals#mock-mcp-servers) | `record` |

1451| `--eval-dir <dir>` | Répertoire sous le plugin qui contient les cas | Le `experimental.evals` du manifeste, sinon `evals` |

1452| `--json [path]` | Imprimez le [document de résultat](/docs/fr/plugin-evals#json-result) sur stdout, ou écrivez-le dans un chemin `.json` | |

1453| `--no-publish` | Gardez le rapport HTML local | |

1454| `-h, --help` | Afficher l'aide pour la commande | |

1455 

1456La commande quitte 0 lorsque chaque cas respecte le seuil, 1 sur un cas défaillant, une erreur de chargement, ou un répertoire de plugin non approuvé, 2 sur une exécution partielle, 130 lorsqu'elle est interrompue, et 143 lorsqu'elle est terminée. Consultez [Exécuter les évaluations en CI](/docs/fr/plugin-evals#run-evals-in-ci).

1457 

1458<h3 id="plugin-eval-init">

1459 plugin eval init

1460</h3>

1461 

1462Créez une suite d'évaluation pour le plugin dans le répertoire courant. Nécessite Claude Code v2.1.269 ou ultérieur. Dans un terminal, cela démarre une interview de création qui lit le plugin, propose des cas et des évaluateurs, les teste, et écrit les fichiers. Avec `--bare`, ou sans terminal, il écrit un modèle de cas unique vierge à la place. Exécutez depuis une session Claude Code interactive, il imprime les instructions d'interview pour que cette session suive plutôt que d'écrire un modèle. Consultez [Créer votre première suite d'évaluation](/docs/fr/plugin-evals#create-your-first-eval-suite).

1463 

1464```bash theme={null}

1465claude plugin eval init [name] [options]

1466```

1467 

1468Le `name` optionnel est un nom de cas : l'interview n'en a pas besoin, tandis que `--bare` et le chemin du modèle sans terminal l'exigent. Il accepte ces options :

1469 

1470| Option | Description | Par défaut |

1471| :------------------ | :-------------------------------------------------------------------------------------------------- | :-------------------------------------------------- |

1472| `--bare` | Écrivez un `prompt.md` vierge et `graders/criteria.md` pour `<name>` au lieu d'exécuter l'interview | |

1473| `-i, --interactive` | Exigez l'interview. Échoue sans terminal au lieu d'écrire un modèle | |

1474| `--eval-dir <dir>` | Répertoire sous le répertoire courant pour écrire les cas dans | Le `experimental.evals` du manifeste, sinon `evals` |

1475| `-h, --help` | Afficher l'aide pour la commande | |

1476 

1477<h3 id="plugin-tag">

1478 plugin tag

1479</h3>

1480 

1481Créez une balise git de version pour un plugin. Par défaut, la commande balise le plugin dans le répertoire courant ; transmettez un chemin pour baliser un plugin ailleurs. Consultez [Baliser les versions de plugin](/docs/fr/plugin-dependencies#tag-plugin-releases-for-version-resolution).

1482 

1483```bash theme={null}

1484claude plugin tag [path] [options]

1485```

1486 

1487La commande prend ces arguments :

1488 

1489* `[path]` : Chemin vers le répertoire du plugin. Par défaut, le répertoire courant.

1490 

1491La commande accepte ces options :

1492 

1493| Option | Description | Par défaut |

1494| :-------------------- | :---------------------------------------------------------------------------------- | :--------- |

1495| `--push` | Poussez la balise vers le serveur distant après l'avoir créée | |

1496| `--dry-run` | Imprimez ce qui serait balisé sans créer la balise | |

1497| `-f, --force` | Créez la balise même si l'arborescence de travail est sale ou la balise existe déjà | |

1498| `-m, --message <msg>` | Message d'annotation de balise. Utilisez `%s` comme espace réservé pour la version | |

1499| `--remote <name>` | Serveur distant vers lequel pousser avec `--push` | `origin` |

1500| `-h, --help` | Afficher l'aide pour la commande | |

1501 

1502***

1503 

1504<h2 id="debugging-and-development-tools">

1505 Outils de débogage et de développement

1506</h2>

1507 

1508<h3 id="debugging-commands">

1509 Commandes de débogage

1510</h3>

1511 

1512Utilisez `claude --debug` pour voir les détails du chargement des plugins :

1513 

1514Cela affiche :

1515 

1516* Les plugins en cours de chargement

1517* Les erreurs dans les manifestes de plugins

1518* L'enregistrement des skills, agents et hooks

1519* L'initialisation du serveur MCP

1520 

1521<h3 id="common-issues">

1522 Problèmes courants

1523</h3>

1524 

1525| Problème | Cause | Solution |

1526| :---------------------------------- | :--------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

1527| Plugin ne se charge pas | `plugin.json` invalide | Exécutez `claude plugin validate ./my-plugin` ou `/plugin validate ./my-plugin`, où `./my-plugin` est votre répertoire de plugin, pour vérifier `plugin.json`, `hooks/hooks.json` et le frontmatter des skills, agents et commandes dans les répertoires par défaut du plugin pour les erreurs de syntaxe et de schéma. Consultez [Validate a plugin or a directory without a manifest](/docs/fr/plugin-marketplaces#validate-a-plugin-or-a-directory-without-a-manifest) pour savoir ce qu'une exécution couvre |

1528| Les skills n'apparaissent pas | Structure de répertoire incorrecte | Assurez-vous que `skills/` ou `commands/` se trouve à la racine du plugin, pas à l'intérieur de `.claude-plugin/` |

1529| Les hooks ne se déclenchent pas | Script non exécutable | Exécutez `chmod +x script.sh` |

1530| Le serveur MCP échoue | `${CLAUDE_PLUGIN_ROOT}` manquant | Utilisez la variable pour tous les chemins de plugin |

1531| Erreurs de chemin | Chemins absolus utilisés | Rendez les chemins relatifs, en commençant par `./` ; consultez [Path behavior rules](#path-behavior-rules), qui couvrent l'exception `"."` du champ `skills` |

1532| LSP `Executable not found in $PATH` | Serveur de langage non installé | Installez le binaire (par exemple, `npm install -g typescript-language-server typescript`) |

1533 

1534<h3 id="example-error-messages">

1535 Exemples de messages d'erreur

1536</h3>

1537 

1538**Erreurs de validation de manifeste** :

1539 

1540* `Invalid JSON syntax: Unexpected token } in JSON at position 142` : vérifiez les virgules manquantes, les virgules supplémentaires ou les chaînes non citées

1541* `Plugin <name> has an invalid manifest file at .claude-plugin/plugin.json. Validation errors: name: Invalid input: expected string, received undefined` : un champ obligatoire est manquant

1542* `Plugin <name> has a corrupt manifest file at .claude-plugin/plugin.json. JSON parse error: ...` : erreur de syntaxe JSON. Avant v2.1.246, Claude Code produisait également cette erreur pour un `plugin.json` enregistré en UTF-8 avec une marque d'ordre des octets (BOM), même lorsque le JSON était par ailleurs valide.

1543 

1544**Erreurs de chargement de plugin** :

1545 

1546* `Warning: No commands found in plugin my-plugin custom directory: ./cmds. Expected .md files or SKILL.md in subdirectories.` : le chemin de la commande existe mais ne contient aucun fichier de commande valide

1547* `Plugin directory not found at path: ./plugins/my-plugin. Check that the marketplace entry has the correct path.` : le chemin `source` dans marketplace.json pointe vers un répertoire inexistant

1548* `Plugin my-plugin has conflicting manifests: both plugin.json and marketplace entry specify components.` : supprimez les définitions de composants en double ou supprimez `strict: false` dans l'entrée marketplace

1549 

1550<h3 id="hook-troubleshooting">

1551 Dépannage des hooks

1552</h3>

1553 

1554**Le script du hook ne s'exécute pas** :

1555 

15561. Vérifiez que le script est exécutable : `chmod +x ./scripts/your-script.sh`

15572. Vérifiez la ligne shebang : La première ligne doit être `#!/bin/bash` ou `#!/usr/bin/env bash`

15583. Vérifiez que le chemin utilise `${CLAUDE_PLUGIN_ROOT}` : `"command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/your-script.sh"`

15594. Testez le script manuellement : `./scripts/your-script.sh`

1560 

1561**Le hook ne se déclenche pas sur les événements attendus** :

1562 

15631. Vérifiez que le nom de l'événement est correct (sensible à la casse) : `PostToolUse`, pas `postToolUse`

15642. Vérifiez que le motif du matcher correspond à vos outils : `"matcher": "Write|Edit"` pour les opérations de fichier

15653. Confirmez que le type de hook est valide : `command`, `http`, `mcp_tool`, `prompt` ou `agent`

1566 

1567<h3 id="mcp-server-troubleshooting">

1568 Dépannage du serveur MCP

1569</h3>

1570 

1571**Le serveur ne démarre pas** :

1572 

15731. Vérifiez que la commande existe et est exécutable

15742. Vérifiez que tous les chemins utilisent la variable `${CLAUDE_PLUGIN_ROOT}`

15753. Vérifiez les journaux du serveur MCP : `claude --debug` affiche les erreurs d'initialisation

15764. Testez le serveur manuellement en dehors de Claude Code

1577 

1578**Les outils du serveur n'apparaissent pas** :

1579 

15801. Assurez-vous que le serveur est correctement configuré dans `.mcp.json` ou `plugin.json`

15812. Vérifiez que le serveur implémente correctement le protocole MCP

15823. Vérifiez les délais d'expiration de la connexion dans la sortie de débogage

1583 

1584<h3 id="directory-structure-mistakes">

1585 Erreurs de structure de répertoire

1586</h3>

1587 

1588**Symptômes** : Le plugin se charge mais les composants (skills, agents, hooks) sont manquants.

1589 

1590**Structure correcte** : Les composants doivent être à la racine du plugin, pas à l'intérieur de `.claude-plugin/`. Seul `plugin.json` appartient à `.claude-plugin/`.

1591 

1592**Liste de contrôle de débogage** :

1593 

15941. Exécutez `claude --debug` et recherchez les messages « loading plugin »

15952. Vérifiez que chaque répertoire de composant est listé dans la sortie de débogage

15963. Vérifiez que les permissions de fichier permettent de lire les fichiers du plugin

1597 

1598***

1599 

1600<h2 id="distribution-and-versioning-reference">

1601 Référence de distribution et de versioning

1602</h2>

1603 

1604<h3 id="version-management">

1605 Gestion des versions

1606</h3>

1607 

1608Claude Code utilise la version du plugin comme clé de cache qui détermine si une mise à jour est disponible. Lorsque vous exécutez `/plugin update` ou que la mise à jour automatique se déclenche, Claude Code calcule la version actuelle et ignore la mise à jour si elle correspond à celle déjà installée. Un plugin [chargé sur place](#plugin-caching-and-file-resolution) à partir d'une marketplace de répertoire local charge ses fichiers source actuels à chaque démarrage de session, quelle que soit sa chaîne de version.

1609 

1610Pour chaque type de source sauf `command`, Claude Code résout la version à partir du premier de ces éléments qui est défini :

1611 

16121. Le champ `version` dans le fichier `plugin.json` du plugin

16132. Le champ `version` dans l'entrée marketplace du plugin dans `marketplace.json`

16143. Le SHA du commit git du plugin, pour les sources `github`, `url`, `git-subdir` et relative-path dans une marketplace hébergée sur git

16154. Le digest SHA-256, pour les [sources `archive`](/docs/fr/plugin-marketplaces#zip-archives) : le pin `sha256` dans l'entrée marketplace, ou le digest du fichier téléchargé lorsque vous ne définissez aucun pin. Claude Code le raccourcit aux 12 premiers caractères

16165. `unknown`, pour les sources `npm` ou les répertoires locaux ne se trouvant pas dans un dépôt git. Claude Code ne prend pas la version à partir d'un référentiel qui enferme le chemin d'installation, comme un `~/.claude` géré par git

1617 

1618Pour une [source `command`](/docs/fr/plugin-marketplaces#command-sources), Claude Code dérive toujours la version à partir de ce que la commande a produit : un hash de contenu de 12 caractères seul, ou ajouté à la version `plugin.json` sous la forme `<version>-<hash>` lorsqu'une version est définie. Claude Code ignore le champ `version` de l'entrée marketplace pour les sources command. Une commande dont la sortie hachée change produit donc une nouvelle version, même lorsque la chaîne de version créée reste la même. En [mode lien](/docs/fr/plugin-marketplaces#copy-mode-and-link-mode), le hash couvre le chemin réel du répertoire imprimé et ses entrées de niveau supérieur plutôt que le contenu des fichiers.

1619 

1620Pour ces types de sources, cela vous donne trois façons de versionner un plugin :

1621 

1622| Approche | Comment | Comportement de mise à jour | Idéal pour |

1623| :------------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------- |

1624| **Version explicite** | Définissez `"version": "2.1.0"` dans `plugin.json` | Les utilisateurs reçoivent les mises à jour uniquement lorsque vous augmentez ce champ. Pousser de nouveaux commits sans l'augmenter n'a aucun effet, et `/plugin update` signale « déjà à la dernière version ». Pour un plugin [chargé sur place](#plugin-caching-and-file-resolution), le nouveau contenu se charge de toute façon. | Plugins publiés avec des cycles de publication stables |

1625| **Version SHA du commit** | Omettez `version` à la fois de `plugin.json` et de l'entrée marketplace | Les utilisateurs reçoivent les mises à jour chaque fois que le commit résolu de la source change | Plugins internes ou d'équipe en développement actif |

1626| **Version du digest** | Utilisez une [source `archive`](/docs/fr/plugin-marketplaces#zip-archives) et omettez `version` à la fois de `plugin.json` et de l'entrée marketplace | Avec un pin `sha256`, les utilisateurs reçoivent les mises à jour lorsque vous modifiez le pin. Sans pin, les utilisateurs reçoivent les mises à jour chaque fois que les octets du fichier zip hébergé changent | Plugins publiés en tant que fichiers zip sur un serveur statique ou un référentiel d'artefacts |

1627 

1628Si vous utilisez des versions explicites, suivez le [versioning sémantique](https://semver.org) (`MAJOR.MINOR.PATCH`) : augmentez MAJOR pour les modifications incompatibles, MINOR pour les nouvelles fonctionnalités, PATCH pour les corrections de bogues. Documentez les modifications dans un fichier `CHANGELOG.md`.

1629 

1630***

1631 

1632<h2 id="see-also">

1633 Voir aussi

1634</h2>

1635 

1636* [Plugins](/docs/fr/plugins) - Tutoriels et utilisation pratique

1637* [Marketplaces de plugins](/docs/fr/plugin-marketplaces) - Création et gestion des marketplaces

1638* [Skills](/docs/fr/skills) - Détails du développement des skills

1639* [Subagents](/docs/fr/sub-agents) - Configuration et capacités des agents

1640* [Hooks](/docs/fr/hooks) - Gestion des événements et automatisation

1641* [MCP](/docs/fr/mcp) - Intégration des outils externes

1642* [Paramètres](/docs/fr/settings) - Options de configuration pour les plugins