plugin-marketplaces.md +0 −1688 deleted
File Deleted View Diff
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# Créer et distribuer une place de marché de plugins
6
7> Créez et hébergez des places de marché de plugins pour distribuer les extensions Claude Code dans vos équipes et communautés.
8
9Une **place de marché de plugins** est un catalogue qui vous permet de distribuer des plugins à d'autres. Les places de marché offrent une découverte centralisée, un suivi des versions, des mises à jour automatiques et la prise en charge de plusieurs types de sources, notamment les dépôts git et les chemins locaux. Ce guide vous montre comment créer votre propre place de marché pour partager des plugins avec votre équipe ou votre communauté.
10
11Vous cherchez à installer des plugins à partir d'une place de marché existante ? Consultez [Découvrir et installer des plugins préconfigurés](/docs/fr/discover-plugins).
12
13<h2 id="overview">
14 Aperçu
15</h2>
16
17La création et la distribution d'une place de marché impliquent :
18
191. **Créer des plugins** : créez un ou plusieurs plugins avec des compétences, des agents, des hooks, des serveurs MCP ou des serveurs LSP. Ce guide suppose que vous avez déjà des plugins à distribuer ; consultez [Créer des plugins](/docs/fr/plugins) pour plus de détails sur la création de plugins.
202. **Créer le fichier de place de marché** : définissez un `marketplace.json` qui répertorie vos plugins et où les trouver. Voir [Créer le fichier de place de marché](#create-the-marketplace-file).
213. **Héberger la place de marché** : poussez vers GitHub, GitLab ou un autre hôte git. Voir [Héberger et distribuer les places de marché](#host-and-distribute-marketplaces).
224. **Partager avec les utilisateurs** : les utilisateurs ajoutent votre place de marché avec `/plugin marketplace add` et installent des plugins individuels. Voir [Découvrir et installer des plugins](/docs/fr/discover-plugins).
23
24Une fois votre place de marché en ligne, vous pouvez la mettre à jour en poussant les modifications vers votre dépôt. Les utilisateurs actualisent leur copie locale avec `/plugin marketplace update`.
25
26<h2 id="walkthrough-create-a-local-marketplace">
27 Procédure pas à pas : créer une place de marché locale
28</h2>
29
30Cet exemple crée une place de marché avec un plugin : une compétence `quality-review` pour les révisions de code. Vous allez créer la structure de répertoires, ajouter une compétence, créer le manifeste du plugin et le catalogue de la place de marché, puis l'installer et la tester.
31
32<Steps>
33 <Step title="Créer la structure de répertoires">
34 ```bash theme={null}
35 mkdir -p my-marketplace/.claude-plugin
36 mkdir -p my-marketplace/plugins/quality-review-plugin/.claude-plugin
37 mkdir -p my-marketplace/plugins/quality-review-plugin/skills/quality-review
38 ```
39 </Step>
40
41 <Step title="Créer la compétence">
42 Créez un fichier `SKILL.md` qui définit ce que fait la compétence `quality-review`.
43
44 ```markdown my-marketplace/plugins/quality-review-plugin/skills/quality-review/SKILL.md theme={null}
45 ---
46 description: Review code for bugs, security, and performance
47 ---
48
49 Review the code I've selected or the recent changes for:
50 - Potential bugs or edge cases
51 - Security concerns
52 - Performance issues
53 - Readability improvements
54
55 Be concise and actionable.
56 ```
57 </Step>
58
59 <Step title="Créer le manifeste du plugin">
60 Créez un fichier `plugin.json` qui décrit le plugin. Le manifeste se trouve dans le répertoire `.claude-plugin/`.
61
62 ```json my-marketplace/plugins/quality-review-plugin/.claude-plugin/plugin.json theme={null}
63 {
64 "name": "quality-review-plugin",
65 "description": "Adds a quality-review skill for quick code reviews",
66 "version": "1.0.0",
67 "author": {
68 "name": "Your Name"
69 }
70 }
71 ```
72
73 <Note>
74 La définition de `version` signifie que les utilisateurs ne reçoivent des mises à jour que lorsque vous modifiez ce champ, donc augmentez-le à chaque version. Un plugin avec une [source `command`](#command-sources) n'est pas épinglé par ce champ. Pas plus qu'un plugin [chargé sur place](/docs/fr/plugins-reference#plugin-caching-and-file-resolution) à partir d'une place de marché ajoutée en tant que répertoire local. Si vous omettez `version`, la version provient de la source suivante dans [gestion des versions](/docs/fr/plugins-reference#version-management).
75 </Note>
76 </Step>
77
78 <Step title="Créer le fichier de place de marché">
79 Créez le catalogue de la place de marché qui répertorie votre plugin.
80
81 ```json my-marketplace/.claude-plugin/marketplace.json theme={null}
82 {
83 "name": "my-plugins",
84 "owner": {
85 "name": "Your Name"
86 },
87 "plugins": [
88 {
89 "name": "quality-review-plugin",
90 "source": "./plugins/quality-review-plugin",
91 "description": "Adds a quality-review skill for quick code reviews"
92 }
93 ]
94 }
95 ```
96 </Step>
97
98 <Step title="Ajouter et installer">
99 À partir du répertoire qui contient `my-marketplace`, démarrez Claude Code et exécutez les commandes suivantes. La commande d'installation ouvre une vue de détails du plugin où vous sélectionnez une portée d'installation pour confirmer l'installation. Vérifiez le résumé d'installation : s'il signale `Run /reload-plugins to activate.`, consultez [Appliquer les modifications du plugin sans redémarrer](/docs/fr/discover-plugins#apply-plugin-changes-without-restarting).
100
101 ```shell theme={null}
102 /plugin marketplace add ./my-marketplace
103 /plugin install quality-review-plugin@my-plugins
104 ```
105 </Step>
106
107 <Step title="Essayer">
108 Sélectionnez du code dans votre éditeur et exécutez votre nouvelle compétence. Les compétences des plugins sont espacées avec le nom du plugin.
109
110 ```shell theme={null}
111 /quality-review-plugin:quality-review
112 ```
113 </Step>
114</Steps>
115
116Pour en savoir plus sur ce que les plugins peuvent faire, notamment les hooks, les agents, les serveurs MCP et les serveurs LSP, consultez [Plugins](/docs/fr/plugins).
117
118<Note>
119 **Comment les plugins sont installés** : lorsque les utilisateurs installent un plugin, Claude Code copie le répertoire du plugin vers un emplacement de cache, sauf si le plugin se charge sur place. Une [source `command` en mode lien](#copy-mode-and-link-mode) se charge sur place, tout comme une [source de chemin relatif](#relative-paths) dans une place de marché ajoutée à partir d'un répertoire local. Les plugins copiés ne peuvent pas référencer des fichiers en dehors de leur répertoire en utilisant des chemins comme `../shared-utils`, car ces fichiers ne seront pas copiés.
120
121 Si vous devez partager des fichiers entre les plugins, utilisez des symlinks. Consultez [Plugin caching and file resolution](/docs/fr/plugins-reference#plugin-caching-and-file-resolution) pour plus de détails.
122</Note>
123
124<h2 id="create-the-marketplace-file">
125 Créer le fichier de place de marché
126</h2>
127
128Créez `.claude-plugin/marketplace.json` à la racine de votre dépôt. Ce fichier définit le nom de votre place de marché, les informations du propriétaire et une liste de plugins avec leurs sources.
129
130Chaque entrée de plugin a besoin au minimum d'un `name` et d'une `source` qui indique à Claude Code où la récupérer. Consultez le [schéma complet](#marketplace-schema) ci-dessous pour tous les champs disponibles.
131
132```json theme={null}
133{
134 "name": "company-tools",
135 "owner": {
136 "name": "DevTools Team",
137 "email": "devtools@example.com"
138 },
139 "plugins": [
140 {
141 "name": "code-formatter",
142 "source": "./plugins/formatter",
143 "description": "Automatic code formatting on save",
144 "version": "2.1.0",
145 "author": {
146 "name": "DevTools Team"
147 }
148 },
149 {
150 "name": "deployment-tools",
151 "source": {
152 "source": "github",
153 "repo": "company/deploy-plugin"
154 },
155 "description": "Deployment automation tools"
156 }
157 ]
158}
159```
160
161<h2 id="marketplace-schema">
162 Schéma de la place de marché
163</h2>
164
165<h3 id="required-fields">
166 Champs obligatoires
167</h3>
168
169| Champ | Type | Description | Exemple |
170| :-------- | :----- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------- |
171| `name` | string | Identifiant de la place de marché en kebab-case, sans espaces, caractères de contrôle ou caractères de formatage bidirectionnel. C'est un élément public : les utilisateurs le voient lors de l'installation de plugins (par exemple, `/plugin install my-tool@your-marketplace`). Chaque utilisateur ne peut enregistrer qu'une seule place de marché par nom : l'ajout d'une deuxième place de marché portant le même nom remplace la première. Pour publier plusieurs plugins sous un seul nom de place de marché, listez-les tous dans un seul [`marketplace.json`](#create-the-marketplace-file). | `"acme-tools"` |
172| `owner` | object | Informations du responsable de la place de marché. Voir [Champs du propriétaire](#owner-fields) | |
173| `plugins` | array | Liste des plugins disponibles | Voir [Entrées de plugin](#plugin-entries) |
174
175<Note>
176 **Noms réservés** : les noms de place de marché suivants sont réservés à l'usage officiel d'Anthropic et ne peuvent pas être utilisés par les places de marché tierces : `claude-code-marketplace`, `claude-code-plugins`, `claude-plugins-official`, `claude-plugins-community`, `claude-community`, `anthropic-marketplace`, `anthropic-plugins`, `agent-skills`, `anthropic-agent-skills`, `knowledge-work-plugins`, `life-sciences`, `claude-for-legal`, `claude-for-financial-services`, `financial-services-plugins`, `first-party-plugins`, `claude-tag-plugins`, `healthcare`. Les noms qui usurpent l'identité de places de marché officielles, comme `official-claude-plugins` ou `anthropic-plugins-v2`, sont également bloqués. La réservation de ces noms empêche une place de marché tierce de se présenter comme une source publiée par Anthropic.
177
178 Claude Code revérifie les noms réservés chaque fois qu'il charge une place de marché, pas seulement lorsque vous en ajoutez une. Une place de marché qui a été enregistrée sous l'un de ces noms avant que le nom ne soit réservé cesse de se charger et signale qu'elle est [enregistrée à partir d'une source non fiable](/docs/fr/errors#marketplace-is-registered-from-an-untrusted-source). Supprimez cette place de marché et rajoutez-la à partir de la source officielle d'Anthropic. Une place de marché tierce affectée par un nom nouvellement réservé se charge à nouveau dès que vous la rajoutez sous un nom différent. Avant la v2.1.205, `first-party-plugins` et `healthcare` n'étaient pas réservés, et une place de marché déjà enregistrée sous un nom réservé continuait à se charger. Avant la v2.1.265, `claude-tag-plugins` n'était pas réservé.
179
180 Vous ne pouvez pas non plus nommer une place de marché `npm`, `pip`, `uv`, `cargo`, `github`, ou `gh`, quelle que soit la casse. Cette vérification nécessite Claude Code v2.1.275 ou version ultérieure.
181</Note>
182
183<h3 id="owner-fields">
184 Champs du propriétaire
185</h3>
186
187| Champ | Type | Obligatoire | Description |
188| :------ | :----- | :---------- | :----------------------------------------------- |
189| `name` | string | Oui | Nom du responsable ou de l'équipe |
190| `email` | string | Non | Adresse e-mail de contact du responsable |
191| `url` | string | Non | Site web, profil GitHub ou URL de l'organisation |
192
193<h3 id="optional-fields">
194 Champs optionnels
195</h3>
196
197| Champ | Type | Description |
198| :------------------------------------ | :----- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
199| `$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. |
200| `description` | string | Brève description de la place de marché |
201| `version` | string | Version du manifeste de la place de marché |
202| `metadata.pluginRoot` | string | Répertoire que Claude Code résout pour les noms de source de plugin nus. Voir [Chemins relatifs](#relative-paths). Nécessite Claude Code v2.1.239 ou version ultérieure. |
203| `allowCrossMarketplaceDependenciesOn` | array | Autres places de marché sur lesquelles les plugins de cette place de marché peuvent dépendre. Les dépendances d'une place de marché non listée ici sont bloquées à l'installation. Voir [Dépendre d'un plugin d'une autre place de marché](/docs/fr/plugin-dependencies#depend-on-a-plugin-from-another-marketplace). |
204| `renames` | object | Mappage d'un ancien nom de plugin `name` à son nom actuel, ou à `null` si le plugin a été supprimé. Permet aux utilisateurs existants de migrer automatiquement lorsque vous renommez ou supprimez une entrée dans `plugins`. Voir [Renommer ou supprimer un plugin](#rename-or-remove-a-plugin). Nécessite Claude Code v2.1.193 ou version ultérieure. |
205
206`description` et `version` sont également acceptés sous `metadata` pour la compatibilité rétroactive.
207
208<h2 id="plugin-entries">
209 Entrées de plugin
210</h2>
211
212Chaque entrée de plugin dans le tableau `plugins` décrit un plugin et où le trouver. Vous pouvez inclure n'importe quel champ du [schéma du manifeste du plugin](/docs/fr/plugins-reference#plugin-manifest-schema), tel que `description`, `version`, `author`, `commands` et `hooks`, plus ces champs spécifiques à la place de marché : `source`, `category`, `tags`, `strict`, `relevance`, `headers` et `headersHelper`.
213
214<h3 id="required-fields-2">
215 Champs obligatoires
216</h3>
217
218| Champ | Type | Description |
219| :------- | :------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
220| `name` | string | Identifiant du plugin en kebab-case, sans espaces, caractères de contrôle ou caractères de formatage bidirectionnel. C'est un élément public : les utilisateurs le voient lors de l'installation (par exemple, `/plugin install my-plugin@marketplace`). |
221| `source` | string\|object | Où récupérer le plugin (voir [Sources de plugin](#plugin-sources) ci-dessous) |
222
223<h3 id="optional-plugin-fields">
224 Champs de plugin optionnels
225</h3>
226
227**Champs de métadonnées standard :**
228
229| Champ | Type | Description |
230| :--------------- | :------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
231| `displayName` | string | Nom lisible affiché dans les surfaces de l'interface utilisateur. Lorsque ni l'entrée ni le `plugin.json` du plugin n'en définissent un, les utilisateurs voient le `name` du plugin. Peut contenir des espaces et n'importe quelle casse. Non utilisé pour l'espace de noms ou la recherche. |
232| `description` | string | Brève description du plugin |
233| `version` | string | Version du plugin. Si défini (ici ou dans `plugin.json`), le plugin est épinglé à cette chaîne et les utilisateurs ne reçoivent des mises à jour que lorsqu'elle change. Un plugin avec une [source `command`](#command-sources) n'est pas épinglé par l'un ou l'autre champ. Ni un plugin [chargé sur place](/docs/fr/plugins-reference#plugin-caching-and-file-resolution) à partir d'une place de marché ajoutée en tant que répertoire local. Si défini dans aucun des deux endroits, la version provient de la source suivante dans [gestion des versions](/docs/fr/plugins-reference#version-management). |
234| `author` | object | Informations sur l'auteur du plugin (`name` obligatoire ; `email` et `url` optionnels) |
235| `homepage` | string | URL de la page d'accueil ou de la documentation du plugin |
236| `repository` | string | URL du dépôt du code source |
237| `license` | string | Identifiant de licence SPDX (par exemple, MIT, Apache-2.0) |
238| `keywords` | array | Balises pour la découverte et la catégorisation des plugins |
239| `metadata` | object | Objet libre pour vos propres champs, tels que les données de droit ou de catalogue. Claude Code ne le lit pas. Avant v2.1.222, `claude plugin validate` signalait la clé comme un champ non reconnu. |
240| `category` | string | Catégorie du plugin pour l'organisation |
241| `tags` | array | Balises pour la recherche |
242| `strict` | boolean | Contrôle si `plugin.json` est l'autorité pour les définitions de composants (par défaut : true). Voir [Mode strict](#strict-mode) ci-dessous. |
243| `relevance` | object | Signaux qui indiquent à Claude Code quand suggérer ce plugin aux utilisateurs. Prend effet uniquement pour les places de marché qu'un administrateur autorise dans les paramètres gérés. Voir [Recommander des plugins pour votre organisation](/docs/fr/plugin-relevance). |
244| `defaultEnabled` | boolean | Si le plugin est activé après l'installation (par défaut : true). Définissez sur `false` pour installer le plugin désactivé jusqu'à ce que l'utilisateur l'active. Prend la priorité sur le même champ dans le `plugin.json` du plugin. Voir [Activation par défaut](/docs/fr/plugins-reference#default-enablement). |
245
246Les deux l'entrée et le `plugin.json` du plugin peuvent définir les champs d'affichage `displayName`, `description`, `author`, `homepage`, `repository`, `license` et `keywords`. Dans les listes de plugins et les détails, avant et après l'installation :
247
248* Pour un champ que vous définissez sur l'entrée, les utilisateurs voient la valeur de l'entrée, même lorsque `plugin.json` en définit une différente.
249* Pour un champ que l'entrée laisse non défini, les utilisateurs voient la valeur de `plugin.json`.
250
251Avant l'installation, Claude Code ne peut lire `plugin.json` que pour les entrées avec une [source de chemin relatif](#relative-paths), dont les fichiers de plugin se trouvent à l'intérieur de la place de marché elle-même. Pour une entrée avec tout autre type de source, les utilisateurs ne voient que les champs de l'entrée elle-même jusqu'à ce qu'ils installent le plugin.
252
253**Champs de configuration des composants :**
254
255| Champ | Type | Description |
256| :----------- | :------------- | :------------------------------------------------------------------------------------ |
257| `skills` | string\|array | Chemins personnalisés vers les répertoires de compétences contenant `<name>/SKILL.md` |
258| `commands` | string\|array | Chemins personnalisés vers les fichiers de compétences `.md` plats ou les répertoires |
259| `agents` | string\|array | Chemins personnalisés vers les fichiers d'agents |
260| `hooks` | string\|object | Configuration personnalisée des hooks ou chemin vers le fichier des hooks |
261| `mcpServers` | string\|object | Configurations du serveur MCP ou chemin vers la configuration MCP |
262| `lspServers` | string\|object | Configurations du serveur LSP ou chemin vers la configuration LSP |
263
264**Champs d'authentification d'archive :**
265
266Définissez ces champs lorsque l'entrée a une [source `archive`](#zip-archives) sur un serveur qui nécessite des identifiants.
267
268| Champ | Type | Description |
269| :-------------- | :----- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
270| `headers` | object | En-têtes HTTP que Claude Code envoie lorsqu'il télécharge l'archive de cette entrée. Remplace les en-têtes de la place de marché du même nom. Nécessite Claude Code v2.1.238 ou version ultérieure. |
271| `headersHelper` | string | Commande qui imprime les en-têtes HTTP pour le téléchargement d'archive de cette entrée sous la forme d'un objet JSON, pour un identifiant qui expire. Voir [Authentifier les téléchargements d'archive](#authenticate-archive-downloads). L'entrée doit également définir [`"strict": false`](#strict-mode). Nécessite Claude Code v2.1.238 ou version ultérieure. |
272
273<h2 id="plugin-sources">
274 Sources de plugin
275</h2>
276
277Les sources de plugin indiquent à Claude Code où récupérer chaque plugin individuel répertorié dans votre place de marché. Elles sont définies dans le champ `source` de chaque entrée de plugin dans `marketplace.json`.
278
279Claude Code copie chaque plugin installé dans le cache de plugin local versionné à `~/.claude/plugins/cache`, sauf si le plugin se charge à la place. Une [source `command` en mode lien](#copy-mode-and-link-mode) se charge à la place, tout comme une [source de chemin relatif](#relative-paths) dans une place de marché ajoutée à partir d'un répertoire local. Claude Code [installe également les dépendances de paquet Node.js éligibles du plugin](/docs/fr/plugins-reference#node-js-package-dependencies) dans la copie en cache. Voir [Mise en cache des plugins et résolution de fichiers](/docs/fr/plugins-reference#plugin-caching-and-file-resolution) pour savoir comment un plugin chargé à la place à partir d'une place de marché de répertoire local récupère vos modifications.
280
281| Source | Type | Champs | Notes |
282| -------------- | -------------------------------------- | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
283| Chemin relatif | `string` (par exemple `"./my-plugin"`) | aucun | Répertoire local dans le dépôt de la place de marché. Doit commencer par `./`, sauf si vous écrivez un [nom nu sous `metadata.pluginRoot`](#relative-paths). Claude Code résout le chemin par rapport à la racine de la place de marché, pas au répertoire `.claude-plugin/` |
284| `github` | object | `repo`, `ref?`, `sha?` | |
285| `url` | object | `url`, `ref?`, `sha?` | Source d'URL Git |
286| `git-subdir` | object | `url`, `path`, `ref?`, `sha?` | Sous-répertoire dans un dépôt git. Clone partiellement pour minimiser la bande passante pour les monodépôts |
287| `npm` | object | `package`, `version?`, `registry?` | Paquet npm, récupéré avec votre client npm et déballé sans exécuter les scripts d'installation |
288| `archive` | object | `url`, `sha256?` | Archive zip téléchargée via HTTPS. Fonctionne sans git ou npm sur la machine de l'utilisateur. Nécessite Claude Code v2.1.224 ou ultérieur |
289| `command` | object | `command`, `timeout?`, `mode?` | Répertoire de plugin produit en exécutant une commande locale, réexécutée une fois par session pour récupérer les modifications. Nécessite Claude Code v2.1.229 ou ultérieur |
290
291<Note>
292 **Sources de place de marché vs sources de plugin** : Ce sont des concepts différents qui contrôlent des choses différentes.
293
294 * **Source de place de marché** : où récupérer le catalogue `marketplace.json` lui-même. Défini lorsque les utilisateurs exécutent `/plugin marketplace add` ou dans les paramètres `extraKnownMarketplaces`. Les sources de place de marché basées sur Git prennent en charge `ref` (branche/tag) mais pas `sha`.
295 * **Source de plugin** : où récupérer un plugin individuel répertorié dans la place de marché. Défini dans le champ `source` de chaque entrée de plugin dans `marketplace.json`. Les sources de plugin basées sur Git prennent en charge à la fois `ref` (branche/tag) et `sha` (commit exact).
296
297 Par exemple, une place de marché hébergée à `acme-corp/plugin-catalog` (source de place de marché) peut répertorier un plugin récupéré à partir de `acme-corp/code-formatter` (source de plugin). La source de place de marché et la source de plugin pointent vers des dépôts différents et sont épinglées indépendamment.
298</Note>
299
300Les types de source basés sur git ci-dessous sont `github`, `url` et `git-subdir`. Lorsque `ref` et `sha` sont tous deux définis sur l'un d'eux, le `sha` est l'épingle effective. Claude Code récupère et vérifie le commit épinglé directement.
301
302Sur la plupart des hôtes git, y compris GitHub, GitLab et Bitbucket, cela signifie que l'installation réussit même si la branche ou le tag nommé par `ref` a depuis été supprimé en amont, tant que le commit est toujours accessible à partir du dépôt. Certains serveurs, tels qu'AWS CodeCommit, ne prennent pas en charge la récupération des commits par SHA. Sur ces serveurs, le `ref` doit toujours exister et le commit épinglé doit être accessible à partir de celui-ci.
303
304Si vous distribuez des plugins via **Paramètres de l'organisation > Plugins**, seuls certains types de source sont autorisés. Voir [Distribuer via les paramètres de l'organisation](#distribute-through-organization-settings).
305
306<h3 id="relative-paths">
307 Chemins relatifs
308</h3>
309
310Pour les plugins dans le même dépôt, utilisez un chemin commençant par `./` :
311
312```json theme={null}
313{
314 "name": "my-plugin",
315 "source": "./plugins/my-plugin"
316}
317```
318
319Les chemins se résolvent par rapport à la racine de la place de marché, qui est le répertoire contenant `.claude-plugin/`. La source `./plugins/my-plugin` pointe donc vers `<repo>/plugins/my-plugin`, même si `marketplace.json` se trouve à `<repo>/.claude-plugin/marketplace.json`. N'utilisez pas `../` pour référencer des chemins en dehors de la racine de la place de marché. Sur macOS et Linux, Claude Code refuse une entrée de chemin avec une barre oblique inverse n'importe où après le `./` initial, donc écrivez les séparateurs comme `/` sur chaque plateforme.
320
321Un nom nu est un seul nom de répertoire sans `/`, tel que `"formatter"`. Pour écrire des noms nus au lieu de chemins `./`, définissez [`metadata.pluginRoot`](#optional-fields) sur le répertoire sous lequel ils se résolvent. Avec `"pluginRoot": "./plugins"`, Claude Code résout `"source": "formatter"` en `./plugins/formatter`. Nécessite Claude Code v2.1.239 ou ultérieur.
322
323`metadata.pluginRoot` doit lui-même être un chemin relatif à l'intérieur de la place de marché. Claude Code l'ignore pour une source qui commence déjà par `./`. Une source qui contient un `/`, tel que `team-a/formatter`, n'est pas un nom nu et a toujours besoin du préfixe `./`, même lorsque `metadata.pluginRoot` est défini.
324
325<Note>
326 Claude Code résout les chemins relatifs par rapport à une copie locale de la place de marché, donc ils fonctionnent lorsque les utilisateurs ajoutent votre place de marché à partir d'une source git ou d'un répertoire local. Si les utilisateurs ajoutent votre place de marché via une URL directe vers le fichier `marketplace.json`, les chemins relatifs ne se résoudront pas, car Claude Code télécharge uniquement ce fichier. Pour la distribution basée sur les URL, utilisez plutôt une autre [source de plugin](#plugin-sources). Voir [Dépannage](#plugins-with-relative-paths-fail-in-url-based-marketplaces) pour plus de détails.
327</Note>
328
329<h3 id="github-repositories">
330 Dépôts GitHub
331</h3>
332
333```json theme={null}
334{
335 "name": "github-plugin",
336 "source": {
337 "source": "github",
338 "repo": "owner/plugin-repo"
339 }
340}
341```
342
343Vous pouvez épingler à une branche, un tag ou un commit spécifique :
344
345```json theme={null}
346{
347 "name": "github-plugin",
348 "source": {
349 "source": "github",
350 "repo": "owner/plugin-repo",
351 "ref": "v2.0.0",
352 "sha": "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0"
353 }
354}
355```
356
357| Champ | Type | Description |
358| :----- | :----- | :--------------------------------------------------------------------------------------- |
359| `repo` | string | Obligatoire. Dépôt GitHub au format `owner/repo` |
360| `ref` | string | Optionnel. Branche ou tag Git (par défaut la branche par défaut du dépôt) |
361| `sha` | string | Optionnel. SHA de commit git complet de 40 caractères pour épingler à une version exacte |
362
363<h3 id="git-repositories">
364 Dépôts Git
365</h3>
366
367```json theme={null}
368{
369 "name": "git-plugin",
370 "source": {
371 "source": "url",
372 "url": "https://gitlab.com/team/plugin.git"
373 }
374}
375```
376
377Vous pouvez épingler à une branche, un tag ou un commit spécifique :
378
379```json theme={null}
380{
381 "name": "git-plugin",
382 "source": {
383 "source": "url",
384 "url": "https://gitlab.com/team/plugin.git",
385 "ref": "main",
386 "sha": "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0"
387 }
388}
389```
390
391| Champ | Type | Description |
392| :---- | :----- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
393| `url` | string | Obligatoire. URL complète du dépôt git (`https://` ou `git@`). Le suffixe `.git` est optionnel, donc les URL Azure DevOps et AWS CodeCommit sans le suffixe fonctionnent |
394| `ref` | string | Optionnel. Branche ou tag Git (par défaut la branche par défaut du dépôt) |
395| `sha` | string | Optionnel. SHA de commit git complet de 40 caractères pour épingler à une version exacte |
396
397<h3 id="git-subdirectories">
398 Sous-répertoires Git
399</h3>
400
401Utilisez `git-subdir` pour pointer vers un plugin qui se trouve dans un sous-répertoire d'un dépôt git. Claude Code utilise un clone partiel et clairsemé pour récupérer uniquement le sous-répertoire, minimisant la bande passante pour les grands monodépôts.
402
403```json theme={null}
404{
405 "name": "my-plugin",
406 "source": {
407 "source": "git-subdir",
408 "url": "https://github.com/acme-corp/monorepo.git",
409 "path": "tools/claude-plugin"
410 }
411}
412```
413
414Vous pouvez épingler à une branche, un tag ou un commit spécifique :
415
416```json theme={null}
417{
418 "name": "my-plugin",
419 "source": {
420 "source": "git-subdir",
421 "url": "https://github.com/acme-corp/monorepo.git",
422 "path": "tools/claude-plugin",
423 "ref": "v2.0.0",
424 "sha": "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0"
425 }
426}
427```
428
429Le champ `url` accepte également un raccourci GitHub (`owner/repo`) ou des URL SSH (`git@github.com:owner/repo.git`).
430
431| Champ | Type | Description |
432| :----- | :----- | :-------------------------------------------------------------------------------------------------------------- |
433| `url` | string | Obligatoire. URL du dépôt Git, raccourci GitHub `owner/repo` ou URL SSH |
434| `path` | string | Obligatoire. Chemin du sous-répertoire dans le dépôt contenant le plugin (par exemple, `"tools/claude-plugin"`) |
435| `ref` | string | Optionnel. Branche ou tag Git (par défaut la branche par défaut du dépôt) |
436| `sha` | string | Optionnel. SHA de commit git complet de 40 caractères pour épingler à une version exacte |
437
438<h3 id="npm-packages">
439 Paquets npm
440</h3>
441
442Une source npm peut nommer n'importe quel paquet du registre npm public ou d'un registre privé que votre équipe héberge. Claude Code résout le paquet avec votre client npm, télécharge la tarball et la déplie dans le cache de plugin.
443
444Les scripts d'installation du paquet, tels que `preinstall` ou `postinstall`, ne s'exécutent jamais, et ses dépendances ne sont pas installées lors de la récupération.
445
446Si le paquet expédie un fichier de verrouillage pris en charge à côté de son `package.json`, Claude Code installe ces [dépendances de paquet Node.js](/docs/fr/plugins-reference#node-js-package-dependencies) dans une étape séparée, également avec les scripts désactivés. Sinon, publiez le plugin avec tout ce dont il a besoin déjà construit. Un serveur MCP qui a besoin d'autres paquets peut se lancer via `npx`, qui les installe à la première exécution.
447
448```json theme={null}
449{
450 "name": "my-npm-plugin",
451 "source": {
452 "source": "npm",
453 "package": "@acme/claude-plugin"
454 }
455}
456```
457
458Pour épingler à une version spécifique, ajoutez le champ `version` :
459
460```json theme={null}
461{
462 "name": "my-npm-plugin",
463 "source": {
464 "source": "npm",
465 "package": "@acme/claude-plugin",
466 "version": "2.1.0"
467 }
468}
469```
470
471Pour installer à partir d'un registre privé ou interne, ajoutez le champ `registry` :
472
473```json theme={null}
474{
475 "name": "my-npm-plugin",
476 "source": {
477 "source": "npm",
478 "package": "@acme/claude-plugin",
479 "version": "^2.0.0",
480 "registry": "https://npm.example.com"
481 }
482}
483```
484
485| Champ | Type | Description |
486| :--------- | :----- | :---------------------------------------------------------------------------------------------------------- |
487| `package` | string | Obligatoire. Nom du paquet ou paquet scopé (par exemple, `@org/plugin`) |
488| `version` | string | Optionnel. Version ou plage de version (par exemple, `2.1.0`, `^2.0.0`, `~1.5.0`) |
489| `registry` | string | Optionnel. URL du registre npm personnalisé. Par défaut le registre npm du système (généralement npmjs.org) |
490
491<h3 id="zip-archives">
492 Archives zip
493</h3>
494
495Utilisez `archive` pour distribuer un plugin en tant que fichier zip que Claude Code télécharge via HTTPS, afin que les installations fonctionnent sans git ou npm sur la machine de l'utilisateur. Hébergez le fichier sur n'importe quel serveur de fichiers statiques ou référentiel d'artefacts, tel qu'un bucket S3, un référentiel générique Artifactory ou nginx. Nécessite Claude Code v2.1.224 ou ultérieur. Sur les versions v2.1.120 à v2.1.223, l'installation du plugin échoue avec `This plugin uses a source type your Claude Code version does not support. Update Claude Code and try again.` ; sur les versions plus anciennes, une place de marché contenant une entrée `archive` ne se charge pas du tout.
496
497Cette entrée installe le plugin à partir d'un fichier zip sur un serveur d'artefacts :
498
499```json theme={null}
500{
501 "name": "my-plugin",
502 "source": {
503 "source": "archive",
504 "url": "https://artifacts.example.com/claude-plugins/my-plugin-2.1.0.zip"
505 }
506}
507```
508
509Lorsque vous créez le zip, vous pouvez zipper le contenu du plugin directement ou zipper le dossier du plugin lui-même. Claude Code recherche `.claude-plugin/` en haut de l'archive, puis à l'intérieur d'un seul dossier de niveau supérieur, donc les deux dispositions s'installent :
510
511```text theme={null}
512my-plugin.zip my-plugin.zip
513├── .claude-plugin/ └── my-plugin/
514│ └── plugin.json ├── .claude-plugin/
515└── commands/ │ └── plugin.json
516 └── commands/
517```
518
519Claude Code ne cherche pas plus profondément qu'un dossier, donc un plugin imbriqué plus loin ne s'installe pas. Claude Code refuse les archives plus grandes que 256 MiB.
520
521Pour épingler le fichier exact, ajoutez un champ `sha256` avec le digest de l'archive :
522
523```json theme={null}
524{
525 "name": "my-plugin",
526 "source": {
527 "source": "archive",
528 "url": "https://artifacts.example.com/claude-plugins/my-plugin-2.1.0.zip",
529 "sha256": "6bfa50e3d2e00c052b46abe51fff89346ac803e45771f76dcf6df1ab74cca5e1"
530 }
531}
532```
533
534Si le fichier téléchargé ne correspond pas à l'épingle, Claude Code refuse l'installation et signale [`Plugin archive integrity check failed`](/docs/fr/errors#plugin-archive-integrity-check-failed).
535
536Les sources d'archive acceptent ces champs :
537
538| Champ | Type | Description |
539| :------- | :----- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
540| `url` | string | Obligatoire. URL HTTPS de l'archive zip. Claude Code rejette les URL `http://`, ainsi que les hôtes de bouclage, lien-local et métadonnées cloud. Chaque saut de redirection doit satisfaire les mêmes règles, ou Claude Code refuse le téléchargement |
541| `sha256` | string | Optionnel. Digest SHA-256 de l'archive en tant que 64 caractères hexadécimaux, majuscules ou minuscules. Claude Code vérifie chaque téléchargement par rapport à celui-ci et refuse l'installation en cas de non-correspondance |
542
543Le digest `sha256` sert également de version du plugin lorsque ni `plugin.json` ni l'entrée de la place de marché n'en déclare une. Voir [Gestion des versions](/docs/fr/plugins-reference#version-management). Si vous déclarez une `version`, cette chaîne de version est le signal de mise à jour, donc après avoir modifié le zip et son digest, augmentez également la version, ou les utilisateurs conservent la copie en cache.
544
545<h4 id="authenticate-archive-downloads">
546 Authentifier les téléchargements d'archive
547</h4>
548
549Pour authentifier un téléchargement d'archive, tel qu'un téléchargement à partir d'un registre privé, définissez les en-têtes HTTP que Claude Code envoie avec celui-ci. Définissez `headers` sur la source `url` à partir de laquelle vous avez enregistré la place de marché, tel qu'une entrée [`extraKnownMarketplaces`](/docs/fr/settings-reference#extraknownmarketplaces). Sur Claude Code v2.1.238 ou ultérieur, vous pouvez le définir sur l'entrée du plugin à la place, à côté de `source`.
550
551Si la valeur que vous mettriez dans `headers` est de courte durée, tel qu'un jeton que votre registre crée à la demande, définissez plutôt une commande `headersHelper` au même endroit. Claude Code exécute la commande et envoie l'objet JSON qu'elle imprime en tant que headers de cet endroit. Nécessite Claude Code v2.1.238 ou ultérieur.
552
553L'endroit que vous choisissez décide quels téléchargements obtiennent les en-têtes et quand Claude Code exécute la commande :
554
555| Endroit | Téléchargements qui obtiennent les en-têtes | Quand Claude Code exécute un `headersHelper` défini là |
556| :--------------------------------- | :------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
557| Source `url` de la place de marché | Téléchargements d'archive sur l'origine de l'URL de la place de marché, ce qui signifie le même schéma, hôte et port | Avant chaque récupération du `marketplace.json` de la place de marché et avant chaque téléchargement d'archive sur cette origine. Claude Code réutilise la sortie d'une exécution pendant jusqu'à 60 secondes |
558| Entrée de plugin | Uniquement le téléchargement de cette entrée | Uniquement lorsqu'un utilisateur installe ou met à jour ce seul plugin par lui-même et [accepte la commande](#how-users-accept-a-headershelper-command) |
559
560Lorsque les deux endroits définissent un en-tête du même nom, Claude Code envoie la valeur de l'entrée. Au sein d'un endroit, un en-tête que la commande imprime remplace un en-tête du même nom répertorié dans `headers`.
561
562<h5 id="add-a-headershelper-to-a-plugin-entry">
563 Ajouter un headersHelper à une entrée de plugin
564</h5>
565
566Cette entrée définit `headersHelper` à côté de `source`. Elle définit également `"strict": false`, que Claude Code exige d'une entrée `marketplace.json` qui définit `headersHelper`. Avec [`"strict": false`](#strict-mode), l'entrée de la place de marché est la définition complète du plugin, afin qu'un utilisateur puisse examiner ce que le plugin contient avant d'accepter la commande :
567
568```json theme={null}
569{
570 "name": "my-plugin",
571 "description": "Formatting commands for internal services",
572 "strict": false,
573 "commands": "./commands",
574 "source": {
575 "source": "archive",
576 "url": "https://registry.example.com/plugins/my-plugin-2.1.0.zip"
577 },
578 "headersHelper": "/opt/bin/mint-registry-token.sh"
579}
580```
581
582Pour vérifier l'entrée, exécutez `claude plugin install my-plugin@your-marketplace`. Claude Code vous montre la commande et l'URL de l'archive, et télécharge le zip après que vous acceptiez.
583
584Avant v2.1.238, Claude Code téléchargeait l'archive d'une entrée sans ses `headers` ou `headersHelper`, donc une installation qui en dépendait échouait avec `HTTP 401 while downloading plugin archive from`, suivi de l'URL, avec le code d'état du registre à la place de 401.
585
586<h4 id="write-the-headershelper-command">
587 Écrire la commande headersHelper
588</h4>
589
590Que vous définissiez `headersHelper` sur la source `url` d'une place de marché ou sur une entrée de plugin, écrivez la commande pour répondre à ces exigences :
591
592* **Texte de commande** : au maximum 500 caractères ASCII imprimables, sans suite de quatre espaces ou plus.
593* **Sortie** : imprimez un objet JSON de noms d'en-têtes et de valeurs de chaîne sur stdout, puis quittez 0 dans les 10 secondes.
594* **Shell et répertoire de travail** : Claude Code exécute la commande via `sh`, ou `cmd.exe` sur Windows, à partir du répertoire de configuration, `~/.claude` ou [`CLAUDE_CONFIG_DIR`](/docs/fr/env-vars#variables). Donnez un chemin absolu ou une commande sur `PATH`, car un chemin relatif se résout par rapport à ce répertoire, pas au projet de l'utilisateur.
595* **Variables que Claude Code supprime** : de l'environnement d'une commande définie dans une entrée `marketplace.json` ou dans le `.claude/settings.json` ou `.claude/settings.local.json` d'un projet, Claude Code supprime chaque variable dont le nom contient un mot tel que `TOKEN`, `SECRET`, `KEY` ou `AUTH`, y compris `ANTHROPIC_API_KEY`. Claude Code n'applique pas cette suppression à une commande définie dans les paramètres utilisateur, un fichier `--settings` ou les paramètres gérés.
596* **Variables que Claude Code définit** : `CLAUDE_CODE_MARKETPLACE_URL` et `CLAUDE_CODE_MARKETPLACE_NAME` pour la commande d'une source `url`, et `CLAUDE_CODE_PLUGIN_NAME` et `CLAUDE_CODE_PLUGIN_ARCHIVE_URL` pour la commande d'une entrée. `CLAUDE_CODE_MARKETPLACE_NAME` n'est pas défini lors de la première récupération après qu'un utilisateur ajoute une place de marché par URL, car cette récupération est ce qui fournit le nom.
597
598Une commande qui crée un jeton porteur imprime un objet comme celui-ci :
599
600```json theme={null}
601{"Authorization": "Bearer eyJhbGciOiJSUzI1NiJ9"}
602```
603
604<h4 id="when-claude-code-skips-a-headershelper-command-or-drops-its-output">
605 Quand Claude Code ignore une commande headersHelper ou abandonne sa sortie
606</h4>
607
608Claude Code n'exécute pas une commande `headersHelper`, ou abandonne les en-têtes qui proviennent de `headers` ou de la sortie de la commande, dans ces situations :
609
610* **La commande échoue** : si la commande quitte non-zéro, s'exécute au-delà de 10 secondes ou imprime autre chose qu'un objet JSON de valeurs de chaîne, Claude Code ne fait pas la récupération ou le téléchargement pour lequel il a exécuté la commande.
611* **L'URL de la place de marché ne commence pas par `https://`** : Claude Code n'exécute pas la commande de cette source `url` et envoie uniquement les en-têtes répertoriés dans son champ `headers`.
612* **La redirection quitte l'origine** : lorsqu'un téléchargement est redirigé hors de l'origine de l'URL de l'archive, Claude Code abandonne les valeurs `headers` et la sortie de la commande de la source `url` de la place de marché et de l'entrée de plugin.
613* **L'entrée définit un en-tête de routage ou d'identité** : Claude Code abandonne les noms de routage de requête et d'identité client tels que `Host`, `Cookie` et `X-Forwarded-*` de l'entrée `headers` et de la sortie de la commande, et conserve les noms d'authentification tels que `Authorization`. Claude Code filtre chaque entrée `marketplace.json` de cette façon, et une [entrée de paramètres en ligne](/docs/fr/settings-reference#extraknownmarketplaces) selon le fichier qui la déclare.
614* **La commande est définie dans les paramètres d'un répertoire `--add-dir`** : Claude Code l'ignore, sur une source `url` et sur une [entrée de plugin en ligne](/docs/fr/settings-reference#extraknownmarketplaces) de même, et envoie uniquement les `headers` de ce fichier.
615* **Les paramètres gérés bloquent la commande** : définir [`disableCommandPluginSources`](/docs/fr/settings-reference#disablecommandpluginsources) sur `true` bloque les commandes `headersHelper`, et [`allowManagedHooksOnly`](/docs/fr/settings-reference#allowmanagedhooksonly) les bloque aussi sauf si `disableCommandPluginSources` est explicitement `false`. Sous l'un ou l'autre bloc, Claude Code exécute toujours la commande pour une place de marché que les paramètres gérés eux-mêmes déclarent.
616
617<h4 id="how-users-accept-a-headershelper-command">
618 Comment les utilisateurs acceptent une commande headersHelper
619</h4>
620
621Un utilisateur accepte la commande d'une entrée de plugin chaque fois qu'il installe ou met à jour ce seul plugin par lui-même, à partir de la vue propre du plugin dans `/plugin` ou avec `claude plugin install` ou `claude plugin update`. Claude Code montre la commande et l'URL de l'archive, et exécute la commande uniquement après que l'utilisateur accepte.
622
623Dans un shell non-interactif, passez [`--yes`](/docs/fr/plugins-reference#plugin-install) pour accepter la commande. Pour accepter uniquement la commande qu'une exécution précédente `--json` a affichée, passez [`--accept-command`](/docs/fr/plugins-reference#plugin-install) avec le `sha256` que l'exécution a signalé.
624
625Claude Code exécute uniquement la commande qu'il a montrée, pour l'URL d'archive qu'il a montrée. Si la commande ou l'URL d'archive de l'entrée a changé entre-temps, Claude Code refuse l'installation ou la mise à jour. Un changement dans la chaîne de requête seul ne compte pas.
626
627<h5 id="installs-and-updates-that-refuse-the-command-instead-of-asking">
628 Installations et mises à jour qui refusent la commande au lieu de demander
629</h5>
630
631Sur toute opération autre qu'une installation ou mise à jour d'un seul plugin, Claude Code n'exécute pas la commande d'une entrée ni ne télécharge son archive, donc le plugin reste à sa version installée ou reste désinstallé. Ce que l'utilisateur voit dépend de l'opération :
632
633* **Installation de plusieurs plugins à la fois, à partir d'une suggestion de plugin ou en tant que dépendance d'un autre plugin** : Claude Code refuse le plugin qui a la commande et pointe l'utilisateur vers la vue propre de ce plugin dans `/plugin`. Les autres plugins dans une installation en masse s'installent toujours. Un plugin qui dépend du plugin refusé ne s'installe pas jusqu'à ce que l'utilisateur installe le plugin refusé par lui-même.
634* **Mise à jour automatique en arrière-plan, ou démarrage de session pour un plugin dont l'archive n'a jamais été téléchargée** : Claude Code répertorie le plugin dans l'onglet `/plugin` Erreurs afin que l'utilisateur sache l'installer ou le mettre à jour à la main. Une mise à jour automatique qui trouve l'entrée annonce toujours la version installée répertorie rien.
635
636<h5 id="when-a-marketplace-url-source’s-command-runs">
637 Quand la commande de la source `url` de la place de marché s'exécute
638</h5>
639
640Un `headersHelper` de source `url` de place de marché est déclaré dans un fichier de paramètres, tel qu'une entrée [`extraKnownMarketplaces`](/docs/fr/settings-reference#extraknownmarketplaces), plutôt que dans le catalogue que la place de marché publie, donc Claude Code ne demande pas à l'utilisateur de l'accepter à chaque installation ou mise à jour. Le fichier de paramètres qui le déclare décide quand Claude Code l'exécute :
641
642| Fichier de paramètres | Quand Claude Code exécute la commande |
643| :----------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
644| Paramètres utilisateur, un fichier `--settings` ou un fichier de paramètres gérés sur la machine | Sans demander, y compris lors d'une actualisation de place de marché en arrière-plan |
645| Le `.claude/settings.json` ou `.claude/settings.local.json` d'un projet | Uniquement après que l'utilisateur accepte la [boîte de dialogue de confiance de l'espace de travail](/docs/fr/permissions#what-runs-before-you-trust-a-folder) pour ce dossier lui-même. Une session `-p` ou SDK ne compte pas comme l'accepter, et la confiance accordée à un dossier parent non plus |
646| Paramètres gérés par le serveur | Uniquement après que l'utilisateur approuve les paramètres livrés dans la [boîte de dialogue d'approbation de sécurité](/docs/fr/server-managed-settings#security-approval-dialogs) |
647
648Dans une session `-p` ou SDK, Claude Code ne peut pas afficher la boîte de dialogue d'approbation de sécurité. Il applique les autres paramètres livrés, mais la récupération de la place de marché, et tout téléchargement d'archive qui a besoin de la commande, échoue jusqu'à ce qu'un utilisateur ait approuvé dans une session interactive.
649
650Pour une [entrée de plugin en ligne](/docs/fr/settings-reference#extraknownmarketplaces) dans l'un de ces fichiers, Claude Code exige la même confiance de dossier ou approbation de paramètres que pour une commande au niveau de la place de marché dans ce fichier, et l'utilisateur accepte également la commande de l'entrée à chaque installation ou mise à jour.
651
652<h3 id="command-sources">
653 Sources de commande
654</h3>
655
656Utilisez `command` lorsqu'un outil installé localement produit le répertoire de plugin, tel qu'un IDE qui rend son plugin pour la chaîne d'outils actuellement sélectionnée. Claude Code exécute la commande lorsque l'utilisateur installe le plugin et la réexécute en arrière-plan une fois par session, afin que vos utilisateurs récupèrent la sortie modifiée de l'outil sans réinstaller. Nécessite Claude Code v2.1.229 ou ultérieur. Sur v2.1.120 à v2.1.228, l'installation du plugin échoue avec `This plugin uses a source type your Claude Code version does not support. Update Claude Code and try again.`, et sur les versions plus anciennes la place de marché entière ne se charge pas.
657
658Cette entrée installe le plugin à partir de quel que soit le répertoire que l'outil imprime :
659
660```json theme={null}
661{
662 "name": "my-plugin",
663 "source": {
664 "source": "command",
665 "command": "my-tool claude-plugin-path"
666 }
667}
668```
669
670Claude Code exécute la commande via le shell de la plateforme, `sh` sur macOS et Linux ou `cmd.exe` sur Windows, à partir du répertoire personnel de l'utilisateur. La commande doit imprimer exactement une ligne sur stdout et quitter avec le code 0. Cette ligne est le chemin absolu d'un répertoire qui contient le plugin complet au moment où la commande quitte, et le chemin peut changer entre les exécutions.
671
672Claude Code arrête une commande qui s'exécute plus longtemps que `timeout` secondes, et l'installation ou la mise à jour échoue. Claude Code refuse également le chemin imprimé dans ces cas, et l'installation ou la mise à jour échoue de la même manière :
673
674* Le répertoire n'a pas de contenu de plugin à son niveau supérieur, tel qu'un répertoire `.claude-plugin/` ou un répertoire `skills/`, `commands/`, `agents/` ou `hooks/`
675* Le répertoire est celui dans lequel Claude Code a été démarré, ou l'un de ses parents
676* Sur Windows, le chemin est un chemin UNC
677
678Les sources de commande acceptent ces champs :
679
680| Champ | Type | Description |
681| :-------- | :----- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
682| `command` | string | Obligatoire. Commande shell qui imprime le chemin absolu du répertoire de plugin en tant que ligne unique sur stdout et quitte 0. Doit être ASCII imprimable, au maximum 500 caractères, sans suite de quatre espaces ou plus, afin que les utilisateurs puissent examiner la commande entière qu'on leur demande d'accepter |
683| `timeout` | number | Optionnel. Nombre entier de secondes à attendre la commande avant d'abandonner (par défaut : 60, maximum : 600) |
684| `mode` | string | Optionnel. `"copy"` (par défaut) copie le répertoire imprimé dans le cache de plugin. `"link"` utilise le répertoire imprimé à la place. Voir [Mode copie et mode lien](#copy-mode-and-link-mode) |
685
686<h4 id="copy-mode-and-link-mode">
687 Mode copie et mode lien
688</h4>
689
690Avec le `"mode": "copy"` par défaut, Claude Code copie le répertoire imprimé dans le cache de plugin versionné et dérive la [version du plugin](/docs/fr/plugins-reference#version-management) d'un hash du contenu du répertoire. Votre outil peut supprimer ou réécrire le répertoire après que la commande quitte, et une réexécution qui produit un contenu identique compte comme à jour. Claude Code refuse d'installer un répertoire plus grand que 256 MiB ou contenant plus de 20 000 entrées.
691
692Définissez `"mode": "link"` pour les grands répertoires de plugin qui ne doivent pas être copiés, tel qu'une exportation SDK rendue. Claude Code remplit l'entrée de cache du plugin avec un lien vers chaque entrée de niveau supérieur du répertoire imprimé et utilise les fichiers à la place, donc rien n'est copié, les contenus de fichiers ne sont pas hashés, et les limites de taille ne s'appliquent pas. L'installation échoue si une entrée de niveau supérieur est un lien symbolique qui pointe en dehors du répertoire imprimé. Claude Code ignore également l'[installation de dépendance de paquet Node.js](/docs/fr/plugins-reference#node-js-package-dependencies) pour un plugin en mode lien, donc imprimez un répertoire qui contient déjà tout `node_modules` dont le plugin a besoin.
693
694Gardez le répertoire imprimé en place tant que le plugin reste installé, car Claude Code charge le plugin via ces liens à chaque démarrage. Claude Code dérive la [version du plugin](/docs/fr/plugins-reference#version-management) du chemin réel du répertoire imprimé et de ses entrées de niveau supérieur, pas des fichiers à l'intérieur, donc imprimez un chemin différent pour signaler un nouveau contenu. Dans une session démarrée dans le répertoire imprimé ou n'importe où en dessous, Claude Code ne charge pas du tout le plugin.
695
696Claude Code ne prend pas en charge le mode lien sur Windows et refuse d'installer un plugin en mode lien là. Déclarez `"mode": "copy"` à la place.
697
698<h4 id="how-users-accept-the-command">
699 Comment les utilisateurs acceptent la commande
700</h4>
701
702Claude Code exécute votre commande sur la machine de l'utilisateur, donc il lie chaque exécution à l'acceptation explicite de l'utilisateur :
703
704* Lorsque les utilisateurs installent le plugin à partir de son écran de détails dans `/plugin`, ou l'installent ou le mettent à jour avec `claude plugin install` ou `claude plugin update` dans un terminal interactif, Claude Code leur montre d'abord la chaîne de commande exacte et enregistre la commande acceptée pour cette installation. Une `claude plugin update` qui peut procéder sur l'acceptation enregistrée de la même commande ne montre rien.
705* Dans un shell non-interactif, tel qu'un script de provisionnement, passez `--yes` à `claude plugin install` ou `claude plugin update` pour accepter la commande qu'il imprime. Pour accepter uniquement la commande qu'une exécution précédente `--json` a affichée, passez [`--accept-command`](/docs/fr/plugins-reference#plugin-install) avec le `sha256` que l'exécution a signalé.
706* Chaque autre chemin exécute uniquement la commande que l'utilisateur a déjà acceptée. Cela inclut les mises à jour démarrées à partir de `/plugin` et les exécutions en arrière-plan décrites dans [Quand Claude Code réexécute la commande](#when-claude-code-re-runs-the-command). Lorsqu'aucune n'a été acceptée, Claude Code refuse d'exécuter la commande et dit à l'utilisateur comment l'examiner. Claude Code n'installe jamais un plugin provenant d'une source de commande en tant que dépendance d'un autre plugin, afin que les utilisateurs l'installent eux-mêmes d'abord.
707* Si vous modifiez la `command` de l'entrée, ou basculez son `mode`, les utilisateurs conservent la version qu'ils ont déjà et Claude Code arrête de réexécuter la commande. Dans les sessions interactives, l'onglet `/plugin` Erreurs montre la nouvelle commande jusqu'à ce que l'utilisateur l'examine et l'accepte en exécutant `claude plugin update <plugin>@<marketplace>`.
708
709Les administrateurs peuvent bloquer les sources de commande dans une organisation avec le paramètre géré [`disableCommandPluginSources`](/docs/fr/settings-reference#disablecommandpluginsources). Si une organisation définit [`allowManagedHooksOnly`](/docs/fr/settings-reference#allowmanagedhooksonly), Claude Code bloque les sources de commande par défaut.
710
711<h4 id="when-claude-code-re-runs-the-command">
712 Quand Claude Code réexécute la commande
713</h4>
714
715Le répertoire imprimé reflète l'état de l'outil au moment où la commande s'est exécutée, donc Claude Code exécute la commande à nouveau à ces moments :
716
717* Chaque fois que l'utilisateur installe ou met à jour le plugin
718* Une fois par session pour chaque plugin provenant d'une source de commande activée, en arrière-plan, peu de temps après le démarrage de la session. Cette exécution ne passe pas par la mise à jour automatique de la place de marché, donc elle ne dépend pas du [paramètre de mise à jour automatique](/docs/fr/discover-plugins#configure-auto-updates) de la place de marché
719* Au démarrage ou sur `/reload-plugins`, lorsque la version installée d'un plugin activé est manquante du cache de plugin
720
721Claude Code ignore les deux exécutions en arrière-plan lorsque l'utilisateur définit [`CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC`](/docs/fr/env-vars). Les installations et mises à jour explicites exécutent toujours la commande avec cette variable définie.
722
723Lorsque la sortie hashée de la commande a changé, Claude Code installe le résultat en tant que nouvelle version et la recharge dans la session interactive en cours, basculant [les mêmes composants que `/reload-plugins` bascule](/docs/fr/plugins-reference#environment-variables). L'utilisateur voit une notification que le plugin a été rechargé. Si le rechargement sur place invaliderait le cache d'invite de la session, Claude Code invite plutôt l'utilisateur à exécuter `/reload-plugins`, qui [avertit du coût du cache et s'applique lorsqu'il est réexécuté avec `--force`](/docs/fr/prompt-caching#enabling-or-disabling-a-plugin).
724
725<h3 id="advanced-plugin-entries">
726 Entrées de plugin avancées
727</h3>
728
729Cet exemple montre une entrée de plugin utilisant de nombreux champs optionnels, notamment des chemins personnalisés pour les commandes, les agents, les hooks et les serveurs MCP :
730
731```json theme={null}
732{
733 "name": "enterprise-tools",
734 "source": {
735 "source": "github",
736 "repo": "company/enterprise-plugin"
737 },
738 "description": "Enterprise workflow automation tools",
739 "version": "2.1.0",
740 "author": {
741 "name": "Enterprise Team",
742 "email": "enterprise@example.com"
743 },
744 "homepage": "https://docs.example.com/plugins/enterprise-tools",
745 "repository": "https://github.com/company/enterprise-plugin",
746 "license": "MIT",
747 "keywords": ["enterprise", "workflow", "automation"],
748 "category": "productivity",
749 "commands": [
750 "./commands/core/",
751 "./commands/enterprise/",
752 "./commands/experimental/preview.md"
753 ],
754 "agents": ["./agents/security-reviewer.md", "./agents/compliance-checker.md"],
755 "hooks": {
756 "PostToolUse": [
757 {
758 "matcher": "Write|Edit",
759 "hooks": [
760 {
761 "type": "command",
762 "command": "${CLAUDE_PLUGIN_ROOT}/scripts/validate.sh"
763 }
764 ]
765 }
766 ]
767 },
768 "mcpServers": {
769 "enterprise-db": {
770 "command": "${CLAUDE_PLUGIN_ROOT}/servers/db-server",
771 "args": ["--config", "${CLAUDE_PLUGIN_ROOT}/config.json"]
772 }
773 },
774 "strict": false
775}
776```
777
778Points clés à noter :
779
780* **`commands` et `agents`** : vous pouvez spécifier plusieurs répertoires ou fichiers individuels. Les chemins sont relatifs à la racine du plugin et doivent rester à l'intérieur.
781 * Claude Code rejette un chemin qui se résout en dehors du répertoire de plugin, tel que `./../shared.md`, avec une erreur [`path escapes plugin directory`](/docs/fr/errors#path-escapes-plugin-directory), et charge toujours le plugin sans ce composant
782* **`${CLAUDE_PLUGIN_ROOT}`** : utilisez cette variable dans les commandes de hook et les configurations du serveur MCP pour référencer les fichiers dans le répertoire d'installation du plugin.
783 * Consultez le [tableau de substitution](/docs/fr/plugins-reference#environment-variables) pour savoir quels champs de configuration le substituent par type de serveur
784 * Pour les dépendances ou l'état qui doivent survivre aux mises à jour des plugins, utilisez [`${CLAUDE_PLUGIN_DATA}`](/docs/fr/plugins-reference#persistent-data-directory) à la place
785* **`strict: false`** : puisque ceci est défini sur false, le plugin n'a pas besoin de son propre `plugin.json`. L'entrée de la place de marché définit tout. Voir [Mode strict](#strict-mode) ci-dessous.
786
787Par défaut, les compétences d'un plugin se chargent à partir du répertoire `skills/` sous sa `source`. Les chemins répertoriés dans le champ `skills` s'ajoutent à cette analyse :
788
789```json theme={null}
790"skills": ["./skills/", "./extra-skills/"]
791```
792
793Lorsque plusieurs entrées de plugin partagent un dossier `skills/` à la racine de la place de marché (`source: "./"`), énumérez plutôt des sous-répertoires spécifiques afin que chaque entrée ne charge que ses propres compétences :
794
795```json theme={null}
796"source": "./",
797"skills": ["./skills/code-review", "./skills/docs"]
798```
799
800Avec une source à la racine de la place de marché, les chemins énumérés constituent l'ensemble complet pour cette entrée, et les autres répertoires dans le dossier `skills/` partagé ne se chargent pas. L'énumération du répertoire `skills/` lui-même, ou de la racine du plugin, maintient l'analyse complète. Si aucun des chemins énumérés n'existe, l'analyse par défaut s'exécute à la place.
801
802<h3 id="strict-mode">
803 Mode strict
804</h3>
805
806Le champ `strict` contrôle si `plugin.json` est l'autorité pour les définitions de composants (compétences, agents, hooks, serveurs MCP, styles de sortie).
807
808| Valeur | Comportement |
809| :------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
810| `true` (par défaut) | `plugin.json` est l'autorité. L'entrée de la place de marché peut la compléter avec des composants supplémentaires, et les deux sources sont fusionnées. |
811| `false` | L'entrée de la place de marché est la définition complète. Si le plugin a également un `plugin.json` qui déclare des composants, c'est un conflit et le plugin ne se charge pas. |
812
813**Quand utiliser chaque mode :**
814
815* **`strict: true`** : le plugin a son propre `plugin.json` et gère ses propres composants. L'entrée de la place de marché peut ajouter des compétences ou des hooks supplémentaires par-dessus. C'est la valeur par défaut et fonctionne pour la plupart des plugins.
816* **`strict: false`** : l'opérateur de la place de marché veut le contrôle total. Le dépôt du plugin fournit des fichiers bruts, et l'entrée de la place de marché définit lesquels de ces fichiers sont exposés en tant que compétences, agents, hooks, etc. Utile lorsque la place de marché restructure ou sélectionne les composants d'un plugin différemment de ce que l'auteur du plugin avait prévu.
817
818<h2 id="host-and-distribute-marketplaces">
819 Héberger et distribuer les places de marché
820</h2>
821
822Lorsque les utilisateurs ajoutent une place de marché hébergée dans un dépôt git, ou installent un plugin basé sur git qu'elle liste, Claude Code clone ce dépôt de place de marché ou de plugin sur leur machine. Le clone ne télécharge jamais le contenu de [Git LFS](https://git-lfs.com), donc les fichiers suivis par LFS arrivent sous forme de fichiers pointeurs. Gardez les fichiers dont vos plugins ont besoin en dehors de LFS.
823
824<h3 id="host-on-github-recommended">
825 Héberger sur GitHub (recommandé)
826</h3>
827
828GitHub est la méthode recommandée pour héberger et distribuer une place de marché :
829
8301. **Créer un dépôt** : Configurez un nouveau dépôt pour votre place de marché
8312. **Ajouter le fichier de place de marché** : Créez `.claude-plugin/marketplace.json` avec vos définitions de plugins
8323. **Partager avec les équipes** : Les utilisateurs ajoutent votre place de marché avec `/plugin marketplace add owner/repo`
833
834**Avantages** : Contrôle de version intégré, suivi des problèmes et fonctionnalités de collaboration d'équipe.
835
836<h3 id="host-on-other-git-services">
837 Héberger sur d'autres services git
838</h3>
839
840N'importe quel service d'hébergement git fonctionne, comme GitLab, Bitbucket et les serveurs auto-hébergés. Les utilisateurs ajoutent avec l'URL complète du dépôt :
841
842```shell theme={null}
843/plugin marketplace add https://gitlab.com/company/plugins.git
844```
845
846<h3 id="private-repositories">
847 Dépôts privés
848</h3>
849
850Claude Code prend en charge l'installation de plugins à partir de dépôts privés. Si vous distribuez votre place de marché via [**Paramètres de l'organisation > Plugins**](https://claude.ai/admin-settings/plugins) à la place, vos credentials git ne sont pas impliqués : la synchronisation de l'organisation lit le dépôt de la place de marché via votre connexion GitHub ou GitLab de l'organisation sur claude.ai. Consultez [Distribuer via les paramètres de l'organisation](#distribute-through-organization-settings) pour les sources de plugins qui peuvent être privées.
851
852<h4 id="commands-you-run">
853 Commandes que vous exécutez
854</h4>
855
856Lorsque vous exécutez `/plugin marketplace add`, `/plugin install`, `/plugin update` ou `/plugin marketplace update`, Claude Code utilise vos assistants de credentials git existants, donc l'accès HTTPS via `gh auth login`, Keychain macOS ou `git-credential-store` fonctionne de la même manière que dans votre terminal. L'accès SSH fonctionne tant que l'hôte est déjà dans votre fichier `known_hosts` et que la clé est chargée dans `ssh-agent`, puisque Claude Code supprime les invites SSH interactives pour l'empreinte digitale de l'hôte et la phrase de passe de la clé. Les sources de raccourci `owner/repo` GitHub clonent par défaut via SSH ; définissez [`CLAUDE_CODE_PLUGIN_PREFER_HTTPS=1`](/docs/fr/env-vars#variables) pour les cloner via HTTPS à la place.
857
858<h4 id="background-auto-updates">
859 Mises à jour automatiques en arrière-plan
860</h4>
861
862La vérification d'actualisation en arrière-plan vérifie le dépôt distant de la place de marché pour les nouveaux commits avec vos assistants de credentials git configurés, de la même manière que les commandes que vous exécutez. Pour les remotes SSH, une clé chargée dans `ssh-agent` authentifie la vérification. Claude Code exécute la vérification de manière non-interactive : il désactive les invites de terminal de git et les programmes askpass, et indique aux assistants de credentials de ne pas inviter. Le fait que la vérification puisse s'authentifier auprès d'un dépôt privé sur HTTPS dépend de votre assistant :
863
864* Un assistant qui peut fournir une credential stockée sans inviter authentifie la vérification. Git Credential Manager, l'assistant Keychain macOS et `git-credential-store` fonctionnent de cette manière une fois qu'ils détiennent une credential pour l'hôte.
865* Un assistant qui a besoin de vous inviter ne peut pas répondre en arrière-plan. La mise à jour échoue silencieusement et le checkout existant reste en place, donc vos plugins continuent de fonctionner à partir du dernier état synchronisé. Exécutez `/plugin marketplace update <name>` pour actualiser la place de marché avec vos credentials.
866
867Lorsque la vérification trouve le checkout à jour, Claude Code le laisse tel quel. Lorsque la vérification trouve de nouveaux commits, ou échoue parce qu'elle ne peut pas atteindre ou s'authentifier auprès du dépôt distant, Claude Code clone la place de marché à nouveau et échange le nouveau clone. Si ce clone échoue, le checkout existant reste en place. Le re-clone peut [expirer sur les grands dépôts](#git-operations-time-out).
868
869Deux paramètres rendent les places de marché privées prévisibles :
870
871* Définissez `CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE=1` pour conserver le checkout existant sans tenter le re-clone lorsque la vérification en arrière-plan ne peut pas atteindre ou s'authentifier auprès du dépôt distant. Vos plugins continuent de fonctionner à partir du dernier état synchronisé, et les mises à jour manuelles avec `/plugin marketplace update` s'authentifient toujours avec vos credentials.
872* Configurez un assistant de credentials git, par exemple avec `gh auth setup-git` pour GitHub, afin que la vérification en arrière-plan et le re-clone puissent s'authentifier sans inviter.
873
874Définir un jeton de fournisseur tel que `GITHUB_TOKEN` dans votre environnement n'active pas par lui-même l'authentification en arrière-plan. Les jetons ne prennent effet que via un assistant de credentials configuré, par exemple l'assistant de l'CLI `gh`, qui lit `GH_TOKEN` et `GITHUB_TOKEN`.
875
876<Note>
877 Dans les environnements CI/CD, configurez un assistant de credentials git avant d'installer des plugins à partir de dépôts privés. Sur GitHub Actions, exportez un jeton avec accès en lecture au dépôt de la place de marché en tant que `GH_TOKEN`, puis exécutez `gh auth setup-git`. Le jeton de workflow par défaut ne peut accéder qu'au dépôt du workflow lui-même, donc une place de marché privée dans un autre dépôt a besoin d'un jeton d'accès personnel ou d'un jeton d'application.
878</Note>
879
880<h3 id="distribute-through-organization-settings">
881 Distribuer via les paramètres de l'organisation
882</h3>
883
884Si vous distribuez des plugins via [**Paramètres de l'organisation > Plugins**](https://claude.ai/admin-settings/plugins) sur un plan Team ou Enterprise, ces règles de source s'appliquent :
885
886* Sur github.com et gitlab.com, le dépôt de la place de marché doit être privé ou interne. La synchronisation de l'organisation le lit via la connexion qui correspond à son hôte :
887 * **github.com** : l'application GitHub Claude
888 * **Votre hôte GitHub Enterprise Server** : votre [application GitHub Enterprise](/docs/fr/github-enterprise-server#admin-setup) de l'organisation
889 * **gitlab.com ou votre instance GitLab auto-gérée** : le jeton d'accès dans votre [configuration GitLab](#sync-a-gitlab-hosted-marketplace) de l'organisation pour cet hôte
890* Chaque source de plugin doit être de type `github`, `url` ou `git-subdir`, ou un [chemin relatif](#relative-paths) qui commence par `./`. Si vous listez un plugin par nom nu sous `metadata.pluginRoot`, la synchronisation de l'organisation le rejette comme source non prise en charge, donc écrivez le chemin, comme `./plugins/deploy-tools`.
891* Une source de plugin peut être privée dans trois cas :
892 * Une source github.com qui partage le propriétaire du dépôt de la place de marché
893 * Une source sur l'hôte GitHub Enterprise de votre organisation avec l'application GHE installée sur le dépôt
894 * Une source `url` ou `git-subdir` sur le même hôte GitLab que le dépôt de la place de marché. Sur gitlab.com, la source doit également être sous le même groupe de niveau supérieur ou espace de noms utilisateur que le dépôt de la place de marché.
895* Toute autre source de plugin doit être un dépôt public sur github.com, gitlab.com ou bitbucket.org, que la synchronisation de l'organisation récupère sans credentials. La synchronisation de l'organisation rejette les sources de plugins sur les hôtes que ces règles ne couvrent pas.
896
897Consultez [Gérer les plugins pour votre organisation](https://support.claude.com/en/articles/13837433) pour le flux de travail administrateur.
898
899Pour inclure des plugins privés, placez les dossiers de plugins à l'intérieur du dépôt de la place de marché et référencez-les avec un [chemin relatif](#relative-paths). La synchronisation de l'organisation empaquette chaque plugin lors de la distribution, donc les utilisateurs n'ont jamais besoin d'accès à un dépôt source séparé.
900
901Par exemple, cette entrée de plugin `marketplace.json` référence un plugin que vous avez commité à `plugins/deploy-tools` dans le dépôt de la place de marché :
902
903```json theme={null}
904{
905 "name": "deploy-tools",
906 "source": "./plugins/deploy-tools"
907}
908```
909
910<h4 id="sync-a-gitlab-hosted-marketplace">
911 Synchroniser une place de marché hébergée sur GitLab
912</h4>
913
914Pour synchroniser une place de marché à partir de gitlab.com ou d'une instance GitLab auto-gérée, un [Propriétaire](/docs/fr/server-managed-settings#access-control) ajoute d'abord une configuration GitLab pour cet hôte à [**Paramètres de l'organisation > Claude Code**](https://claude.ai/admin-settings/claude-code). Les configurations GitLab sont en bêta publique et s'appliquent uniquement à la synchronisation de la place de marché des plugins. L'ajout d'une ne rend pas les dépôts GitLab disponibles dans [Claude Code sur le web](/docs/fr/claude-code-on-the-web#limitations). Consultez [Gérer les plugins pour votre organisation](https://support.claude.com/en/articles/13837433) pour les étapes de configuration.
915
916Lorsque vous ajoutez la place de marché, entrez l'URL HTTPS du projet, comme `https://gitlab.example.com/platform/claude-plugins`. Les projets dans les sous-groupes imbriqués fonctionnent. La synchronisation de l'organisation lit la branche par défaut du projet. Si vous activez **Synchroniser automatiquement**, seuls les pushes vers la branche par défaut démarrent une synchronisation.
917
918<h4 id="keep-executables-out-of-the-top-level-bin-directory">
919 Garder les exécutables hors du répertoire bin de niveau supérieur
920</h4>
921
922N'incluez pas de répertoire `bin/` de niveau supérieur dans aucun plugin que vous distribuez via les paramètres de l'organisation. claude.ai rejette un plugin qui en a un, que le plugin arrive par synchronisation de place de marché ou par téléchargement direct :
923
924* **Synchronisation de place de marché** : la synchronisation de l'organisation rejette ce plugin et synchronise le reste de la place de marché. Le message d'erreur commence par `Plugin contains a top-level bin/ directory`.
925* **Téléchargement direct** : si vous téléchargez le plugin dans [**Paramètres de l'organisation > Plugins**](https://claude.ai/admin-settings/plugins) à la place, claude.ai rejette le téléchargement avec le même message.
926
927Gardez les exécutables dans un autre répertoire, comme `scripts/`, et référencez-les comme `${CLAUDE_PLUGIN_ROOT}/scripts/<name>` à partir de vos [skills, hooks ou configurations de serveur MCP](/docs/fr/plugins-reference#environment-variables).
928
929<h3 id="require-marketplaces-for-your-team">
930 Exiger des places de marché pour votre équipe
931</h3>
932
933Vous pouvez configurer votre dépôt pour que Claude Code ajoute votre place de marché pour les membres de l'équipe une fois qu'ils [font confiance au dossier du projet](/docs/fr/permissions#what-runs-before-you-trust-a-folder), sans invite séparée. Ajoutez votre place de marché à `.claude/settings.json` :
934
935```json theme={null}
936{
937 "extraKnownMarketplaces": {
938 "company-tools": {
939 "source": {
940 "source": "github",
941 "repo": "your-org/claude-plugins"
942 }
943 }
944 }
945}
946```
947
948Vous pouvez également spécifier quels plugins doivent être activés par défaut :
949
950```json theme={null}
951{
952 "enabledPlugins": {
953 "code-formatter@company-tools": true,
954 "deployment-tools@company-tools": true
955 }
956}
957```
958
959Pour les options de configuration complètes, consultez [Paramètres des plugins](/docs/fr/settings-reference#plugin-settings).
960
961<Note>
962 Si vous utilisez une source `directory` ou `file` locale avec un chemin relatif, le chemin se résout par rapport au checkout principal de votre dépôt. Lorsque vous exécutez Claude Code à partir d'une git worktree, le chemin pointe toujours vers le checkout principal, donc toutes les worktrees partagent le même emplacement de place de marché. L'état de la place de marché est stocké une fois par utilisateur dans `~/.claude/plugins/known_marketplaces.json`, pas par projet.
963</Note>
964
965<h3 id="pre-populate-plugins-for-containers">
966 Pré-remplir les plugins pour les conteneurs
967</h3>
968
969Pour les images de conteneur et les environnements CI, vous pouvez pré-remplir un répertoire de plugins au moment de la construction afin que Claude Code démarre avec des places de marché et des plugins déjà disponibles, sans rien cloner au moment de l'exécution. Définissez la variable d'environnement `CLAUDE_CODE_PLUGIN_SEED_DIR` pour pointer vers ce répertoire.
970
971Pour superposer plusieurs répertoires de seed, séparez les chemins avec `:` sur Unix ou `;` sur Windows. Claude Code recherche chaque répertoire dans l'ordre et utilise le premier seed qui contient une place de marché ou un cache de plugin donné.
972
973Le répertoire de seed reflète la structure de `~/.claude/plugins` :
974
975```
976$CLAUDE_CODE_PLUGIN_SEED_DIR/
977 known_marketplaces.json
978 marketplaces/<name>/...
979 cache/<marketplace>/<plugin>/<version>/...
980```
981
982Pour construire un répertoire de seed, exécutez Claude Code une fois lors de la construction de l'image, installez les plugins dont vous avez besoin, puis copiez le répertoire `~/.claude/plugins` résultant dans votre image et pointez `CLAUDE_CODE_PLUGIN_SEED_DIR` vers lui.
983
984Pour ignorer l'étape de copie, définissez `CLAUDE_CODE_PLUGIN_CACHE_DIR` sur votre chemin de seed cible lors de la construction afin que les plugins s'installent directement là :
985
986```bash theme={null}
987CLAUDE_CODE_PLUGIN_CACHE_DIR=/opt/claude-seed claude plugin marketplace add your-org/plugins
988CLAUDE_CODE_PLUGIN_CACHE_DIR=/opt/claude-seed claude plugin install my-tool@your-plugins
989```
990
991Ensuite, définissez `CLAUDE_CODE_PLUGIN_SEED_DIR=/opt/claude-seed` dans l'environnement d'exécution de votre conteneur afin que Claude Code lise à partir du seed au démarrage.
992
993Au démarrage, Claude Code enregistre les places de marché trouvées dans le `known_marketplaces.json` du seed dans la configuration principale, et utilise les caches de plugins trouvés sous `cache/` en place sans re-cloner. Cela fonctionne à la fois en mode interactif et en mode non-interactif avec le drapeau `-p`.
994
995Détails du comportement :
996
997* **Lecture seule** : Claude Code n'écrit jamais dans le répertoire de seed.
998* **Mises à jour automatiques désactivées** : les places de marché de seed ne se mettent pas à jour automatiquement.
999* **Les entrées de seed ont la priorité** : les places de marché déclarées dans le seed remplacent toutes les entrées correspondantes dans la configuration de l'utilisateur à chaque démarrage. Pour refuser un plugin de seed, utilisez `/plugin disable` plutôt que de supprimer la place de marché.
1000* **Résolution des chemins** : Claude Code localise le contenu de la place de marché en sondant `$CLAUDE_CODE_PLUGIN_SEED_DIR/marketplaces/<name>/` au moment de l'exécution, pas en faisant confiance aux chemins stockés dans le JSON du seed. Cela signifie que le seed fonctionne correctement même lorsqu'il est monté à un chemin différent de celui où il a été construit.
1001* **La mutation est bloquée** : l'exécution de `/plugin marketplace remove` ou `/plugin marketplace update` contre une place de marché gérée par seed échoue avec des conseils pour demander à votre administrateur de mettre à jour l'image de seed.
1002* **Compose avec les paramètres** : si `extraKnownMarketplaces` ou `enabledPlugins` déclarent une place de marché qui existe déjà dans le seed, Claude Code utilise la copie du seed au lieu de cloner.
1003
1004<h3 id="managed-marketplace-restrictions">
1005 Restrictions des places de marché gérées
1006</h3>
1007
1008Pour les organisations nécessitant un contrôle strict sur les sources de plugins, les administrateurs peuvent restreindre les places de marché de plugins que les utilisateurs sont autorisés à ajouter en utilisant le paramètre [`strictKnownMarketplaces`](/docs/fr/settings-reference#strictknownmarketplaces) dans les paramètres gérés. Pour également rejeter les drapeaux CLI qui chargent les plugins, les agents et les serveurs MCP pour une seule exécution, associez-le à [`disableSideloadFlags`](/docs/fr/settings-reference#disablesideloadflags). Pour créer une liste blanche des places de marché dont les plugins peuvent apparaître comme suggestions d'installation contextuelle, définissez [`pluginSuggestionMarketplaces`](/docs/fr/settings-reference#pluginsuggestionmarketplaces).
1009
1010`strictKnownMarketplaces` correspond à la place de marché d'où provient un plugin, pas aux entrées à l'intérieur, donc les utilisateurs peuvent toujours installer un plugin avec une [source `command`](#command-sources) à partir d'une place de marché autorisée. Pour bloquer également les sources de commande, définissez [`disableCommandPluginSources`](/docs/fr/settings-reference#disablecommandpluginsources).
1011
1012Lorsque `strictKnownMarketplaces` est configuré dans les paramètres gérés, le comportement de restriction dépend de la valeur :
1013
1014| Valeur | Comportement |
1015| ----------------------- | --------------------------------------------------------------------------------------------------------------------------- |
1016| Non défini (par défaut) | Aucune restriction. Les utilisateurs peuvent ajouter n'importe quelle place de marché |
1017| Tableau vide `[]` | Verrouillage complet. Bloque chaque source de place de marché, y compris la place de marché officielle Anthropic |
1018| Liste de sources | Liste d'autorisation appliquée. Les utilisateurs ne peuvent ajouter que les places de marché qui correspondent à une entrée |
1019
1020<h4 id="common-configurations">
1021 Configurations courantes
1022</h4>
1023
1024Désactiver tous les ajouts de place de marché, y compris la place de marché officielle Anthropic :
1025
1026```json theme={null}
1027{
1028 "strictKnownMarketplaces": []
1029}
1030```
1031
1032Claude Code télécharge les plugins [synchronisés à partir de claude.ai](/docs/fr/plugins-reference#synced-plugins) à partir de votre compte plutôt que d'une place de marché, donc ce verrouillage ne les couvre pas. Pour arrêter ceux-ci également, définissez [`syncClaudeAiPlugins`](/docs/fr/settings-reference#syncclaudeaiplugins) à `false` dans les paramètres gérés, ou désactivez les Skills pour votre organisation sur claude.ai.
1033
1034Autoriser uniquement la place de marché officielle Anthropic. La correspondance pour une entrée de dépôt unique est exacte, donc cette entrée ne couvre pas les variantes `ref` ou `path` du même dépôt :
1035
1036```json theme={null}
1037{
1038 "strictKnownMarketplaces": [
1039 {
1040 "source": "github",
1041 "repo": "anthropics/claude-plugins-official"
1042 }
1043 ]
1044}
1045```
1046
1047Avec cette entrée, Claude Code garde une place de marché officielle déjà enregistrée disponible et, sur une machine neuve, enregistre la place de marché automatiquement la première fois que vous démarrez Claude Code de manière interactive.
1048
1049L'enregistrement automatique ne couvre pas chaque machine. Il manque le plus souvent :
1050
1051* Les environnements non-interactifs qui s'exécutent avant le premier lancement interactif de la machine.
1052* Les machines où Claude Code a déjà fonctionné de manière interactive sous une politique qui a bloqué la place de marché, comme le verrouillage du tableau vide. Claude Code enregistre la tentative bloquée et ne réessaie pas après le changement de politique.
1053
1054Sur ces machines, ajoutez la place de marché à [`extraKnownMarketplaces`](/docs/fr/settings-reference#extraknownmarketplaces) dans le même `managed-settings.json` afin que Claude Code l'enregistre automatiquement, ou exécutez `claude plugin marketplace add anthropics/claude-plugins-official`.
1055
1056Autoriser uniquement les places de marché spécifiques :
1057
1058```json theme={null}
1059{
1060 "strictKnownMarketplaces": [
1061 {
1062 "source": "github",
1063 "repo": "acme-corp/approved-plugins"
1064 },
1065 {
1066 "source": "github",
1067 "repo": "acme-corp/security-tools",
1068 "ref": "v2.0"
1069 },
1070 {
1071 "source": "url",
1072 "url": "https://plugins.example.com/marketplace.json"
1073 }
1074 ]
1075}
1076```
1077
1078Autoriser chaque dépôt de place de marché sous une organisation GitHub avec une entrée [owner-wildcard](/docs/fr/settings-reference#owner-wildcards). Les owner-wildcards nécessitent Claude Code v2.1.223 ou ultérieur.
1079
1080```json theme={null}
1081{
1082 "strictKnownMarketplaces": [
1083 {
1084 "source": "github",
1085 "repo": "acme-corp/*"
1086 }
1087 ]
1088}
1089```
1090
1091Autoriser toutes les places de marché d'un serveur git interne en utilisant la correspondance de motif regex sur l'hôte. C'est l'approche recommandée pour [GitHub Enterprise Server](/docs/fr/github-enterprise-server#plugin-marketplaces-on-ghes) ou les instances GitLab auto-hébergées :
1092
1093```json theme={null}
1094{
1095 "strictKnownMarketplaces": [
1096 {
1097 "source": "hostPattern",
1098 "hostPattern": "^github\\.example\\.com$"
1099 }
1100 ]
1101}
1102```
1103
1104Autoriser les places de marché basées sur le système de fichiers à partir d'un répertoire spécifique en utilisant la correspondance de motif regex sur le chemin :
1105
1106```json theme={null}
1107{
1108 "strictKnownMarketplaces": [
1109 {
1110 "source": "pathPattern",
1111 "pathPattern": "^/opt/approved/"
1112 }
1113 ]
1114}
1115```
1116
1117Utilisez `".*"` comme `pathPattern` pour autoriser n'importe quel chemin du système de fichiers tout en contrôlant les sources réseau avec `hostPattern`.
1118
1119<Note>
1120 `strictKnownMarketplaces` restreint ce que les utilisateurs peuvent ajouter, mais n'enregistre pas les places de marché par lui-même. Pour enregistrer une place de marché autorisée pour les utilisateurs automatiquement, ajoutez-la à [`extraKnownMarketplaces`](/docs/fr/settings-reference#extraknownmarketplaces) dans le même `managed-settings.json`.
1121
1122 La place de marché officielle Anthropic est la seule que Claude Code enregistre par lui-même, et seulement lorsque la liste d'autorisation l'autorise. L'enregistrement automatique manque également certaines machines, comme les environnements non-interactifs et les machines où une politique antérieure l'a bloquée. Pour couvrir ces machines, ajoutez également la place de marché officielle à `extraKnownMarketplaces`. Pour les deux paramètres côte à côte, consultez la [référence `strictKnownMarketplaces`](/docs/fr/settings-reference#strictknownmarketplaces).
1123</Note>
1124
1125<h4 id="how-restrictions-work">
1126 Comment fonctionnent les restrictions
1127</h4>
1128
1129Les restrictions sont vérifiées avant toute opération réseau ou système de fichiers. La vérification s'exécute lors de l'ajout de place de marché et lors de l'installation, la mise à jour, l'actualisation et la mise à jour automatique du plugin. Si une place de marché a été ajoutée avant la configuration de la politique et que sa source ne correspond plus à la liste d'autorisation, Claude Code refuse d'installer ou de mettre à jour les plugins à partir de celle-ci. L'application de la même restriction s'applique à `blockedMarketplaces`.
1130
1131Où les deux listes sont appliquées dépend de l'endroit où vous les définissez :
1132
1133* **La console d'administration claude.ai** : Claude Code applique les deux listes dans les sessions qui [lisent les paramètres gérés par serveur](/docs/fr/managed-settings#where-and-when-a-policy-applies). claude.ai les vérifie également lorsque quelqu'un dans votre organisation ajoute une nouvelle place de marché à partir d'un dépôt git sur claude.ai, ou à partir de **Personnaliser** dans l'application Claude Desktop en dehors de son onglet Code. Cela couvre une place de marché qu'un membre ajoute pour son propre compte et une place de marché ajoutée pour toute l'organisation sous [**Paramètres de l'organisation > Plugins**](https://claude.ai/admin-settings/plugins). claude.ai refuse un dépôt que la liste d'autorisation n'admet pas ou que la liste de blocage nomme. Il ne re-vérifie pas une place de marché qui a été ajoutée dans l'un ou l'autre endroit avant que vous définissiez les listes, et il ne vérifie pas les plugins téléchargés.
1134* **Un fichier de paramètres gérés, une politique au niveau du système d'exploitation ou une autre source gérée** : Claude Code applique les deux listes où il lit cette source. claude.ai ne la lit pas.
1135
1136Pour bloquer chaque dépôt de place de marché sous un propriétaire GitHub, utilisez la forme owner-wildcard dans une entrée `blockedMarketplaces` : `{ "source": "github", "repo": "untrusted-org/*" }`. Nécessite Claude Code v2.1.223 ou ultérieur. Pour les règles de correspondance, qui diffèrent entre la liste de blocage et la liste d'autorisation, consultez [Owner wildcards](/docs/fr/settings-reference#owner-wildcards).
1137
1138Lorsqu'un utilisateur ajoute une URL de dépôt `https://` que Claude Code [clone plutôt que récupère](/docs/fr/discover-plugins#add-from-other-git-hosts), comme une URL de dépôt `github.com` ou `gitlab.com` nu, Claude Code la vérifie également par rapport aux entrées `url` dans `blockedMarketplaces`. Claude Code bloque l'ajout si une entrée nomme la même URL. Dans cette comparaison, Claude Code ignore le suffixe `.git` et toute ref que l'utilisateur ajoute après `#`. Nécessite Claude Code v2.1.232 ou ultérieur. Avant v2.1.232, Claude Code ne correspondait à une entrée `url` que par rapport à une URL qu'il récupérait en tant que fichier `marketplace.json` hébergé.
1139
1140La liste d'autorisation utilise la correspondance exacte pour la plupart des types de sources, à part les entrées `github` owner-wildcard. Pour qu'une place de marché soit autorisée, tous les champs spécifiés doivent correspondre :
1141
1142* Pour les sources GitHub : `repo` est obligatoire, nommant soit un dépôt soit utilisant la forme owner-wildcard `owner/*` pour couvrir chaque dépôt sous ce propriétaire. Pour la façon dont les entrées wildcard correspondent, y compris les règles de casse, consultez [Owner wildcards](/docs/fr/settings-reference#owner-wildcards). Pour les entrées de dépôt unique, `ref` doit correspondre exactement ou être absent à la fois de la source de place de marché et de l'entrée de liste d'autorisation, et la même règle s'applique à `path`
1143* Pour les sources URL : l'URL complète doit correspondre exactement
1144* Pour les sources `hostPattern` : l'hôte de la place de marché est comparé au motif regex
1145* Pour les sources `pathPattern` : le chemin du système de fichiers de la place de marché est comparé au motif regex
1146
1147La correspondance exacte de la liste d'autorisation traite les URL qui diffèrent uniquement par une barre oblique finale, un suffixe `.git` ou le schéma `ssh://` et `https://` comme des valeurs différentes. Si la place de marché de votre organisation peut être clonée par plus d'une forme d'URL, préférez une entrée `hostPattern` à une URL littérale afin que les formes `https://`, `ssh://` et `user@host:path` correspondent toutes.
1148
1149Une [place de marché hébergée sur claude.ai](/docs/fr/discover-plugins#add-from-claude-ai) est appariée par hôte : une entrée `hostPattern` qui correspond à `claude.ai` la gouverne, dans `strictKnownMarketplaces` et dans `blockedMarketplaces`. Sur la liste d'autorisation, une telle entrée n'admet pas les téléchargements personnels claude.ai d'un membre. Nécessite Claude Code v2.1.273 ou ultérieur.
1150
1151Parce que `strictKnownMarketplaces` est défini dans les [paramètres gérés](/docs/fr/managed-settings), les configurations individuelles des utilisateurs et des projets ne peuvent pas contourner ces restrictions.
1152
1153Pour les détails de configuration complets, y compris tous les types de sources pris en charge et la comparaison avec `extraKnownMarketplaces`, consultez la [référence strictKnownMarketplaces](/docs/fr/settings-reference#strictknownmarketplaces).
1154
1155<h3 id="version-resolution-and-release-channels">
1156 Résolution des versions et canaux de publication
1157</h3>
1158
1159Les versions des plugins déterminent les chemins du cache et la détection des mises à jour : si la version résolue correspond à ce qu'un utilisateur possède déjà, `/plugin update` et la mise à jour automatique ignorent le plugin. Pour les sources basées sur git, si vous omettez `version`, Claude Code utilise le SHA du commit résolu de la source, donc les utilisateurs obtiennent une mise à jour chaque fois que ce commit change ; c'est la configuration la plus simple pour les plugins internes ou en développement actif. Consultez [Gestion des versions](/docs/fr/plugins-reference#version-management) pour l'ordre de résolution complet, y compris les sources `archive`.
1160
1161<Warning>
1162 Définir `version` épingle le plugin pour chaque type de source sauf [`command`](#command-sources), dont la version inclut toujours un hash de ce que la commande a produit. Un plugin [chargé en place](/docs/fr/plugins-reference#plugin-caching-and-file-resolution) à partir d'une place de marché ajoutée en tant que répertoire local n'est pas épinglé non plus. Si vous déclarez `"version": "1.0.0"` dans `plugin.json` et poussez de nouveaux commits sans changer cette chaîne, les utilisateurs existants de ces sources conservent la copie en cache, car Claude Code voit la même version. Augmentez le champ à chaque publication, ou omettez-le pour revenir à la version résolue.
1163
1164 Évitez de définir `version` à la fois dans `plugin.json` et dans l'entrée de la place de marché. La valeur `plugin.json` gagne toujours silencieusement, donc une version de manifeste obsolète peut masquer une version que vous avez définie dans `marketplace.json`.
1165</Warning>
1166
1167<h4 id="set-up-release-channels">
1168 Configurer les canaux de publication
1169</h4>
1170
1171Pour prendre en charge les canaux de publication « stable » et « latest » pour vos plugins, vous pouvez configurer deux places de marché qui pointent vers différentes refs ou SHAs du même dépôt. Vous pouvez ensuite assigner chaque groupe d'utilisateurs sa propre place de marché via les paramètres gérés de l'une des deux façons suivantes :
1172
1173* Déployez des [paramètres gérés gérés par endpoint](/docs/fr/managed-settings#delivery-mechanisms) séparés, comme un fichier de paramètres gérés ou un profil MDM, aux appareils de chaque groupe. [Comment Claude Code combine les sources gérées](/docs/fr/managed-settings#precedence-within-the-managed-tier) indique si le fichier ou le profil par groupe s'applique sur un appareil qui a également une source à l'échelle de l'organisation.
1174* Définissez une [politique de passerelle d'applications Claude](/docs/fr/claude-apps-gateway-config#managed) par groupe. La passerelle applique la première politique dont la règle de correspondance correspond à un utilisateur, donc ordonnez les politiques afin que chaque utilisateur atteigne la politique de son groupe. La `extraKnownMarketplaces` d'une politique de groupe remplace la carte de la politique de rattrapage plutôt que de fusionner avec elle, donc listez chaque place de marché dont le groupe a besoin dans la politique du groupe, pas seulement sa place de marché de canal.
1175
1176Les paramètres gérés par serveur à partir de la console d'administration [s'appliquent à chaque utilisateur de votre organisation](/docs/fr/server-managed-settings#current-limitations), donc ils ne peuvent pas porter une affectation par groupe.
1177
1178<Warning>
1179 Chaque canal doit se résoudre en une version différente. Si vous utilisez des versions explicites, `plugin.json` doit déclarer une `version` différente à chaque ref ou SHA épinglé. Si vous omettez `version`, les SHAs de commit distincts distinguent déjà les canaux. Si deux refs se résolvent en la même chaîne de version, Claude Code les traite comme identiques et ignore la mise à jour.
1180</Warning>
1181
1182<h5 id="example">
1183 Exemple
1184</h5>
1185
1186```json theme={null}
1187{
1188 "name": "stable-tools",
1189 "plugins": [
1190 {
1191 "name": "code-formatter",
1192 "source": {
1193 "source": "github",
1194 "repo": "acme-corp/code-formatter",
1195 "ref": "stable"
1196 }
1197 }
1198 ]
1199}
1200```
1201
1202```json theme={null}
1203{
1204 "name": "latest-tools",
1205 "plugins": [
1206 {
1207 "name": "code-formatter",
1208 "source": {
1209 "source": "github",
1210 "repo": "acme-corp/code-formatter",
1211 "ref": "latest"
1212 }
1213 }
1214 ]
1215}
1216```
1217
1218<h5 id="assign-channels-to-user-groups">
1219 Assigner les canaux aux groupes d'utilisateurs
1220</h5>
1221
1222Assignez chaque place de marché à son groupe d'utilisateurs via les paramètres gérés par endpoint par groupe ou la politique de passerelle décrite sous [Configurer les canaux de publication](#set-up-release-channels). Par exemple, le groupe stable reçoit :
1223
1224```json theme={null}
1225{
1226 "extraKnownMarketplaces": {
1227 "stable-tools": {
1228 "source": {
1229 "source": "github",
1230 "repo": "acme-corp/stable-tools"
1231 }
1232 }
1233 }
1234}
1235```
1236
1237Le groupe early-access reçoit `latest-tools` à la place :
1238
1239```json theme={null}
1240{
1241 "extraKnownMarketplaces": {
1242 "latest-tools": {
1243 "source": {
1244 "source": "github",
1245 "repo": "acme-corp/latest-tools"
1246 }
1247 }
1248 }
1249}
1250```
1251
1252<h4 id="pin-dependency-versions">
1253 Épingler les versions des dépendances
1254</h4>
1255
1256Un plugin peut contraindre ses dépendances à une plage semver afin que les mises à jour d'une dépendance ne cassent pas le plugin dépendant. Consultez [Contraindre les versions des dépendances de plugins](/docs/fr/plugin-dependencies) pour la convention de balise git `{plugin-name}--v{version}`, la syntaxe de plage et la façon dont plusieurs contraintes sur la même dépendance sont combinées.
1257
1258<h3 id="rename-or-remove-a-plugin">
1259 Renommer ou supprimer un plugin
1260</h3>
1261
1262Le `name` d'un plugin est son identifiant stable. Les utilisateurs le référencent dans `enabledPlugins`, `pluginConfigs` et les commandes `/plugin install`, donc le changer casse chaque installation existante. Pour changer l'étiquette affichée dans l'interface utilisateur sans casser les installations, définissez [`displayName`](#optional-plugin-fields) et gardez `name` inchangé.
1263
1264Si vous devez changer le `name` d'un plugin, ou si vous supprimez un plugin du tableau `plugins`, ajoutez une entrée `renames` au niveau supérieur afin que les utilisateurs existants migrent au lieu de voir une erreur `plugin-not-found`. La migration automatique nécessite Claude Code v2.1.193 ou ultérieur. Mappez chaque ancien nom à son nouveau nom, ou à `null` si le plugin n'existe plus. L'exemple suivant renomme `formatter` en `code-formatter` et enregistre que `legacy-linter` a été supprimé :
1265
1266```json theme={null}
1267{
1268 "name": "acme-tools",
1269 "owner": { "name": "Acme" },
1270 "plugins": [
1271 { "name": "code-formatter", "source": "./plugins/code-formatter" }
1272 ],
1273 "renames": {
1274 "formatter": "code-formatter",
1275 "legacy-linter": null
1276 }
1277}
1278```
1279
1280Lorsqu'un utilisateur démarre Claude Code avec l'ancien nom toujours dans ses paramètres, Claude Code suit la carte `renames` :
1281
1282* Si l'entrée pointe vers un nouveau nom, Claude Code charge le plugin sous son nouveau nom et affiche un avis d'une ligne tel que `Renamed to "code-formatter" in the "acme-tools" marketplace`. Il réécrit ensuite l'ancienne clé vers la nouvelle clé dans les portées de paramètres utilisateur, projet et local pour `enabledPlugins` et `pluginConfigs`, afin que l'avis n'apparaisse qu'une fois.
1283* Pour une entrée `null`, Claude Code supprime l'ancienne clé et l'avis signale que le plugin a été supprimé de la place de marché.
1284* Si le plugin renommé utilise une source distante telle que `github` ou `npm`, Claude Code signale `plugin-cache-miss` après le renommage et l'utilisateur doit exécuter `/plugin install` une fois pour le récupérer sous le nouveau nom.
1285
1286Traitez `renames` comme un historique d'ajout uniquement : gardez les anciennes entrées en place même après vous attendre à ce que chaque utilisateur ait migré. Claude Code suit les chaînes, donc si vous renommez ultérieurement `code-formatter` en `formatter-pro`, ajoutez une deuxième entrée plutôt que de modifier la première. Un utilisateur qui a toujours le `formatter` original activé se résout ensuite à travers les deux entrées vers `formatter-pro`.
1287
1288Exécutez `claude plugin validate .` après avoir modifié la carte ; il rejette toute entrée dont la chaîne forme un cycle ou ne se termine pas à `null` ou à un nom listé dans `plugins`.
1289
1290<Note>
1291 Les paramètres gérés et de politique sont en lecture seule pour Claude Code, donc les plugins activés là ne peuvent pas être réécrits automatiquement. Le plugin renommé se charge toujours à chaque session, mais l'avis de renommage se répète jusqu'à ce qu'un administrateur mette à jour `enabledPlugins` dans le fichier de paramètres gérés pour utiliser le nouveau nom. La même chose s'applique aux plugins activés via d'autres sources en lecture seule telles que `--add-dir`.
1292</Note>
1293
1294Les versions antérieures de Claude Code ignorent le champ `renames` et signalent `plugin-not-found` pour l'ancien nom.
1295
1296<h2 id="validation-and-testing">
1297 Validation et test
1298</h2>
1299
1300Testez votre place de marché avant de la partager. La validation vérifie la structure des fichiers ; pour tester si un plugin modifie le comportement de Claude sur des invites réalistes, exécutez sa suite d'évaluation avec [`claude plugin eval`](/docs/fr/plugin-evals) avant de publier une nouvelle version.
1301
1302Depuis votre répertoire de place de marché, validez la syntaxe JSON :
1303
1304```bash theme={null}
1305claude plugin validate .
1306```
1307
1308Ou depuis Claude Code :
1309
1310```shell theme={null}
1311/plugin validate .
1312```
1313
1314Ajoutez la place de marché pour le test :
1315
1316```shell theme={null}
1317/plugin marketplace add ./path/to/marketplace
1318```
1319
1320Installez un plugin de test pour vérifier que tout fonctionne :
1321
1322```shell theme={null}
1323/plugin install test-plugin@marketplace-name
1324```
1325
1326Pour les flux de travail complets de test de plugins, consultez [Tester vos plugins localement](/docs/fr/plugins#test-your-plugins-locally). Pour le dépannage technique, consultez [Référence des plugins](/docs/fr/plugins-reference).
1327
1328<h2 id="manage-marketplaces-from-the-cli">
1329 Gérer les places de marché à partir de la CLI
1330</h2>
1331
1332Claude Code fournit des sous-commandes `claude plugin marketplace` non-interactives pour les scripts et l'automatisation. Elles sont équivalentes aux commandes `/plugin marketplace` disponibles dans une session interactive.
1333
1334<h3 id="plugin-marketplace-add">
1335 Plugin marketplace add
1336</h3>
1337
1338Ajoutez une place de marché à partir d'un dépôt GitHub, d'une URL git, d'une URL distante ou d'un chemin local.
1339
1340```bash theme={null}
1341claude plugin marketplace add <source> [options]
1342```
1343
1344**Arguments :**
1345
1346* `<source>` : Raccourci GitHub `owner/repo`, URL git, URL distante vers un fichier `marketplace.json` ou chemin de répertoire local. Pour épingler à une branche ou un tag, ajoutez `@ref` au raccourci GitHub ou `#ref` à une URL git
1347
1348Une URL doit inclure son schéma. À partir de Claude Code v2.1.196, un hôte saisi sans schéma, tel que `gitlab.example.com/team/plugins`, est rejeté comme un raccourci `owner/repo` invalide et l'erreur vous indique d'ajouter `https://` ou d'utiliser `./` pour un chemin local. Les versions antérieures l'interprétaient mal comme un chemin de dépôt GitHub et échouent au moment du clonage avec une erreur GitHub non trouvé.
1349
1350**Options :**
1351
1352| Option | Description | Par défaut |
1353| :-------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------- |
1354| `--scope <scope>` | Où déclarer la place de marché : `user`, `project` ou `local`. Voir [Portées d'installation des plugins](/docs/fr/plugins-reference#plugin-installation-scopes) | `user` |
1355| `--sparse <paths...>` | Limiter le checkout à des répertoires spécifiques via git sparse-checkout. Utile pour les monodépôts | |
1356| `--claudeai` | Lire l'argument comme le nom d'une [place de marché hébergée sur claude.ai](/docs/fr/discover-plugins#add-from-claude-ai) au lieu d'une source. Nécessite Claude Code v2.1.273 ou ultérieur | |
1357
1358Ajoutez une place de marché à partir de GitHub en utilisant le raccourci `owner/repo` :
1359
1360```bash theme={null}
1361claude plugin marketplace add acme-corp/claude-plugins
1362```
1363
1364Épinglez à une branche ou un tag spécifique avec `@ref` :
1365
1366```bash theme={null}
1367claude plugin marketplace add acme-corp/claude-plugins@v2.0
1368```
1369
1370Ajoutez à partir d'une URL git sur un hôte non-GitHub :
1371
1372```bash theme={null}
1373claude plugin marketplace add https://gitlab.example.com/team/plugins.git
1374```
1375
1376Ajoutez à partir d'une URL distante qui sert le fichier `marketplace.json` directement :
1377
1378```bash theme={null}
1379claude plugin marketplace add https://example.com/marketplace.json
1380```
1381
1382Ajoutez à partir d'un répertoire local pour le test :
1383
1384```bash theme={null}
1385claude plugin marketplace add ./my-marketplace
1386```
1387
1388Déclarez la place de marché à la portée du projet afin qu'elle soit partagée avec votre équipe via `.claude/settings.json` :
1389
1390```bash theme={null}
1391claude plugin marketplace add acme-corp/claude-plugins --scope project
1392```
1393
1394Pour un monodépôt, limitez le checkout aux répertoires qui contiennent le contenu du plugin :
1395
1396```bash theme={null}
1397claude plugin marketplace add acme-corp/monorepo --sparse .claude-plugin plugins
1398```
1399
1400Ajoutez une [place de marché hébergée sur claude.ai](/docs/fr/discover-plugins#add-from-claude-ai) par le nom imprimé dans la section `From claude.ai:` de `claude plugin marketplace list` :
1401
1402```bash theme={null}
1403claude plugin marketplace add --claudeai claudeai-organization-library
1404```
1405
1406Avec `--claudeai`, la commande refuse `--scope` et `--sparse`. La place de marché est hébergée pour votre compte, pas déclarée dans un fichier de paramètres, donc vous ne pouvez pas la partager via le `.claude/settings.json` d'un projet.
1407
1408<h3 id="plugin-marketplace-list">
1409 Plugin marketplace list
1410</h3>
1411
1412Listez toutes les places de marché configurées.
1413
1414```bash theme={null}
1415claude plugin marketplace list [options]
1416```
1417
1418**Options :**
1419
1420| Option | Description |
1421| :------- | :------------- |
1422| `--json` | Sortie en JSON |
1423
1424Avec `--json`, chaque entrée inclut `name`, `source`, un champ `installLocation` avec le chemin du cache local où la place de marché est stockée, et des champs spécifiques à la source : `repo` pour les sources GitHub, `url` pour les sources git et URL, et `path` pour les sources locales. Les sources GitHub et git incluent également un champ `ref` lorsque la place de marché a été ajoutée avec une branche ou un tag épinglé.
1425
1426Une [place de marché claude.ai](/docs/fr/discover-plugins#add-from-claude-ai) ajoutée n'a pas de clone local, donc son entrée porte ses identifiants claude.ai, `marketplaceId` et `organizationUuid`, à la place de `installLocation`.
1427
1428Dans les sessions de terminal où [les plugins se synchronisent à partir de votre compte claude.ai](/docs/fr/plugins-reference#synced-plugins), la liste textuelle se termine par une section `From claude.ai:` nommant ce que claude.ai liste pour votre compte au-delà des places de marché que vous avez ajoutées. Pour en ajouter une, voir [Ajouter à partir de claude.ai](/docs/fr/discover-plugins#add-from-claude-ai). La sortie `--json` couvre uniquement les places de marché configurées et laisse cette section de côté. Nécessite Claude Code v2.1.273 ou ultérieur.
1429
1430<h3 id="plugin-marketplace-remove">
1431 Plugin marketplace remove
1432</h3>
1433
1434Supprimez une place de marché configurée. L'alias `rm` est également accepté.
1435
1436```bash theme={null}
1437claude plugin marketplace remove <name> [options]
1438```
1439
1440**Arguments :**
1441
1442* `<name>` : nom de la place de marché à supprimer, comme indiqué par `claude plugin marketplace list`. C'est le `name` de `marketplace.json`, pas la source que vous avez passée à `add`
1443
1444**Options :**
1445
1446| Option | Description | Par défaut |
1447| :---------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------- |
1448| `--scope <scope>` | Restreindre la suppression à une seule portée de paramètres : `user`, `project` ou `local`. Voir [Portées d'installation des plugins](/docs/fr/plugins-reference#plugin-installation-scopes). Lorsqu'il est omis, la déclaration est supprimée de chaque portée modifiable. Lorsqu'il est donné, seule la déclaration de cette portée est supprimée ; l'état partagé, le cache et les données des plugins installés sont préservés lorsque la place de marché est toujours déclarée dans une autre portée | (toutes les portées) |
1449
1450<Warning>
1451 La suppression d'une place de marché de sa dernière portée restante désinstalle également tous les plugins que vous avez installés à partir de celle-ci. Pour actualiser une place de marché sans perdre les plugins installés, utilisez `claude plugin marketplace update` à la place.
1452</Warning>
1453
1454<h3 id="plugin-marketplace-update">
1455 Plugin marketplace update
1456</h3>
1457
1458Actualisez les places de marché à partir de leurs sources pour récupérer les nouveaux plugins et les changements de version. Une place de marché ajoutée avec une branche ou un tag `ref` se met à jour vers le dernier commit de cette ref, pas la branche par défaut du dépôt.
1459
1460```bash theme={null}
1461claude plugin marketplace update [name]
1462```
1463
1464**Arguments :**
1465
1466* `[name]` : nom de la place de marché à mettre à jour, comme indiqué par `claude plugin marketplace list`. Met à jour toutes les places de marché si omis
1467
1468À la fois `remove` et `update` échouent lorsqu'ils sont exécutés contre une place de marché gérée par seed, qui est en lecture seule. Lors de la mise à jour de toutes les places de marché, les entrées gérées par seed sont ignorées et les autres places de marché se mettent toujours à jour. Pour modifier les plugins fournis par seed, demandez à votre administrateur de mettre à jour l'image de seed. Voir [Pré-remplir les plugins pour les conteneurs](#pre-populate-plugins-for-containers).
1469
1470<h2 id="troubleshooting">
1471 Dépannage
1472</h2>
1473
1474<h3 id="marketplace-not-loading">
1475 La place de marché ne se charge pas
1476</h3>
1477
1478**Symptômes** : Impossible d'ajouter la place de marché ou de voir les plugins qu'elle contient
1479
1480**Solutions** :
1481
1482* Vérifiez que l'URL de la place de marché est accessible
1483* Vérifiez que `.claude-plugin/marketplace.json` existe au chemin spécifié
1484* Assurez-vous que la syntaxe JSON est valide en utilisant `claude plugin validate .` ou `/plugin validate .` à partir du répertoire de la place de marché. Pour vérifier le frontmatter des compétences, agents et commandes, consultez [Valider un plugin ou un répertoire sans manifeste](#validate-a-plugin-or-a-directory-without-a-manifest)
1485* Pour les dépôts privés, confirmez que vous avez les permissions d'accès
1486
1487<h3 id="marketplace-validation-errors">
1488 Erreurs de validation de la place de marché
1489</h3>
1490
1491Exécutez `claude plugin validate .` ou `/plugin validate .` à partir de votre répertoire de place de marché pour vérifier les problèmes. Lorsqu'il est pointé sur un répertoire de place de marché, le validateur vérifie `marketplace.json` pour les erreurs de schéma, les noms de plugins en doublon et la traversée de chemin source. Pour chaque entrée dont la `source` est un chemin local, il valide également le `plugin.json` de ce plugin et avertit lorsque la `version` de l'entrée ne correspond pas à celle dans `plugin.json`. Les problèmes trouvés dans le `plugin.json` d'un plugin sont préfixés par l'index d'entrée, sous la forme `plugins[2] plugin.json →`.
1492
1493À partir de Claude Code v2.1.196, la passe par entrée inclut également :
1494
1495* les plugins dont la `source` est `.`
1496* s'exécute lorsque `marketplace.json` est en dehors d'un répertoire `.claude-plugin`, en résolvant les sources par rapport au répertoire du fichier lui-même
1497* signale les problèmes de chaque entrée même lorsqu'une autre partie du fichier a des erreurs de schéma
1498
1499Les versions antérieures ignorent les plugins à la racine de la place de marché et ne descendent que depuis un `.claude-plugin/marketplace.json`.
1500
1501À partir d'un répertoire de place de marché, Claude Code n'ouvre pas les fichiers de compétence, agent, commande ou hook des plugins. Pour trouver les erreurs dans ces fichiers, consultez [Valider un plugin ou un répertoire sans manifeste](#validate-a-plugin-or-a-directory-without-a-manifest). Le tableau ci-dessous énumère les erreurs les plus courantes d'un répertoire de place de marché, avec la cause et la correction pour chacune :
1502
1503| Erreur | Cause | Solution |
1504| :------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------- |
1505| `No manifest found in directory. Expected .claude-plugin/marketplace.json or .claude-plugin/plugin.json` | Le répertoire que vous avez nommé n'a pas de `.claude-plugin/marketplace.json` ou `plugin.json`, et aucun fichier de compétence, agent ou commande à vérifier | Exécutez à partir de la racine de la place de marché, ou créez `.claude-plugin/marketplace.json` avec les champs obligatoires |
1506| `Invalid JSON syntax: Unexpected token...` | Erreur de syntaxe JSON dans marketplace.json | Vérifiez les virgules manquantes, les virgules supplémentaires ou les chaînes non citées |
1507| `Duplicate plugin name "x" found in marketplace` | Deux plugins partagent le même nom | Donnez à chaque plugin une valeur `name` unique |
1508| `plugins[0].source: Path contains ".."` | Un segment du chemin source est `..` | Utilisez des chemins relatifs à la racine de la place de marché sans segments `..`. Voir [Chemins relatifs](#relative-paths) |
1509| `Marketplace name cannot contain control or bidirectional-formatting characters` | Le nom de la place de marché contient un caractère de formatage bidirectionnel Unicode ou un caractère de contrôle, tel qu'une échappement ou une nouvelle ligne | Supprimez le caractère du nom. Avant v2.1.247, ces caractères produisaient l'erreur `Marketplace name impersonates an official Anthropic/Claude marketplace` |
1510| `Plugin name cannot contain control or bidirectional-formatting characters` | Un nom de plugin contient un caractère de formatage bidirectionnel Unicode ou un caractère de contrôle, tel qu'une échappement ou une nouvelle ligne | Supprimez le caractère du nom. Avant v2.1.247, Claude Code n'exécutait pas cette vérification |
1511
1512**Avertissements** (non bloquants) :
1513
1514* `Marketplace has no plugins defined` : ajoutez au moins un plugin au tableau `plugins`
1515* `No marketplace description provided` : ajoutez une `description` au niveau supérieur pour aider les utilisateurs à comprendre votre place de marché
1516* `Plugin name "x" is not kebab-case` : renommez en minuscules, chiffres et tirets uniquement (par exemple, `my-plugin`). Claude Code accepte d'autres formes, mais la synchronisation de la place de marché claude.ai les rejette.
1517* `Marketplace name "x" is reserved in Claude Desktop` : la place de marché est nommée `org`, `org-provisioned` ou `unknown`, dans n'importe quelle casse. Claude Code accepte ces noms, mais la synchronisation de la place de marché gérée de Claude Desktop rejette la place de marché entière. Renommez la place de marché. Avant v2.1.221, `claude plugin validate` n'exécutait pas cette vérification.
1518* `Marketplace name "x" is not accepted by Claude Desktop` ou `Plugin name "x" is not accepted by Claude Desktop` : Claude Desktop accepte les noms de jusqu'à 128 caractères composés de lettres, chiffres, `.`, `_` et `-`, commençant par une lettre ou un chiffre. Claude Code accepte d'autres formes, mais la synchronisation de la place de marché gérée de Claude Desktop rejette une place de marché dont le nom échoue à la vérification et supprime silencieusement une entrée de plugin dont le nom échoue. Renommez la place de marché ou le plugin. Avant v2.1.221, `claude plugin validate` n'exécutait pas ces vérifications.
1519
1520<h4 id="validate-a-plugin-or-a-directory-without-a-manifest">
1521 Valider un plugin ou un répertoire sans manifeste
1522</h4>
1523
1524Pour trouver les fichiers de compétence, agent et commande dont le frontmatter ne s'analyse pas, exécutez `claude plugin validate` et nommez le répertoire qui les contient. Claude Code ne regarde pas en dehors du répertoire que vous nommez. Chaque exécution sauf une contre un plugin qui a un `plugin.json` nécessite Claude Code v2.1.233 ou ultérieur.
1525
1526<h5 id="pick-the-directory-to-name">
1527 Choisir le répertoire à nommer
1528</h5>
1529
1530Claude Code vérifie différents fichiers selon le répertoire que vous nommez. Trouvez ce que vous voulez vérifier dans la première colonne, et exécutez la commande de cette ligne :
1531
1532| Pour vérifier | Exécutez | Claude Code vérifie |
1533| :----------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
1534| Un plugin qui a un `plugin.json` | `claude plugin validate ./plugins/my-plugin` | `plugin.json`, `hooks/hooks.json`, et les répertoires `skills`, `agents` et `commands` à la racine du plugin |
1535| Un répertoire de compétences, agents ou commandes, comme un plugin qui n'a pas encore de `plugin.json` | `claude plugin validate .claude/skills`, `~/.claude/agents`, ou `./my-plugin/agents` | Chaque fichier de compétence, agent ou commande dans ce répertoire |
1536| Un dossier dont la compétence est son `SKILL.md` racine | `claude plugin validate ./skills`, en nommant le répertoire `skills` qui contient le dossier | Le `SKILL.md` racine de chaque dossier. Le répertoire contenant doit être nommé `skills` ; un dossier sous un autre nom, comme `plugins/`, n'a pas d'exécution qui vérifie son `SKILL.md` racine |
1537| Les trois répertoires d'un projet à la fois | `claude plugin validate .claude`, ou la racine du projet lorsqu'il n'a pas de manifeste `.claude-plugin/` | `.claude/skills`, `.claude/agents` et `.claude/commands` |
1538| Vos répertoires au niveau utilisateur | `claude plugin validate ~/.claude` | `~/.claude/skills`, `~/.claude/agents` et `~/.claude/commands` |
1539
1540<h5 id="check-a-plugin-whose-skill-is-its-root-skill-md">
1541 Vérifier un plugin dont la compétence est son `SKILL.md` racine
1542</h5>
1543
1544Lorsque vous exécutez `claude plugin validate` contre un répertoire de plugin, Claude Code ne vérifie pas un `SKILL.md` à la racine du plugin. Lorsque le plugin se trouve dans un répertoire nommé `skills`, exécutez la commande deux fois :
1545
1546* Nommez ce répertoire `skills` pour vérifier le `SKILL.md` racine du plugin.
1547* Nommez le répertoire du plugin pour vérifier le reste.
1548
1549Lorsque le plugin se trouve sous un autre nom, comme `plugins/`, l'exécution du répertoire `skills` n'est pas disponible, et aucune exécution ne vérifie son `SKILL.md` racine.
1550
1551<h5 id="check-files-behind-symlinks">
1552 Vérifier les fichiers derrière les symlinks
1553</h5>
1554
1555Lorsque vous exécutez `claude plugin validate`, Claude Code ne suit pas les symlinks à l'intérieur du répertoire que vous nommez. Ce qu'il fait dépend de l'endroit où se trouve le lien :
1556
1557* **Un répertoire `skills`, `agents` ou `commands` lié sous la racine du plugin ou `.claude`** : Claude Code avertit que rien dedans n'a été lu.
1558* **Une entrée liée à l'intérieur d'un répertoire `skills`, `agents` ou `commands`** : Claude Code la saute et avertit, par répertoire, combien d'entrées il a sautées qu'une session chargerait.
1559* **Le répertoire `skills`, `agents` ou `commands` que vous nommez est lui-même un symlink, ou son répertoire parent `.claude` est** : Claude Code signale une erreur et ne vérifie rien dedans. Nommez le répertoire réel à la place.
1560
1561Dans deux cas de compétences, l'exécution réussit avec des avertissements. Pour vérifier les fichiers liés, exécutez à nouveau et nommez un répertoire qui les contient directement :
1562
1563* **Un plugin dont le répertoire `skills` [est lié au répertoire skills d'un plugin frère](/docs/fr/plugins-reference#share-files-within-a-marketplace-with-symlinks)** : nommez le répertoire du plugin frère.
1564* **Une [entrée de compétence liée](/docs/fr/skills#where-skills-live) dans `~/.claude/skills` ou `.claude/skills`** : Claude Code suit l'entrée dans une session. Pour la vérifier, nommez un répertoire appelé `skills` qui contient le dossier réel.
1565
1566<h5 id="read-the-validation-results">
1567 Lire les résultats de validation
1568</h5>
1569
1570Une exécution propre se termine par `Validation passed`.
1571
1572`No manifest found in directory` signifie que Claude Code n'a trouvé aucun `plugin.json` ou `marketplace.json` là-bas, et aucun fichier de compétence, agent ou commande dans les répertoires qu'il sonde en dessous. Nommez le répertoire `skills`, `agents` ou `commands` qui contient vos fichiers à la place.
1573
1574Deux des erreurs que Claude Code signale à partir de ces exécutions, avec la correction pour chacune :
1575
1576* `YAML frontmatter failed to parse: ...` : corrigez le YAML dans le bloc frontmatter du fichier de compétence, agent ou commande. Jusqu'à ce que vous le fassiez, une session ne lit aucun champ frontmatter du fichier
1577* `Invalid JSON syntax: ...` sur `hooks/hooks.json` : corrigez la syntaxe JSON. Jusqu'à ce que vous le fassiez, une session charge le plugin sans les hooks dans ce fichier. Claude Code signale cette erreur uniquement dans une exécution de plugin
1578
1579Dans une exécution de plugin, Claude Code avertit également d'un `CLAUDE.md` à la racine du plugin. Pour les chemins que vous définissez via les [champs de chemin de composant](/docs/fr/plugins-reference#component-path-fields) dans `plugin.json`, Claude Code vérifie que chaque chemin existe mais ne lit pas les fichiers là-bas.
1580
1581<h3 id="plugin-installation-failures">
1582 Échecs d'installation de plugins
1583</h3>
1584
1585**Symptômes** : La place de marché apparaît mais l'installation du plugin échoue
1586
1587**Solutions** :
1588
1589* Vérifiez que les URL sources des plugins sont accessibles
1590* Vérifiez que les répertoires des plugins contiennent les fichiers requis
1591* Pour les sources GitHub, assurez-vous que les dépôts sont publics ou que vous avez accès
1592* Testez manuellement les sources de plugins en les clonant/téléchargeant
1593* Si la source épingle à la fois `ref` et `sha`, une branche ou un tag en amont supprimé ne bloque pas l'installation sur la plupart des hôtes git, y compris GitHub, GitLab et Bitbucket. Sur les serveurs qui ne supportent pas la récupération des commits par SHA, comme AWS CodeCommit, le `ref` doit toujours exister et le commit épinglé doit être accessible à partir de celui-ci. Si l'installation échoue toujours, confirmez que le commit épinglé existe toujours dans le dépôt
1594
1595<h3 id="private-repository-authentication-fails">
1596 L'authentification du dépôt privé échoue
1597</h3>
1598
1599**Symptômes** : Erreurs d'authentification lors de l'installation de plugins à partir de dépôts privés
1600
1601**Solutions** :
1602
1603Pour l'installation manuelle et les mises à jour :
1604
1605* Vérifiez que vous êtes authentifié auprès de votre fournisseur git (par exemple, exécutez `gh auth status` pour GitHub)
1606* Vérifiez que votre assistant de credentials est configuré : `git config --global credential.helper`
1607* Exécutez `git ls-remote <marketplace-url>` pour tester si git peut s'authentifier seul. Si git demande un nom d'utilisateur ou un mot de passe, stockez d'abord les credentials : pour GitHub via HTTPS, exécutez `gh auth setup-git`, et pour les dépôts SSH, chargez votre clé dans `ssh-agent`
1608
1609Pour les mises à jour automatiques en arrière-plan :
1610
1611* La vérification en arrière-plan utilise vos assistants de credentials git configurés mais ne demande jamais, donc votre assistant doit pouvoir répondre avec une credential stockée. Les dépôts SSH avec une clé chargée dans `ssh-agent` s'authentifient également
1612* Si votre assistant a besoin de vous demander, la mise à jour en arrière-plan échoue silencieusement et le clone existant reste en place. Connectez-vous à votre assistant d'abord pour qu'il détienne une credential pour l'hôte. Pour GitHub, exécutez `gh auth login`, puis `gh auth setup-git`
1613* Lorsque la vérification trouve de nouveaux commits, ou ne peut pas atteindre ou s'authentifier auprès du serveur distant, Claude Code re-clone la place de marché avec les mêmes credentials. Le re-clone peut expirer sur les grands dépôts
1614* Définissez `CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE=1` pour conserver le clone existant sans tenter le re-clone lorsque la vérification en arrière-plan ne peut pas atteindre ou s'authentifier auprès du serveur distant
1615* Si le re-clonage expire sur un grand dépôt, augmentez la limite avec [`CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS`](#git-operations-time-out)
1616* Ou mettez à jour les places de marché privées manuellement avec `/plugin marketplace update <name>`, qui utilise vos credentials
1617
1618Avant v2.1.280, la vérification en arrière-plan s'exécutait sans vos assistants de credentials et ne pouvait pas s'authentifier auprès des dépôts privés via HTTPS.
1619
1620<h3 id="marketplace-updates-fail-in-offline-environments">
1621 Les mises à jour de la place de marché échouent dans les environnements hors ligne
1622</h3>
1623
1624**Symptômes** : Dans un environnement hors ligne ou isolé, la vérification en arrière-plan de la place de marché ne peut pas atteindre le serveur distant et Claude Code tente à plusieurs reprises un re-clone qui ne peut pas réussir.
1625
1626**Cause** : La vérification en arrière-plan vérifie le serveur distant de la place de marché pour les nouveaux commits, et lorsque la vérification ne peut pas atteindre le serveur distant, Claude Code tente de cloner la place de marché à nouveau. Hors ligne, le clone échoue de la même manière et le clone existant reste en place. Avant v2.1.274, la vérification exécutait `git pull` dans le clone existant, déplaçait le clone de côté pour re-cloner lorsque le pull échouait, et le restaurait ensuite au mieux.
1627
1628La vérification s'exécute en arrière-plan après le démarrage, de sorte qu'elle ne retarde pas le démarrage. Chaque session répète toujours la tentative échouée, et chaque opération git peut attendre le [délai d'expiration de 120 secondes](#git-operations-time-out).
1629
1630**Solution** : Définissez `CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE=1` pour ignorer la tentative de re-clone et continuer à utiliser le clone existant lorsque la vérification ne peut pas atteindre le serveur distant :
1631
1632```bash theme={null}
1633export CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE=1
1634```
1635
1636Pour les déploiements entièrement hors ligne où le dépôt ne sera jamais accessible, utilisez [`CLAUDE_CODE_PLUGIN_SEED_DIR`](#pre-populate-plugins-for-containers) pour pré-remplir le répertoire des plugins au moment de la construction à la place.
1637
1638<h3 id="git-operations-time-out">
1639 Les opérations Git expirent
1640</h3>
1641
1642**Symptômes** : L'installation du plugin ou les mises à jour de la place de marché échouent avec une erreur de délai d'expiration comme `Git clone timed out after 120s`.
1643
1644**Cause** : Claude Code utilise un délai d'expiration de 120 secondes pour toutes les opérations git, y compris le clonage des dépôts de plugins et le re-clonage d'une place de marché pour la mettre à jour. Les grands dépôts ou les connexions réseau lentes peuvent dépasser cette limite.
1645
1646**Solution** : Augmentez le délai d'expiration en utilisant la variable d'environnement `CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS`. La valeur est en millisecondes :
1647
1648```bash theme={null}
1649export CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS=300000 # 5 minutes
1650```
1651
1652<h3 id="plugins-with-relative-paths-fail-in-url-based-marketplaces">
1653 Les plugins avec chemins relatifs échouent dans les places de marché basées sur les URL
1654</h3>
1655
1656**Symptômes** : Vous avez ajouté une place de marché via une URL comme `https://example.com/marketplace.json`, mais les plugins avec des sources de chemin relatif comme `"./plugins/my-plugin"` échouent à installer avec `its marketplace entry path does not stay inside the marketplace directory`. Les plugins déjà installés échouent à charger avec `Plugin source path refused`. Les deux messages ont une [entrée de référence d'erreur](/docs/fr/errors#marketplace-entry-path-does-not-stay-inside-the-marketplace-directory).
1657
1658**Cause** : L'ajout d'une place de marché basée sur les URL télécharge uniquement le fichier `marketplace.json` lui-même, et Claude Code ne récupère pas les fichiers de plugins par chemin relatif à partir de ce serveur. Les chemins relatifs dans l'entrée de la place de marché référencent des fichiers sur le serveur distant qui n'ont pas été téléchargés.
1659
1660**Solutions** :
1661
1662* **Utiliser des sources externes** : changez les entrées de plugins pour n'importe quelle [source de plugin](#plugin-sources) autre qu'un chemin relatif :
1663 ```json theme={null}
1664 { "name": "my-plugin", "source": { "source": "github", "repo": "owner/repo" } }
1665 ```
1666* **Utiliser une place de marché basée sur Git** : Hébergez votre place de marché dans un dépôt Git et ajoutez-la avec l'URL git. Les places de marché basées sur Git clonent le dépôt entier, ce qui rend les chemins relatifs fonctionnels.
1667
1668<h3 id="files-not-found-after-installation">
1669 Fichiers non trouvés après l'installation
1670</h3>
1671
1672**Symptômes** : Le plugin s'installe mais les références aux fichiers échouent, en particulier les fichiers en dehors du répertoire du plugin
1673
1674**Cause** : Claude Code copie les plugins installés vers un répertoire de cache, sauf si le plugin se charge sur place. Une [source `command` en mode lien](#copy-mode-and-link-mode) se charge sur place, tout comme une [source de chemin relatif](#relative-paths) dans une place de marché ajoutée à partir d'un répertoire local. Les chemins qui référencent des fichiers en dehors du répertoire du plugin copié (comme `../shared-utils`) ne fonctionneront pas car ces fichiers ne sont pas copiés.
1675
1676**Solutions** : Consultez [Plugin caching and file resolution](/docs/fr/plugins-reference#plugin-caching-and-file-resolution) pour les solutions de contournement, y compris les symlinks et la restructuration des répertoires.
1677
1678Pour des outils de débogage supplémentaires et des problèmes courants, consultez [Debugging and development tools](/docs/fr/plugins-reference#debugging-and-development-tools).
1679
1680<h2 id="see-also">
1681 Voir aussi
1682</h2>
1683
1684* [Découvrir et installer des plugins préconfigurés](/docs/fr/discover-plugins) - Installation de plugins à partir de places de marché existantes
1685* [Plugins](/docs/fr/plugins) - Création de vos propres plugins
1686* [Référence des plugins](/docs/fr/plugins-reference) - Spécifications techniques complètes et schémas
1687* [Paramètres des plugins](/docs/fr/settings-reference#plugin-settings) - Options de configuration des plugins
1688* [Référence strictKnownMarketplaces](/docs/fr/settings-reference#strictknownmarketplaces) - Restrictions des places de marché gérées