1> ## Documentation Index
2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
3> Use this file to discover all available pages before exploring further.
4
5# Komponenten zu einem Plugin hinzufügen
6
7> Fügen Sie Skills, Hooks, MCP-Server und alle anderen Komponententypen zu einem Claude Code-Plugin hinzu, mit einem Beispiel, das für jeden validiert.
8
9export const Piece = ({id, children}) => <div className="pe-piece" data-piece={id}>{children}</div>;
10
11export const PluginExplorer = ({children}) => {
12 const PIECES = [{
13 id: 'manifest',
14 name: 'Manifest',
15 path: '.claude-plugin/plugin.json',
16 required: "Required by Anthropic's directory",
17 lines: [{
18 depth: 0,
19 kind: 'folder',
20 text: '.claude-plugin/'
21 }, {
22 depth: 1,
23 kind: 'file',
24 text: 'plugin.json'
25 }],
26 href: '/en/plugins/manifest-reference#manifest-file',
27 linkText: 'Go to the manifest reference'
28 }, {
29 id: 'skills',
30 name: 'Skills',
31 path: 'skills/review/SKILL.md',
32 lines: [{
33 depth: 0,
34 kind: 'folder',
35 text: 'skills/'
36 }, {
37 depth: 1,
38 kind: 'folder',
39 text: 'review/'
40 }, {
41 depth: 2,
42 kind: 'file',
43 text: 'SKILL.md'
44 }],
45 href: '/en/plugins/components#skills',
46 linkText: 'Go to the Skills section'
47 }, {
48 id: 'commands',
49 name: 'Commands',
50 path: 'commands/about.md',
51 lines: [{
52 depth: 0,
53 kind: 'folder',
54 text: 'commands/'
55 }, {
56 depth: 1,
57 kind: 'file',
58 text: 'about.md'
59 }],
60 href: '/en/plugins/components#commands',
61 linkText: 'Go to the Commands section'
62 }, {
63 id: 'agents',
64 name: 'Agents',
65 path: 'agents/security-reviewer.md',
66 lines: [{
67 depth: 0,
68 kind: 'folder',
69 text: 'agents/'
70 }, {
71 depth: 1,
72 kind: 'file',
73 text: 'security-reviewer.md'
74 }],
75 href: '/en/plugins/components#agents',
76 linkText: 'Go to the Agents section'
77 }, {
78 id: 'hooks',
79 name: 'Hooks',
80 path: 'hooks/hooks.json',
81 lines: [{
82 depth: 0,
83 kind: 'folder',
84 text: 'hooks/'
85 }, {
86 depth: 1,
87 kind: 'file',
88 text: 'hooks.json'
89 }],
90 href: '/en/plugins/components#hooks',
91 linkText: 'Go to the Hooks section'
92 }, {
93 id: 'monitors',
94 name: 'Monitors',
95 path: 'monitors/monitors.json',
96 lines: [{
97 depth: 0,
98 kind: 'folder',
99 text: 'monitors/'
100 }, {
101 depth: 1,
102 kind: 'file',
103 text: 'monitors.json'
104 }],
105 href: '/en/plugins/components#monitors',
106 linkText: 'Go to the Monitors section'
107 }, {
108 id: 'output-styles',
109 name: 'Output styles',
110 path: 'output-styles/terse.md',
111 lines: [{
112 depth: 0,
113 kind: 'folder',
114 text: 'output-styles/'
115 }, {
116 depth: 1,
117 kind: 'file',
118 text: 'terse.md'
119 }],
120 href: '/en/plugins/components#themes-and-output-styles',
121 linkText: 'Go to the Themes and output styles section'
122 }, {
123 id: 'themes',
124 name: 'Themes',
125 path: 'themes/dracula.json',
126 lines: [{
127 depth: 0,
128 kind: 'folder',
129 text: 'themes/'
130 }, {
131 depth: 1,
132 kind: 'file',
133 text: 'dracula.json'
134 }],
135 href: '/en/plugins/components#themes-and-output-styles',
136 linkText: 'Go to the Themes and output styles section'
137 }, {
138 id: 'workflows',
139 name: 'Workflows',
140 path: 'workflows/audit-routes.js',
141 lines: [{
142 depth: 0,
143 kind: 'folder',
144 text: 'workflows/'
145 }, {
146 depth: 1,
147 kind: 'file',
148 text: 'audit-routes.js'
149 }],
150 href: '/en/workflows#distribute-a-workflow-in-a-plugin',
151 linkText: 'Go to Distribute a workflow in a plugin'
152 }, {
153 id: 'bin',
154 name: 'Executables',
155 path: 'bin/hello-plugin',
156 lines: [{
157 depth: 0,
158 kind: 'folder',
159 text: 'bin/'
160 }, {
161 depth: 1,
162 kind: 'file',
163 text: 'hello-plugin'
164 }],
165 href: '/en/plugins/components#executables',
166 linkText: 'Go to the Executables section'
167 }, {
168 id: 'scripts',
169 name: 'Scripts',
170 path: 'scripts/format.sh',
171 lines: [{
172 depth: 0,
173 kind: 'folder',
174 text: 'scripts/'
175 }, {
176 depth: 1,
177 kind: 'file',
178 text: 'format.sh'
179 }],
180 href: '/en/plugins/components#hooks',
181 linkText: 'Go to the Hooks section'
182 }, {
183 id: 'settings',
184 name: 'Default settings',
185 path: 'settings.json',
186 lines: [{
187 depth: 0,
188 kind: 'file',
189 text: 'settings.json'
190 }],
191 href: '/en/plugins/components#default-settings',
192 linkText: 'Go to the Default settings section'
193 }, {
194 id: 'mcp',
195 name: 'MCP servers',
196 path: '.mcp.json',
197 lines: [{
198 depth: 0,
199 kind: 'file',
200 text: '.mcp.json'
201 }],
202 href: '/en/plugins/components#mcp-servers',
203 linkText: 'Go to the MCP servers section'
204 }, {
205 id: 'lsp',
206 name: 'LSP servers',
207 path: '.lsp.json',
208 lines: [{
209 depth: 0,
210 kind: 'file',
211 text: '.lsp.json'
212 }],
213 href: '/en/plugins/components#lsp-servers',
214 linkText: 'Go to the LSP servers section'
215 }];
216 const [selectedId, setSelectedId] = useState('manifest');
217 const [isFullscreen, setIsFullscreen] = useState(false);
218 const rootRef = useRef(null);
219 useEffect(() => {
220 const onFsChange = () => setIsFullscreen(!!document.fullscreenElement);
221 document.addEventListener('fullscreenchange', onFsChange);
222 return () => document.removeEventListener('fullscreenchange', onFsChange);
223 }, []);
224 const toggleFullscreen = () => {
225 if (!rootRef.current) return;
226 if (document.fullscreenElement) document.exitFullscreen(); else rootRef.current.requestFullscreen().catch(() => {});
227 };
228 const selected = PIECES.find(p => p.id === selectedId) || PIECES[0];
229 const onTreeKeyDown = e => {
230 const keys = ['ArrowDown', 'ArrowUp', 'Home', 'End'];
231 if (keys.indexOf(e.key) === -1) return;
232 const i = PIECES.findIndex(p => p.id === selectedId);
233 let next = i;
234 if (e.key === 'ArrowDown') next = Math.min(PIECES.length - 1, i + 1);
235 if (e.key === 'ArrowUp') next = Math.max(0, i - 1);
236 if (e.key === 'Home') next = 0;
237 if (e.key === 'End') next = PIECES.length - 1;
238 e.preventDefault();
239 if (next === i) return;
240 const id = PIECES[next].id;
241 setSelectedId(id);
242 const el = document.getElementById('pe-node-' + id);
243 if (el) el.focus();
244 };
245 const FolderIcon = () => <svg className="pe-icon" width="15" height="15" viewBox="0 0 16 16" fill="none" stroke="currentColor" strokeWidth="1.3" strokeLinejoin="round" aria-hidden="true">
246 <path d="M1.5 4.5a1 1 0 0 1 1-1h3.2l1.3 1.5h6a1 1 0 0 1 1 1V12a1 1 0 0 1-1 1h-10.5a1 1 0 0 1-1-1z" />
247 </svg>;
248 const FileIcon = () => <svg className="pe-icon" width="15" height="15" viewBox="0 0 16 16" fill="none" stroke="currentColor" strokeWidth="1.3" strokeLinejoin="round" aria-hidden="true">
249 <path d="M4 1.5h5.5L13 5v9.5H4z" />
250 <path d="M9.5 1.5V5H13" />
251 </svg>;
252 return <div ref={rootRef} className={isFullscreen ? 'pe-root pe-fullscreen not-prose' : 'pe-root not-prose'} data-selected={selected.id}>
253 <style>{`
254 .pe-root {
255 --pe-mono: var(--font-mono, ui-monospace, SFMono-Regular, Menlo, monospace);
256 --pe-accent: #D97757;
257 --pe-accent-text: #A8502F;
258 --pe-accent-bg: rgba(217,119,87,0.10);
259 --pe-bg: #FFFFFF;
260 --pe-surface: #FAFAF7;
261 --pe-hover: #F0EEE6;
262 --pe-border: #E8E6DC;
263 --pe-text: #141413;
264 --pe-text-2: #3D3D3A;
265 --pe-text-3: #5E5D59;
266 font-family: inherit;
267 background: var(--pe-bg);
268 color: var(--pe-text);
269 border: 1px solid var(--pe-border);
270 border-radius: 12px;
271 margin: 1.5rem 0;
272 overflow: hidden;
273 box-sizing: border-box;
274 }
275 .dark .pe-root {
276 --pe-accent-text: #EBA98F;
277 --pe-accent-bg: rgba(217,119,87,0.18);
278 --pe-bg: #1A1918;
279 --pe-surface: #232221;
280 --pe-hover: #2E2D2B;
281 --pe-border: #3A3936;
282 --pe-text: #F1EFE9;
283 --pe-text-2: #D6D4CA;
284 --pe-text-3: #B8B5AD;
285 }
286 .pe-root *, .pe-root *::before, .pe-root *::after { box-sizing: border-box; }
287 .pe-head { display: flex; align-items: flex-start; gap: 12px; padding: 18px 24px 16px; border-bottom: 1px solid var(--pe-border); }
288 .pe-head-text { flex: 1; min-width: 0; }
289 .pe-fs-btn { flex-shrink: 0; width: 32px; height: 32px; display: inline-flex; align-items: center; justify-content: center; border: 1px solid var(--pe-border); border-radius: 6px; background: var(--pe-surface); color: var(--pe-text-2); font-size: 15px; line-height: 1; cursor: pointer; }
290 .pe-fs-btn:hover { background: var(--pe-hover); }
291 .pe-fs-btn:focus-visible { outline: 2px solid var(--pe-accent); outline-offset: 2px; }
292 .pe-fullscreen { border-radius: 0; height: 100vh; display: flex; flex-direction: column; overflow: auto; }
293 .pe-fullscreen .pe-body { flex: 1; }
294 .pe-title { font-size: 19px; font-weight: 600; line-height: 1.3; color: var(--pe-text); margin: 0; }
295 .pe-sub { font-size: 15px; line-height: 1.5; color: var(--pe-text-3); margin: 4px 0 0; }
296 .pe-sub code { font-family: var(--pe-mono); font-size: 0.88em; padding: 1px 5px; border-radius: 4px; background: var(--pe-surface); border: 1px solid var(--pe-border); }
297 .pe-body { display: flex; align-items: stretch; }
298 .pe-tree-pane { width: 270px; flex-shrink: 0; background: var(--pe-surface); border-right: 1px solid var(--pe-border); padding: 16px 0 12px; }
299 .pe-panel { flex: 1; min-width: 0; padding: 16px 24px 24px; }
300 .pe-caption { font-size: 13px; font-weight: 600; color: var(--pe-text-3); margin: 0 0 10px; }
301 .pe-tree-pane .pe-caption { padding: 0 16px; }
302 .pe-rootline { display: flex; align-items: center; gap: 7px; padding: 3px 16px; font-family: var(--pe-mono); font-size: 13.5px; color: var(--pe-text-3); }
303 .pe-node {
304 display: block; width: 100%; margin: 0; padding: 3px 16px 3px 30px; text-align: left; cursor: pointer;
305 background: transparent; color: var(--pe-text-2);
306 border: none; border-left: 3px solid transparent;
307 font-family: var(--pe-mono); font-size: 13.5px; line-height: 1.4;
308 }
309 .pe-node:hover { background: var(--pe-hover); }
310 .pe-node:focus-visible { outline: 2px solid var(--pe-accent); outline-offset: -2px; }
311 .pe-node[aria-pressed="true"] { background: var(--pe-accent-bg); border-left-color: var(--pe-accent); color: var(--pe-accent-text); font-weight: 600; }
312 .pe-line { display: flex; align-items: center; gap: 7px; padding: 2px 0; }
313 .pe-line-tree { flex-wrap: wrap; }
314 .pe-line-tree .pe-req { flex-basis: 100%; margin: 2px 0 0 22px; white-space: normal; width: fit-content; max-width: calc(100% - 22px); }
315 .pe-line span { overflow-wrap: anywhere; }
316 .pe-piece { display: none; font-size: 16px; line-height: 1.6; color: var(--pe-text-2); }
317 .pe-root[data-selected="manifest"] .pe-piece[data-piece="manifest"],
318 .pe-root[data-selected="skills"] .pe-piece[data-piece="skills"],
319 .pe-root[data-selected="commands"] .pe-piece[data-piece="commands"],
320 .pe-root[data-selected="agents"] .pe-piece[data-piece="agents"],
321 .pe-root[data-selected="hooks"] .pe-piece[data-piece="hooks"],
322 .pe-root[data-selected="monitors"] .pe-piece[data-piece="monitors"],
323 .pe-root[data-selected="output-styles"] .pe-piece[data-piece="output-styles"],
324 .pe-root[data-selected="themes"] .pe-piece[data-piece="themes"],
325 .pe-root[data-selected="workflows"] .pe-piece[data-piece="workflows"],
326 .pe-root[data-selected="bin"] .pe-piece[data-piece="bin"],
327 .pe-root[data-selected="scripts"] .pe-piece[data-piece="scripts"],
328 .pe-root[data-selected="settings"] .pe-piece[data-piece="settings"],
329 .pe-root[data-selected="mcp"] .pe-piece[data-piece="mcp"],
330 .pe-root[data-selected="lsp"] .pe-piece[data-piece="lsp"] { display: block; }
331 .pe-piece p { margin: 0 0 10px; }
332 .pe-piece p:last-child { margin-bottom: 0; }
333 .pe-piece code { font-family: var(--pe-mono); font-size: 0.88em; padding: 1px 5px; border-radius: 4px; background: var(--pe-surface); border: 1px solid var(--pe-border); }
334 .pe-piece .code-block { margin: 12px 0 0; }
335 .pe-piece pre code { padding: 0; border: none; background: none; }
336 .pe-piece a { color: var(--pe-accent-text); }
337 .pe-line-compact { display: none; }
338 .pe-icon { flex-shrink: 0; }
339 .pe-req { margin-left: 8px; padding: 0 6px; border-radius: 999px; font-size: 11px; line-height: 18px; letter-spacing: .02em; color: var(--pe-accent-text); border: 1px solid var(--pe-border); background: var(--pe-surface); white-space: nowrap; font-weight: 500; vertical-align: middle; }
340 .pe-name { font-size: 22px; font-weight: 600; line-height: 1.25; letter-spacing: -0.2px; color: var(--pe-text); margin: 0; }
341 .pe-path { font-family: var(--pe-mono); font-size: 13.5px; color: var(--pe-accent-text); margin: 4px 0 0; overflow-wrap: anywhere; }
342 .pe-block { margin: 20px 0 0; }
343 .pe-link {
344 display: inline-block; margin: 24px 0 0; padding: 8px 14px; border-radius: 8px;
345 font-size: 14.5px; font-weight: 600; text-decoration: none;
346 color: var(--pe-accent-text); background: var(--pe-accent-bg); border: 1px solid var(--pe-accent);
347 }
348 .pe-link:hover { filter: brightness(0.97); }
349 .pe-link:focus-visible { outline: 2px solid var(--pe-accent); outline-offset: 2px; }
350 @media (max-width: 700px) {
351 .pe-head { padding: 16px 16px 14px; }
352 .pe-body { flex-direction: column; }
353 .pe-tree-pane { width: 100%; border-right: none; border-bottom: 1px solid var(--pe-border); }
354 .pe-line-tree { display: none; }
355 .pe-line-compact { display: flex; }
356 .pe-panel { padding: 16px 16px 20px; }
357 }
358 `}</style>
359
360 <div className="pe-head">
361 <div className="pe-head-text">
362 <div className="pe-title">What goes in a plugin</div>
363 <div className="pe-sub">This example plugin, <code>my-plugin</code>, has one of every kind of component, each in its default location. Select a file or folder to read what it’s for and see what goes in it.</div>
364 </div>
365 <button type="button" className="pe-fs-btn" onClick={toggleFullscreen} aria-label={isFullscreen ? 'Exit fullscreen' : 'Fullscreen'} title={isFullscreen ? 'Exit fullscreen' : 'Fullscreen'}>
366 {isFullscreen ? '⤡' : '⛶'}
367 </button>
368 </div>
369
370 <div className="pe-body">
371 <div className="pe-tree-pane">
372 <div className="pe-caption" id="pe-tree-caption">Plugin directory</div>
373 <div role="group" aria-labelledby="pe-tree-caption" onKeyDown={onTreeKeyDown}>
374 <div className="pe-rootline"><FolderIcon /><span>my-plugin/</span></div>
375 {PIECES.map(p => <button key={p.id} id={'pe-node-' + p.id} type="button" className="pe-node" aria-pressed={p.id === selected.id} aria-label={p.name + ', ' + p.path} onClick={() => setSelectedId(p.id)}>
376 {p.lines.map((line, i) => <span key={i} className="pe-line pe-line-tree" style={{
377 paddingLeft: line.depth * 18 + 'px'
378 }}>
379 {line.kind === 'folder' ? <FolderIcon /> : <FileIcon />}
380 <span>{line.text}</span>
381 {p.required && i === p.lines.length - 1 ? <span className="pe-req">{p.required}</span> : null}
382 </span>)}
383 <span className="pe-line pe-line-compact">
384 <FileIcon />
385 <span>{p.path}</span>
386 {p.required ? <span className="pe-req">{p.required}</span> : null}
387 </span>
388 </button>)}
389 </div>
390 </div>
391
392 <div className="pe-panel" role="region" aria-labelledby="pe-panel-caption" aria-live="polite" aria-atomic="true">
393 <div className="pe-caption" id="pe-panel-caption">Selected piece</div>
394 <div className="pe-name">{selected.name}{selected.required ? <span className="pe-req">{selected.required}</span> : null}</div>
395 <div className="pe-path">{selected.path}</div>
396
397 <div className="pe-block">{children}</div>
398
399 <a className="pe-link" href={selected.href}>{selected.linkText}</a>
400 </div>
401 </div>
402 </div>;
403};
404
405Ein Claude Code-Plugin wird aus Komponenten erstellt, wie Skills, Agents, Hooks und MCP-Servern. Jede Komponente hat einen Standard-Ordner im Plugin, einen optionalen Manifest-Schlüssel in `.claude-plugin/plugin.json`, der diesen Ordner ersetzt oder ergänzt, und einen Namen, den der Benutzer sieht. Für jede Schlüssels vollständige Feldtabelle siehe die [Manifest-Referenz](/docs/de/plugins/manifest-reference#fields).
406
407Verwenden Sie diese Seite, um eine Komponente zu einem Plugin hinzuzufügen, das bereits geladen wird.
408
409Nachdem Sie eine Komponente hinzugefügt haben, führen Sie `/reload-plugins` in einer laufenden Sitzung aus oder starten Sie eine neue, damit Claude Code sie lädt. Um die Datei der Komponente vor dem Laden zu überprüfen, führen Sie [`claude plugin validate .`](/docs/de/plugins/cli-reference#plugin-validate) in Ihrer Shell aus dem Plugin-Verzeichnis aus.
410
411<Note>
412 Diese Fälle werden auf anderen Seiten behandelt:
413
414 * **Ihr erstes Plugin erstellen**: Beginnen Sie mit [Plugin erstellen](/docs/de/plugins/create)
415 * **Plugin von jemand anderem installieren**: Siehe [Plugins installieren](/docs/de/plugins/install)
416 * **Ihre Plugin-Benutzer sind auf claude.ai oder in Cowork**: Ein anderer Satz von Komponenten wird dort geladen. Siehe [Plugins auf claude.ai und in Cowork](https://claude.com/docs/plugins/overview)
417</Note>
418
419<h2 id="explore-the-plugin-directory">
420 Plugin-Verzeichnis erkunden
421</h2>
422
423Der Explorer zeigt ein Beispiel-Plugin, `my-plugin`, das an seinem Standard-Speicherort eine von jeder Art von Komponente hat:
424
425* Ein Review-Skill und einen `about`-Befehl
426* Einen Security-Review-Subagenten
427* Einen Hook, der Dateien nach Claude-Bearbeitungen formatiert, und den `scripts/`-Ordner, den er aufruft
428* Einen Log-Monitor
429* Einen Output-Stil und ein Farbschema
430* Einen Route-Audit-Workflow
431* Eine `hello-plugin`-Ausführungsdatei
432* Standard-Einstellungen
433* Einen lokalen MCP-Server und einen Go-Sprachserver
434
435Jede Datei ist das kleinste gültige Beispiel ihres Formats, um die Form zu zeigen, nicht um nützlich zu sein: Ein echter Skill oder Agent trägt vollständige Anweisungen und oft unterstützende Dateien, und ein echter Hook oder Monitor führt echte Arbeit aus. Die Abschnitte nach dem Explorer verwenden die gleichen Dateien als ihre Beispiele und verlinken auf vollständigere. Wählen Sie eine Datei oder einen Ordner aus, um zu lesen, wofür sie gedacht ist, zu sehen, was darin geht, und den Abschnitt zu finden, der sie behandelt.
436
437<PluginExplorer>
438 <Piece id="manifest">
439 Das [Manifest](/docs/de/plugins/manifest-reference) ist die `plugin.json`-Datei im `.claude-plugin/`-Verzeichnis eines Plugins. Sie enthält die Metadaten des Plugins und die `userConfig`-Werte, die Claude Code den Benutzer fragt. Nur `name` ist erforderlich. In diesem Fall ist `description` der Text, den Benutzer für das Plugin in `/plugin` sehen, und `version` hält Benutzer auf dieser Version, bis Sie sie ändern:
440
441 ```json theme={null}
442 {
443 "name": "my-plugin",
444 "version": "1.0.0",
445 "description": "Review, formatting, and database tools for this team"
446 }
447 ```
448 </Piece>
449
450 <Piece id="skills">
451 Ein [Skill](/docs/de/skills) ist eine `SKILL.md`-Datei. Speichern Sie jeden Skill in seinem eigenen Verzeichnis unter `skills/`. Claude liest die `description` jedes Skills, und wenn das, was der Benutzer fragt, damit übereinstimmt, wie zum Beispiel Claude zu bitten, einen Pull Request zu überprüfen, lädt Claude die Anweisungen des Skills und folgt ihnen. Der Benutzer kann ihn auch direkt als `/my-plugin:review` ausführen:
452
453 ```markdown theme={null}
454 ---
455 description: Reviews a pull request for style and test coverage. Use when asked to review code.
456 ---
457
458 Review the changed files. Report style problems first, then missing tests.
459 ```
460 </Piece>
461
462 <Piece id="commands">
463 Ein Befehl ist eine einzelne Markdown-Datei, die der Benutzer nach Name ausführt. Befehle sind das ältere Format: Ein Skill wird auf die gleiche Weise nach Name ausgeführt und kann auch unterstützende Dateien in seinem eigenen Verzeichnis tragen, daher schreiben Sie neue als Skills und behalten Sie `commands/` für Dateien, die Sie bereits haben. Diese Datei wird zu `/my-plugin:about` und nimmt die gleiche Frontmatter wie ein Skill:
464
465 ```markdown theme={null}
466 ---
467 description: Summarize the repository
468 ---
469
470 Summarize what this repository does in three sentences.
471 ```
472 </Piece>
473
474 <Piece id="agents">
475 Ein [Subagent](/docs/de/sub-agents) ist ein separater Assistent mit seinen eigenen Anweisungen und seinem eigenen Kontextfenster, dem Claude eine Aufgabe delegieren und ein Ergebnis zurückbekommen kann. Jede Markdown-Datei unter `agents/` definiert einen: Die Frontmatter benennt ihn und sagt, wann er zu verwenden ist, und der Text ist sein System-Prompt. Dieser wird `my-plugin:security-reviewer` genannt, und der Benutzer kann ihn mit `@agent-my-plugin:security-reviewer` aufrufen:
476
477 ```markdown theme={null}
478 ---
479 name: security-reviewer
480 description: Reviews code changes for security issues. Use after edits to authentication or input handling.
481 model: sonnet
482 ---
483
484 You are a security reviewer. Read the changed files and report injection, authentication, and secrets-handling risks.
485 ```
486 </Piece>
487
488 <Piece id="hooks">
489 Ein [Hook](/docs/de/hooks-guide) führt etwas automatisch an einem Punkt im Lebenszyklus von Claude Code aus, wie zum Beispiel nach jeder Dateibearbeitung: ein Shell-Befehl, eine HTTP-Anfrage, ein MCP-Tool-Aufruf, ein Prompt an ein Modell oder ein Subagent. Speichern Sie die Hooks des Plugins in `hooks/hooks.json` im Plugin-Root. Dieser führt das `scripts/format.sh` des Plugins nach jedem Write oder Edit aus:
490
491 ```json theme={null}
492 {
493 "hooks": {
494 "PostToolUse": [
495 {
496 "matcher": "Write|Edit",
497 "hooks": [
498 {
499 "type": "command",
500 "command": "\"${CLAUDE_PLUGIN_ROOT}/scripts/format.sh\""
501 }
502 ]
503 }
504 ]
505 }
506 }
507 ```
508 </Piece>
509
510 <Piece id="monitors">
511 Ein Monitor ist ein Shell-Befehl, den Claude Code im Hintergrund startet, wenn die Sitzung startet, und der läuft, bis sie endet, unter Verwendung des [Monitor-Tools](/docs/de/tools-reference#monitor-tool). Was er ausgibt, erreicht Claude als Benachrichtigungen. Ein `when`-Feld kann ihn stattdessen starten, wenn ein benannter Skill zum ersten Mal ausgeführt wird. Dieser verfolgt ein Fehlerprotokoll:
512
513 ```json theme={null}
514 [
515 {
516 "name": "error-log",
517 "command": "tail -F ./logs/error.log",
518 "description": "Application error log"
519 }
520 ]
521 ```
522 </Piece>
523
524 <Piece id="output-styles">
525 Ein Plugin kann [Output-Stile](/docs/de/output-styles) enthalten, die ändern, wie Claude seine Antworten formatiert und formuliert. Speichern Sie jeden Output-Stil als `output-styles/<name>.md`. Dieser erscheint in `/output-style` als `my-plugin:terse`:
526
527 ```markdown theme={null}
528 ---
529 name: terse
530 description: Answer in as few words as possible
531 keep-coding-instructions: true
532 ---
533
534 Keep every reply short. Skip preambles and summaries.
535 ```
536 </Piece>
537
538 <Piece id="themes">
539 Ein Plugin kann [Farbschemas](/docs/de/terminal-config#create-a-custom-theme) für die Claude Code-Schnittstelle enthalten. Speichern Sie jedes Schema als `themes/<slug>.json`. Dieses erscheint in `/theme` als `Dracula`, markiert als von `my-plugin`:
540
541 ```json theme={null}
542 {
543 "name": "Dracula",
544 "base": "dark",
545 "overrides": {
546 "claude": "#bd93f9",
547 "error": "#ff5555"
548 }
549 }
550 ```
551 </Piece>
552
553 <Piece id="workflows">
554 Der `workflows/`-Ordner enthält [Workflow](/docs/de/workflows) `.js`-Dateien: einen `meta`-Block, dann einen Script-Text, der mehrere Subagenten orchestriert. Dieser läuft als `/my-plugin:audit-routes`:
555
556 ```javascript theme={null}
557 export const meta = {
558 name: 'audit-routes',
559 description: 'Audit every route handler for missing auth checks',
560 }
561
562 const found = await agent('List every .ts file under src/routes/.', {
563 schema: { type: 'object', required: ['files'], properties: { files: { type: 'array', items: { type: 'string' } } } },
564 })
565
566 const audits = await pipeline(found.files, file =>
567 agent(`Audit ${file} for missing authentication checks.`, { label: file }),
568 )
569
570 return audits.filter(Boolean)
571 ```
572 </Piece>
573
574 <Piece id="bin">
575 `bin/` ist, wie ein Plugin ein Befehlszeilentool versendet. Während das Plugin aktiviert ist, setzt Claude Code diesen Ordner auf den `PATH` der Shell, in der es Befehle ausführt, damit Claude oder die Anweisungen eines Skills das Tool nach Name ausführen können, ohne dass der Benutzer etwas installieren muss. Mit dieser [ausführbaren Datei](#executables) an Ort und Stelle ist `hello-plugin` ein Befehl, den Claude ausführen kann:
576
577 ```bash theme={null}
578 #!/bin/bash
579 echo "hello from my-plugin"
580 ```
581 </Piece>
582
583 <Piece id="scripts">
584 Der Hook in `hooks/hooks.json` führt ein Script aus, und dieser Ordner ist, wo das Beispiel es behält. Der Name `scripts/` ist eine Konvention, nicht etwas, das Claude Code sucht: Der Hook zeigt auf die Datei nach ihrem Pfad, `${CLAUDE_PLUGIN_ROOT}/scripts/format.sh`. Ein Formatter-Script könnte so aussehen:
585
586 ```bash theme={null}
587 #!/bin/bash
588 npx prettier --write .
589 ```
590 </Piece>
591
592 <Piece id="settings">
593 Eine `settings.json` im Plugin-Root hält [Einstellungen](/docs/de/settings-reference), die gelten, während das Plugin aktiviert ist, damit ein Plugin ändern kann, wie sich die Sitzung verhält, und nicht nur Komponenten hinzufügt. Nur zwei Schlüssel wirken sich von einem Plugin aus, [`agent`](/docs/de/settings-reference#agent) und [`subagentStatusLine`](/docs/de/settings-reference#subagentstatusline); jeder andere Schlüssel wird gelöscht. Siehe [Standard-Einstellungen](#default-settings).
594
595 Dieser setzt `agent`, der die Haupt-Thread-Sitzung als den eigenen `security-reviewer`-Agent des Plugins ausführt, damit der System-Prompt, die Tool-Einschränkungen und das Modell dieses Agenten auf die ganze Sitzung angewendet werden:
596
597 ```json theme={null}
598 {
599 "agent": "security-reviewer"
600 }
601 ```
602 </Piece>
603
604 <Piece id="mcp">
605 Ein [MCP-Server](/docs/de/mcp) gibt Claude Tools von einem externen System. Deklarieren Sie ihn in `.mcp.json` im Plugin-Root. Dieser startet einen lokalen Server aus einem Script im Plugin und erscheint in `/mcp` als `plugin:my-plugin:db`:
606
607 ```json theme={null}
608 {
609 "mcpServers": {
610 "db": {
611 "command": "node",
612 "args": ["${CLAUDE_PLUGIN_ROOT}/server.js"]
613 }
614 }
615 }
616 ```
617 </Piece>
618
619 <Piece id="lsp">
620 Ein LSP-Server gibt Claude [Diagnostik und Code-Navigation](/docs/de/plugins/code-intelligence) für eine Sprache. Deklarieren Sie den Server in `.lsp.json` im Plugin-Root. Dieser verbindet den Go-Sprachserver für `.go`-Dateien:
621
622 ```json theme={null}
623 {
624 "gopls": {
625 "command": "gopls",
626 "args": ["serve"],
627 "extensionToLanguage": {
628 ".go": "go"
629 }
630 }
631 }
632 ```
633 </Piece>
634</PluginExplorer>
635
636<h2 id="add-each-kind-of-component">
637 Fügen Sie jede Art von Komponente hinzu
638</h2>
639
640Jeder Abschnitt unten behandelt eine Art von Komponente: wo ihre Dateien im Plugin gehen, ein Beispiel, das validiert, was der Benutzer sieht, sobald das Plugin geladen wird, und der Manifest-Schlüssel, der den Standard-Speicherort ändert. Fügen Sie die hinzu, die Ihr Plugin benötigt; keine ist erforderlich.
641
642<h3 id="skills">
643 Skills
644</h3>
645
646Ein [Skill](/docs/de/skills) ist eine `SKILL.md`-Datei, die Claude laden kann, wenn ihre Beschreibung der Aufgabe entspricht. Der Benutzer kann ihn auch als Befehl ausführen. Speichern Sie jeden Skill in seinem eigenen Verzeichnis unter `skills/`:
647
648```text theme={null}
649my-plugin/
650├── .claude-plugin/
651│ └── plugin.json
652└── skills/
653 └── review/
654 └── SKILL.md
655```
656
657Geben Sie der `SKILL.md` eine `description`, damit Claude weiß, wann er sie verwenden soll:
658
659```markdown skills/review/SKILL.md theme={null}
660---
661description: Reviews a pull request for style and test coverage. Use when asked to review code.
662---
663
664Review the changed files. Report style problems first, then missing tests.
665```
666
667Nachdem Sie das Plugin geladen haben, führt `/my-plugin:review` den Skill aus. Der Befehlsname und wer ihn aufrufen kann, folgen diesen Regeln:
668
669* **Befehlsname**: `/<plugin>:<directory>`, also `skills/review/SKILL.md` in `my-plugin` ist `/my-plugin:review`. Wenn Sie `name` in der Frontmatter setzen, ersetzt es das letzte Segment und das Plugin-Präfix bleibt. Siehe [wie ein Skill seinen Befehlsnamen erhält](/docs/de/skills#how-a-skill-gets-its-command-name)
670* **Wer ruft ihn auf**: Claude, der Benutzer oder beide, gesteuert durch Frontmatter. Siehe [Kontrollieren Sie, wer einen Skill aufruft](/docs/de/skills#control-who-invokes-a-skill)
671
672Sie können auch Skills außerhalb des Standard-`skills/`-Verzeichnisses platzieren:
673
674* **Zusätzliche Verzeichnisse**: Listen Sie sie im `skills`-Manifest-Schlüssel auf. Sie ergänzen den Standard-`skills/`-Scan, anstatt ihn zu ersetzen, anders als `commands` und `agents`
675* **Ein einzelner Skill im Plugin-Root**: Ohne `skills/`-Verzeichnis und ohne `skills`-Manifest-Schlüssel lädt eine `SKILL.md` im Plugin-Root als ein Skill. Setzen Sie `name` in seiner Frontmatter, da sonst eine Marketplace-Installation den Skill nach seinem [Cache-Verzeichnis](/docs/de/plugins/loading#find-plugins-on-disk) benennt, anstatt nach Ihrem Plugin
676
677Um Anweisungen in ein Plugin einzubeziehen, schreiben Sie sie als Skill. Claude Code lädt keine `CLAUDE.md` im Plugin-Root, und `claude plugin validate` warnt `CLAUDE.md at the plugin root is not loaded as project context`.
678
679Für Frontmatter-Felder und unterstützende Dateien siehe [Skills](/docs/de/skills).
680
681<h3 id="commands">
682 Befehle
683</h3>
684
685Ein Befehl ist eine einzelne Markdown-Datei, die der Benutzer nach Name ausführt, wie `/my-plugin:about`.
686
687<Note>
688 Befehle sind das ältere Format, und [Skills](#skills) ersetzen sie für neue Arbeiten. Ein Skill wird auf die gleiche Weise nach Name ausgeführt, und er kann auch unterstützende Dateien in seinem Verzeichnis tragen. Behalten Sie `commands/` für Dateien, die Sie von `.claude/commands/` verschieben.
689</Note>
690
691Speichern Sie einen Befehl unter `commands/<file>.md` und er wird zu `/<plugin>:<file>`. Ein Unterverzeichnis fügt ein Segment hinzu, also ist `commands/db/migrate.md` `/my-plugin:db:migrate`.
692
693Befehlsdateien nehmen die gleiche Frontmatter wie Skills.
694
695<h4 id="define-commands-in-the-manifest">
696 Definieren Sie Befehle im Manifest
697</h4>
698
699Sie brauchen dies nur, wenn Sie Befehlsdateien irgendwo anders als `commands/` behalten möchten, oder um einen kurzen Befehl in `plugin.json` ohne separate Markdown-Datei zu definieren. Setzen Sie den `commands`-Manifest-Schlüssel, und Claude Code liest ihn statt `commands/` zu scannen. Der Schlüssel nimmt einen Pfad, ein Array von Pfaden oder ein Objekt, das jeden Befehlsnamen entweder auf eine `source`-Datei oder inline `content` abbildet.
700
701Dieses Manifest definiert `/my-plugin:about` inline, ohne Markdown-Datei:
702
703```json .claude-plugin/plugin.json theme={null}
704{
705 "name": "my-plugin",
706 "commands": {
707 "about": {
708 "content": "Summarize what this repository does in three sentences.",
709 "description": "Summarize the repository"
710 }
711 }
712}
713```
714
715Laden Sie das Plugin und führen Sie `/my-plugin:about` in der Sitzung aus, um zu bestätigen, dass es geladen wurde.
716
717Für die vollständige Schlüsselsyntax siehe [`commands`](/docs/de/plugins/manifest-reference#commands).
718
719<h3 id="agents">
720 Agents
721</h3>
722
723Ein [Subagent](/docs/de/sub-agents) ist ein separater Assistent mit seinen eigenen Anweisungen und Kontextfenster, dem Claude eine Aufgabe delegieren kann. Jede Markdown-Datei unter `agents/` definiert einen:
724
725```markdown agents/security-reviewer.md theme={null}
726---
727name: security-reviewer
728description: Reviews code changes for security issues. Use after edits to authentication or input handling.
729model: sonnet
730---
731
732You are a security reviewer. Read the changed files and report injection, authentication, and secrets-handling risks.
733```
734
735Dieser Agent wird `my-plugin:security-reviewer` genannt, und der Benutzer kann ihn [explizit aufrufen](/docs/de/sub-agents#invoke-subagents-explicitly) mit `@agent-my-plugin:security-reviewer`. Die Namensform ist `<plugin>:<name>`, wobei `<name>` aus der Frontmatter kommt, oder aus dem Dateinamen, wenn es keine gibt.
736
737Der `agents`-Manifest-Schlüssel ersetzt den `agents/`-Scan.
738
739<h4 id="organize-agents-in-subfolders">
740 Organisieren Sie Agents in Unterordnern
741</h4>
742
743Sie können Plugin-Agent-Dateien in Unterordnern von `agents/` platzieren. Claude Code [lädt sie rekursiv](/docs/de/sub-agents#choose-the-subagent-scope) und verbindet den Plugin-Namen, jeden Unterordnernamen und den Dateinamen mit Doppelpunkten, um den scoped Namen des Agenten zu bilden. Zum Beispiel lädt `agents/review/security.md` in einem Plugin namens `my-plugin` als `my-plugin:review:security`. Zwei Einstellungen ändern diesen Namen:
744
745* Frontmatter `name`: Sie ersetzt nur den Dateinamen, also `name: audit` in `agents/review/security.md` lädt als `my-plugin:review:audit`
746* Manifest [`agents`](/docs/de/plugins/manifest-reference#fields)-Feld: Eine Datei, die Sie dort auflisten, lädt ohne Unterordnernamen, also `"agents": "./custom/review/security.md"` lädt als `my-plugin:security`
747
748<h4 id="frontmatter-fields-in-plugin-agents">
749 Frontmatter-Felder in Plugin-Agents
750</h4>
751
752Die Frontmatter eines Plugin-Agenten folgt diesen Regeln:
753
754* **Unterstützte Felder**: `name`, `description`, `model`, `effort`, `maxTurns`, `tools`, `disallowedTools`, `skills`, `memory`, `background`, `omitClaudeMd`, `isolation`, `color` und der `cacheTtl`-Schlüssel von `experimental`. Der einzige gültige `isolation`-Wert ist `"worktree"`. Siehe [unterstützte Frontmatter-Felder](/docs/de/sub-agents#supported-frontmatter-fields) für das, was jedes tut
755* **Ignorierte Felder**: `permissionMode`, `hooks`, `mcpServers` und `initialPrompt`. Eine Agent-Datei kann nicht auf eigene Faust Hooks oder MCP-Server hinzufügen, daher fügen Sie diese stattdessen als Plugin-[Hooks](#hooks) und [MCP-Server](#mcp-servers) hinzu
756* **Frontmatter, die nicht analysiert wird**: Der Agent lädt immer noch mit jedem Feld ignoriert. Er wird nach der Datei benannt, und seine Beschreibung liest `Agent from my-plugin plugin`. Führen Sie [`claude plugin validate`](/docs/de/plugins/cli-reference#plugin-validate) in Ihrer Shell aus, um diese Dateien zu finden
757
758Für das, was jedes Feld tut und die Vorrangregeln, siehe [Subagents](/docs/de/sub-agents#supported-frontmatter-fields).
759
760<h3 id="hooks">
761 Hooks
762</h3>
763
764Ein [Hook](/docs/de/hooks-guide) führt etwas automatisch an einem Punkt im Lebenszyklus von Claude Code aus, wie zum Beispiel nach jeder Dateibearbeitung: ein Shell-Befehl, eine HTTP-Anfrage, ein MCP-Tool-Aufruf, ein Prompt an ein Modell oder ein Subagent. Speichern Sie die Hooks des Plugins in `hooks/hooks.json` im Plugin-Root, unter einem Top-Level-`"hooks"`-Schlüssel, in der gleichen Form wie das `hooks`-Objekt in `settings.json`. Das ermöglicht es Ihnen, einen bestehenden Settings-Hook unverändert zu kopieren.
765
766Dieser Hook führt ein gebündeltes Script nach jedem `Write` oder `Edit` aus:
767
768```json hooks/hooks.json theme={null}
769{
770 "hooks": {
771 "PostToolUse": [
772 {
773 "matcher": "Write|Edit",
774 "hooks": [
775 {
776 "type": "command",
777 "command": "\"${CLAUDE_PLUGIN_ROOT}/scripts/format.sh\""
778 }
779 ]
780 }
781 ]
782 }
783}
784```
785
786Speichern Sie das Script unter `scripts/format.sh` und machen Sie es ausführbar.
787
788Laden Sie das Plugin und bitten Sie Claude, eine Datei zu bearbeiten. Ein `PostToolUse`-Hook, der 0 beendet, zeigt nichts im Transkript, daher bestätigen Sie, dass er mit [Debug-Logging](/docs/de/hooks#debug-hooks) oder durch das, was das Script selbst ändert, gelaufen ist.
789
790Hooks in `hooks/hooks.json` und im `hooks`-Manifest-Schlüssel laden beide. Für jedes Ereignis und seine Nutzlast siehe [Hook-Ereignisse](/docs/de/hooks#hook-events).
791
792<h4 id="when-plugin-hooks-fire">
793 Wenn Plugin-Hooks auslösen
794</h4>
795
796Die Hooks eines Plugins warten nicht darauf, dass einer der Skills oder Befehle des Plugins verwendet wird. Claude Code registriert sie, wenn eine Sitzung das Plugin lädt, und sie lösen auf ihren Ereignissen von da an aus. Um einzuschränken, wann ein Hook läuft, verengen Sie seinen `matcher`.
797
798Wenn ein Hook nie auslöst, siehe [Hooks, die nicht auslösen](/docs/de/plugins/troubleshooting#failed-to-load-hooks-from-and-hooks-that-dont-fire).
799
800<h4 id="environment-quoting-and-matching-mcp-tools">
801 Umgebung, Anführungszeichen und Matching von MCP-Tools
802</h4>
803
804Die Umgebung des Hooks, die Anführungszeichen von `${CLAUDE_PLUGIN_ROOT}` und Matcher für die eigenen MCP-Tools des Plugins funktionieren wie folgt:
805
806* **Umgebung**: Jeder Hook-Prozess erhält `CLAUDE_PLUGIN_ROOT` und `CLAUDE_PLUGIN_DATA` in seiner Umgebung, plus `CLAUDE_PLUGIN_OPTION_<KEY>` für jeden [Benutzerkonfiguration](#user-configuration)-Wert, damit Ihr Script sie von dort lesen kann
807* **Anführungszeichen**: Wenn `command` keine `args` hat, läuft es durch eine Shell, daher wickeln Sie den `${CLAUDE_PLUGIN_ROOT}`-Pfad in doppelte Anführungszeichen, wie das Beispiel `hooks/hooks.json` unter [Hooks](#hooks) tut, um den erweiterten Pfad ein Shell-Wort zu halten. Wenn Sie stattdessen `args` übergeben, wird jedes Element als ein Argument ohne Shell übergeben und braucht keine Anführungszeichen. Siehe [Exec-Form und Shell-Form](/docs/de/hooks#exec-form-and-shell-form)
808* **Matching der eigenen MCP-Tools des Plugins**: Ein Tool von einem [MCP-Server, den dieses Plugin deklariert](#mcp-servers), wird `mcp__plugin_<plugin>_<server>__<tool>` genannt, daher schreiben Sie diesen vollständigen Namen in den Matcher. Ein Matcher nur auf dem Servernamen löst nie aus. Siehe [Match MCP-Tools](/docs/de/hooks#match-mcp-tools)
809
810<h3 id="mcp-servers">
811 MCP-Server
812</h3>
813
814Ein MCP-Server gibt Claude Tools von einem externen System. Deklarieren Sie ihn in `.mcp.json` im Plugin-Root, in der gleichen Form wie ein [Projekt `.mcp.json`](/docs/de/mcp#project-scope). Diese `.mcp.json` deklariert einen Server namens `db`:
815
816```json .mcp.json theme={null}
817{
818 "mcpServers": {
819 "db": {
820 "command": "node",
821 "args": ["${CLAUDE_PLUGIN_ROOT}/server.js"]
822 }
823 }
824}
825```
826
827Sie können auch den `mcpServers`-Wrapper weglassen und `db` auf der Top-Level der Datei platzieren.
828
829Laden Sie das Plugin und führen Sie `/mcp` aus, um zu bestätigen, dass der Server als `plugin:my-plugin:db` erscheint.
830
831`claude plugin validate` überprüft `.mcp.json` und meldet einen Server-Eintrag, den Claude Code zur Ladezeit als Fehler ablegen würde. Erfordert Claude Code v2.1.281 oder später.
832
833Für wo ein schlechter Eintrag zur Ladezeit angezeigt wird, siehe [MCP-Server, die nicht starten](/docs/de/plugins/troubleshooting#invalid-mcp-server-config-for-and-mcp-servers-that-dont-start).
834
835Der `mcpServers`-Manifest-Schlüssel nimmt eine inline Server-Map, einen Pfad zu einer JSON-Datei oder ein Array davon. Wenn ein Manifest-Server den gleichen Namen wie einer in `.mcp.json` hat, ersetzt der Manifest-Server ihn.
836
837<h4 id="reach-users-on-claude-ai-and-cowork">
838 Erreichen Sie Benutzer auf claude.ai und Cowork
839</h4>
840
841Ein lokaler Stdio-Server, wie der `db`-Server unter [MCP-Server](#mcp-servers), läuft in Claude Code und in einer Cowork-Sitzung, die auf Ihrem Computer in der Claude Desktop-App läuft, aber nicht auf claude.ai. Um Benutzer dort auch zu erreichen, referenzieren Sie einen Remote-Server durch seine `https://`-URL, die claude.ai und Cowork dem Benutzer als Connector anbieten.
842
843<h4 id="server-names-tool-names-and-reloads">
844 Server-Namen, Tool-Namen und Neuladen
845</h4>
846
847Die Namen des Servers, die Variable-Substitution und das Neuladen-Verhalten folgen diesen Regeln:
848
849* **Server-Name**: `plugin:<plugin>:<server>`, also der `db`-Server in `my-plugin` ist `plugin:my-plugin:db` in `/mcp`. Verwenden Sie die gleiche Form, um den Server in einem [`mcp_tool`-Hook](/docs/de/hooks#mcp-tool-hook-fields) zu benennen
850* **Tool-Namen**: `mcp__plugin_<plugin>_<server>__<tool>`, also ein `query`-Tool auf diesem `db`-Server ist `mcp__plugin_my-plugin_db__query`. Das ist der Name, der in [Berechtigungsregeln](/docs/de/permissions) und [Hook-Matchern](#hooks) verwendet wird
851* **Substitution**: `${CLAUDE_PLUGIN_ROOT}` und die anderen [Pfad-Variablen](#path-variables-and-persistent-data) werden in `command`, `args` und `env` ersetzt. Keine Anführungszeichen sind in `args` erforderlich, da jedes Element als ein Argument übergeben wird
852* **Neuladen**: Wenn der Benutzer `/reload-plugins` ausführt und [das Neuladen angewendet wird](/docs/de/plugins/cli-reference#reloads-that-change-mcp-tools), behält ein Server, dessen Konfiguration unverändert ist, seine Verbindung. Ein Server, dessen Konfiguration sich geändert hat, verbindet sich neu, und einer, den Sie entfernt haben, trennt sich
853
854<h4 id="include-a-packaged-mcpb-server">
855 Schließen Sie einen verpackten MCPB-Server ein
856</h4>
857
858Der `mcpServers`-Schlüssel akzeptiert auch einen verpackten Server als [MCPB-Datei](https://github.com/modelcontextprotocol/mcpb), deren Erweiterung `.mcpb` oder die ältere `.dxt` ist. Zeigen Sie den Schlüssel auf die Datei, als Pfad im Plugin oder eine `https://`-URL:
859
860```json .claude-plugin/plugin.json theme={null}
861{
862 "name": "my-plugin",
863 "mcpServers": "./servers/db.mcpb"
864}
865```
866
867Der Server nimmt seinen Namen aus dem `name` im Manifest des Bundles.
868
869Für Transporte und Authentifizierung siehe [MCP](/docs/de/mcp#plugin-provided-mcp-servers).
870
871<h3 id="lsp-servers">
872 LSP-Server
873</h3>
874
875Ein LSP-Server gibt Claude Diagnostik und Code-Navigation für eine Sprache. Wenn ein [offizielles Code-Intelligence-Plugin](/docs/de/plugins/code-intelligence) Ihre Sprache bereits abdeckt, installieren Sie das statt einen zu schreiben. Andernfalls deklarieren Sie den Server in `.lsp.json` im Plugin-Root:
876
877```json .lsp.json theme={null}
878{
879 "gopls": {
880 "command": "gopls",
881 "args": ["serve"],
882 "extensionToLanguage": {
883 ".go": "go"
884 }
885 }
886}
887```
888
889Die Datei bildet jeden Server-Namen direkt auf seine Konfiguration ab, ohne ein Wrapper-Objekt um die Map. `command` ist der Name des Binärs, mit seinen Argumenten in `args`. `extensionToLanguage` braucht mindestens eine Erweiterung, jede beginnend mit `.`.
890
891`claude plugin validate` liest diese Datei nicht. Wenn ein Eintrag ungültig ist, wird die ganze Datei zur Ladezeit übersprungen und `Invalid LSP server config for ".lsp.json"` erscheint in der `/plugin`-Registerkarte **Errors**.
892
893Ihr Plugin konfiguriert die Verbindung, installiert aber nicht das Server-Binär, und jede Dateierweiterung bekommt einen Server:
894
895* **Fehlendes Binär**: Claude Code startet `command` nach Name aus dem `PATH` des Benutzers. Wenn das Binär nicht da ist, schlägt der Server fehl zu starten und `claude --debug` protokolliert `LSP server <name> failed to start`
896* **Erweiterungs-Konflikte**: Wenn zwei aktivierte Server die gleiche Erweiterung beanspruchen, behandelt der erste registrierte diese Dateien und der andere wird nicht für sie verwendet, ob die Server von einem Plugin oder zwei kommen. Die `/plugin`-Registerkarte **Errors** zeigt die Warnung `LSP server "<name>" is not used for <ext> files`
897
898Der `lspServers`-Manifest-Schlüssel nimmt die gleiche Map inline, einen Pfad zu einer JSON-Datei oder ein Array davon, und seine Server ergänzen die in `.lsp.json`. Wenn ein Manifest-Server den gleichen Namen wie einer in `.lsp.json` hat, ersetzt der Manifest-Server ihn.
899
900Für `transport`, Timeouts, Neustarts und die anderen Felder siehe [`lspServers`](/docs/de/plugins/manifest-reference#lspservers).
901
902Senden Sie Log-Ausgabe an stderr, nicht stdout. Claude Code liest den stdout eines Servers nur als Protokoll-Nachrichten und akzeptiert Nachrichten-Header bis zu 64 KiB und einen Nachrichten-Text bis zu 32 MiB.
903
904Claude Code trennt einen Server, der eines der Limits überschreitet oder nicht-Protokoll-Ausgabe an stdout schreibt, und zählt die Trennung als Absturz für `restartOnCrash` und `maxRestarts`. Wenn Sie mit `--debug` laufen, schreibt Claude Code einen Fehler, der die Ursache benennt, in das Debug-Log.
905
906<h3 id="executables">
907 Ausführbare Dateien
908</h3>
909
910Dateien in `bin/` im Plugin-Root sind auf dem `PATH` der Shell des Bash-Tools, während das Plugin aktiviert ist, daher kann Claude sie als bloße Befehle ausführen. Fügen Sie ein ausführbares Script hinzu:
911
912```bash bin/hello-plugin theme={null}
913#!/bin/bash
914echo "hello from my-plugin"
915```
916
917Machen Sie es mit `chmod +x bin/hello-plugin` ausführbar und laden Sie das Plugin. Wenn Sie Claude bitten, `hello-plugin` auszuführen, zeigt das Bash-Tool-Ergebnis die Ausgabe des Scripts.
918
919Plugin-`bin/`-Verzeichnisse kommen nach den eigenen `PATH`-Einträgen des Benutzers, daher kann ein Plugin nicht `git`, `ls` oder einen anderen System-Befehl überschatten.
920
921claude.ai und Cowork installieren kein Plugin, das ein Top-Level-`bin/`-Verzeichnis hat, einschließlich eines, das Sie [über claude.ai-Organisationseinstellungen verteilen](/docs/de/plugins/host-marketplace#distribute-through-organization-settings).
922
923<h3 id="default-settings">
924 Standard-Einstellungen
925</h3>
926
927Um Standard-Einstellungen zu setzen, die gelten, während das Plugin aktiviert ist, fügen Sie eine `settings.json` im Plugin-Root hinzu, oder setzen Sie das gleiche Objekt inline im `settings`-Manifest-Schlüssel. Zwei Schlüssel wirken sich aus, `agent` und `subagentStatusLine`, und jeder andere Schlüssel wird gelöscht.
928
929Setzen Sie `agent`, um einen der eigenen Agents des Plugins als Haupt-Thread auszuführen:
930
931```json settings.json theme={null}
932{
933 "agent": "security-reviewer"
934}
935```
936
937Laden Sie das Plugin und starten Sie eine Sitzung. Claude antwortet dann in der Haupt-Konversation mit dem System-Prompt und Modell des `security-reviewer`-Agenten.
938
939Für alles, das der Schlüssel kontrolliert, siehe die [`agent`-Einstellung](/docs/de/settings-reference#agent).
940
941Wenn der gleiche Schlüssel an mehr als einem Ort gesetzt ist, entscheiden diese Regeln, welcher Wert angewendet wird:
942
943* **Datei über Manifest**: Wenn beide existieren und `settings.json` mindestens einen unterstützten Schlüssel setzt, wendet `settings.json` an und das Manifest `settings` wird ignoriert
944* **Benutzer-Einstellungen über Plugin-Standard**: Über Einstellungs-Quellen hinweg sind Plugin-Standard die niedrigste Schicht, daher überschreibt Ihr eigenes `agent` eines Benutzers in `~/.claude/settings.json` Ihres
945* **Zwei Plugins setzen den gleichen Schlüssel**: Der Wert vom zuletzt geladenen Plugin wendet an, und `claude --debug` protokolliert `overrides setting`
946
947Für die `subagentStatusLine`-Form siehe [Subagent-Statuszeilen](/docs/de/statusline#subagent-status-lines).
948
949<h3 id="themes-and-output-styles">
950 Themen und Output-Stile
951</h3>
952
953Ein Plugin kann Farbschemas und Output-Stile enthalten. Beide erscheinen in den gleichen Pickern wie die des Benutzers. Für jeden setzt der Manifest-Schlüssel den Ordner-Scan.
954
955| Komponente | Speichern unter | Format | Erscheint in | Manifest-Schlüssel |
956| :---------- | :------------------------ | :------------------------------------------------------------------------------------------------------------------------------------ | :------------------------------------- | :-------------------- |
957| Thema | `themes/<slug>.json` | Das [benutzerdefinierte Thema-Dateiformat](/docs/de/terminal-config#create-a-custom-theme), das Benutzer in `~/.claude/themes/` schreiben | `/theme`, unter dem `name` der Datei | `experimental.themes` |
958| Output-Stil | `output-styles/<name>.md` | Das [benutzerdefinierte Output-Stil-Format](/docs/de/output-styles#create-a-custom-output-style), mit `name` und `description`-Frontmatter | `/output-style`, als `<plugin>:<name>` | `outputStyles` |
959
960Plugin-Themen sind schreibgeschützt, daher wenn ein Benutzer eines in `/theme` bearbeitet, wird die Bearbeitung als Kopie in seinem eigenen Themen-Verzeichnis gespeichert.
961
962Dieses Thema färbt den Prompt-Akzent und Fehlertext auf der dunklen Voreinstellung um:
963
964```json themes/dracula.json theme={null}
965{
966 "name": "Dracula",
967 "base": "dark",
968 "overrides": {
969 "claude": "#bd93f9",
970 "error": "#ff5555"
971 }
972}
973```
974
975<h3 id="channels">
976 Kanäle
977</h3>
978
979Ein [Kanal](/docs/de/channels) ermöglicht es einem externen System wie einer Chat-App, Nachrichten in eine Sitzung zu senden. In einem Plugin ist ein Kanal einer der MCP-Server plus ein `channels`-Eintrag, der sich daran bindet und seine eigene Konfiguration auffordern kann. Dieses Manifest bindet einen Kanal an einen `telegram`-Server und fragt nach einem Bot-Token:
980
981```json .claude-plugin/plugin.json theme={null}
982{
983 "name": "my-plugin",
984 "mcpServers": {
985 "telegram": {
986 "command": "node",
987 "args": ["${CLAUDE_PLUGIN_ROOT}/server.js"],
988 "env": { "BOT_TOKEN": "${user_config.bot_token}" }
989 }
990 },
991 "channels": [
992 {
993 "server": "telegram",
994 "userConfig": {
995 "bot_token": {
996 "type": "string",
997 "title": "Bot token",
998 "description": "Telegram bot token",
999 "sensitive": true
1000 }
1001 }
1002 }
1003 ]
1004}
1005```
1006
1007`server` muss einem Schlüssel in `mcpServers` entsprechen. Die pro-Kanal `userConfig` nimmt die gleiche Form wie der [Top-Level-`userConfig`-Schlüssel](#user-configuration).
1008
1009Für das, was der Server implementieren muss und wie Benutzer einen Kanal-Plugin aktivieren, siehe [Als Plugin verpacken](/docs/de/channels-reference#package-as-a-plugin) in der Kanäle-Referenz. Für die Feldtabelle siehe [`channels`](/docs/de/plugins/manifest-reference#channels).
1010
1011<h3 id="monitors">
1012 Monitore
1013</h3>
1014
1015Ein Monitor ist ein Shell-Befehl, der im Hintergrund für die ganze Sitzung läuft. Was er ausgibt, erreicht Claude als Benachrichtigungen, daher kann Claude auf ein Protokoll oder eine Statusänderung reagieren, ohne gebeten zu werden, es zu beobachten. Speichern Sie die Einträge in `monitors/monitors.json`:
1016
1017```json monitors/monitors.json theme={null}
1018[
1019 {
1020 "name": "error-log",
1021 "command": "tail -F ./logs/error.log",
1022 "description": "Application error log"
1023 }
1024]
1025```
1026
1027Der Befehl läuft in einer Shell, im Arbeitsverzeichnis, in dem die Sitzung gestartet wurde.
1028
1029Der Befehl eines Monitors ist begrenzt, wo er startet und was er referenzieren kann:
1030
1031* **Nur interaktive Sitzungen**: Plugin-Monitore starten in einer interaktiven Sitzung und nie im nicht-interaktiven Modus mit dem `-p`-Flag. Sie starten auch nur, wo das [Monitor-Tool](/docs/de/tools-reference#monitor-tool) verfügbar ist
1032* **Keine Benutzerkonfiguration**: `command` erhält die [Pfad-Variablen](#path-variables-and-persistent-data) und `${ENV_VAR}` aus der Umgebung, aber nie `${user_config.*}`. Ein Monitor, der einen referenziert, startet nicht, und Monitor-Prozesse erhalten auch nicht `CLAUDE_PLUGIN_OPTION_<KEY>`
1033* **Deaktivieren während der Sitzung**: Wenn Sie ein Plugin während der Sitzung deaktivieren, stoppt Claude Code nicht die Monitore, die bereits laufen. Sie stoppen, wenn die Sitzung endet
1034
1035Der `experimental.monitors`-Manifest-Schlüssel nimmt das gleiche Array inline oder einen Pfad zu einer JSON-Datei und wird statt `monitors/monitors.json` gelesen.
1036
1037Für den `when`-Trigger und die anderen Felder siehe [`monitors`](/docs/de/plugins/manifest-reference#monitors).
1038
1039<h2 id="user-configuration">
1040 Fragen Sie den Benutzer nach Konfigurationswerten
1041</h2>
1042
1043Deklarieren Sie die Werte, die Ihr Plugin vom Benutzer benötigt, im `userConfig`-Manifest-Schlüssel, damit Benutzer nicht `settings.json` selbst bearbeiten. Jede Option erscheint in einem Dialog mit seinem `title` als Label und seiner `description` darunter.
1044
1045Setzen Sie `"sensitive": true` für einen Token oder ein Passwort. Der Dialog maskiert dann die Eingabe, und der Wert wird in sicherer Speicherung statt `settings.json` gespeichert.
1046
1047Dieses Manifest fragt nach einem Endpunkt und einem Token:
1048
1049```json .claude-plugin/plugin.json theme={null}
1050{
1051 "name": "my-plugin",
1052 "userConfig": {
1053 "api_url": {
1054 "type": "string",
1055 "title": "API URL",
1056 "description": "Base URL of your team's API"
1057 },
1058 "api_token": {
1059 "type": "string",
1060 "title": "API token",
1061 "description": "Token for your team's API",
1062 "sensitive": true
1063 }
1064 }
1065}
1066```
1067
1068<h3 id="when-the-configuration-dialog-appears">
1069 Wenn der Konfigurationsdialog erscheint
1070</h3>
1071
1072Der Dialog erscheint nur in der interaktiven `/plugin`-Schnittstelle. Er öffnet sich für jede Option, die noch nicht gesetzt ist, wenn der Benutzer eines der folgenden tut:
1073
1074* Installiert das Plugin in `/plugin`
1075* Führt `/plugin install <plugin>@<marketplace>` in einer Sitzung aus
1076* Aktiviert das Plugin aus der **Installed**-Registerkarte in `/plugin`
1077
1078Um den gleichen Dialog jederzeit zu öffnen, führt der Benutzer `/plugin configure <plugin>@<marketplace>` aus.
1079
1080Der `claude plugin install`-Shell-Befehl fordert nie `userConfig`-Werte auf. Um Werte aus der Shell zu setzen, übergeben Sie jeden als `--config KEY=VALUE`. Wenn Optionen ungesetzt bleiben, druckt der Befehl eine `userConfig options not yet set`-Zeile, die beide Wege benennt, um sie zu setzen. [Der `userConfig`-Dialog erscheint nie](/docs/de/plugins/troubleshooting#the-userconfig-dialog-never-appears) zitiert die Zeile.
1081
1082Für die Optionsfelder, wo jeder Wert gespeichert wird, wie eine Komponente einen gespeicherten Wert referenziert und welche Felder `${user_config.*}` ablehnen, siehe [Benutzerkonfiguration](/docs/de/plugins/manifest-reference#user-configuration).
1083
1084<h2 id="path-variables-and-persistent-data">
1085 Referenzieren Sie Plugin-Pfade und speichern Sie Daten
1086</h2>
1087
1088Sie wissen nicht, wo Ihr Plugin installiert wird, daher referenzieren Sie seine Dateien und Daten durch diese Variablen statt fester Pfade. Sie werden in Skill-, Befehls- und Agent-Inhalten, in Hook- und Monitor-Befehlen und in MCP- und LSP-Server-Konfigurationen ersetzt. Sie werden auch an Hook-, MCP- und LSP-Prozesse exportiert:
1089
1090* **`${CLAUDE_PLUGIN_ROOT}`**: Das Installationsverzeichnis des Plugins. Jede Version hat ihr eigenes [Cache-Verzeichnis](/docs/de/plugins/loading#find-plugins-on-disk), daher ändert sich der Pfad, wenn das Plugin aktualisiert wird. Schreiben Sie keinen Zustand dort
1091* **`${CLAUDE_PLUGIN_DATA}`**: Ein Verzeichnis, das Updates überlebt, für `node_modules`, virtuelle Umgebungen und Caches. Es wird zu `~/.claude/plugins/data/<id>/` aufgelöst und wird erstellt, wenn zuerst referenziert
1092* **`${CLAUDE_PROJECT_DIR}`**: Das Projekt-Root, der gleiche Wert, den Hooks erhalten
1093
1094Im Pfad des Daten-Verzeichnisses ist `<id>` die Plugin-ID mit jedem Zeichen außer Buchstaben, Ziffern, `_` und `-` ersetzt durch `-`, daher wird `my-plugin@my-marketplace` zu `my-plugin-my-marketplace`.
1095
1096Auf Windows verwenden die ersetzten Pfade Schrägstriche, daher liest eine Shell Backslashes nicht als Escapes.
1097
1098<h3 id="install-dependencies-into-the-data-directory">
1099 Installieren Sie Abhängigkeiten in das Daten-Verzeichnis
1100</h3>
1101
1102Für ein Marketplace-installiertes Plugin installiert Claude Code automatisch berechtigte [Node.js-Paket-Abhängigkeiten](/docs/de/plugins/loading#node-js-package-dependencies), wenn es das Plugin zwischenspeichert, daher müssen Sie sie möglicherweise nicht selbst installieren. Wenn Sie es tun, installiert dieser `SessionStart`-Hook `node_modules` in `${CLAUDE_PLUGIN_DATA}` beim ersten Lauf und erneut nach einer Aktualisierung, die `package.json` ändert:
1103
1104```json hooks/hooks.json theme={null}
1105{
1106 "hooks": {
1107 "SessionStart": [
1108 {
1109 "hooks": [
1110 {
1111 "type": "command",
1112 "command": "diff -q \"${CLAUDE_PLUGIN_ROOT}/package.json\" \"${CLAUDE_PLUGIN_DATA}/package.json\" >/dev/null 2>&1 || (cd \"${CLAUDE_PLUGIN_DATA}\" && cp \"${CLAUDE_PLUGIN_ROOT}/package.json\" . && npm install) || rm -f \"${CLAUDE_PLUGIN_DATA}/package.json\""
1113 }
1114 ]
1115 }
1116 ]
1117 }
1118}
1119```
1120
1121Nach der ersten Sitzung existiert `~/.claude/plugins/data/<id>/node_modules`. Ein MCP-Server kann dann `NODE_PATH` auf `${CLAUDE_PLUGIN_DATA}/node_modules` in seinem `env` setzen. Für welche Felder welche Variable ersetzen, siehe [Umgebungsvariablen](/docs/de/plugins/manifest-reference#environment-variables).
1122
1123<h2 id="next-steps">
1124 Nächste Schritte
1125</h2>
1126
1127* [Plugin-Manifest-Referenz](/docs/de/plugins/manifest-reference): `plugin.json`-Felder, Pfad-Regeln und das Standard-Layout
1128* [Testen Sie Plugins mit Evals](/docs/de/plugin-evals): Überprüfen Sie, dass die Komponenten, die Sie hinzugefügt haben, Claudes Verhalten so ändern, wie Sie beabsichtigen
1129* [Veröffentlichen und verteilen Sie ein Plugin](/docs/de/plugins/publish): Versionieren Sie das Plugin und setzen Sie es in einen Marketplace
1130* [Beheben Sie Plugin-Probleme](/docs/de/plugins/troubleshooting): Was zu tun ist, wenn eine Komponente nicht lädt oder ein Hook nicht auslöst