Go Premium Account

plugin-marketplaces.md 2026-09-24 22:57 UTC to 2026-09-25 23:58 UTC

This page contains 0 additions and 1688 deletions.

2026

Wed 9 22:58 Sat 12 03:02 Fri 18 23:58 Wed 23 23:57 Thu 24 22:57 Fri 25 23:58

This document has no rendered page for this history range.

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.~~

~~5# Erstellen und Verteilen eines Plugin-Marktplatzes~~

~~7> Erstellen und hosten Sie Plugin-Marktplätze, um Claude Code-Erweiterungen in Teams und Communities zu verteilen.~~

9Ein **Plugin-Marktplatz** ist ein Katalog, mit dem Sie Plugins an andere verteilen können. Marktplätze bieten zentrale Entdeckung, Versionsverfolgung, automatische Updates und Unterstützung für mehrere Quellentypen, einschließlich Git-Repositories und lokaler Pfade. Diese Anleitung zeigt Ihnen, wie Sie Ihren eigenen Marktplatz erstellen, um Plugins mit Ihrem Team oder Ihrer Community zu teilen.

~~11Möchten Sie Plugins aus einem vorhandenen Marktplatz installieren? Siehe [Entdecken und Installieren vorgefertigter Plugins](/docs/de/discover-plugins).~~

~~13<h2 id="overview">~~

~~14 Übersicht~~

~~15</h2>~~

~~17Das Erstellen und Verteilen eines Marktplatzes umfasst:~~

191. **Plugins erstellen**: Erstellen Sie ein oder mehrere Plugins mit skills, Agents, hooks, MCP servers oder LSP servers. Diese Anleitung setzt voraus, dass Sie bereits Plugins zum Verteilen haben; siehe [Plugins erstellen](/docs/de/plugins) für Details zum Erstellen von Plugins.

~~202. **Marktplatzdatei erstellen**: Definieren Sie eine `marketplace.json`, die Ihre Plugins und deren Speicherorte auflistet. Siehe [Marktplatzdatei erstellen](#create-the-marketplace-file).~~

~~213. **Marktplatz hosten**: Pushen Sie zu GitHub, GitLab oder einem anderen Git-Host. Siehe [Marktplätze hosten und verteilen](#host-and-distribute-marketplaces).~~

224. **Mit Benutzern teilen**: Benutzer fügen Ihren Marktplatz mit `/plugin marketplace add` hinzu und installieren einzelne Plugins. Siehe [Plugins entdecken und installieren](/docs/de/discover-plugins).

~~24Sobald Ihr Marktplatz live ist, können Sie ihn aktualisieren, indem Sie Änderungen in Ihr Repository pushen. Benutzer aktualisieren ihre lokale Kopie mit `/plugin marketplace update`.~~

~~26<h2 id="walkthrough-create-a-local-marketplace">~~

~~27 Anleitung: Erstellen Sie einen lokalen Marktplatz~~

~~28</h2>~~

30Dieses Beispiel erstellt einen Marktplatz mit einem Plugin: ein `quality-review` skill für Code-Reviews. Sie erstellen die Verzeichnisstruktur, fügen ein skill hinzu, erstellen das Plugin-Manifest und den Marktplatzkatalog und installieren und testen ihn dann.

~~32<Steps>~~

~~33 <Step title="Erstellen Sie die Verzeichnisstruktur">~~

~~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>~~

~~41 <Step title="Erstellen Sie das skill">~~

~~42 Erstellen Sie eine `SKILL.md`-Datei, die definiert, was das `quality-review` skill tut.~~

~~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 ---~~

~~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~~

~~55 Be concise and actionable.~~

~~56 ```~~

~~57 </Step>~~

~~59 <Step title="Erstellen Sie das Plugin-Manifest">~~

~~60 Erstellen Sie eine `plugin.json`-Datei, die das Plugin beschreibt. Das Manifest befindet sich im `.claude-plugin/`-Verzeichnis.~~

~~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 ```~~

~~73 <Note>~~

74 Das Festlegen von `version` bedeutet, dass Benutzer nur Updates erhalten, wenn Sie dieses Feld ändern. Erhöhen Sie es daher bei jeder Veröffentlichung. Ein Plugin mit einer [`command` Quelle](#command-sources) wird nicht durch dieses Feld fixiert. Weder ist ein Plugin [in Ort geladen](/docs/de/plugins-reference#plugin-caching-and-file-resolution) aus einem Marktplatz, der als lokales Verzeichnis hinzugefügt wurde. Wenn Sie `version` weglassen, kommt die Version aus der nächsten Quelle in der [Versionsverwaltung](/docs/de/plugins-reference#version-management).

~~75 </Note>~~

~~76 </Step>~~

~~78 <Step title="Erstellen Sie die Marktplatzdatei">~~

~~79 Erstellen Sie den Marktplatzkatalog, der Ihr Plugin auflistet.~~

~~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>~~

~~98 <Step title="Hinzufügen und Installieren">~~

99 Starten Sie Claude Code aus dem Verzeichnis, das `my-marketplace` enthält, und führen Sie die folgenden Befehle aus. Der Installationsbefehl öffnet eine Plugin-Detailansicht, in der Sie einen Installationsbereich auswählen, um die Installation zu bestätigen. Überprüfen Sie die Installationszusammenfassung: Wenn sie `Run /reload-plugins to activate.` meldet, siehe [Plugin-Änderungen ohne Neustart anwenden](/docs/de/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="Probieren Sie es aus">

108 Wählen Sie etwas Code in Ihrem Editor aus und führen Sie Ihr neues skill aus. Plugin-skills sind mit dem Plugin-Namen namespaced.

~~109~~

110 ```shell theme={null}

111 /quality-review-plugin:quality-review

112 ```

113 </Step>

114</Steps>

~~115~~

116Um mehr über die Möglichkeiten von Plugins zu erfahren, einschließlich hooks, Agents, MCP servers und LSP servers, siehe [Plugins](/docs/de/plugins).

~~117~~

118<Note>

119 **Wie Plugins installiert werden**: Wenn Benutzer ein Plugin installieren, kopiert Claude Code das Plugin-Verzeichnis an einen Cache-Speicherort, es sei denn, das Plugin wird in Ort geladen. Eine [`command` Quelle im Link-Modus](#copy-mode-and-link-mode) wird in Ort geladen, und ebenso eine [relative Pfad-Quelle](#relative-paths) in einem Marktplatz, der aus einem lokalen Verzeichnis hinzugefügt wurde. Kopierte Plugins können keine Dateien außerhalb ihres Verzeichnisses mit Pfaden wie `../shared-utils` referenzieren, da diese Dateien nicht kopiert werden.

~~120~~

121 Wenn Sie Dateien über Plugins hinweg teilen müssen, verwenden Sie Symlinks. Siehe [Plugin-Caching und Dateiauflösung](/docs/de/plugins-reference#plugin-caching-and-file-resolution) für Details.

122</Note>

~~123~~

124<h2 id="create-the-marketplace-file">

125 Marktplatzdatei erstellen

126</h2>

~~127~~

128Erstellen Sie `.claude-plugin/marketplace.json` im Stammverzeichnis Ihres Repositories. Diese Datei definiert den Namen Ihres Marktplatzes, Eigentümerinformationen und eine Liste von Plugins mit ihren Quellen.

~~129~~

130Jeder Plugin-Eintrag benötigt mindestens einen `name` und eine `source`, die Claude Code mitteilt, woher es abgerufen werden soll. Siehe das [vollständige Schema](#marketplace-schema) unten für alle verfügbaren Felder.

~~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 Marktplatz-Schema

163</h2>

~~164~~

165<h3 id="required-fields">

166 Erforderliche Felder

167</h3>

~~168~~

170| :-------- | :----- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------- |

171| `name` | string | Marktplatz-Identifier in Kebab-Case, ohne Leerzeichen, Steuerzeichen oder bidirektionale Formatierungszeichen. Dies ist öffentlich sichtbar: Benutzer sehen es beim Installieren von Plugins (z. B. `/plugin install my-tool@your-marketplace`). Jeder Benutzer kann nur einen Marktplatz pro Name registrieren: Wenn er einen zweiten Marktplatz mit demselben Namen hinzufügt, ersetzt Claude Code den ersten. Um mehrere Plugins unter einem Marktplatznamen zu veröffentlichen, listen Sie diese alle in einer [einzelnen `marketplace.json`](#create-the-marketplace-file) auf. | `"acme-tools"` |

~~174~~

175<Note>

176 **Reservierte Namen**: Die folgenden Marktplatznamen sind für die offizielle Nutzung durch Anthropic reserviert und können nicht von Drittanbieter-Marktplätzen verwendet werden: `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`. Namen, die offizielle Marktplätze imitieren, wie `official-claude-plugins` oder `anthropic-plugins-v2`, sind ebenfalls blockiert. Das Reservieren dieser Namen verhindert, dass sich ein Drittanbieter-Marktplatz als von Anthropic veröffentlichte Quelle darstellt.

~~177~~

178 Claude Code überprüft reservierte Namen jedes Mal, wenn es einen Marktplatz lädt, nicht nur wenn Sie einen hinzufügen. Ein Marktplatz, der unter einem dieser Namen registriert wurde, bevor der Name reserviert wurde, wird nicht mehr geladen und meldet, dass er [von einer nicht vertrauenswürdigen Quelle registriert ist](/docs/de/errors#marketplace-is-registered-from-an-untrusted-source). Entfernen Sie diesen Marktplatz und fügen Sie ihn erneut aus der offiziellen Anthropic-Quelle hinzu. Ein Drittanbieter-Marktplatz, der von einem neu reservierten Namen betroffen ist, wird erneut geladen, sobald Sie ihn unter einem anderen Namen erneut hinzufügen. Vor v2.1.205 waren `first-party-plugins` und `healthcare` nicht reserviert, und ein Marktplatz, der bereits unter einem reservierten Namen registriert war, wurde weiterhin geladen. Vor v2.1.265 war `claude-tag-plugins` nicht reserviert.

~~179~~

180 Sie können einen Marktplatz auch nicht `npm`, `pip`, `uv`, `cargo`, `github` oder `gh` nennen, in beliebiger Schreibweise. Diese Überprüfung erfordert Claude Code v2.1.275 oder später.

181</Note>

~~182~~

183<h3 id="owner-fields">

184 Eigentümer-Felder

185</h3>

~~186~~

187| Feld | Typ | Erforderlich | Beschreibung |

188| :------ | :----- | :----------- | :-------------------------------------------- |

~~192~~

193<h3 id="optional-fields">

194 Optionale Felder

195</h3>

~~196~~

197| Feld | Typ | Beschreibung |

198| :------------------------------------ | :----- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

199| `$schema` | string | JSON-Schema-URL für Editor-Autovervollständigung und Validierung. Claude Code ignoriert dieses Feld beim Laden. |

200| `description` | string | Kurze Marktplatzbeschreibung |

201| `version` | string | Marktplatz-Manifest-Version |

202| `metadata.pluginRoot` | string | Verzeichnis, das Claude Code für bare Plugin-Quellnamen auflöst. Siehe [Relative Pfade](#relative-paths). Erfordert Claude Code v2.1.239 oder später. |

203| `allowCrossMarketplaceDependenciesOn` | array | Andere Marktplätze, von denen Plugins in diesem Marktplatz abhängen können. Abhängigkeiten von einem Marktplatz, der hier nicht aufgelistet ist, werden bei der Installation blockiert. Siehe [Von einem Plugin aus einem anderen Marktplatz abhängen](/docs/de/plugin-dependencies#depend-on-a-plugin-from-another-marketplace). |

204| `renames` | object | Zuordnung von einem früheren Plugin-`name` zu seinem aktuellen Namen oder zu `null`, wenn das Plugin entfernt wurde. Ermöglicht es bestehenden Benutzern, automatisch zu migrieren, wenn Sie einen Eintrag in `plugins` umbenennen oder entfernen. Siehe [Plugin umbenennen oder entfernen](#rename-or-remove-a-plugin). Erfordert Claude Code v2.1.193 oder später. |

~~205~~

206`description` und `version` werden auch unter `metadata` für Rückwärtskompatibilität akzeptiert.

~~207~~

208<h2 id="plugin-entries">

209 Plugin-Einträge

210</h2>

~~211~~

212Jeder Plugin-Eintrag im `plugins`-Array beschreibt ein Plugin und wo man es findet. Sie können jedes Feld aus dem [Plugin-Manifest-Schema](/docs/de/plugins-reference#plugin-manifest-schema) einbeziehen, wie `description`, `version`, `author`, `commands` und `hooks`, plus diese Marktplatz-spezifischen Felder: `source`, `category`, `tags`, `strict`, `relevance`, `headers` und `headersHelper`.

~~213~~

214<h3 id="required-fields-2">

215 Erforderliche Felder

216</h3>

~~217~~

218| Feld | Typ | Beschreibung |

219| :------- | :------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

220| `name` | string | Plugin-Identifier in Kebab-Case, ohne Leerzeichen, Steuerzeichen oder bidirektionale Formatierungszeichen. Dies ist öffentlich sichtbar: Benutzer sehen es beim Installieren (z. B. `/plugin install my-plugin@marketplace`). |

~~222~~

223<h3 id="optional-plugin-fields">

224 Optionale Plugin-Felder

225</h3>

~~226~~

227**Standard-Metadatenfelder:**

~~228~~

229| Feld | Typ | Beschreibung |

230| :--------------- | :------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

231| `displayName` | string | Benutzerfreundlicher Name, der in UI-Oberflächen angezeigt wird. Wenn weder der Eintrag noch die `plugin.json` des Plugins einen festlegen, sehen Benutzer den `name` des Plugins. Kann Leerzeichen und beliebige Groß-/Kleinschreibung enthalten. Wird nicht für Namensräume oder Suche verwendet. |

232| `description` | string | Kurze Plugin-Beschreibung |

233| `version` | string | Plugin-Version. Falls gesetzt (hier oder in `plugin.json`), wird das Plugin auf diese Zeichenkette festgelegt und Benutzer erhalten Updates nur, wenn sie sich ändert. Ein Plugin mit einer [`command`-Quelle](#command-sources) wird durch keines der beiden Felder festgelegt. Auch nicht ein Plugin, das [an Ort und Stelle geladen](/docs/de/plugins-reference#plugin-caching-and-file-resolution) wird von einem Marktplatz, der als lokales Verzeichnis hinzugefügt wurde. Falls an keiner Stelle gesetzt, kommt die Version aus der nächsten Quelle in [Versionsverwaltung](/docs/de/plugins-reference#version-management). |

234| `author` | object | Plugin-Autoreninformationen (`name` erforderlich; `email` und `url` optional) |

235| `homepage` | string | Plugin-Homepage oder Dokumentations-URL |

236| `repository` | string | Quellcode-Repository-URL |

237| `license` | string | SPDX-Lizenz-Identifier (z. B. MIT, Apache-2.0) |

238| `keywords` | array | Tags für Plugin-Entdeckung und Kategorisierung |

239| `metadata` | object | Freies Objekt für Ihre eigenen Felder, wie Berechtigung oder Katalogdaten. Claude Code liest es nicht. Vor v2.1.222 meldete `claude plugin validate` den Schlüssel als unbekanntes Feld. |

240| `category` | string | Plugin-Kategorie zur Organisation |

241| `tags` | array | Tags für Suchbarkeit |

242| `strict` | boolean | Steuert, ob `plugin.json` die Autorität für Komponentendefinitionen ist (Standard: true). Siehe [Strict Mode](#strict-mode) unten. |

243| `relevance` | object | Signale, die Claude Code mitteilen, wann dieses Plugin Benutzern empfohlen werden soll. Wirkt sich nur auf Marktplätze aus, die ein Administrator in verwalteten Einstellungen auf die Whitelist setzt. Siehe [Plugins für Ihre Organisation empfehlen](/docs/de/plugin-relevance). |

244| `defaultEnabled` | boolean | Ob das Plugin nach der Installation aktiviert ist (Standard: true). Setzen Sie auf `false`, um das Plugin deaktiviert zu installieren, bis sich der Benutzer anmeldet. Hat Vorrang vor dem gleichen Feld in der `plugin.json` des Plugins. Siehe [Standardaktivierung](/docs/de/plugins-reference#default-enablement). |

~~245~~

246Sowohl der Eintrag als auch die `plugin.json` des Plugins können die Anzeigefelder `displayName`, `description`, `author`, `homepage`, `repository`, `license` und `keywords` festlegen. In Plugin-Auflistungen und Details vor und nach der Installation:

~~247~~

248* Für ein Feld, das Sie im Eintrag festlegen, sehen Benutzer den Wert des Eintrags, auch wenn `plugin.json` einen anderen festlegt.

249* Für ein Feld, das der Eintrag nicht festlegt, sehen Benutzer den `plugin.json`-Wert.

~~250~~

251Vor der Installation kann Claude Code `plugin.json` nur für Einträge mit einer [Relative-Pfad-Quelle](#relative-paths) lesen, deren Plugin-Dateien sich im Marktplatz selbst befinden. Für einen Eintrag mit einem anderen Quellentyp sehen Benutzer nur die eigenen Felder des Eintrags, bis sie das Plugin installieren.

~~252~~

253**Komponenten-Konfigurationsfelder:**

~~254~~

255| Feld | Typ | Beschreibung |

256| :----------- | :------------- | :-------------------------------------------------------------------------------- |

~~263~~

264**Archive-Authentifizierungsfelder:**

~~265~~

266Setzen Sie diese, wenn der Eintrag eine [`archive`-Quelle](#zip-archives) auf einem Server hat, der Anmeldedaten erfordert.

~~267~~

268| Feld | Typ | Beschreibung |

269| :-------------- | :----- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

270| `headers` | object | HTTP-Header, die Claude Code beim Download des Archivs dieses Eintrags sendet. Überschreibt die Header des Marktplatzes mit demselben Namen. Erfordert Claude Code v2.1.238 oder später. |

271| `headersHelper` | string | Befehl, der die HTTP-Header für den Archiv-Download dieses Eintrags als ein JSON-Objekt ausgibt, für eine Berechtigung, die abläuft. Siehe [Archive-Downloads authentifizieren](#authenticate-archive-downloads). Der Eintrag muss auch [`"strict": false`](#strict-mode) setzen. Erfordert Claude Code v2.1.238 oder später. |

~~272~~

273<h2 id="plugin-sources">

274 Plugin-Quellen

275</h2>

~~276~~

277Plugin-Quellen teilen Claude Code mit, wo jedes einzelne Plugin in Ihrem Marktplatz abgerufen werden soll. Diese werden im `source`-Feld jedes Plugin-Eintrags in `marketplace.json` festgelegt.

~~278~~

279Claude Code kopiert jedes installierte Plugin in den lokalen versionierten Plugin-Cache unter `~/.claude/plugins/cache`, außer das Plugin wird an Ort und Stelle geladen. Eine [`command`-Quelle im Link-Modus](#copy-mode-and-link-mode) wird an Ort und Stelle geladen, und ebenso eine [relative Pfad-Quelle](#relative-paths) in einem Marktplatz, der aus einem lokalen Verzeichnis hinzugefügt wurde. Claude Code [installiert auch die berechtigten Node.js-Paketabhängigkeiten des Plugins](/docs/de/plugins-reference#node-js-package-dependencies) in die zwischengespeicherte Kopie. Siehe [Plugin-Caching und Dateiauflösung](/docs/de/plugins-reference#plugin-caching-and-file-resolution), um zu erfahren, wie ein Plugin, das an Ort und Stelle aus einem Marktplatz mit lokalem Verzeichnis geladen wird, Ihre Änderungen übernimmt.

~~280~~

281| Quelle | Typ | Felder | Notizen |

282| -------------- | -------------------------------- | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

283| Relativer Pfad | `string` (z. B. `"./my-plugin"`) | keine | Lokales Verzeichnis im Marktplatz-Repo. Muss mit `./` beginnen, es sei denn, Sie schreiben einen [bloßen Namen unter `metadata.pluginRoot`](#relative-paths). Claude Code löst den Pfad relativ zum Marktplatz-Root auf, nicht zum `.claude-plugin/`-Verzeichnis |

289| `command` | object | `command`, `timeout?`, `mode?` | Plugin-Verzeichnis, das durch Ausführung eines lokalen Befehls erzeugt wird, wird einmal pro Sitzung erneut ausgeführt, um Änderungen zu übernehmen. Erfordert Claude Code v2.1.229 oder später |

~~290~~

291<Note>

292 **Marktplatz-Quellen vs. Plugin-Quellen**: Dies sind unterschiedliche Konzepte, die unterschiedliche Dinge steuern.

~~293~~

294 * **Marktplatz-Quelle**: wo der `marketplace.json`-Katalog selbst abgerufen werden soll. Wird festgelegt, wenn Benutzer `/plugin marketplace add` ausführen oder in `extraKnownMarketplaces`-Einstellungen. Git-basierte Marktplatz-Quellen unterstützen `ref` (Branch/Tag), aber nicht `sha`.

295 * **Plugin-Quelle**: wo ein einzelnes Plugin in der Marktplatz-Liste abgerufen werden soll. Wird im `source`-Feld jedes Plugin-Eintrags in `marketplace.json` festgelegt. Git-basierte Plugin-Quellen unterstützen sowohl `ref` (Branch/Tag) als auch `sha` (exakter Commit).

~~296~~

297 Beispielsweise kann ein Marktplatz, der unter `acme-corp/plugin-catalog` gehostet wird (Marktplatz-Quelle), ein Plugin auflisten, das von `acme-corp/code-formatter` abgerufen wird (Plugin-Quelle). Die Marktplatz-Quelle und die Plugin-Quelle verweisen auf unterschiedliche Repositories und werden unabhängig voneinander angeheftet.

298</Note>

~~299~~

300Die Git-basierten Quellentypen unten sind `github`, `url` und `git-subdir`. Wenn sowohl `ref` als auch `sha` auf einem von ihnen gesetzt sind, ist `sha` die effektive Anheftung. Claude Code ruft den angehefteten Commit direkt ab und checkt ihn aus.

~~301~~

302Auf den meisten Git-Hosts, einschließlich GitHub, GitLab und Bitbucket, bedeutet dies, dass die Installation erfolgreich ist, auch wenn der Branch oder Tag, der durch `ref` benannt wird, inzwischen upstream gelöscht wurde, solange der Commit noch vom Repository aus erreichbar ist. Einige Server, wie AWS CodeCommit, unterstützen das Abrufen von Commits nach SHA nicht. Auf diesen Servern muss `ref` noch vorhanden sein und der angeheftete Commit muss von ihm aus erreichbar sein.

~~303~~

304Wenn Sie Plugins über **Organisationseinstellungen > Plugins** verteilen, sind nur einige Quellentypen zulässig. Siehe [Verteilung über Organisationseinstellungen](#distribute-through-organization-settings).

~~305~~

306<h3 id="relative-paths">

307 Relative Pfade

308</h3>

~~309~~

310Für Plugins im selben Repository verwenden Sie einen Pfad, der mit `./` beginnt:

~~311~~

312```json theme={null}

313{

314 "name": "my-plugin",

315 "source": "./plugins/my-plugin"

316}

317```

~~318~~

319Pfade werden relativ zum Marktplatz-Root aufgelöst, das ist das Verzeichnis, das `.claude-plugin/` enthält. Im obigen Beispiel verweist `./plugins/my-plugin` auf `<repo>/plugins/my-plugin`, obwohl `marketplace.json` unter `<repo>/.claude-plugin/marketplace.json` lebt. Verwenden Sie nicht `../`, um Pfade außerhalb des Marktplatz-Root zu referenzieren. Auf macOS und Linux lehnt Claude Code einen Eintragspfad mit einem Backslash irgendwo nach dem führenden `./` ab, daher schreiben Sie die Trennzeichen auf jeder Plattform als `/`.

~~320~~

321Ein bloßer Name ist ein einzelner Verzeichnisname ohne `/`, wie z. B. `"formatter"`. Um bloße Namen statt `./`-Pfade zu schreiben, setzen Sie [`metadata.pluginRoot`](#optional-fields) auf das Verzeichnis, unter dem sie aufgelöst werden. Mit `"pluginRoot": "./plugins"` löst Claude Code `"source": "formatter"` zu `./plugins/formatter` auf. Erfordert Claude Code v2.1.239 oder später.

~~322~~

323`metadata.pluginRoot` muss selbst ein relativer Pfad im Marktplatz sein. Claude Code ignoriert ihn für eine Quelle, die bereits mit `./` beginnt. Eine Quelle, die ein `/` enthält, wie z. B. `team-a/formatter`, ist kein bloßer Name und benötigt immer noch das `./`-Präfix, auch wenn `metadata.pluginRoot` gesetzt ist.

~~324~~

325<Note>

326 Claude Code löst relative Pfade gegen eine lokale Kopie des Marktplatzes auf, daher funktionieren sie, wenn Benutzer Ihren Marktplatz aus einer Git-Quelle oder einem lokalen Verzeichnis hinzufügen. Wenn Benutzer Ihren Marktplatz über eine direkte URL zur `marketplace.json`-Datei hinzufügen, werden relative Pfade nicht aufgelöst, da nur diese Datei heruntergeladen wird. Verwenden Sie für URL-basierte Verteilung stattdessen eine andere [Plugin-Quelle](#plugin-sources). Siehe [Fehlerbehebung](#plugins-with-relative-paths-fail-in-url-based-marketplaces) für Details.

327</Note>

~~328~~

329<h3 id="github-repositories">

330 GitHub-Repositories

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~~

343Sie können an einen bestimmten Branch, Tag oder Commit anheften:

~~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| Feld | Typ | Beschreibung |

358| :----- | :----- | :-------------------------------------------------------------------------------------- |

359| `repo` | string | Erforderlich. GitHub-Repository im Format `owner/repo` |

360| `ref` | string | Optional. Git-Branch oder Tag (Standard: Standard-Branch des Repositories) |

361| `sha` | string | Optional. Vollständiger 40-stelliger Git-Commit-SHA zum Anheften an eine exakte Version |

~~362~~

363<h3 id="git-repositories">

364 Git-Repositories

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~~

377Sie können an einen bestimmten Branch, Tag oder Commit anheften:

~~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| Feld | Typ | Beschreibung |

392| :---- | :----- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

393| `url` | string | Erforderlich. Vollständige Git-Repository-URL (`https://` oder `git@`). Das `.git`-Suffix ist optional, daher funktionieren Azure DevOps- und AWS CodeCommit-URLs ohne das Suffix |

394| `ref` | string | Optional. Git-Branch oder Tag (Standard: Standard-Branch des Repositories) |

395| `sha` | string | Optional. Vollständiger 40-stelliger Git-Commit-SHA zum Anheften an eine exakte Version |

~~396~~

397<h3 id="git-subdirectories">

398 Git-Unterverzeichnisse

399</h3>

~~400~~

401Verwenden Sie `git-subdir`, um auf ein Plugin zu verweisen, das sich in einem Unterverzeichnis eines Git-Repositories befindet. Claude Code verwendet einen sparsamen, teilweisen Klon, um nur das Unterverzeichnis abzurufen und die Bandbreite für große Monorepos zu minimieren.

~~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~~

414Sie können an einen bestimmten Branch, Tag oder Commit anheften:

~~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~~

429Das `url`-Feld akzeptiert auch eine GitHub-Kurzform (`owner/repo`) oder SSH-URLs (`git@github.com:owner/repo.git`).

~~430~~

431| Feld | Typ | Beschreibung |

432| :----- | :----- | :------------------------------------------------------------------------------------------------- |

433| `url` | string | Erforderlich. Git-Repository-URL, GitHub `owner/repo`-Kurzform oder SSH-URL |

434| `path` | string | Erforderlich. Unterverzeichnispfad im Repo, das das Plugin enthält (z. B. `"tools/claude-plugin"`) |

435| `ref` | string | Optional. Git-Branch oder Tag (Standard: Standard-Branch des Repositories) |

436| `sha` | string | Optional. Vollständiger 40-stelliger Git-Commit-SHA zum Anheften an eine exakte Version |

~~437~~

438<h3 id="npm-packages">

439 npm-Pakete

440</h3>

~~441~~

442Eine npm-Quelle kann jedes Paket in der öffentlichen npm-Registry oder in einer privaten Registry, die Ihr Team hostet, benennen. Claude Code löst das Paket mit Ihrem npm-Client auf, lädt das Tarball herunter und entpackt es in den Plugin-Cache.

~~443~~

444Die Installationsskripte des Pakets, wie z. B. `preinstall` oder `postinstall`, werden niemals ausgeführt, und seine Abhängigkeiten werden während des Abrufs nicht installiert.

~~445~~

446Wenn das Paket eine unterstützte Sperrdatei neben seiner `package.json` enthält, installiert Claude Code diese [Node.js-Paketabhängigkeiten](/docs/de/plugins-reference#node-js-package-dependencies) in einem separaten Schritt, auch mit deaktivierten Skripten. Andernfalls veröffentlichen Sie das Plugin mit allem, was es bereits erstellt benötigt. Ein MCP-Server, der andere Pakete benötigt, kann über `npx` gestartet werden, das sie beim ersten Lauf installiert.

~~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~~

458Um an eine bestimmte Version anzuheften, fügen Sie das `version`-Feld hinzu:

~~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~~

471Um von einer privaten oder internen Registry zu installieren, fügen Sie das `registry`-Feld hinzu:

~~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| Feld | Typ | Beschreibung |

486| :--------- | :----- | :------------------------------------------------------------------------------------------------------------ |

487| `package` | string | Erforderlich. Paketname oder Scoped-Paket (z. B. `@org/plugin`) |

488| `version` | string | Optional. Version oder Versionsspanne (z. B. `2.1.0`, `^2.0.0`, `~1.5.0`) |

489| `registry` | string | Optional. Benutzerdefinierte npm-Registry-URL. Standard ist die System-npm-Registry (normalerweise npmjs.org) |

~~490~~

491<h3 id="zip-archives">

492 Zip-Archive

493</h3>

~~494~~

495Verwenden Sie `archive`, um ein Plugin als Zip-Datei zu verteilen, die Claude Code über HTTPS herunterlädt, damit Installationen ohne Git oder npm auf dem Computer des Benutzers funktionieren. Hosten Sie die Datei auf einem beliebigen statischen Dateiserver oder Artefakt-Repository, wie z. B. einem S3-Bucket, einem Artifactory-Repository für generische Artefakte oder nginx. Erfordert Claude Code v2.1.224 oder später. In den Versionen v2.1.120 bis v2.1.223 schlägt die Installation des Plugins mit `This plugin uses a source type your Claude Code version does not support. Update Claude Code and try again.` fehl; in älteren Versionen kann ein Marktplatz mit einem `archive`-Eintrag überhaupt nicht geladen werden.

~~496~~

497Dieser Eintrag installiert das Plugin aus einer Zip-Datei auf einem Artefakt-Server:

~~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~~

509Wenn Sie die Zip-Datei erstellen, können Sie den Inhalt des Plugins direkt zippen oder den Plugin-Ordner selbst zippen. Claude Code sucht nach `.claude-plugin/` oben im Archiv und dann in einem einzelnen Top-Level-Ordner, daher funktionieren beide Layouts:

~~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 sucht nicht tiefer als einen Ordner, daher schlägt ein Plugin, das tiefer verschachtelt ist, bei der Installation fehl. Claude Code lehnt Archive ab, die größer als 256 MiB sind.

~~520~~

521Um die genaue Datei anzuheften, fügen Sie ein `sha256`-Feld mit dem Digest des Archivs hinzu:

~~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~~

534Wenn die heruntergeladene Datei nicht mit der Anheftung übereinstimmt, lehnt Claude Code die Installation ab und meldet [`Plugin archive integrity check failed`](/docs/de/errors#plugin-archive-integrity-check-failed).

~~535~~

536Archive-Quellen akzeptieren diese Felder:

~~537~~

538| Feld | Typ | Beschreibung |

539| :------- | :----- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

540| `url` | string | Erforderlich. HTTPS-URL des Zip-Archivs. Claude Code lehnt `http://`-URLs sowie Loopback-, Link-Local- und Cloud-Metadaten-Hosts ab. Jeder Umleitungs-Hop muss die gleichen Regeln erfüllen, oder Claude Code lehnt den Download ab |

541| `sha256` | string | Optional. SHA-256-Digest des Archivs als 64 Hex-Zeichen, Groß- oder Kleinbuchstaben. Claude Code überprüft jeden Download dagegen und lehnt die Installation bei einer Nichtübereinstimmung ab |

~~542~~

543Das `sha256`-Digest dient auch als Version des Plugins, wenn weder `plugin.json` noch der Marktplatz-Eintrag eine deklariert. Siehe [Versionsverwaltung](/docs/de/plugins-reference#version-management). Wenn Sie eine `version` deklarieren, ist diese Versionsnummer das Update-Signal, daher müssen Sie nach dem Ändern der Zip-Datei und ihres Digests auch die Version erhöhen, oder Benutzer behalten die zwischengespeicherte Kopie.

~~544~~

545<h4 id="authenticate-archive-downloads">

546 Archive-Downloads authentifizieren

547</h4>

~~548~~

549Um einen Archive-Download zu authentifizieren, wie z. B. einen Download aus einer privaten Registry, setzen Sie die HTTP-Header, die Claude Code damit sendet. Setzen Sie `headers` auf der `url`-Quelle, von der Sie den Marktplatz registriert haben, wie z. B. einem [`extraKnownMarketplaces`](/docs/de/settings-reference#extraknownmarketplaces)-Eintrag. In Claude Code v2.1.238 oder später können Sie ihn stattdessen auf dem Eintrag des Plugins setzen, neben `source`.

~~550~~

551Wenn der Wert, den Sie in `headers` einfügen würden, kurzlebig ist, wie z. B. ein Token, den Ihre Registry auf Anfrage ausstellt, setzen Sie stattdessen einen `headersHelper`-Befehl an derselben Stelle. Claude Code führt den Befehl aus und sendet das JSON-Objekt, das er ausgibt, als Header dieses Ortes. Erfordert Claude Code v2.1.238 oder später.

~~552~~

553Der Ort, den Sie wählen, entscheidet, welche Downloads die Header erhalten und wann Claude Code einen `headersHelper`-Befehl ausführt:

~~554~~

555| Ort | Downloads, die die Header erhalten | Wann Claude Code einen `headersHelper` an diesem Ort ausführt |

556| :---------------------- | :--------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

557| Marktplatz-`url`-Quelle | Archive-Downloads auf dem Ursprung der Marktplatz-URL, d. h. das gleiche Schema, Host und Port | Vor jedem Abrufen der `marketplace.json` des Marktplatzes und vor jedem Archive-Download auf diesem Ursprung. Claude Code verwendet die Ausgabe eines Laufs bis zu 60 Sekunden lang erneut |

558| Plugin-Eintrag | Nur der Download dieses Eintrags | Nur wenn ein Benutzer dieses eine Plugin selbst installiert oder aktualisiert und [den Befehl akzeptiert](#how-users-accept-a-headershelper-command) |

~~559~~

560Wenn beide Orte einen Header mit dem gleichen Namen setzen, sendet Claude Code den Wert des Eintrags. Innerhalb eines Ortes überschreibt ein Header, den der Befehl ausgibt, einen Header mit dem gleichen Namen in der `headers`-Liste.

~~561~~

562<h5 id="add-a-headershelper-to-a-plugin-entry">

563 Fügen Sie einen headersHelper zu einem Plugin-Eintrag hinzu

564</h5>

~~565~~

566Dieser Eintrag setzt `headersHelper` neben `source`. Er setzt auch `"strict": false`, was Claude Code von einem `marketplace.json`-Eintrag verlangt, der `headersHelper` setzt. Mit [`"strict": false`](#strict-mode) ist der Marktplatz-Eintrag die gesamte Definition des Plugins, daher kann ein Benutzer überprüfen, was das Plugin enthält, bevor er den Befehl akzeptiert:

~~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~~

582Um den Eintrag zu überprüfen, führen Sie `claude plugin install my-plugin@your-marketplace` aus. Claude Code zeigt Ihnen den Befehl und die Archive-URL und lädt die Zip-Datei herunter, nachdem Sie akzeptieren.

~~583~~

584Vor v2.1.238 hat Claude Code das Archive eines Eintrags ohne seine `headers` oder `headersHelper` heruntergeladen, daher schlugen Installationen, die sich darauf verließen, mit `HTTP 401 while downloading plugin archive from` fehl, gefolgt von der URL, mit dem Status-Code der Registry anstelle von 401.

~~585~~

586<h4 id="write-the-headershelper-command">

587 Schreiben Sie den headersHelper-Befehl

588</h4>

~~589~~

590Ob Sie `headersHelper` auf einer Marktplatz-`url`-Quelle oder auf einem Plugin-Eintrag setzen, schreiben Sie den Befehl, um diese Anforderungen zu erfüllen:

~~591~~

592* **Befehlstext**: höchstens 500 Zeichen druckbares ASCII, ohne Lauf von vier oder mehr Leerzeichen.

593* **Ausgabe**: geben Sie ein JSON-Objekt von Header-Namen und Zeichenkettenwerten auf stdout aus, dann beenden Sie mit 0 innerhalb von 10 Sekunden.

594* **Shell und Arbeitsverzeichnis**: Claude Code führt den Befehl durch `sh` oder `cmd.exe` unter Windows aus, vom Konfigurationsverzeichnis, `~/.claude` oder [`CLAUDE_CONFIG_DIR`](/docs/de/env-vars#variables). Geben Sie einen absoluten Pfad oder einen Befehl auf `PATH` an, da ein relativer Pfad gegen dieses Verzeichnis aufgelöst wird, nicht gegen das Projekt des Benutzers.

595* **Variablen, die Claude Code entfernt**: aus der Umgebung eines Befehls, der in einem `marketplace.json`-Eintrag oder in einer Projekt-`.claude/settings.json` oder `.claude/settings.local.json` gesetzt ist, entfernt Claude Code jede Variable, deren Name ein Wort wie `TOKEN`, `SECRET`, `KEY` oder `AUTH` enthält, einschließlich `ANTHROPIC_API_KEY`. Claude Code wendet diese Entfernung nicht auf einen Befehl an, der in Benutzereinstellungen, einer `--settings`-Datei oder verwalteten Einstellungen gesetzt ist.

596* **Variablen, die Claude Code setzt**: `CLAUDE_CODE_MARKETPLACE_URL` und `CLAUDE_CODE_MARKETPLACE_NAME` für den Befehl einer `url`-Quelle, und `CLAUDE_CODE_PLUGIN_NAME` und `CLAUDE_CODE_PLUGIN_ARCHIVE_URL` für den Befehl eines Eintrags. `CLAUDE_CODE_MARKETPLACE_NAME` ist beim ersten Abrufen nach dem Hinzufügen eines Marktplatzes durch URL nicht gesetzt, da dieses Abrufen der Name liefert.

~~597~~

598Ein Befehl, der ein Bearer-Token ausstellt, gibt ein Objekt wie dieses aus:

~~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 Wenn Claude Code einen headersHelper-Befehl überspringt oder seine Ausgabe verwirft

606</h4>

~~607~~

608Claude Code führt einen `headersHelper`-Befehl nicht aus oder verwirft Header, die von `headers` oder vom Befehl's Ausgabe kamen, in diesen Situationen:

~~609~~

610* **Befehl schlägt fehl**: Wenn der Befehl mit Nicht-Null beendet wird, länger als 10 Sekunden läuft oder etwas anderes als ein JSON-Objekt von Zeichenkettenwerten ausgibt, macht Claude Code den Abruf oder Download nicht, für den er den Befehl ausgeführt hat.

611* **Marktplatz-URL beginnt nicht mit `https://`**: Claude Code führt den Befehl dieser `url`-Quelle nicht aus und sendet nur die in ihrem `headers`-Feld aufgelisteten Header.

612* **Umleitung verlässt den Ursprung**: Wenn ein Download von der Archive-URL's Ursprung umgeleitet wird, verwirft Claude Code die `headers`-Werte und die Befehlsausgabe sowohl der Marktplatz-`url`-Quelle als auch des Plugin-Eintrags.

613* **Eintrag setzt einen Routing- oder Identity-Header**: Claude Code verwirft Request-Routing- und Client-Identity-Namen wie `Host`, `Cookie` und `X-Forwarded-*` aus einem Eintrag's `headers` und Befehlsausgabe und behält Authentifizierungsnamen wie `Authorization`. Claude Code filtert jeden `marketplace.json`-Eintrag auf diese Weise und einen [Inline-Einstellungseintrag](/docs/de/settings-reference#extraknownmarketplaces) je nachdem, welche Datei ihn deklariert.

614* **Befehl in den Einstellungen eines `--add-dir`-Verzeichnisses gesetzt**: Claude Code ignoriert ihn, auf einer `url`-Quelle und auf einem [Inline-Plugin-Eintrag](/docs/de/settings-reference#extraknownmarketplaces) gleichermaßen, und sendet nur die `headers` dieser Datei.

615* **Verwaltete Einstellungen blockieren den Befehl**: Das Setzen von [`disableCommandPluginSources`](/docs/de/settings-reference#disablecommandpluginsources) auf `true` blockiert `headersHelper`-Befehle, und [`allowManagedHooksOnly`](/docs/de/settings-reference#allowmanagedhooksonly) blockiert sie auch, es sei denn, `disableCommandPluginSources` ist explizit `false`. Unter einer dieser Blockierungen führt Claude Code den Befehl immer noch für einen Marktplatz aus, den verwaltete Einstellungen selbst deklarieren.

~~616~~

617<h4 id="how-users-accept-a-headershelper-command">

618 Wie Benutzer einen headersHelper-Befehl akzeptieren

619</h4>

~~620~~

621Ein Benutzer akzeptiert den Befehl eines Plugin-Eintrags jedes Mal, wenn er dieses eine Plugin selbst installiert oder aktualisiert, aus der eigenen Ansicht des Plugins in `/plugin` oder mit `claude plugin install` oder `claude plugin update`. Claude Code zeigt den Befehl und die Archive-URL und führt den Befehl nur aus, nachdem der Benutzer akzeptiert.

~~622~~

623In einer nicht-interaktiven Shell übergeben Sie [`--yes`](/docs/de/plugins-reference#plugin-install), um den Befehl zu akzeptieren. Um nur den Befehl zu akzeptieren, den ein vorheriger `--json`-Lauf angezeigt hat, übergeben Sie [`--accept-command`](/docs/de/plugins-reference#plugin-install) mit dem `sha256`, den der Lauf gemeldet hat.

~~624~~

625Claude Code führt nur den Befehl aus, den er angezeigt hat, für die Archive-URL, die er angezeigt hat. Wenn sich der Befehl oder die Archive-URL des Eintrags dazwischen geändert haben, lehnt Claude Code die Installation oder Aktualisierung ab. Eine Änderung nur in der Abfragezeichenkette zählt nicht.

~~626~~

627<h5 id="installs-and-updates-that-refuse-the-command-instead-of-asking">

628 Installationen und Aktualisierungen, die den Befehl ablehnen, statt zu fragen

629</h5>

~~630~~

631Bei jeder Operation außer einer einzelnen Plugin-Installation oder Aktualisierung führt Claude Code den Befehl eines Eintrags nicht aus und lädt sein Archive nicht herunter, daher bleibt das Plugin bei seiner installierten Version oder bleibt deinstalliert. Was der Benutzer sieht, hängt von der Operation ab:

~~632~~

633* **Installation mehrerer Plugins gleichzeitig, aus einem Plugin-Vorschlag oder als Abhängigkeit eines anderen Plugins**: Claude Code lehnt das Plugin mit dem Befehl ab und verweist den Benutzer auf die eigene Ansicht dieses Plugins in `/plugin`. Die anderen Plugins in einer Masseninstallation werden immer noch installiert. Ein Plugin, das vom abgelehnten Plugin abhängt, schlägt bei der Installation fehl, bis der Benutzer das abgelehnte Plugin selbst installiert.

634* **Hintergrund-Auto-Update oder Sitzungsstart für ein Plugin, dessen Archive nie heruntergeladen wurde**: Claude Code listet das Plugin auf der Registerkarte `/plugin` Fehler auf, damit der Benutzer weiß, dass er es manuell installieren oder aktualisieren muss. Ein Auto-Update, das die Ankündigung der installierten Version findet, listet nichts auf.

~~635~~

636<h5 id="when-a-marketplace-url-source’s-command-runs">

637 Wenn der headersHelper-Befehl einer Marktplatz-`url`-Quelle ausgeführt wird

638</h5>

~~639~~

640Ein `headersHelper` einer Marktplatz-`url`-Quelle wird in einer Einstellungsdatei deklariert, wie z. B. einem [`extraKnownMarketplaces`](/docs/de/settings-reference#extraknownmarketplaces)-Eintrag, statt im Katalog, den der Marktplatz veröffentlicht, daher fragt Claude Code den Benutzer nicht, ihn bei jeder Installation oder Aktualisierung zu akzeptieren. Die Einstellungsdatei, die ihn deklariert, entscheidet, wann Claude Code ihn ausführt:

~~641~~

642| Einstellungsdatei | Wann Claude Code den Befehl ausführt |

643| :----------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

644| Benutzereinstellungen, eine `--settings`-Datei oder eine verwaltete Einstellungsdatei auf dem Computer | Ohne zu fragen, einschließlich während einer Hintergrund-Marktplatz-Aktualisierung |

645| Eine Projekt-`.claude/settings.json` oder `.claude/settings.local.json` | Nur nachdem der Benutzer den [Workspace-Trust-Dialog](/docs/de/permissions#what-runs-before-you-trust-a-folder) für diesen Ordner selbst akzeptiert. Eine `-p`- oder SDK-Sitzung zählt nicht als Akzeptanz, und auch nicht das Vertrauen, das einem übergeordneten Ordner gewährt wird |

646| Server-verwaltete Einstellungen | Nur nachdem der Benutzer die bereitgestellten Einstellungen im [Sicherheitsgenehmigungsdialog](/docs/de/server-managed-settings#security-approval-dialogs) genehmigt |

~~647~~

648In einer `-p`- oder SDK-Sitzung kann Claude Code den Sicherheitsgenehmigungsdialog nicht anzeigen. Es wendet die anderen bereitgestellten Einstellungen an, aber der Marktplatz-Abruf und jeder Archive-Download, der den Befehl benötigt, schlägt fehl, bis ein Benutzer in einer interaktiven Sitzung genehmigt hat.

~~649~~

650Für einen [Inline-Plugin-Eintrag](/docs/de/settings-reference#extraknownmarketplaces) in einer dieser Dateien verlangt Claude Code das gleiche Ordner-Vertrauen oder die gleiche Einstellungsgenehmigung wie für einen Marktplatz-Befehl in dieser Datei, und der Benutzer akzeptiert auch den Befehl des Eintrags bei jeder Installation oder Aktualisierung.

~~651~~

652<h3 id="command-sources">

653 Command-Quellen

654</h3>

~~655~~

656Verwenden Sie `command`, wenn ein lokal installiertes Tool das Plugin-Verzeichnis erzeugt, wie z. B. eine IDE, die ihr Plugin für die aktuell ausgewählte Toolchain rendert. Claude Code führt den Befehl aus, wenn der Benutzer das Plugin installiert, und führt ihn im Hintergrund einmal pro Sitzung erneut aus, damit Ihre Benutzer die geänderte Ausgabe des Tools ohne Neuinstallation übernehmen. Erfordert Claude Code v2.1.229 oder später. In v2.1.120 bis v2.1.228 schlägt die Installation des Plugins mit `This plugin uses a source type your Claude Code version does not support. Update Claude Code and try again.` fehl, und in älteren Versionen kann der ganze Marktplatz nicht geladen werden.

~~657~~

658Dieser Eintrag installiert das Plugin aus dem Verzeichnis, das das Tool ausgibt:

~~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 führt den Befehl durch die Plattform-Shell aus, `sh` unter macOS und Linux oder `cmd.exe` unter Windows, vom Home-Verzeichnis des Benutzers. Der Befehl muss genau eine Zeile auf stdout ausgeben und mit Code 0 beenden. Diese Zeile ist der absolute Pfad eines Verzeichnisses, das das komplette Plugin enthält, wenn der Befehl beendet wird, und der Pfad kann sich zwischen Läufen ändern.

~~671~~

672Claude Code stoppt einen Befehl, der länger als `timeout` Sekunden läuft, und die Installation oder Aktualisierung schlägt fehl. Claude Code lehnt auch den ausgegebenen Pfad in diesen Fällen ab, und die Installation oder Aktualisierung schlägt auf die gleiche Weise fehl:

~~673~~

674* Das Verzeichnis hat keinen Plugin-Inhalt auf seiner obersten Ebene, wie z. B. ein `.claude-plugin/`-Verzeichnis oder ein `skills/`-, `commands/`-, `agents/`- oder `hooks/`-Verzeichnis

675* Das Verzeichnis ist das, in dem Claude Code gestartet wurde, oder eines seiner übergeordneten Verzeichnisse

676* Unter Windows ist der Pfad ein UNC-Pfad

~~677~~

678Command-Quellen akzeptieren diese Felder:

~~679~~

680| Feld | Typ | Beschreibung |

681| :-------- | :----- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

682| `command` | string | Erforderlich. Shell-Befehl, der den absoluten Pfad des Plugin-Verzeichnisses als einzelne Zeile auf stdout ausgibt und 0 beendet. Muss druckbares ASCII sein, höchstens 500 Zeichen, ohne Läufe von vier oder mehr Leerzeichen, damit Benutzer den ganzen Befehl überprüfen können, den sie akzeptieren sollen |

683| `timeout` | number | Optional. Ganze Anzahl von Sekunden, die auf den Befehl gewartet werden soll, bevor aufgegeben wird (Standard: 60, Maximum: 600) |

684| `mode` | string | Optional. `"copy"` (Standard) kopiert das ausgegebene Verzeichnis in den Plugin-Cache. `"link"` verwendet das ausgegebene Verzeichnis an Ort und Stelle. Siehe [Copy-Modus und Link-Modus](#copy-mode-and-link-mode) |

~~685~~

686<h4 id="copy-mode-and-link-mode">

687 Copy-Modus und Link-Modus

688</h4>

~~689~~

690Mit dem Standard `"mode": "copy"` kopiert Claude Code das ausgegebene Verzeichnis in den versionierten Plugin-Cache und leitet die [Plugin-Version](/docs/de/plugins-reference#version-management) von einem Hash des Verzeichnisinhalts ab. Ihr Tool kann das Verzeichnis nach dem Befehlsende löschen oder umschreiben, und ein erneuter Lauf, der identischen Inhalt erzeugt, zählt als aktuell. Claude Code lehnt die Installation eines Verzeichnisses ab, das größer als 256 MiB ist oder mehr als 20.000 Einträge enthält.

~~691~~

692Setzen Sie `"mode": "link"` für große Plugin-Verzeichnisse, die nicht kopiert werden sollten, wie z. B. ein gerenderter SDK-Export. Claude Code füllt den Plugin-Cache-Eintrag mit einem Link zu jedem Top-Level-Eintrag des ausgegebenen Verzeichnisses und verwendet die Dateien an Ort und Stelle, daher wird nichts kopiert, Dateiinhalte werden nicht gehasht, und die Größenlimits gelten nicht. Die Installation schlägt fehl, wenn ein Top-Level-Eintrag ein Symlink ist, der außerhalb des ausgegebenen Verzeichnisses verweist. Claude Code überspringt auch die [Node.js-Paketabhängigkeitsinstallation](/docs/de/plugins-reference#node-js-package-dependencies) für ein Link-Modus-Plugin, daher geben Sie ein Verzeichnis aus, das bereits alle `node_modules` enthält, die das Plugin benötigt.

~~693~~

694Halten Sie das ausgegebene Verzeichnis an Ort und Stelle, solange das Plugin installiert bleibt, da Claude Code das Plugin bei jedem Start durch diese Links lädt. Claude Code leitet die [Plugin-Version](/docs/de/plugins-reference#version-management) vom echten Pfad des ausgegebenen Verzeichnisses und seinen Top-Level-Einträgen ab, nicht von den Dateien darin, daher geben Sie einen anderen Pfad aus, um neuen Inhalt zu signalisieren. In einer Sitzung, die im ausgegebenen Verzeichnis oder irgendwo darunter gestartet wird, lädt Claude Code das Plugin überhaupt nicht.

~~695~~

696Claude Code unterstützt Link-Modus nicht unter Windows und lehnt die Installation eines Link-Modus-Plugins dort ab. Deklarieren Sie stattdessen `"mode": "copy"`.

~~697~~

698<h4 id="how-users-accept-the-command">

699 Wie Benutzer den Befehl akzeptieren

700</h4>

~~701~~

702Claude Code führt Ihren Befehl auf dem Computer des Benutzers aus, daher bindet jeder Lauf an die explizite Akzeptanz des Benutzers:

~~703~~

704* Wenn Benutzer das Plugin aus seinem Detailbildschirm in `/plugin` installieren oder es mit `claude plugin install` oder `claude plugin update` in einem interaktiven Terminal installieren oder aktualisieren, zeigt Claude Code ihnen zuerst die genaue Befehlszeichenkette und zeichnet den akzeptierten Befehl für diese Installation auf. Ein `claude plugin update`, das auf der aufgezeichneten Akzeptanz des gleichen Befehls fortfahren kann, zeigt nichts.

705* In einer nicht-interaktiven Shell, wie z. B. einem Bereitstellungsskript, übergeben Sie `--yes` an `claude plugin install` oder `claude plugin update`, um den Befehl zu akzeptieren, den es ausgibt. Um nur den Befehl zu akzeptieren, den ein vorheriger `--json`-Lauf angezeigt hat, übergeben Sie [`--accept-command`](/docs/de/plugins-reference#plugin-install) mit dem `sha256`, den der Lauf gemeldet hat.

706* Jeder andere Pfad führt nur den Befehl aus, den der Benutzer bereits akzeptiert hat. Dies umfasst Updates, die von `/plugin` gestartet werden, und die Hintergrund-Läufe, die in [Wenn Claude Code den Befehl erneut ausführt](#when-claude-code-re-runs-the-command) beschrieben sind. Wenn keiner akzeptiert wurde, lehnt Claude Code die Ausführung des Befehls ab und teilt dem Benutzer mit, wie er ihn überprüfen kann. Claude Code installiert niemals ein Command-Quellen-Plugin als Abhängigkeit eines anderen Plugins, daher installieren Benutzer es selbst zuerst.

707* Wenn Sie den Eintrag's `command` ändern oder seinen `mode` wechseln, behalten Benutzer die Version, die sie bereits haben, und Claude Code stoppt die erneute Ausführung des Befehls. In interaktiven Sitzungen zeigt die Registerkarte `/plugin` Fehler den neuen Befehl, bis der Benutzer ihn überprüft und akzeptiert, indem er `claude plugin update <plugin>@<marketplace>` ausführt.

~~708~~

709Administratoren können Command-Quellen in einer Organisation mit der verwalteten Einstellung [`disableCommandPluginSources`](/docs/de/settings-reference#disablecommandpluginsources) blockieren. Wenn eine Organisation [`allowManagedHooksOnly`](/docs/de/settings-reference#allowmanagedhooksonly) setzt, blockiert Claude Code Command-Quellen standardmäßig.

~~710~~

711<h4 id="when-claude-code-re-runs-the-command">

712 Wenn Claude Code den Befehl erneut ausführt

713</h4>

~~714~~

715Das ausgegebene Verzeichnis spiegelt den Zustand des Tools zum Zeitpunkt der Befehlsausführung wider, daher führt Claude Code den Befehl zu diesen Zeiten erneut aus:

~~716~~

717* Jedes Mal, wenn der Benutzer das Plugin installiert oder aktualisiert

718* Einmal pro Sitzung für jedes aktivierte Command-Quellen-Plugin, im Hintergrund, kurz nach dem Sitzungsstart. Dieser Lauf geht nicht durch die Marktplatz-Auto-Update, daher hängt er nicht von der [Auto-Update-Einstellung](/docs/de/discover-plugins#configure-auto-updates) des Marktplatzes ab

719* Beim Start oder auf `/reload-plugins`, wenn die installierte Version eines aktivierten Plugins im Plugin-Cache fehlt

~~720~~

721Claude Code überspringt die zwei Hintergrund-Läufe, wenn der Benutzer [`CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC`](/docs/de/env-vars) setzt. Explizite Installationen und Aktualisierungen führen den Befehl immer noch mit dieser Variable gesetzt aus.

~~722~~

723Wenn sich die gehashte Ausgabe des Befehls geändert hat, installiert Claude Code das Ergebnis als neue Version und lädt es in der laufenden interaktiven Sitzung erneut, wobei [die gleichen Komponenten gewechselt werden, die `/reload-plugins` wechselt](/docs/de/plugins-reference#environment-variables). Der Benutzer sieht eine Benachrichtigung, dass das Plugin erneut geladen wurde. Wenn das Neuladen an Ort und Stelle den Prompt-Cache der Sitzung ungültig machen würde, fordert Claude Code den Benutzer stattdessen auf, `/reload-plugins` auszuführen, was [vor den Cache-Kosten warnt und angewendet wird, wenn es mit `--force` erneut ausgeführt wird](/docs/de/prompt-caching#enabling-or-disabling-a-plugin).

~~724~~

725<h3 id="advanced-plugin-entries">

726 Erweiterte Plugin-Einträge

727</h3>

~~728~~

729Dieses Beispiel zeigt einen Plugin-Eintrag mit vielen optionalen Feldern, einschließlich benutzerdefinierter Pfade für Befehle, Agents, hooks und MCP-Server:

~~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~~

778Wichtige Dinge zu beachten:

~~779~~

780* **`commands` und `agents`**: Sie können mehrere Verzeichnisse oder einzelne Dateien angeben. Pfade sind relativ zum Plugin-Root und müssen darin bleiben.

781 * Claude Code lehnt einen Pfad ab, der außerhalb des Plugin-Verzeichnisses aufgelöst wird, wie z. B. `./../shared.md`, mit einem [`path escapes plugin directory`](/docs/de/errors#path-escapes-plugin-directory)-Fehler ab und lädt das Plugin immer noch ohne diese Komponente

782* **`${CLAUDE_PLUGIN_ROOT}`**: Verwenden Sie diese Variable in Hook-Befehlen und MCP-Server-Konfigurationen, um auf Dateien im Installationsverzeichnis des Plugins zu verweisen.

783 * Siehe die [Substitutionstabelle](/docs/de/plugins-reference#environment-variables) für welche Konfigurationsfelder sie pro Servertyp ersetzen

784 * Verwenden Sie für Abhängigkeiten oder Status, die Plugin-Updates überstehen sollten, stattdessen [`${CLAUDE_PLUGIN_DATA}`](/docs/de/plugins-reference#persistent-data-directory)

785* **`strict: false`**: Da dies auf false gesetzt ist, benötigt das Plugin keine eigene `plugin.json`. Der Marktplatz-Eintrag definiert alles. Siehe [Strict Mode](#strict-mode) unten.

~~786~~

787Standardmäßig werden die Skills eines Plugins aus dem `skills/`-Verzeichnis unter seiner `source` geladen. Pfade, die im `skills`-Feld aufgelistet sind, werden zu diesem Scan hinzugefügt:

~~788~~

789```json theme={null}

790"skills": ["./skills/", "./extra-skills/"]

791```

~~792~~

793Wenn mehrere Plugin-Einträge einen `skills/`-Ordner im Marktplatz-Root gemeinsam nutzen (`source: "./"`), listen Sie stattdessen bestimmte Unterverzeichnisse auf, damit jeder Eintrag nur seine eigenen Skills lädt:

~~794~~

795```json theme={null}

796"source": "./",

797"skills": ["./skills/code-review", "./skills/docs"]

798```

~~799~~

800Mit einer Marktplatz-Root-Quelle ist die aufgelistete Pfadliste die vollständige Menge für diesen Eintrag, und andere Verzeichnisse im gemeinsamen `skills/`-Ordner werden nicht geladen. Das Auflisten des `skills/`-Verzeichnisses selbst oder des Plugin-Root behält den vollständigen Scan bei. Wenn keiner der aufgelisteten Pfade existiert, wird stattdessen der Standard-Scan ausgeführt.

~~801~~

802<h3 id="strict-mode">

803 Strict Mode

804</h3>

~~805~~

806Das `strict`-Feld steuert, ob `plugin.json` die Autorität für Komponentendefinitionen ist (skills, Agents, hooks, MCP-Server, Ausgabestile).

~~807~~

808| Wert | Verhalten |

809| :---------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

810| `true` (Standard) | `plugin.json` ist die Autorität. Der Marktplatz-Eintrag kann es mit zusätzlichen Komponenten ergänzen, und beide Quellen werden zusammengeführt. |

811| `false` | Der Marktplatz-Eintrag ist die gesamte Definition. Wenn das Plugin auch eine `plugin.json` hat, die Komponenten deklariert, ist das ein Konflikt und das Plugin kann nicht geladen werden. |

~~812~~

813**Wann jeder Modus verwendet werden sollte:**

~~814~~

815* **`strict: true`**: Das Plugin hat seine eigene `plugin.json` und verwaltet seine eigenen Komponenten. Der Marktplatz-Eintrag kann zusätzliche Skills oder hooks hinzufügen. Dies ist der Standard und funktioniert für die meisten Plugins.

816* **`strict: false`**: Der Marktplatz-Betreiber möchte vollständige Kontrolle. Das Plugin-Repo stellt Rohdateien bereit, und der Marktplatz-Eintrag definiert, welche dieser Dateien als Skills, Agents, hooks usw. verfügbar gemacht werden. Nützlich, wenn der Marktplatz die Komponenten eines Plugins anders strukturiert oder kuratiert als vom Plugin-Autor beabsichtigt.

~~817~~

818<h2 id="host-and-distribute-marketplaces">

819 Marktplätze hosten und verteilen

820</h2>

~~821~~

822Wenn Benutzer einen in einem Git-Repository gehosteten Marktplatz hinzufügen oder ein Git-basiertes Plugin installieren, das dieser auflistet, klont Claude Code diesen Marktplatz oder das Plugin-Repository auf ihre Maschine. Der Klon lädt niemals [Git LFS](https://git-lfs.com)-Inhalte herunter, daher kommen LFS-verfolgte Dateien als Zeigerdateien an. Halten Sie die Dateien, die Ihre Plugins benötigen, aus LFS heraus.

~~823~~

824<h3 id="host-on-github-recommended">

825 Auf GitHub hosten (empfohlen)

826</h3>

~~827~~

828GitHub ist die empfohlene Methode zum Hosten und Verteilen eines Marktplatzes:

~~829~~

8301. **Repository erstellen**: Richten Sie ein neues Repository für Ihren Marktplatz ein

8312. **Marktplatzdatei hinzufügen**: Erstellen Sie `.claude-plugin/marketplace.json` mit Ihren Plugin-Definitionen

8323. **Mit Teams teilen**: Benutzer fügen Ihren Marktplatz mit `/plugin marketplace add owner/repo` hinzu

~~833~~

834**Vorteile**: Integrierte Versionskontrolle, Issue-Tracking und Team-Zusammenarbeitsfunktionen.

~~835~~

836<h3 id="host-on-other-git-services">

837 Auf anderen Git-Services hosten

838</h3>

~~839~~

840Jeder Git-Hosting-Service funktioniert, wie GitLab, Bitbucket und selbstgehostete Server. Benutzer fügen mit der vollständigen Repository-URL hinzu:

~~841~~

842```shell theme={null}

843/plugin marketplace add https://gitlab.com/company/plugins.git

844```

~~845~~

846<h3 id="private-repositories">

847 Private Repositories

848</h3>

~~849~~

850Claude Code unterstützt die Installation von Plugins aus privaten Repositories. Wenn Sie Ihren Marktplatz stattdessen über [**Organisationseinstellungen > Plugins**](https://claude.ai/admin-settings/plugins) verteilen, sind Ihre Git-Anmeldedaten nicht beteiligt: Die Organisationssynchronisierung liest das Marktplatz-Repository über Ihre Organisation's GitHub- oder GitLab-Verbindung auf claude.ai. Siehe [Über Organisationseinstellungen verteilen](#distribute-through-organization-settings) für die Regeln, welche Plugin-Quellen privat sein können.

~~851~~

852<h4 id="commands-you-run">

853 Befehle, die Sie ausführen

854</h4>

~~855~~

856Wenn Sie `/plugin marketplace add`, `/plugin install`, `/plugin update` oder `/plugin marketplace update` ausführen, verwendet Claude Code Ihre vorhandenen Git-Credential-Helper, daher funktioniert HTTPS-Zugriff über `gh auth login`, macOS Keychain oder `git-credential-store` genauso wie in Ihrem Terminal. SSH-Zugriff funktioniert, solange der Host bereits in Ihrer `known_hosts`-Datei vorhanden ist und der Schlüssel in `ssh-agent` geladen ist, da Claude Code interaktive SSH-Eingabeaufforderungen für den Host-Fingerprint und die Schlüsselpassphrase unterdrückt. GitHub `owner/repo`-Kurzform-Quellen klonen standardmäßig über SSH; legen Sie [`CLAUDE_CODE_PLUGIN_PREFER_HTTPS=1`](/docs/de/env-vars#variables) fest, um sie stattdessen über HTTPS zu klonen.

~~857~~

858<h4 id="background-auto-updates">

859 Hintergrund-Auto-Updates

860</h4>

~~861~~

862Die Hintergrund-Aktualisierung überprüft das Remote-Repository des Marktplatzes auf neue Commits mit Ihren konfigurierten Git-Credential-Helpern, genauso wie die Befehle, die Sie ausführen. Für SSH-Remotes authentifiziert ein in `ssh-agent` geladener Schlüssel die Überprüfung. Claude Code führt die Überprüfung nicht-interaktiv aus: Es deaktiviert Git-Terminal-Eingabeaufforderungen und Askpass-Programme und teilt Credential-Helpern mit, nicht zu fragen. Ob die Überprüfung sich bei einem privaten Repository über HTTPS authentifizieren kann, hängt von Ihrem Helper ab:

~~863~~

864* Ein Helper, der eine gespeicherte Anmeldedaten ohne Eingabeaufforderung bereitstellen kann, authentifiziert die Überprüfung. Git Credential Manager, der macOS Keychain-Helper und `git-credential-store` funktionieren auf diese Weise, sobald sie eine Anmeldedaten für den Host halten.

865* Ein Helper, der Sie auffordern muss, kann nicht im Hintergrund antworten. Das Update schlägt stillschweigend fehl und der vorhandene Checkout bleibt an Ort und Stelle, daher funktionieren Ihre Plugins aus dem letzten synchronisierten Zustand. Führen Sie `/plugin marketplace update <name>` aus, um den Marktplatz mit Ihren Anmeldedaten zu aktualisieren.

~~866~~

867Wenn die Überprüfung den Checkout als aktuell feststellt, lässt Claude Code ihn unverändert. Wenn die Überprüfung neue Commits findet oder fehlschlägt, weil sie das Remote nicht erreichen oder sich nicht authentifizieren kann, klont Claude Code den Marktplatz erneut und tauscht den neuen Klon aus. Wenn dieser Klon fehlschlägt, bleibt der vorhandene Checkout an Ort und Stelle. Das erneute Klonen kann bei großen Repositories [zeitlich überschritten werden](#git-operations-time-out).

~~868~~

869Zwei Einstellungen machen private Marktplätze vorhersehbar:

~~870~~

871* Legen Sie `CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE=1` fest, um den vorhandenen Checkout beizubehalten, ohne das erneute Klonen zu versuchen, wenn die Hintergrund-Überprüfung das Remote nicht erreichen oder sich nicht authentifizieren kann. Ihre Plugins funktionieren weiterhin aus dem letzten synchronisierten Zustand, und manuelle Updates mit `/plugin marketplace update` authentifizieren sich immer noch mit Ihren Anmeldedaten.

872* Konfigurieren Sie einen Git-Credential-Helper, beispielsweise mit `gh auth setup-git` für GitHub, damit die Hintergrund-Überprüfung und das erneute Klonen sich ohne Eingabeaufforderung authentifizieren können.

~~873~~

874Das Festlegen eines Provider-Tokens wie `GITHUB_TOKEN` in Ihrer Umgebung ermöglicht nicht von selbst die Hintergrund-Authentifizierung. Tokens wirken sich nur durch einen konfigurierten Credential-Helper aus, beispielsweise den Helper der `gh` CLI, der `GH_TOKEN` und `GITHUB_TOKEN` liest.

~~875~~

876<Note>

877 In CI/CD-Umgebungen konfigurieren Sie einen Git-Credential-Helper, bevor Sie Plugins aus privaten Repositories installieren. Auf GitHub Actions exportieren Sie ein Token mit Lesezugriff auf das Marktplatz-Repository als `GH_TOKEN`, führen Sie dann `gh auth setup-git` aus. Das Standard-Workflow-Token kann nur auf das eigene Repository des Workflows zugreifen, daher benötigt ein privater Marktplatz in einem anderen Repository ein persönliches Zugriffs-Token oder App-Token.

878</Note>

~~879~~

880<h3 id="distribute-through-organization-settings">

881 Über Organisationseinstellungen verteilen

882</h3>

~~883~~

884Wenn Sie Plugins über [**Organisationseinstellungen > Plugins**](https://claude.ai/admin-settings/plugins) in einem Team- oder Enterprise-Plan verteilen, gelten diese Quellregeln:

~~885~~

886* Auf github.com und gitlab.com muss das Marktplatz-Repository privat oder intern sein. Die Organisationssynchronisierung liest das Repository über die Verbindung, die seinem Host entspricht:

887 * **github.com**: die Claude GitHub App

888 * **Ihr GitHub Enterprise Server-Host**: Ihre Organisation's [GitHub Enterprise App](/docs/de/github-enterprise-server#admin-setup)

889 * **gitlab.com oder Ihre selbstverwaltete GitLab-Instanz**: das Zugriffs-Token in Ihrer Organisation's [GitLab-Konfiguration](#sync-a-gitlab-hosted-marketplace) für diesen Host

890* Jede Plugin-Quelle muss vom Typ `github`, `url` oder `git-subdir` sein, oder ein [relativer Pfad](#relative-paths), der mit `./` beginnt. Wenn Sie ein Plugin unter `metadata.pluginRoot` nach bloßem Namen auflisten, lehnt die Organisationssynchronisierung es als nicht unterstützte Quelle ab, daher schreiben Sie den Pfad aus, wie `./plugins/deploy-tools`.

891* Eine Plugin-Quelle kann in drei Fällen privat sein:

892 * Eine github.com-Quelle, die den Besitzer des Marktplatz-Repositories teilt

893 * Eine Quelle auf Ihrem GitHub Enterprise-Host der Organisation mit der GHE App, die auf dem Repository installiert ist

894 * Eine `url`- oder `git-subdir`-Quelle auf dem gleichen GitLab-Host wie das Marktplatz-Repository. Auf gitlab.com muss die Quelle auch unter der gleichen Top-Level-Gruppe oder dem gleichen Benutzer-Namespace wie das Marktplatz-Repository sein

895* Jede andere Plugin-Quelle muss ein öffentliches Repository auf github.com, gitlab.com oder bitbucket.org sein, das die Organisationssynchronisierung ohne Anmeldedaten abruft. Die Organisationssynchronisierung lehnt Plugin-Quellen auf Hosts ab, die diese Regeln nicht abdecken.

~~896~~

897Siehe [Plugins für Ihre Organisation verwalten](https://support.claude.com/en/articles/13837433) für den Admin-Workflow.

~~898~~

899Um private Plugins einzuschließen, platzieren Sie die Plugin-Ordner im Marktplatz-Repository und verweisen Sie auf sie mit einem [relativen Pfad](#relative-paths). Die Organisationssynchronisierung verpackt jedes Plugin während der Verteilung, daher benötigen Benutzer niemals Zugriff auf ein separates Quell-Repository.

~~900~~

901Beispielsweise verweist dieser `marketplace.json`-Plugin-Eintrag auf ein Plugin, das Sie unter `plugins/deploy-tools` im Marktplatz-Repository committed haben:

~~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 Synchronisieren Sie einen GitLab-gehosteten Marktplatz

912</h4>

~~913~~

914Um einen Marktplatz von gitlab.com oder einer selbstverwalteten GitLab-Instanz zu synchronisieren, fügt ein [Besitzer](/docs/de/server-managed-settings#access-control) zunächst eine GitLab-Konfiguration für diesen Host unter [**Organisationseinstellungen > Claude Code**](https://claude.ai/admin-settings/claude-code) hinzu. GitLab-Konfigurationen befinden sich in öffentlicher Beta und gelten nur für die Plugin-Marktplatz-Synchronisierung. Das Hinzufügen einer Konfiguration macht GitLab-Repositories nicht in [Claude Code im Web](/docs/de/claude-code-on-the-web#limitations) verfügbar. Siehe [Plugins für Ihre Organisation verwalten](https://support.claude.com/en/articles/13837433) für die Einrichtungsschritte.

~~915~~

916Wenn Sie den Marktplatz hinzufügen, geben Sie die HTTPS-URL des Projekts ein, wie `https://gitlab.example.com/platform/claude-plugins`. Projekte in verschachtelten Untergruppen funktionieren. Die Organisationssynchronisierung liest den Standard-Branch des Projekts. Wenn Sie **Automatisch synchronisieren** aktivieren, starten nur Pushes zum Standard-Branch eine Synchronisierung.

~~917~~

918<h4 id="keep-executables-out-of-the-top-level-bin-directory">

919 Halten Sie ausführbare Dateien aus dem Top-Level-bin-Verzeichnis heraus

920</h4>

~~921~~

922Schließen Sie kein Top-Level-`bin/`-Verzeichnis in Plugins ein, die Sie über Organisationseinstellungen verteilen. claude.ai lehnt ein Plugin ab, das eines hat, unabhängig davon, ob das Plugin durch Marktplatz-Synchronisierung oder direktes Hochladen ankommt:

~~923~~

924* **Marktplatz-Synchronisierung**: Die Organisationssynchronisierung lehnt dieses Plugin ab und synchronisiert den Rest des Marktplatzes. Die Fehlermeldung beginnt mit `Plugin contains a top-level bin/ directory`.

925* **Direktes Hochladen**: Wenn Sie das Plugin stattdessen in [**Organisationseinstellungen > Plugins**](https://claude.ai/admin-settings/plugins) hochladen, lehnt claude.ai das Hochladen mit der gleichen Meldung ab.

~~926~~

927Halten Sie ausführbare Dateien in einem anderen Verzeichnis, wie `scripts/`, und verweisen Sie auf sie als `${CLAUDE_PLUGIN_ROOT}/scripts/<name>` aus Ihren [Skills, Hooks oder MCP-Server-Konfigurationen](/docs/de/plugins-reference#environment-variables).

~~928~~

929<h3 id="require-marketplaces-for-your-team">

930 Marktplätze für Ihr Team erforderlich machen

931</h3>

~~932~~

933Sie können Ihr Repository so konfigurieren, dass Claude Code Ihren Marktplatz für Teammitglieder hinzufügt, sobald sie [dem Projektordner vertrauen](/docs/de/permissions#what-runs-before-you-trust-a-folder), ohne separate Eingabeaufforderung. Fügen Sie Ihren Marktplatz zu `.claude/settings.json` hinzu:

~~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~~

948Sie können auch angeben, welche Plugins standardmäßig aktiviert sein sollen:

~~949~~

950```json theme={null}

951{

952 "enabledPlugins": {

953 "code-formatter@company-tools": true,

954 "deployment-tools@company-tools": true

955 }

956}

957```

~~958~~

959Für vollständige Konfigurationsoptionen siehe [Plugin-Einstellungen](/docs/de/settings-reference#plugin-settings).

~~960~~

961<Note>

962 Wenn Sie eine lokale `directory`- oder `file`-Quelle mit einem relativen Pfad verwenden, wird der Pfad gegen den Haupt-Checkout Ihres Repositories aufgelöst. Wenn Sie Claude Code aus einem Git Worktree ausführen, verweist der Pfad immer noch auf den Haupt-Checkout, sodass alle Worktrees denselben Marktplatz-Speicherort teilen. Der Marktplatz-Status wird einmal pro Benutzer in `~/.claude/plugins/known_marketplaces.json` gespeichert, nicht pro Projekt.

963</Note>

~~964~~

965<h3 id="pre-populate-plugins-for-containers">

966 Plugins für Container vorab ausfüllen

967</h3>

~~968~~

969Für Container-Images und CI-Umgebungen können Sie ein Plugins-Verzeichnis zur Build-Zeit vorab ausfüllen, damit Claude Code mit bereits verfügbaren Marktplätzen und Plugins startet, ohne zur Laufzeit etwas zu klonen. Legen Sie die Umgebungsvariable `CLAUDE_CODE_PLUGIN_SEED_DIR` fest, um auf dieses Verzeichnis zu verweisen.

~~970~~

971Um mehrere Seed-Verzeichnisse zu schichten, trennen Sie Pfade mit `:` auf Unix oder `;` auf Windows. Claude Code durchsucht jedes Verzeichnis in der Reihenfolge und verwendet den ersten Seed, der einen bestimmten Marktplatz oder Plugin-Cache enthält.

~~972~~

973Das Seed-Verzeichnis spiegelt die Struktur von `~/.claude/plugins`:

~~974~~

975```

976$CLAUDE_CODE_PLUGIN_SEED_DIR/

977 known_marketplaces.json

978 marketplaces/<name>/...

979 cache/<marketplace>/<plugin>/<version>/...

980```

~~981~~

982Um ein Seed-Verzeichnis zu erstellen, führen Sie Claude Code einmal während des Image-Builds aus, installieren Sie die benötigten Plugins, kopieren Sie dann das resultierende `~/.claude/plugins`-Verzeichnis in Ihr Image und verweisen Sie `CLAUDE_CODE_PLUGIN_SEED_DIR` darauf.

~~983~~

984Um den Kopierungsschritt zu überspringen, legen Sie `CLAUDE_CODE_PLUGIN_CACHE_DIR` während des Builds auf Ihren Ziel-Seed-Pfad fest, damit Plugins direkt dort installiert werden:

~~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~~

991Legen Sie dann `CLAUDE_CODE_PLUGIN_SEED_DIR=/opt/claude-seed` in der Laufzeitumgebung Ihres Containers fest, damit Claude Code beim Start aus dem Seed liest.

~~992~~

993Beim Start registriert Claude Code Marktplätze, die in der Seed-Datei `known_marketplaces.json` gefunden werden, in der primären Konfiguration und verwendet Plugin-Caches, die unter `cache/` gefunden werden, ohne erneut zu klonen. Dies funktioniert sowohl im interaktiven Modus als auch im nicht-interaktiven Modus mit dem `-p`-Flag.

~~994~~

995Verhaltensdetails:

~~996~~

997* **Schreibgeschützt**: Claude Code schreibt niemals in das Seed-Verzeichnis.

998* **Auto-Updates deaktiviert**: Seed-Marktplätze werden nicht automatisch aktualisiert.

999* **Seed-Einträge haben Vorrang**: Marktplätze, die in der Seed deklariert sind, überschreiben alle übereinstimmenden Einträge in der Benutzerkonfiguration bei jedem Start. Um sich von einem Seed-Plugin abzumelden, verwenden Sie `/plugin disable`, anstatt den Marktplatz zu entfernen.

1000* **Pfadauflösung**: Claude Code lokalisiert Marktplatz-Inhalte, indem es `$CLAUDE_CODE_PLUGIN_SEED_DIR/marketplaces/<name>/` zur Laufzeit durchsucht, nicht indem es Pfaden vertraut, die in der Seed-JSON gespeichert sind. Dies bedeutet, dass die Seed korrekt funktioniert, auch wenn sie an einem anderen Pfad als dort, wo sie erstellt wurde, bereitgestellt wird.

1001* **Mutation ist blockiert**: Das Ausführen von `/plugin marketplace remove` oder `/plugin marketplace update` gegen einen Seed-verwalteten Marktplatz schlägt mit Anleitung fehl, um Ihren Administrator zu bitten, das Seed-Image zu aktualisieren.

1002* **Komponiert mit Einstellungen**: Wenn `extraKnownMarketplaces` oder `enabledPlugins` einen Marktplatz deklarieren, der bereits in der Seed vorhanden ist, verwendet Claude Code die Seed-Kopie, anstatt zu klonen.

~~1003~~

1004<h3 id="managed-marketplace-restrictions">

1005 Verwaltete Marktplatz-Einschränkungen

1006</h3>

~~1007~~

1008Für Organisationen, die strikte Kontrolle über Plugin-Quellen benötigen, können Administratoren einschränken, welche Plugin-Marktplätze Benutzer hinzufügen dürfen, indem sie die Einstellung [`strictKnownMarketplaces`](/docs/de/settings-reference#strictknownmarketplaces) in verwalteten Einstellungen verwenden. Um auch die CLI-Flags abzulehnen, die Plugins, Agenten und MCP-Server für einen einzelnen Durchlauf seitenladen, kombinieren Sie es mit [`disableSideloadFlags`](/docs/de/settings-reference#disablesideloadflags). Um eine Zulassungsliste zu erstellen, welche Plugins von Marktplätzen als kontextuelle Installationsvorschläge angezeigt werden können, legen Sie [`pluginSuggestionMarketplaces`](/docs/de/settings-reference#pluginsuggestionmarketplaces) fest.

~~1009~~

1010`strictKnownMarketplaces` stimmt mit dem Marktplatz überein, aus dem ein Plugin stammt, nicht mit den Einträgen darin, daher können Benutzer immer noch ein Plugin mit einer [`command`-Quelle](#command-sources) aus einem zulässigen Marktplatz installieren. Um Command-Quellen auch zu blockieren, legen Sie [`disableCommandPluginSources`](/docs/de/settings-reference#disablecommandpluginsources) fest.

~~1011~~

1012Wenn `strictKnownMarketplaces` in verwalteten Einstellungen konfiguriert ist, hängt das Einschränkungsverhalten vom Wert ab:

~~1013~~

1014| Wert | Verhalten |

1015| -------------------------- | ----------------------------------------------------------------------------------------------------------------- |

1016| Nicht definiert (Standard) | Keine Einschränkungen. Benutzer können jeden Marktplatz hinzufügen |

1017| Leeres Array `[]` | Vollständige Sperrung. Blockiert jeden Marktplatz-Quelltyp, einschließlich des offiziellen Anthropic-Marktplatzes |

1018| Liste von Quellen | Zulassungsliste erzwungen. Benutzer können nur Marktplätze hinzufügen, die einem Eintrag entsprechen |

~~1019~~

1020<h4 id="common-configurations">

1021 Häufige Konfigurationen

1022</h4>

~~1023~~

1024Deaktivieren Sie alle Marktplatz-Ergänzungen, einschließlich des offiziellen Anthropic-Marktplatzes:

~~1025~~

1026```json theme={null}

1027{

1028 "strictKnownMarketplaces": []

1029}

1030```

~~1031~~

1032Claude Code lädt die Plugins [von claude.ai synchronisiert](/docs/de/plugins-reference#synced-plugins) von Ihrem Konto statt von einem Marktplatz herunter, daher deckt diese Sperrung sie nicht ab. Um diese auch zu stoppen, legen Sie [`syncClaudeAiPlugins`](/docs/de/settings-reference#syncclaudeaiplugins) in verwalteten Einstellungen auf `false` fest, oder deaktivieren Sie Skills für Ihre Organisation auf claude.ai.

~~1033~~

1034Nur den offiziellen Anthropic-Marktplatz zulassen. Der Abgleich für einen einzelnen Repository-Eintrag ist exakt, daher deckt dieser Eintrag keine `ref`- oder `path`-Varianten desselben Repositories ab:

~~1035~~

1036```json theme={null}

1037{

1038 "strictKnownMarketplaces": [

1039 {

1040 "source": "github",

1041 "repo": "anthropics/claude-plugins-official"

1042 }

1043 ]

1044}

1045```

~~1046~~

1047Mit diesem Eintrag behält Claude Code einen bereits registrierten offiziellen Marktplatz verfügbar und registriert den Marktplatz auf einer neuen Maschine automatisch beim ersten Mal, wenn Sie Claude Code interaktiv starten.

~~1048~~

1049Die automatische Registrierung deckt nicht jede Maschine ab. Sie fehlt am häufigsten:

~~1050~~

1051* Nicht-interaktive Umgebungen, die vor dem ersten interaktiven Start der Maschine ausgeführt werden.

1052* Maschinen, auf denen Claude Code bereits interaktiv unter einer Richtlinie ausgeführt wurde, die den Marktplatz blockierte, wie die Sperrung mit leerem Array. Claude Code zeichnet den blockierten Versuch auf und versucht nicht erneut, nachdem die Richtlinie geändert wird.

~~1053~~

1054Auf diesen Maschinen fügen Sie den Marktplatz zu [`extraKnownMarketplaces`](/docs/de/settings-reference#extraknownmarketplaces) in derselben `managed-settings.json` hinzu, damit Claude Code ihn automatisch registriert, oder führen Sie `claude plugin marketplace add anthropics/claude-plugins-official` aus.

~~1055~~

1056Nur bestimmte Marktplätze zulassen:

~~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~~

1078Alle Marktplatz-Repositories unter einer GitHub-Organisation mit einem [Owner-Wildcard](/docs/de/settings-reference#owner-wildcards)-Eintrag zulassen. Owner-Wildcards erfordern Claude Code v2.1.223 oder später.

~~1079~~

1080```json theme={null}

1081{

1082 "strictKnownMarketplaces": [

1083 {

1084 "source": "github",

1085 "repo": "acme-corp/*"

1086 }

1087 ]

1088}

1089```

~~1090~~

1091Alle Marktplätze von einem internen Git-Server mit Regex-Musterabgleich auf dem Host zulassen. Dies ist der empfohlene Ansatz für [GitHub Enterprise Server](/docs/de/github-enterprise-server#plugin-marketplaces-on-ghes) oder selbstgehostete GitLab-Instanzen:

~~1092~~

1093```json theme={null}

1094{

1095 "strictKnownMarketplaces": [

1096 {

1097 "source": "hostPattern",

1098 "hostPattern": "^github\\.example\\.com$"

1099 }

1100 ]

1101}

1102```

~~1103~~

1104Dateisystem-basierte Marktplätze aus einem bestimmten Verzeichnis mit Regex-Musterabgleich auf dem Pfad zulassen:

~~1105~~

1106```json theme={null}

1107{

1108 "strictKnownMarketplaces": [

1109 {

1110 "source": "pathPattern",

1111 "pathPattern": "^/opt/approved/"

1112 }

1113 ]

1114}

1115```

~~1116~~

1117Verwenden Sie `".*"` als `pathPattern`, um jeden Dateisystempfad zuzulassen und gleichzeitig Netzwerkquellen mit `hostPattern` zu steuern.

~~1118~~

1119<Note>

1120 `strictKnownMarketplaces` schränkt ein, was Benutzer hinzufügen können, registriert aber nicht selbst Marktplätze. Um zulässige Marktplätze für Benutzer automatisch zu registrieren, fügen Sie sie zu [`extraKnownMarketplaces`](/docs/de/settings-reference#extraknownmarketplaces) in derselben `managed-settings.json` hinzu.

~~1121~~

1122 Der offizielle Anthropic-Marktplatz ist der einzige, den Claude Code von selbst registriert, und nur wenn die Zulassungsliste ihn zulässt. Die automatische Registrierung fehlt auch auf einigen Maschinen, wie nicht-interaktiven Umgebungen und Maschinen, auf denen eine frühere Richtlinie ihn blockierte. Um diese Maschinen abzudecken, fügen Sie den offiziellen Marktplatz auch zu `extraKnownMarketplaces` hinzu. Für die beiden Einstellungen nebeneinander siehe die [`strictKnownMarketplaces`-Referenz](/docs/de/settings-reference#strictknownmarketplaces).

1123</Note>

~~1124~~

1125<h4 id="how-restrictions-work">

1126 Wie Einschränkungen funktionieren

1127</h4>

~~1128~~

1129Einschränkungen werden überprüft, bevor Netzwerk- oder Dateisystemoperationen durchgeführt werden. Die Überprüfung wird beim Hinzufügen von Marktplätzen und beim Installieren, Aktualisieren, Aktualisieren und Auto-Update von Plugins durchgeführt. Wenn ein Marktplatz hinzugefügt wurde, bevor die Richtlinie konfiguriert wurde, und seine Quelle nicht mehr mit der Zulassungsliste übereinstimmt, weigert sich Claude Code, Plugins daraus zu installieren oder zu aktualisieren. Die gleiche Durchsetzung gilt für `blockedMarketplaces`.

~~1130~~

1131Wo die beiden Listen durchgesetzt werden, hängt davon ab, wo Sie sie festlegen:

~~1132~~

1133* **Die claude.ai Admin-Konsole**: Claude Code erzwingt beide Listen in den Sitzungen, die [Server-verwaltete Einstellungen lesen](/docs/de/managed-settings#where-and-when-a-policy-applies). claude.ai überprüft sie auch, wenn jemand in Ihrer Organisation einen neuen Marktplatz aus einem Git-Repository auf claude.ai hinzufügt, oder aus **Anpassen** in der Claude Desktop-App außerhalb ihrer Code-Registerkarte. Das deckt einen Marktplatz ab, den ein Mitglied für sein eigenes Konto hinzufügt, und einen, der für die ganze Organisation unter [**Organisationseinstellungen > Plugins**](https://claude.ai/admin-settings/plugins) hinzugefügt wird. claude.ai lehnt ein Repository ab, das die Zulassungsliste nicht zulässt oder das die Blockliste benennt. Es überprüft nicht erneut einen Marktplatz, der an beiden Orten hinzugefügt wurde, bevor Sie die Listen festlegten, und es überprüft nicht hochgeladene Plugins.

1134* **Eine verwaltete Einstellungsdatei, OS-Richtlinie oder andere verwaltete Quelle**: Claude Code erzwingt beide Listen, wo es diese Quelle liest. claude.ai liest sie nicht.

~~1135~~

1136Um jeden Marktplatz-Repository unter einem GitHub-Besitzer zu blockieren, verwenden Sie die Owner-Wildcard-Form in einem `blockedMarketplaces`-Eintrag: `{ "source": "github", "repo": "untrusted-org/*" }`. Erfordert Claude Code v2.1.223 oder später. Für die Abgleichregeln, die zwischen der Blockliste und der Zulassungsliste unterscheiden, siehe [Owner-Wildcards](/docs/de/settings-reference#owner-wildcards).

~~1137~~

1138Wenn ein Benutzer eine `https://`-Repository-URL hinzufügt, die Claude Code [klont statt abruft](/docs/de/discover-plugins#add-from-other-git-hosts), wie eine bloße `github.com`- oder `gitlab.com`-Repository-URL, überprüft Claude Code sie auch gegen die `url`-Einträge in `blockedMarketplaces`. Claude Code blockiert die Ergänzung, wenn ein Eintrag die gleiche URL benennt. Bei diesem Vergleich ignoriert Claude Code das `.git`-Suffix und jeden Ref, den der Benutzer nach `#` anhängt. Erfordert Claude Code v2.1.232 oder später. Vor v2.1.232 stimmte Claude Code einen `url`-Eintrag nur gegen eine URL ab, die es als gehostete `marketplace.json`-Datei abrief.

~~1139~~

1140Die Zulassungsliste verwendet exakten Abgleich für die meisten Quellentypen, abgesehen von Owner-Wildcard-`github`-Einträgen. Damit ein Marktplatz zulässig ist, müssen alle angegebenen Felder übereinstimmen:

~~1141~~

1142* Für GitHub-Quellen: `repo` ist erforderlich, entweder benannt ein Repository oder verwendet die Owner-Wildcard-Form `owner/*`, um jedes Repository unter diesem Besitzer abzudecken. Für die Abgleichregeln von Wildcard-Einträgen, einschließlich der Fallregeln, siehe [Owner-Wildcards](/docs/de/settings-reference#owner-wildcards). Für einzelne Repository-Einträge muss `ref` genau übereinstimmen oder in beiden dem Marktplatz-Quelltyp und dem Zulassungslisten-Eintrag fehlen, und die gleiche Regel gilt für `path`

1143* Für URL-Quellen: Die vollständige URL muss genau übereinstimmen

1144* Für `hostPattern`-Quellen: Der Marktplatz-Host wird gegen das Regex-Muster abgeglichen

1145* Für `pathPattern`-Quellen: Der Dateisystempfad des Marktplatzes wird gegen das Regex-Muster abgeglichen

~~1146~~

1147Der exakte Abgleich der Zulassungsliste behandelt URLs, die sich nur durch einen nachgestellten Schrägstrich, ein `.git`-Suffix oder das `ssh://`- und `https://`-Schema unterscheiden, als unterschiedliche Werte. Wenn Ihr Organisations-Marktplatz durch mehr als eine URL-Form geklont werden kann, bevorzugen Sie einen `hostPattern`-Eintrag gegenüber einer literalen URL, damit die `https://`-, `ssh://`- und `user@host:path`-Formen alle übereinstimmen.

~~1148~~

1149Ein [auf claude.ai gehosteter Marktplatz](/docs/de/discover-plugins#add-from-claude-ai) wird nach Host abgeglichen: Ein `hostPattern`-Eintrag, der `claude.ai` abgleicht, regelt ihn in `strictKnownMarketplaces` und in `blockedMarketplaces`. Auf der Zulassungsliste lässt ein solcher Eintrag nicht die persönlichen claude.ai-Uploads eines Mitglieds zu. Erfordert Claude Code v2.1.273 oder später.

~~1150~~

1151Da `strictKnownMarketplaces` in [verwalteten Einstellungen](/docs/de/managed-settings) festgelegt ist, können einzelne Benutzer und Projektkonfigurationen diese Einschränkungen nicht überschreiben.

~~1152~~

1153Für vollständige Konfigurationsdetails einschließlich aller unterstützten Quellentypen und Vergleich mit `extraKnownMarketplaces` siehe die [strictKnownMarketplaces-Referenz](/docs/de/settings-reference#strictknownmarketplaces).

~~1154~~

1155<h3 id="version-resolution-and-release-channels">

1156 Versionsauflösung und Release-Kanäle

1157</h3>

~~1158~~

1159Plugin-Versionen bestimmen Cache-Pfade und Update-Erkennung: Wenn die aufgelöste Version mit dem übereinstimmt, was ein Benutzer bereits hat, überspringen `/plugin update` und Auto-Update das Plugin. Für Git-basierte Quellen, wenn Sie `version` weglassen, verwendet Claude Code den aufgelösten Commit-SHA der Quelle, daher erhalten Benutzer ein Update, wenn sich dieser Commit ändert; dies ist die einfachste Einrichtung für interne oder aktiv entwickelte Plugins. Siehe [Versionsverwaltung](/docs/de/plugins-reference#version-management) für die vollständige Auflösungsreihenfolge, einschließlich `archive`-Quellen.

~~1160~~

1161<Warning>

1162 Das Festlegen von `version` heftet das Plugin für jeden Quellentyp außer [`command`](#command-sources) an, dessen Version immer einen Hash dessen enthält, was der Befehl produziert hat. Ein Plugin [geladen an Ort und Stelle](/docs/de/plugins-reference#plugin-caching-and-file-resolution) aus einem Marktplatz, der als lokales Verzeichnis hinzugefügt wurde, ist auch nicht angeheftet. Wenn Sie `"version": "1.0.0"` in `plugin.json` deklarieren und neue Commits pushen, ohne diese Zeichenkette zu ändern, behalten bestehende Benutzer dieser Quellen die zwischengespeicherte Kopie, da Claude Code die gleiche Version sieht. Erhöhen Sie das Feld bei jeder Veröffentlichung, oder lassen Sie es weg, um auf die aufgelöste Version zurückzugreifen.

~~1163~~

1164 Vermeiden Sie das Festlegen von `version` sowohl in `plugin.json` als auch im Marktplatz-Eintrag. Claude Code verwendet immer den `plugin.json`-Wert ohne Warnung, daher kann eine veraltete Manifest-Version eine Version maskieren, die Sie in `marketplace.json` festgelegt haben.

1165</Warning>

~~1166~~

1167<h4 id="set-up-release-channels">

1168 Richten Sie Release-Kanäle ein

1169</h4>

~~1170~~

1171Um "stabile" und "neueste" Release-Kanäle für Ihre Plugins zu unterstützen, können Sie zwei Marktplätze einrichten, die auf verschiedene Refs oder SHAs desselben Repos verweisen. Sie können dann jeder Benutzergruppe ihren eigenen Marktplatz durch verwaltete Einstellungen auf eine von zwei Arten geben:

~~1172~~

1173* Stellen Sie separate [Endpoint-verwaltete Einstellungen](/docs/de/managed-settings#delivery-mechanisms), wie eine verwaltete Einstellungsdatei oder ein MDM-Profil, für die Geräte jeder Gruppe bereit. [Wie Claude Code verwaltete Quellen kombiniert](/docs/de/managed-settings#precedence-within-the-managed-tier) sagt, ob die Pro-Gruppe-Datei oder das Profil auf einem Gerät gilt, das auch eine organisationsweite Quelle hat.

1174* Definieren Sie eine [Claude Apps Gateway-Richtlinie](/docs/de/claude-apps-gateway-config#managed) pro Gruppe. Das Gateway wendet die erste Richtlinie an, deren Abgleichsregel zu einem Benutzer passt, daher ordnen Sie die Richtlinien so, dass jeder Benutzer die Richtlinie seiner Gruppe erreicht. Eine Gruppen-Richtlinie `extraKnownMarketplaces` ersetzt die Catch-All-Richtlinie-Zuordnung, anstatt sie zu zusammenzuführen, daher listen Sie jeden Marktplatz auf, den die Gruppe in der Gruppen-Richtlinie benötigt, nicht nur ihren Kanal-Marktplatz.

~~1175~~

1176Server-verwaltete Einstellungen aus der Admin-Konsole [gelten für jeden Benutzer in Ihrer Organisation](/docs/de/server-managed-settings#current-limitations), daher können sie keine Pro-Gruppe-Zuweisung tragen.

~~1177~~

1178<Warning>

1179 Jeder Kanal muss sich zu einer anderen Version auflösen. Wenn Sie explizite Versionen verwenden, muss `plugin.json` eine andere `version` bei jedem angehefteten Ref deklarieren. Wenn Sie `version` weglassen, unterscheiden die unterschiedlichen Commit-SHAs bereits die Kanäle. Wenn zwei Refs sich zu der gleichen Versionskette auflösen, behandelt Claude Code sie als identisch und überspringt das Update.

1180</Warning>

~~1181~~

1182<h5 id="example">

1183 Beispiel

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 Kanäle Benutzergruppen zuweisen

1220</h5>

~~1221~~

1222Weisen Sie jeden Marktplatz seiner Benutzergruppe durch die unter [Release-Kanäle einrichten](#set-up-release-channels) beschriebenen Pro-Gruppe-Endpoint-verwalteten Einstellungen oder Gateway-Richtlinie zu. Beispielsweise erhält die stabile Gruppe:

~~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~~

1237Die Early-Access-Gruppe erhält stattdessen `latest-tools`:

~~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 Abhängigkeitsversionen anheften

1254</h4>

~~1255~~

1256Ein Plugin kann seine Abhängigkeiten auf einen Semver-Bereich beschränken, damit Updates einer Abhängigkeit das abhängige Plugin nicht unterbrechen. Siehe [Plugin-Abhängigkeitsversionen einschränken](/docs/de/plugin-dependencies) für die `{plugin-name}--v{version}` Git-Tag-Konvention, Bereichssyntax und wie mehrere Einschränkungen auf die gleiche Abhängigkeit kombiniert werden.

~~1257~~

1258<h3 id="rename-or-remove-a-plugin">

1259 Ein Plugin umbenennen oder entfernen

1260</h3>

~~1261~~

1262Der `name` eines Plugins ist sein stabiler Bezeichner. Benutzer verweisen darauf in `enabledPlugins`, `pluginConfigs` und `/plugin install`-Befehlen, daher bricht das Ändern davon jede vorhandene Installation. Um das in der Benutzeroberfläche angezeigte Label zu ändern, ohne Installationen zu unterbrechen, legen Sie [`displayName`](#optional-plugin-fields) fest und behalten Sie `name` unverändert.

~~1263~~

1264Wenn Sie den `name` eines Plugins ändern müssen oder ein Plugin aus dem `plugins`-Array entfernen, fügen Sie einen Top-Level-`renames`-Eintrag hinzu, damit bestehende Benutzer migrieren, anstatt einen `plugin-not-found`-Fehler zu sehen. Die automatische Migration erfordert Claude Code v2.1.193 oder später. Ordnen Sie jeden früheren Namen seinem aktuellen Namen zu, oder zu `null`, wenn das Plugin nicht mehr existiert. Das folgende Beispiel benennt `formatter` in `code-formatter` um und verzeichnet, dass `legacy-linter` entfernt wurde:

~~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~~

1280Wenn ein Benutzer Claude Code mit dem alten Namen noch in seinen Einstellungen startet, folgt Claude Code der `renames`-Zuordnung:

~~1281~~

1282* Wenn der Eintrag auf einen neuen Namen verweist, lädt Claude Code das Plugin unter seinem neuen Namen und zeigt eine einzeilige Mitteilung wie `Renamed to "code-formatter" in the "acme-tools" marketplace` an. Es schreibt dann den alten Schlüssel in den neuen Schlüssel in den Benutzer-, Projekt- und lokalen Einstellungsbereichen für sowohl `enabledPlugins` als auch `pluginConfigs` um, sodass die Mitteilung einmal angezeigt wird.

1283* Für einen `null`-Eintrag löscht Claude Code den alten Schlüssel und die Mitteilung meldet, dass das Plugin aus dem Marktplatz entfernt wurde.

1284* Wenn das umbenannte Plugin eine Remote-Quelle wie `github` oder `npm` verwendet, meldet Claude Code `plugin-cache-miss` nach der Umbenennung und der Benutzer muss `/plugin install` einmal ausführen, um es unter dem neuen Namen zu holen.

~~1285~~

1286Behandeln Sie `renames` als Nur-Anhängen-Verlauf: Behalten Sie alte Einträge an Ort und Stelle, auch nachdem Sie erwarten, dass jeder Benutzer migriert hat. Claude Code folgt Ketten, daher wenn Sie später `code-formatter` in `formatter-pro` umbenennen, fügen Sie einen zweiten Eintrag hinzu, anstatt den ersten zu bearbeiten. Ein Benutzer, der immer noch das Original `formatter` aktiviert hat, löst sich dann durch beide Einträge zu `formatter-pro` auf.

~~1287~~

1288Führen Sie `claude plugin validate .` nach dem Bearbeiten der Zuordnung aus; es lehnt jeden Eintrag ab, dessen Kette einen Zyklus bildet oder nicht bei `null` oder einem Namen in `plugins` endet.

~~1289~~

1290<Note>

1291 Verwaltete und Richtlinieneinstellungen sind schreibgeschützt für Claude Code, daher können dort aktivierte Plugins nicht automatisch umgeschrieben werden. Das umbenannte Plugin wird weiterhin jede Sitzung geladen, aber die Umbenennungsmitteilung wiederholt sich, bis ein Administrator `enabledPlugins` in der verwalteten Einstellungsdatei aktualisiert, um den neuen Namen zu verwenden. Das gleiche gilt für Plugins, die über andere schreibgeschützte Quellen wie `--add-dir` aktiviert werden.

1292</Note>

~~1293~~

1294Frühere Versionen von Claude Code ignorieren das `renames`-Feld und melden `plugin-not-found` für den alten Namen.

~~1295~~

1296<h2 id="validation-and-testing">

1297 Validierung und Tests

1298</h2>

~~1299~~

1300Testen Sie Ihren Marktplatz vor dem Teilen. Die Validierung überprüft die Dateistruktur; um zu testen, ob ein Plugin ändert, was Claude bei realistischen Eingabeaufforderungen tut, führen Sie seine Eval-Suite mit [`claude plugin eval`](/docs/de/plugin-evals) aus, bevor Sie eine neue Version veröffentlichen.

~~1301~~

1302Validieren Sie die JSON-Syntax aus Ihrem Marktplatz-Verzeichnis:

~~1303~~

1304```bash theme={null}

1305claude plugin validate .

1306```

~~1307~~

1308Oder von innerhalb von Claude Code:

~~1309~~

1310```shell theme={null}

1311/plugin validate .

1312```

~~1313~~

1314Fügen Sie den Marktplatz zum Testen hinzu:

~~1315~~

1316```shell theme={null}

1317/plugin marketplace add ./path/to/marketplace

1318```

~~1319~~

1320Installieren Sie ein Test-Plugin, um zu überprüfen, ob alles funktioniert:

~~1321~~

1322```shell theme={null}

1323/plugin install test-plugin@marketplace-name

1324```

~~1325~~

1326Für vollständige Plugin-Test-Workflows siehe [Testen Sie Ihre Plugins lokal](/docs/de/plugins#test-your-plugins-locally). Für technische Fehlerbehebung siehe [Plugins-Referenz](/docs/de/plugins-reference).

~~1327~~

1328<h2 id="manage-marketplaces-from-the-cli">

1329 Verwalten Sie Marktplätze über die CLI

1330</h2>

~~1331~~

1332Claude Code bietet nicht-interaktive `claude plugin marketplace` Unterbefehle zum Scripting und zur Automatisierung. Diese entsprechen den `/plugin marketplace` Befehlen, die in einer interaktiven Sitzung verfügbar sind.

~~1333~~

1334<h3 id="plugin-marketplace-add">

1335 Plugin marketplace add

1336</h3>

~~1337~~

1338Fügen Sie einen Marktplatz aus einem GitHub-Repository, einer Git-URL, einer Remote-URL oder einem lokalen Pfad hinzu.

~~1339~~

1340```bash theme={null}

1341claude plugin marketplace add <source> [options]

1342```

~~1343~~

1344**Argumente:**

~~1345~~

1346* `<source>`: GitHub `owner/repo` Kurzform, Git-URL, Remote-URL zu einer `marketplace.json`-Datei oder lokaler Verzeichnispfad. Um an einen Branch oder Tag anzuheften, fügen Sie `@ref` zur GitHub-Kurzform oder `#ref` zu einer Git-URL hinzu

~~1347~~

1348Eine URL muss ihr Schema enthalten. Ab Claude Code v2.1.196 wird ein Host, der ohne eines eingegeben wird, wie `gitlab.example.com/team/plugins`, als ungültige `owner/repo` Kurzform abgelehnt und die Fehlermeldung teilt Ihnen mit, dass Sie `https://` hinzufügen oder `./` für einen lokalen Pfad verwenden sollen. Frühere Versionen lasen es als GitHub-Repository-Pfad fehl und schlagen beim Klonen mit einem GitHub-Fehler fehl.

~~1349~~

1350**Optionen:**

~~1351~~

1352| Option | Beschreibung | Standard |

1353| :-------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------- |

1354| `--scope <scope>` | Wo der Marktplatz deklariert werden soll: `user`, `project` oder `local`. Siehe [Plugin-Installationsbereiche](/docs/de/plugins-reference#plugin-installation-scopes) | `user` |

1355| `--sparse <paths...>` | Begrenzen Sie den Checkout auf bestimmte Verzeichnisse über git sparse-checkout. Nützlich für Monorepos | |

1356| `--claudeai` | Lesen Sie das Argument als den Namen eines [auf claude.ai gehosteten Marktplatzes](/docs/de/discover-plugins#add-from-claude-ai) statt als eine Quelle. Erfordert Claude Code v2.1.273 oder später | |

~~1357~~

1358Fügen Sie einen Marktplatz aus GitHub mit `owner/repo` Kurzform hinzu:

~~1359~~

1360```bash theme={null}

1361claude plugin marketplace add acme-corp/claude-plugins

1362```

~~1363~~

1364Heften Sie an einen bestimmten Branch oder Tag mit `@ref` an:

~~1365~~

1366```bash theme={null}

1367claude plugin marketplace add acme-corp/claude-plugins@v2.0

1368```

~~1369~~

1370Fügen Sie von einer Git-URL auf einem nicht-GitHub-Host hinzu:

~~1371~~

1372```bash theme={null}

1373claude plugin marketplace add https://gitlab.example.com/team/plugins.git

1374```

~~1375~~

1376Fügen Sie von einer Remote-URL hinzu, die die `marketplace.json`-Datei direkt bereitstellt:

~~1377~~

1378```bash theme={null}

1379claude plugin marketplace add https://example.com/marketplace.json

1380```

~~1381~~

1382Fügen Sie von einem lokalen Verzeichnis zum Testen hinzu:

~~1383~~

1384```bash theme={null}

1385claude plugin marketplace add ./my-marketplace

1386```

~~1387~~

1388Deklarieren Sie den Marktplatz im Projektbereich, damit er mit Ihrem Team über `.claude/settings.json` geteilt wird:

~~1389~~

1390```bash theme={null}

1391claude plugin marketplace add acme-corp/claude-plugins --scope project

1392```

~~1393~~

1394Für ein Monorepo begrenzen Sie den Checkout auf die Verzeichnisse, die Plugin-Inhalte enthalten:

~~1395~~

1396```bash theme={null}

1397claude plugin marketplace add acme-corp/monorepo --sparse .claude-plugin plugins

1398```

~~1399~~

1400Fügen Sie einen [auf claude.ai gehosteten Marktplatz](/docs/de/discover-plugins#add-from-claude-ai) nach dem Namen hinzu, der im Abschnitt `From claude.ai:` von `claude plugin marketplace list` angezeigt wird:

~~1401~~

1402```bash theme={null}

1403claude plugin marketplace add --claudeai claudeai-organization-library

1404```

~~1405~~

1406Mit `--claudeai` lehnt der Befehl `--scope` und `--sparse` ab. Der Marktplatz wird für Ihr Konto gehostet, nicht in einer Einstellungsdatei deklariert, daher können Sie ihn nicht über die `.claude/settings.json` eines Projekts teilen.

~~1407~~

1408<h3 id="plugin-marketplace-list">

1409 Plugin marketplace list

1410</h3>

~~1411~~

1412Listet alle konfigurierten Marktplätze auf.

~~1413~~

1414```bash theme={null}

1415claude plugin marketplace list [options]

1416```

~~1417~~

1418**Optionen:**

~~1419~~

1420| Option | Beschreibung |

1421| :------- | :--------------- |

1422| `--json` | Ausgabe als JSON |

~~1423~~

1424Mit `--json` enthält jeder Eintrag `name`, `source`, ein `installLocation`-Feld mit dem lokalen Cache-Pfad, wo der Marktplatz gespeichert ist, und quellenspezifische Felder: `repo` für GitHub-Quellen, `url` für Git- und URL-Quellen und `path` für lokale Quellen. GitHub- und Git-Quellen enthalten auch ein `ref`-Feld, wenn der Marktplatz mit einem angehefteten Branch oder Tag hinzugefügt wurde.

~~1425~~

1426Ein hinzugefügter [claude.ai-Marktplatz](/docs/de/discover-plugins#add-from-claude-ai) hat keinen lokalen Klon, daher enthält sein Eintrag seine claude.ai-Identifikatoren, `marketplaceId` und `organizationUuid`, anstelle von `installLocation`.

~~1427~~

1428In Terminal-Sitzungen, in denen [Plugins von Ihrem claude.ai-Konto synchronisiert werden](/docs/de/plugins-reference#synced-plugins), endet die Textauflistung mit einem Abschnitt `From claude.ai:`, der auflistet, was claude.ai für Ihr Konto über die Marktplätze hinaus auflistet, die Sie hinzugefügt haben. Um einen von ihnen hinzuzufügen, siehe [Hinzufügen von claude.ai](/docs/de/discover-plugins#add-from-claude-ai). Die `--json`-Ausgabe umfasst nur konfigurierte Marktplätze und lässt diesen Abschnitt aus. Erfordert Claude Code v2.1.273 oder später.

~~1429~~

1430<h3 id="plugin-marketplace-remove">

1431 Plugin marketplace remove

1432</h3>

~~1433~~

1434Entfernen Sie einen konfigurierten Marktplatz. Der Alias `rm` wird auch akzeptiert.

~~1435~~

1436```bash theme={null}

1437claude plugin marketplace remove <name> [options]

1438```

~~1439~~

1440**Argumente:**

~~1441~~

1442* `<name>`: Marktplatz-Name zum Entfernen, wie von `claude plugin marketplace list` angezeigt. Dies ist der `name` aus `marketplace.json`, nicht die Quelle, die Sie an `add` übergeben haben

~~1443~~

1444**Optionen:**

~~1445~~

1446| Option | Beschreibung | Standard |

1447| :---------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------- |

1448| `--scope <scope>` | Beschränken Sie die Entfernung auf einen einzelnen Einstellungsbereich: `user`, `project` oder `local`. Siehe [Plugin-Installationsbereiche](/docs/de/plugins-reference#plugin-installation-scopes). Wenn weggelassen, wird die Deklaration aus jedem bearbeitbaren Bereich entfernt. Wenn angegeben, wird nur die Deklaration dieses Bereichs entfernt; der gemeinsame Status, der Cache und die installierten Plugin-Daten werden beibehalten, wenn der Marktplatz noch in einem anderen Bereich deklariert ist | (alle Bereiche) |

~~1449~~

1450<Warning>

1451 Das Entfernen eines Marktplatzes aus seinem letzten verbleibenden Bereich deinstalliert auch alle Plugins, die Sie von ihm installiert haben. Um einen Marktplatz zu aktualisieren, ohne installierte Plugins zu verlieren, verwenden Sie stattdessen `claude plugin marketplace update`.

1452</Warning>

~~1453~~

1454<h3 id="plugin-marketplace-update">

1455 Plugin marketplace update

1456</h3>

~~1457~~

1458Aktualisieren Sie Marktplätze von ihren Quellen, um neue Plugins und Versionsänderungen abzurufen. Ein Marktplatz, der mit einem Branch oder Tag `ref` hinzugefügt wurde, wird auf den neuesten Commit dieses Refs aktualisiert, nicht auf den Standard-Branch des Repositorys.

~~1459~~

1460```bash theme={null}

1461claude plugin marketplace update [name]

1462```

~~1463~~

1464**Argumente:**

~~1465~~

1466* `[name]`: Marktplatz-Name zum Aktualisieren, wie von `claude plugin marketplace list` angezeigt. Aktualisiert alle Marktplätze, wenn weggelassen

~~1467~~

1468Sowohl `remove` als auch `update` schlagen fehl, wenn sie gegen einen Seed-verwalteten Marktplatz ausgeführt werden, der schreibgeschützt ist. Beim Aktualisieren aller Marktplätze werden Seed-verwaltete Einträge übersprungen und andere Marktplätze werden weiterhin aktualisiert. Um Seed-bereitgestellte Plugins zu ändern, bitten Sie Ihren Administrator, das Seed-Image zu aktualisieren. Siehe [Plugins für Container vorab ausfüllen](#pre-populate-plugins-for-containers).

~~1469~~

1470<h2 id="troubleshooting">

1471 Fehlerbehebung

1472</h2>

~~1473~~

1474<h3 id="marketplace-not-loading">

1475 Marktplatz wird nicht geladen

1476</h3>

~~1477~~

1478**Symptome**: Kann Marktplatz nicht hinzufügen oder Plugins von ihm nicht sehen

~~1479~~

1480**Lösungen**:

~~1481~~

1482* Überprüfen Sie, dass die Marktplatz-URL erreichbar ist

1483* Überprüfen Sie, dass `.claude-plugin/marketplace.json` im angegebenen Pfad vorhanden ist

1484* Stellen Sie sicher, dass die JSON-Syntax gültig ist, indem Sie `claude plugin validate .` oder `/plugin validate .` aus dem Marktplatz-Verzeichnis verwenden. Um Skill-, Agent- und Befehl-Frontmatter zu überprüfen, siehe [Validieren Sie ein Plugin oder ein Verzeichnis ohne Manifest](#validate-a-plugin-or-a-directory-without-a-manifest)

1485* Bestätigen Sie für private Repositories, dass Sie Zugriffsberechtigung haben

~~1486~~

1487<h3 id="marketplace-validation-errors">

1488 Marktplatz-Validierungsfehler

1489</h3>

~~1490~~

1491Führen Sie `claude plugin validate .` oder `/plugin validate .` aus Ihrem Marktplatz-Verzeichnis aus, um auf Probleme zu überprüfen. Wenn der Validator auf ein Marktplatz-Verzeichnis verweist, überprüft er `marketplace.json` auf Schema-Fehler, doppelte Plugin-Namen und Quellpfad-Traversal. Für jeden Eintrag, dessen `source` ein lokaler Pfad ist, validiert er auch die `plugin.json` dieses Plugins und warnt, wenn die `version` des Eintrags nicht mit der in `plugin.json` übereinstimmt. Probleme, die in der `plugin.json` eines Plugins gefunden werden, werden mit dem Eintrag-Index in der Form `plugins[2] plugin.json →` vorangestellt.

~~1492~~

1493Ab Claude Code v2.1.196 umfasst die Pro-Eintrag-Überprüfung auch:

~~1494~~

1495* Plugins, deren `source` `.` ist

1496* wird ausgeführt, wenn `marketplace.json` außerhalb eines `.claude-plugin`-Verzeichnisses liegt, wobei Quellen gegen das Verzeichnis der Datei selbst aufgelöst werden

1497* meldet die Probleme jedes Eintrags, auch wenn ein anderer Teil der Datei Schema-Fehler hat

~~1498~~

1499Frühere Versionen überspringen Plugins im Marktplatz-Root und steigen nur von einer `.claude-plugin/marketplace.json` ab.

~~1500~~

1501Aus einem Marktplatz-Verzeichnis öffnet Claude Code nicht die Skill-, Agent-, Befehl- oder Hook-Dateien der Plugins. Um Fehler in diesen Dateien zu finden, siehe [Validieren Sie ein Plugin oder ein Verzeichnis ohne Manifest](#validate-a-plugin-or-a-directory-without-a-manifest). Die folgende Tabelle listet die häufigsten Fehler aus einem Marktplatz-Verzeichnis auf, mit der Ursache und Lösung für jeden:

~~1502~~

1503| Fehler | Ursache | Lösung |

1504| :------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------- |

1505| `No manifest found in directory. Expected .claude-plugin/marketplace.json or .claude-plugin/plugin.json` | Das benannte Verzeichnis hat keine `.claude-plugin/marketplace.json` oder `plugin.json`, und keine Skill-, Agent- oder Befehlsdateien zum Überprüfen | Führen Sie aus dem Marktplatz-Root aus, oder erstellen Sie `.claude-plugin/marketplace.json` mit erforderlichen Feldern |

1506| `Invalid JSON syntax: Unexpected token...` | JSON-Syntaxfehler in marketplace.json | Überprüfen Sie auf fehlende Kommas, zusätzliche Kommas oder nicht zitierte Strings |

1507| `Duplicate plugin name "x" found in marketplace` | Zwei Plugins teilen denselben Namen | Geben Sie jedem Plugin einen eindeutigen `name`-Wert |

1508| `plugins[0].source: Path contains ".."` | Ein Segment des Quellpfads ist `..` | Verwenden Sie Pfade relativ zum Marktplatz-Root ohne `..`-Segmente. Siehe [Relative Pfade](#relative-paths) |

1509| `Marketplace name cannot contain control or bidirectional-formatting characters` | Der Marktplatz-`name` enthält ein Unicode-Bidirektional-Formatierungszeichen oder ein Steuerzeichen, wie ein Escape oder ein Zeilenumbruch | Entfernen Sie das Zeichen aus dem Namen. Vor v2.1.247 erzeugten diese Zeichen den Fehler `Marketplace name impersonates an official Anthropic/Claude marketplace` |

1510| `Plugin name cannot contain control or bidirectional-formatting characters` | Ein Plugin-`name` enthält ein Unicode-Bidirektional-Formatierungszeichen oder ein Steuerzeichen, wie ein Escape oder ein Zeilenumbruch | Entfernen Sie das Zeichen aus dem Namen. Vor v2.1.247 führte Claude Code diese Überprüfung nicht durch |

~~1511~~

1512**Warnungen** (nicht blockierend):

~~1513~~

1514* `Marketplace has no plugins defined`: Fügen Sie mindestens ein Plugin zum `plugins`-Array hinzu

1515* `No marketplace description provided`: Fügen Sie eine Top-Level-`description` hinzu, um Benutzern zu helfen, Ihren Marktplatz zu verstehen

1516* `Plugin name "x" is not kebab-case`: Benennen Sie in Kleinbuchstaben, Ziffern und Bindestriche um (z. B. `my-plugin`). Claude Code akzeptiert andere Formen, aber die claude.ai-Marktplatz-Synchronisierung lehnt sie ab.

1517* `Marketplace name "x" is reserved in Claude Desktop`: Der Marktplatz ist mit `org`, `org-provisioned` oder `unknown` benannt, in beliebiger Schreibweise. Claude Code akzeptiert diese Namen, aber die verwaltete Marktplatz-Synchronisierung von Claude Desktop lehnt den gesamten Marktplatz ab. Benennen Sie den Marktplatz um. Vor v2.1.221 führte `claude plugin validate` diese Überprüfung nicht durch.

1518* `Marketplace name "x" is not accepted by Claude Desktop` oder `Plugin name "x" is not accepted by Claude Desktop`: Claude Desktop akzeptiert Namen von bis zu 128 Zeichen, bestehend aus Buchstaben, Ziffern, `.`, `_` und `-`, beginnend mit einem Buchstaben oder einer Ziffer. Claude Code akzeptiert andere Formen, aber die verwaltete Marktplatz-Synchronisierung von Claude Desktop lehnt einen Marktplatz ab, dessen Name die Überprüfung nicht besteht, und lässt einen Plugin-Eintrag, dessen Name nicht akzeptiert wird, stillschweigend fallen. Benennen Sie den Marktplatz oder das Plugin um. Vor v2.1.221 führte `claude plugin validate` diese Überprüfungen nicht durch.

~~1519~~

1520<h4 id="validate-a-plugin-or-a-directory-without-a-manifest">

1521 Validieren Sie ein Plugin oder ein Verzeichnis ohne Manifest

1522</h4>

~~1523~~

1524Um Skill-, Agent- und Befehlsdateien zu finden, deren Frontmatter nicht analysiert wird, führen Sie `claude plugin validate` aus und benennen Sie das Verzeichnis, das sie enthält. Claude Code schaut nicht außerhalb des benannten Verzeichnisses. Jede Ausführung außer einer gegen ein Plugin, das eine `plugin.json` hat, erfordert Claude Code v2.1.233 oder später.

~~1525~~

1526<h5 id="pick-the-directory-to-name">

1527 Wählen Sie das zu benennende Verzeichnis

1528</h5>

~~1529~~

1530Claude Code überprüft verschiedene Dateien, je nachdem, welches Verzeichnis Sie benennen. Finden Sie, was Sie überprüfen möchten, in der ersten Spalte, und führen Sie den Befehl dieser Zeile aus:

~~1531~~

1532| Zu überprüfen | Führen Sie aus | Claude Code überprüft |

1533| :------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

1534| Ein Plugin, das eine `plugin.json` hat | `claude plugin validate ./plugins/my-plugin` | `plugin.json`, `hooks/hooks.json` und die Verzeichnisse `skills`, `agents` und `commands` im Plugin-Root |

1535| Ein Verzeichnis von Skills, Agents oder Befehlen, wie ein Plugin, das noch keine `plugin.json` hat | `claude plugin validate .claude/skills`, `~/.claude/agents` oder `./my-plugin/agents` | Jede Skill-, Agent- oder Befehlsdatei in diesem Verzeichnis |

1536| Ein Ordner, dessen Skill seine Root-`SKILL.md` ist | `claude plugin validate ./skills`, benennend das `skills`-Verzeichnis, das den Ordner enthält | Die Root-`SKILL.md` jedes Ordners. Das Halte-Verzeichnis muss `skills` benannt sein; ein Ordner unter einem anderen Namen, wie `plugins/`, hat keine Ausführung, die seine Root-`SKILL.md` überprüft |

1537| Die drei Verzeichnisse eines Projekts auf einmal | `claude plugin validate .claude` oder das Projekt-Root, wenn es kein `.claude-plugin/`-Manifest hat | `.claude/skills`, `.claude/agents` und `.claude/commands` |

1538| Ihre Verzeichnisse auf Benutzerebene | `claude plugin validate ~/.claude` | `~/.claude/skills`, `~/.claude/agents` und `~/.claude/commands` |

~~1539~~

1540<h5 id="check-a-plugin-whose-skill-is-its-root-skill-md">

1541 Überprüfen Sie ein Plugin, dessen Skill seine Root-`SKILL.md` ist

1542</h5>

~~1543~~

1544Wenn Sie `claude plugin validate` gegen ein Plugin-Verzeichnis ausführen, überprüft Claude Code keine `SKILL.md` im Plugin-Root. Wenn das Plugin in einem Verzeichnis namens `skills` sitzt, führen Sie den Befehl zweimal aus:

~~1545~~

1546* Benennen Sie dieses `skills`-Verzeichnis, um die Root-`SKILL.md` des Plugins zu überprüfen.

1547* Benennen Sie das Plugin-Verzeichnis, um den Rest zu überprüfen.

~~1548~~

1549Wenn das Plugin unter einem anderen Namen sitzt, wie `plugins/`, ist die `skills`-Verzeichnis-Ausführung nicht verfügbar, und keine Ausführung überprüft seine Root-`SKILL.md`.

~~1550~~

1551<h5 id="check-files-behind-symlinks">

1552 Überprüfen Sie Dateien hinter Symlinks

1553</h5>

~~1554~~

1555Wenn Sie `claude plugin validate` ausführen, folgt Claude Code nicht Symlinks innerhalb des benannten Verzeichnisses. Was es tut, hängt davon ab, wo der Link ist:

~~1556~~

1557* **Ein verknüpftes `skills`-, `agents`- oder `commands`-Verzeichnis unter dem Plugin- oder `.claude`-Root**: Claude Code warnt, dass nichts darin gelesen wurde.

1558* **Ein verknüpfter Eintrag innerhalb eines `skills`-, `agents`- oder `commands`-Verzeichnisses**: Claude Code überspringt ihn und warnt pro Verzeichnis, wie viele Einträge es übersprungen hat, die eine Sitzung laden würde.

1559* **Das `skills`-, `agents`- oder `commands`-Verzeichnis, das Sie benennen, ist selbst ein Symlink, oder sein übergeordnetes `.claude`-Verzeichnis ist**: Claude Code meldet einen Fehler und überprüft nichts darin. Benennen Sie stattdessen das echte Verzeichnis.

~~1560~~

1561In zwei Skills-Fällen wird die Ausführung mit Warnungen bestanden. Um die verknüpften Dateien zu überprüfen, führen Sie erneut aus und benennen Sie ein Verzeichnis, das sie direkt enthält:

~~1562~~

1563* **Ein Plugin, dessen `skills`-Verzeichnis [auf die Skills eines Sibling-Plugins verlinkt](/docs/de/plugins-reference#share-files-within-a-marketplace-with-symlinks)**: Benennen Sie das Verzeichnis des Sibling-Plugins.

1564* **Ein [verknüpfter Skill-Eintrag](/docs/de/skills#where-skills-live) in `~/.claude/skills` oder `.claude/skills`**: Claude Code folgt dem Eintrag in einer Sitzung. Um ihn zu überprüfen, benennen Sie ein Verzeichnis namens `skills`, das den echten Ordner enthält.

~~1565~~

1566<h5 id="read-the-validation-results">

1567 Lesen Sie die Validierungsergebnisse

1568</h5>

~~1569~~

1570Eine saubere Ausführung endet mit `Validation passed`.

~~1571~~

1572`No manifest found in directory` bedeutet, dass Claude Code dort keine `plugin.json` oder `marketplace.json` gefunden hat, und keine Skill-, Agent- oder Befehlsdatei in den Verzeichnissen, die es darunter überprüft. Benennen Sie stattdessen das `skills`-, `agents`- oder `commands`-Verzeichnis, das Ihre Dateien enthält.

~~1573~~

1574Zwei der Fehler, die Claude Code aus diesen Ausführungen meldet, mit der Lösung für jeden:

~~1575~~

1576* `YAML frontmatter failed to parse: ...`: Beheben Sie das YAML im Frontmatter-Block der Skill-, Agent- oder Befehlsdatei. Bis Sie das tun, liest eine Sitzung keine Frontmatter-Felder aus der Datei

1577* `Invalid JSON syntax: ...` auf `hooks/hooks.json`: Beheben Sie die JSON-Syntax. Bis Sie das tun, lädt eine Sitzung das Plugin ohne die Hooks in dieser Datei. Claude Code meldet diesen Fehler nur in einer Plugin-Ausführung

~~1578~~

1579In einer Plugin-Ausführung warnt Claude Code auch vor einer `CLAUDE.md` im Plugin-Root. Für Pfade, die Sie durch die [Komponenten-Pfadfelder](/docs/de/plugins-reference#component-path-fields) in `plugin.json` festlegen, überprüft Claude Code, dass jeder Pfad vorhanden ist, liest aber die Dateien dort nicht.

~~1580~~

1581<h3 id="plugin-installation-failures">

1582 Plugin-Installationsfehler

1583</h3>

~~1584~~

1585**Symptome**: Marktplatz wird angezeigt, aber Plugin-Installation schlägt fehl

~~1586~~

1587**Lösungen**:

~~1588~~

1589* Überprüfen Sie, dass Plugin-Quell-URLs erreichbar sind

1590* Überprüfen Sie, dass Plugin-Verzeichnisse erforderliche Dateien enthalten

1591* Überprüfen Sie für GitHub-Quellen, dass Repositories öffentlich sind oder Sie Zugriff haben

1592* Testen Sie Plugin-Quellen manuell durch Klonen/Herunterladen

1593* Wenn die Quelle sowohl `ref` als auch `sha` festlegt, blockiert ein gelöschter Upstream-Branch oder Tag die Installation nicht auf den meisten Git-Hosts, einschließlich GitHub, GitLab und Bitbucket. Auf Servern, die das Abrufen von Commits nach SHA nicht unterstützen, wie AWS CodeCommit, muss die `ref` immer noch vorhanden sein und der angeheftete Commit muss von ihr erreichbar sein. Wenn die Installation immer noch fehlschlägt, bestätigen Sie, dass der angeheftete Commit immer noch im Repository vorhanden ist

~~1594~~

1595<h3 id="private-repository-authentication-fails">

1596 Authentifizierung für private Repositories schlägt fehl

1597</h3>

~~1598~~

1599**Symptome**: Authentifizierungsfehler beim Installieren von Plugins aus privaten Repositories

~~1600~~

1601**Lösungen**:

~~1602~~

1603Für manuelle Installation und Updates:

~~1604~~

1605* Überprüfen Sie, dass Sie bei Ihrem Git-Anbieter authentifiziert sind (führen Sie z. B. `gh auth status` für GitHub aus)

1606* Überprüfen Sie, dass Ihr Credential-Helper konfiguriert ist: `git config --global credential.helper`

1607* Führen Sie `git ls-remote <marketplace-url>` aus, um zu testen, ob Git sich selbst authentifizieren kann. Wenn Git nach einem Benutzernamen oder Passwort fragt, speichern Sie zuerst die Anmeldedaten: Führen Sie für GitHub über HTTPS `gh auth setup-git` aus, und für SSH-Remotes laden Sie Ihren Schlüssel in `ssh-agent`

~~1608~~

1609Für Hintergrund-Auto-Updates:

~~1610~~

1611* Die Hintergrund-Überprüfung verwendet Ihre konfigurierten Git-Credential-Helper, fordert aber nie auf, sodass Ihr Helper mit einer gespeicherten Anmeldedaten antworten können muss. SSH-Remotes mit einem in `ssh-agent` geladenen Schlüssel authentifizieren sich auch

1612* Wenn Ihr Helper Sie auffordern muss, schlägt die Hintergrund-Aktualisierung stillschweigend fehl und der vorhandene Klon bleibt an Ort und Stelle. Melden Sie sich zuerst bei Ihrem Helper an, damit er eine Anmeldedaten für den Host hält. Für GitHub führen Sie `gh auth login` aus, dann `gh auth setup-git`

1613* Wenn die Überprüfung neue Commits findet oder den Remote nicht erreichen oder authentifizieren kann, klont Claude Code den Marktplatz mit denselben Anmeldedaten erneut. Das erneute Klonen kann bei großen Repositories zeitüberschreiten

1614* Legen Sie `CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE=1` fest, um den vorhandenen Klon beizubehalten, ohne das erneute Klonen zu versuchen, wenn die Hintergrund-Überprüfung den Remote nicht erreichen oder authentifizieren kann

1615* Wenn das erneute Klonen bei einem großen Repository zeitüberschreitet, erhöhen Sie das Limit mit [`CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS`](#git-operations-time-out)

1616* Oder aktualisieren Sie private Marktplätze manuell mit `/plugin marketplace update <name>`, das Ihre Anmeldedaten verwendet

~~1617~~

1618Vor v2.1.280 führte die Hintergrund-Überprüfung ohne Ihre Credential-Helper aus und konnte sich nicht bei privaten Repositories über HTTPS authentifizieren.

~~1619~~

1620<h3 id="marketplace-updates-fail-in-offline-environments">

1621 Marktplatz-Updates schlagen in Offline-Umgebungen fehl

1622</h3>

~~1623~~

1624**Symptome**: In einer Offline- oder Airgapped-Umgebung kann die Hintergrund-Marktplatz-Aktualisierung den Remote nicht erreichen und Claude Code versucht wiederholt ein erneutes Klonen, das nicht erfolgreich sein kann.

~~1625~~

1626**Ursache**: Die Hintergrund-Aktualisierung überprüft den Remote des Marktplatzes auf neue Commits, und wenn die Überprüfung den Remote nicht erreichen kann, versucht Claude Code, den Marktplatz erneut zu klonen. Offline schlägt das Klonen auf die gleiche Weise fehl und der vorhandene Klon bleibt an Ort und Stelle. Vor v2.1.274 führte die Aktualisierung `git pull` im vorhandenen Klon aus, verschob den Klon zur Seite zum erneuten Klonen, wenn der Pull fehlschlägt, und stellte ihn danach auf Best-Effort-Basis wieder her.

~~1627~~

1628Die Aktualisierung wird im Hintergrund nach dem Start ausgeführt, sodass sie den Start nicht verzögert. Jede Sitzung wiederholt immer noch den fehlgeschlagenen Versuch, und jede Git-Operation kann das [120-Sekunden-Timeout](#git-operations-time-out) abwarten.

~~1629~~

1630**Lösung**: Legen Sie `CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE=1` fest, um den erneuten Klon-Versuch zu überspringen und den vorhandenen Klon weiterhin zu verwenden, wenn die Überprüfung den Remote nicht erreichen kann:

~~1631~~

1632```bash theme={null}

1633export CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE=1

1634```

~~1635~~

1636Für vollständig Offline-Bereitstellungen, bei denen das Repository nie erreichbar sein wird, verwenden Sie stattdessen [`CLAUDE_CODE_PLUGIN_SEED_DIR`](#pre-populate-plugins-for-containers), um das Plugins-Verzeichnis zur Build-Zeit vorab auszufüllen.

~~1637~~

1638<h3 id="git-operations-time-out">

1639 Git-Operationen zeitüberschreitung

1640</h3>

~~1641~~

1642**Symptome**: Plugin-Installation oder Marktplatz-Updates schlagen mit einem Timeout-Fehler fehl, wie `Git clone timed out after 120s`.

~~1643~~

1644**Ursache**: Claude Code verwendet ein 120-Sekunden-Timeout für alle Git-Operationen, einschließlich Klonen von Plugin-Repositories und erneutes Klonen eines Marktplatzes zum Aktualisieren. Große Repositories oder langsame Netzwerkverbindungen können dieses Limit überschreiten.

~~1645~~

1646**Lösung**: Erhöhen Sie das Timeout mit der Umgebungsvariable `CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS`. Der Wert ist in Millisekunden:

~~1647~~

1648```bash theme={null}

1649export CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS=300000 # 5 Minuten

1650```

~~1651~~

1652<h3 id="plugins-with-relative-paths-fail-in-url-based-marketplaces">

1653 Plugins mit relativen Pfaden schlagen in URL-basierten Marktplätzen fehl

1654</h3>

~~1655~~

1656**Symptome**: Einen Marktplatz über eine URL wie `https://example.com/marketplace.json` hinzugefügt, aber Plugins mit relativen Pfadquellen wie `"./plugins/my-plugin"` schlagen mit `its marketplace entry path does not stay inside the marketplace directory` fehl. Bereits installierte Plugins schlagen mit `Plugin source path refused` fehl. Beide Meldungen haben einen [Fehlerreferenzeintrag](/docs/de/errors#marketplace-entry-path-does-not-stay-inside-the-marketplace-directory).

~~1657~~

1658**Ursache**: Das Hinzufügen eines URL-basierten Marktplatzes lädt nur die `marketplace.json`-Datei selbst herunter, und Claude Code lädt Plugin-Dateien nicht nach relativem Pfad von diesem Server herunter. Relative Pfade im Marktplatz-Eintrag verweisen auf Dateien auf dem Remote-Server, die nicht heruntergeladen wurden.

~~1659~~

1660**Lösungen**:

~~1661~~

1662* **Verwenden Sie externe Quellen**: Ändern Sie Plugin-Einträge in jede [Plugin-Quelle](#plugin-sources) außer einem relativen Pfad:

1663 ```json theme={null}

1664 { "name": "my-plugin", "source": { "source": "github", "repo": "owner/repo" } }

1665 ```

1666* **Verwenden Sie einen Git-basierten Marktplatz**: Hosten Sie Ihren Marktplatz in einem Git-Repository und fügen Sie ihn mit der Git-URL hinzu. Git-basierte Marktplätze klonen das gesamte Repository, wodurch relative Pfade funktionieren.

~~1667~~

1668<h3 id="files-not-found-after-installation">

1669 Dateien nicht gefunden nach Installation

1670</h3>

~~1671~~

1672**Symptome**: Plugin wird installiert, aber Verweise auf Dateien schlagen fehl, besonders Dateien außerhalb des Plugin-Verzeichnisses

~~1673~~

1674**Ursache**: Claude Code kopiert installierte Plugins in ein Cache-Verzeichnis, anstatt sie an Ort und Stelle zu verwenden, außer wenn ein Plugin in Place lädt. Eine [`command`-Quelle im Link-Modus](#copy-mode-and-link-mode) lädt in Place, und so auch eine [relative Pfad-Quelle](#relative-paths) in einem Marktplatz, der aus einem lokalen Verzeichnis hinzugefügt wurde. Pfade, die auf Dateien außerhalb eines kopierten Plugin-Verzeichnisses verweisen (wie `../shared-utils`), funktionieren nicht, da diese Dateien nicht kopiert werden.

~~1675~~

1676**Lösungen**: Siehe [Plugin-Caching und Dateiauflösung](/docs/de/plugins-reference#plugin-caching-and-file-resolution) für Workarounds, einschließlich Symlinks und Verzeichnisumstrukturierung.

~~1677~~

1678Für zusätzliche Debugging-Tools und häufige Probleme siehe [Debugging- und Entwicklungstools](/docs/de/plugins-reference#debugging-and-development-tools).

~~1679~~

1680<h2 id="see-also">

1681 Siehe auch

1682</h2>

~~1683~~

1684* [Entdecken und Installieren vorgefertigter Plugins](/docs/de/discover-plugins) - Installieren von Plugins aus vorhandenen Marktplätzen

1685* [Plugins](/docs/de/plugins) - Erstellen Ihrer eigenen Plugins

1686* [Plugins-Referenz](/docs/de/plugins-reference) - Vollständige technische Spezifikationen und Schemas

1687* [Plugin-Einstellungen](/docs/de/settings-reference#plugin-settings) - Plugin-Konfigurationsoptionen

1688* [strictKnownMarketplaces-Referenz](/docs/de/settings-reference#strictknownmarketplaces) - Verwaltete Marktplatz-Einschränkungen