File Deleted
View Diff
1> ## Documentation Index
2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
3> Use this file to discover all available pages before exploring further.
4
5# Plugins reference
6
7> Riferimento tecnico completo per il sistema di plugin di Claude Code, inclusi schemi, comandi CLI e specifiche dei componenti.
8
9<Tip>
10 Stai cercando di installare plugin? Vedi [Scopri e installa plugin](/docs/it/discover-plugins). Per creare plugin, vedi [Plugin](/docs/it/plugins). Per distribuire plugin, vedi [Plugin marketplaces](/docs/it/plugin-marketplaces).
11</Tip>
12
13Un **plugin** è una directory autonoma di componenti che estende Claude Code con funzionalità personalizzate. I componenti del plugin includono skills, agents, hooks, server MCP, server LSP e monitor.
14
15<h2 id="plugin-components-reference">
16 Riferimento dei componenti del plugin
17</h2>
18
19<h3 id="skills">
20 Skills
21</h3>
22
23I plugin aggiungono skills a Claude Code, creando scorciatoie `/name` che tu o Claude potete invocare.
24
25**Posizione**: directory `skills/` o `commands/` nella radice del plugin, oppure un singolo file `SKILL.md` nella radice del plugin
26
27**Formato file**: Gli skills sono directory con `SKILL.md`; i commands sono semplici file markdown
28
29**Struttura skill**:
30
31```text theme={null}
32skills/
33├── pdf-processor/
34│ ├── SKILL.md
35│ ├── reference.md (opzionale)
36│ └── scripts/ (opzionale)
37└── code-reviewer/
38 └── SKILL.md
39```
40
41Gli skills e i commands vengono rilevati automaticamente quando il plugin viene installato.
42
43Se un plugin non ha una directory `skills/` e nessun campo manifest `skills`, un `SKILL.md` nella radice del plugin viene caricato come un singolo skill. Impostare il campo frontmatter `name` per controllare il nome di invocazione dello skill. Senza di esso, Claude Code ricade al nome della directory di installazione. Per un plugin [copiato nella cache](#plugin-caching-and-file-resolution), quel nome è una stringa di versione che cambia ad ogni aggiornamento. Per i plugin che forniscono più di uno skill, utilizzare il layout della directory `skills/` mostrato sopra.
44
45Negli skills e nei commands del plugin, i campi frontmatter booleani come `disable-model-invocation` accettano `yes`, `no`, `on`, `off`, `1` e `0` in qualsiasi caso di lettera, oltre a `true` e `false`. Prima della v2.1.218, Claude Code riconosceva solo `true` e `false`.
46
47Per i dettagli completi, vedere [Skills](/docs/it/skills).
48
49<h3 id="agents">
50 Agents
51</h3>
52
53I plugin possono fornire subagent specializzati per compiti specifici che Claude può invocare automaticamente quando appropriato.
54
55**Posizione**: directory `agents/` nella radice del plugin
56
57**Formato file**: File markdown che descrivono le capacità dell'agent
58
59**Struttura agent**:
60
61```markdown theme={null}
62name: agent-name
63description: In cosa si specializza questo agent e quando Claude dovrebbe invocarlo
64model: sonnet
65effort: medium
66maxTurns: 20
67disallowedTools: Write, Edit
68
69Prompt di sistema dettagliato per l'agent che descrive il suo ruolo, competenza e comportamento.
70```
71
72<h4 id="plugin-agent-frontmatter">
73 Frontmatter dell'agent del plugin
74</h4>
75
76Un file agent del plugin utilizza gli stessi [campi frontmatter di un file subagent](/docs/it/sub-agents#supported-frontmatter-fields), tranne che Claude Code onora solo alcuni di essi quando l'agent proviene da un plugin:
77
78* **Supportati**: `name`, `description`, `model`, `effort`, `maxTurns`, `tools`, `disallowedTools`, `skills`, `memory`, `background`, `omitClaudeMd`, `isolation`, `color` e `experimental`. L'unico valore `isolation` valido è `"worktree"`.
79* **Non supportati, per motivi di sicurezza**: `hooks`, `mcpServers` e `permissionMode`. Claude Code ignora questi quando carica un agent da un plugin. Per utilizzarli, copia il file agent in `.claude/agents/` o `~/.claude/agents/`.
80* **Non supportati**: `initialPrompt`.
81
82Puoi mettere i file degli agent del plugin in sottocartelle di `agents/`. Claude Code [li carica ricorsivamente](/docs/it/sub-agents#choose-the-subagent-scope) e unisce il nome del plugin, ogni nome di sottocartella e il nome del file con i due punti per formare il nome con scope dell'agent. Ad esempio, `agents/review/security.md` in un plugin denominato `my-plugin` viene caricato come `my-plugin:review:security`. Due impostazioni cambiano quel nome:
83
84* Frontmatter `name`: sostituisce solo il nome del file, quindi `name: audit` in `agents/review/security.md` viene caricato come `my-plugin:review:audit`
85* Campo manifest [`agents`](#component-path-fields): un file che elenchi lì viene caricato senza nomi di sottocartella, quindi `"agents": "./custom/review/security.md"` viene caricato come `my-plugin:security`
86
87Claude Code carica un agent del plugin anche quando il suo frontmatter non ha `name` o non viene analizzato:
88
89* Nessun `name`: Claude Code nomina l'agent in base al file, quindi `agents/reviewer.md` in un plugin denominato `my-plugin` viene caricato come `my-plugin:reviewer`
90* Frontmatter che non viene analizzato: Claude Code nomina l'agent in base al file, utilizza `Agent from my-plugin plugin` come sua descrizione e ignora ogni campo nel file
91
92Al contrario, Claude Code salta un file di progetto, utente o agent gestito il cui frontmatter non ha `name` o non viene analizzato.
93
94Per trovare i file nella directory `agents/` predefinita di un plugin il cui frontmatter non viene analizzato, eseguire `claude plugin validate`. Il percorso che passi dipende dal fatto che il plugin abbia un manifest, e entrambi gli esempi utilizzano `./my-plugin` come directory del plugin:
95
96* Un plugin con un manifest: `claude plugin validate ./my-plugin`
97* Un plugin senza un manifest: `claude plugin validate ./my-plugin/agents`. Richiede Claude Code v2.1.233 o successivo.
98
99Gli agent vengono visualizzati nella [typeahead @-mention](/docs/it/sub-agents#invoke-subagents-explicitly) con il loro nome con scope, come `my-plugin:code-reviewer`, una volta che il plugin è abilitato.
100
101Per i dettagli completi, vedere [Subagent](/docs/it/sub-agents).
102
103<h3 id="hooks">
104 Hooks
105</h3>
106
107I plugin possono fornire gestori di eventi che rispondono automaticamente agli eventi di Claude Code.
108
109**Posizione**: `hooks/hooks.json` nella radice del plugin, oppure inline in plugin.json
110
111**Formato**: Configurazione JSON con matcher di eventi e azioni
112
113`hooks/hooks.json` può contenere una chiave `$schema` di livello superiore che nomina un URL JSON Schema per l'autocompletamento dell'editor e la convalida. Claude Code ignora la chiave al momento del caricamento.
114
115**Configurazione hook**:
116
117```json theme={null}
118{
119 "hooks": {
120 "PostToolUse": [
121 {
122 "matcher": "Write|Edit",
123 "hooks": [
124 {
125 "type": "command",
126 "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/format-code.sh"
127 }
128 ]
129 }
130 ]
131 }
132}
133```
134
135Gli hook del plugin rispondono agli stessi eventi del ciclo di vita degli [hook definiti dall'utente](/docs/it/hooks):
136
137| Evento | Quando si attiva |
138| :-------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
139| `SessionStart` | Quando una sessione inizia o riprende |
140| `Setup` | Quando avvii Claude Code con `--init-only`, o con `--init` o `--maintenance` in modalità `-p`. Per la preparazione una tantum in CI o script |
141| `UserPromptSubmit` | Quando invii un prompt, prima che Claude lo elabori |
142| `UserPromptExpansion` | Quando un comando digitato dall'utente si espande in un prompt, prima che raggiunga Claude. Può bloccare l'espansione |
143| `PreToolUse` | Prima che una chiamata a uno strumento si esegua. Può bloccarla |
144| `PermissionRequest` | Quando una chiamata a uno strumento necessita di una decisione di autorizzazione |
145| `PermissionDenied` | Quando la modalità automatica nega una chiamata a uno strumento, inclusi i rifiuti senza un verdetto del classificatore. Utilizza JSON `hookSpecificOutput.retry: true` per indicare al modello che può riprovare la chiamata allo strumento negata. Claude Code ignora `retry` quando il classificatore non ha prodotto alcun verdetto |
146| `PostToolUse` | Dopo che una chiamata a uno strumento ha successo |
147| `PostToolUseFailure` | Dopo che una chiamata a uno strumento fallisce |
148| `PostToolBatch` | Dopo che un intero batch di chiamate a strumenti paralleli si risolve, prima della prossima chiamata al modello |
149| `Notification` | Quando Claude Code invia una notifica |
150| `MessageDisplay` | Mentre il testo del messaggio dell'assistente viene visualizzato |
151| `SubagentStart` | Quando un subagente viene generato |
152| `SubagentStop` | Quando un subagente termina |
153| `TaskCreated` | Quando un'attività viene creata tramite `TaskCreate` |
154| `TaskCompleted` | Quando un'attività viene contrassegnata come completata |
155| `Stop` | Quando Claude finisce di rispondere |
156| `StopFailure` | Quando il turno termina a causa di un errore API |
157| `TeammateIdle` | Quando un compagno di squadra di un [team di agenti](/docs/it/agent-teams) sta per diventare inattivo |
158| `InstructionsLoaded` | Quando un file CLAUDE.md o `.claude/rules/*.md` viene caricato nel contesto. Si attiva all'inizio della sessione e quando i file vengono caricati in modo pigro durante una sessione |
159| `ConfigChange` | Quando un file di configurazione cambia durante una sessione |
160| `CwdChanged` | Quando la directory di lavoro cambia, ad esempio quando Claude esegue un comando `cd`. Utile per la gestione reattiva dell'ambiente con strumenti come direnv |
161| `DirectoryAdded` | Quando una directory di lavoro viene aggiunta a metà sessione tramite `/add-dir` o la richiesta di controllo SDK `register_repo_root` |
162| `FileChanged` | Quando un file osservato cambia su disco. Il campo `matcher` specifica quali nomi di file osservare |
163| `WorktreeCreate` | Quando un worktree viene creato tramite `--worktree`, `isolation: "worktree"`, o per una sessione in background. Sostituisce il comportamento git predefinito |
164| `WorktreeRemove` | Quando un worktree viene rimosso all'uscita della sessione, quando un subagente termina, o quando elimini una sessione in background |
165| `PreCompact` | Prima della compattazione del contesto |
166| `PostCompact` | Dopo che la compattazione del contesto è completata |
167| `PreModelSwitch` | Prima che Claude Code applichi un cambio di modello che hai richiesto tu o un client. Può bloccare il cambio |
168| `PostModelSwitch` | Dopo che il modello della sessione cambia, inclusi i cambiamenti che Claude Code effettua autonomamente, come il ripristino del modello quando riprendi una sessione |
169| `Elicitation` | Quando un server MCP richiede input dell'utente durante una chiamata a uno strumento |
170| `ElicitationResult` | Dopo che un utente risponde a un'elicitazione MCP, prima che la risposta venga inviata al server |
171| `SessionEnd` | Quando una sessione termina |
172
173**Tipi di hook**:
174
175* `command`: eseguire comandi shell o script
176* `http`: inviare l'evento JSON come richiesta POST a un URL
177* `mcp_tool`: chiamare uno strumento su un [server MCP](/docs/it/mcp) configurato
178* `prompt`: valutare un prompt con un LLM (utilizza il placeholder `$ARGUMENTS` per il contesto)
179* `agent`: eseguire un verificatore agentico con strumenti per compiti di verifica complessi
180
181Gli hook che puntano al [server MCP bundled](#mcp-servers) del plugin devono utilizzare i suoi nomi con scope. I matcher di strumenti e i campi `if` prendono il nome dello strumento con scope `mcp__plugin_<plugin-name>_<server-name>__<tool>`, e il campo `server` di un hook `mcp_tool` prende `plugin:<plugin-name>:<server-name>`. Un matcher scritto contro la chiave del server nuda non si attiva mai. Vedere [Match MCP tools](/docs/it/hooks#match-mcp-tools) e [Plugin-provided MCP servers](/docs/it/mcp#plugin-provided-mcp-servers).
182
183<h3 id="mcp-servers">
184 MCP servers
185</h3>
186
187I plugin possono raggruppare server Model Context Protocol (MCP) per connettere Claude Code con strumenti e servizi esterni.
188
189**Posizione**: `.mcp.json` nella radice del plugin, oppure inline in plugin.json
190
191**Formato**: Configurazione standard del server MCP
192
193**Configurazione del server MCP**:
194
195```json theme={null}
196{
197 "mcpServers": {
198 "plugin-database": {
199 "command": "${CLAUDE_PLUGIN_ROOT}/servers/db-server",
200 "args": ["--config", "${CLAUDE_PLUGIN_ROOT}/config.json"],
201 "env": {
202 "DB_PATH": "${CLAUDE_PLUGIN_ROOT}/data"
203 }
204 },
205 "plugin-api-client": {
206 "command": "npx",
207 "args": ["@company/mcp-server", "--plugin-mode"]
208 }
209 }
210}
211```
212
213**Comportamento di integrazione**:
214
215* I server MCP del plugin si avviano automaticamente quando il plugin è abilitato
216* I server vengono visualizzati come strumenti MCP standard nel toolkit di Claude
217* I server del plugin possono essere configurati indipendentemente dai server MCP dell'utente
218* Se esegui [`/reload-plugins`](/docs/it/discover-plugins#apply-plugin-changes-without-restarting) a metà sessione, Claude Code mantiene le connessioni live dei server la cui configurazione è invariata
219
220<h3 id="lsp-servers">
221 LSP servers
222</h3>
223
224<Tip>
225 Stai cercando di utilizzare plugin LSP? Installali dal marketplace ufficiale: cerca "lsp" nella scheda Discover `/plugin`. Questa sezione documenta come creare plugin LSP per linguaggi non coperti dal marketplace ufficiale.
226</Tip>
227
228I plugin possono fornire server [Language Server Protocol](https://microsoft.github.io/language-server-protocol/) (LSP) per dare a Claude [intelligenza del codice in tempo reale](/docs/it/discover-plugins#code-intelligence) mentre lavori sulla tua codebase.
229
230**Posizione**: `.lsp.json` nella radice del plugin, oppure inline in `plugin.json`
231
232**Formato**: Configurazione JSON che mappa i nomi dei server di linguaggio alle loro configurazioni
233
234**Formato file `.lsp.json`**:
235
236```json theme={null}
237{
238 "go": {
239 "command": "gopls",
240 "args": ["serve"],
241 "extensionToLanguage": {
242 ".go": "go"
243 }
244 }
245}
246```
247
248**Inline in `plugin.json`**:
249
250```json theme={null}
251{
252 "name": "my-plugin",
253 "lspServers": {
254 "go": {
255 "command": "gopls",
256 "args": ["serve"],
257 "extensionToLanguage": {
258 ".go": "go"
259 }
260 }
261 }
262}
263```
264
265**Campi obbligatori:**
266
267| Field | Description |
268| :-------------------- | :------------------------------------------------------------ |
269| `command` | Il binario LSP da eseguire (deve essere in PATH) |
270| `extensionToLanguage` | Mappa le estensioni di file agli identificatori di linguaggio |
271
272**Campi opzionali:**
273
274| Field | Description |
275| :---------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
276| `args` | Argomenti della riga di comando per il server LSP |
277| `transport` | Trasporto di comunicazione: `stdio` (predefinito) o `socket`. Claude Code accetta `socket` ma esegue ogni server su stdio, quindi le regole del protocollo stdout si applicano a tutti i server |
278| `env` | Variabili di ambiente da impostare all'avvio del server |
279| `initializationOptions` | Opzioni passate al server durante l'inizializzazione |
280| `settings` | Impostazioni passate tramite `workspace/didChangeConfiguration` |
281| `workspaceFolder` | Percorso della cartella di lavoro per il server |
282| `startupTimeout` | Tempo massimo di attesa per l'avvio del server (millisecondi) |
283| `shutdownTimeout` | Tempo massimo di attesa per l'arresto graduale (millisecondi). Quando il timeout scade, Claude Code termina il processo del server. Se non impostato, non si applica alcun timeout |
284| `restartOnCrash` | Se riavviare il server dopo un crash. Predefinito su `true`. Impostare su `false` per lasciare un server bloccato fermo invece di riavviarlo |
285| `maxRestarts` | Numero massimo di tentativi di riavvio prima di rinunciare |
286| `diagnostics` | Se inserire la diagnostica nel contesto di Claude dopo le modifiche (predefinito `true`). Impostare su `false` per mantenere la navigazione del codice ma sopprimere l'iniezione automatica della diagnostica. |
287
288`restartOnCrash` e `shutdownTimeout` richiedono Claude Code v2.1.205 o successivo. Prima della v2.1.205, lo schema di configurazione accettava entrambe le opzioni ma l'impostazione di una di esse causava a Claude Code di saltare completamente quel server LSP all'avvio, con il motivo visibile solo nell'output di `claude --debug`.
289
290**Più server per la stessa estensione**: quando più di un server LSP abilitato dichiara la stessa estensione di file in `extensionToLanguage`, indipendentemente dal fatto che i server provengano da un plugin o da plugin diversi, il primo server registrato gestisce i file con quell'estensione e gli altri non si avviano mai. L'interfaccia `/plugin` mostra un avviso che nomina il plugin il cui server è attivo.
291
292**Server che non riescono a inizializzare**: Claude Code salta un server la cui configurazione non è valida, ad esempio uno che manca `command` o `extensionToLanguage`, e gli altri server configurati si avviano comunque. Eseguire `claude --debug` per vedere perché un server è stato saltato.
293
294Un server saltato non rivendica le sue estensioni di file, quindi un altro server valido che dichiara la stessa estensione, dallo stesso plugin o da un plugin diverso, gestisce comunque quei file.
295
296**Invia l'output del log a stderr, non a stdout**: Claude Code legge lo stdout di un server solo come messaggi di protocollo e accetta intestazioni di messaggi fino a 64 KiB e un corpo di messaggio fino a 32 MiB. Claude Code disconnette un server che supera uno dei due limiti o scrive output non-protocollo a stdout, e conta la disconnessione come un crash per `restartOnCrash` e `maxRestarts`. Quando esegui con `--debug`, Claude Code scrive un errore che nomina la causa nel log di debug.
297
298<Warning>
299 **Devi installare il binario del server di linguaggio separatamente.** I plugin LSP configurano come Claude Code si connette a un server di linguaggio, ma non includono il server stesso. Se vedi `Executable not found in $PATH` nella scheda Errors `/plugin`, installa il binario richiesto per il tuo linguaggio.
300</Warning>
301
302**Plugin LSP disponibili:**
303
304| Plugin | Language server | Install command |
305| :------------------ | :------------------------- | :------------------------------------------------------------------------------------------ |
306| `pyright-lsp` | Pyright (Python) | `pip install pyright` o `npm install -g pyright` |
307| `typescript-lsp` | TypeScript Language Server | `npm install -g typescript-language-server typescript` |
308| `rust-analyzer-lsp` | rust-analyzer | [Vedi rust-analyzer installation](https://rust-analyzer.github.io/manual.html#installation) |
309
310Installa il server di linguaggio per primo, quindi installa il plugin dal marketplace.
311
312<h3 id="monitors">
313 Monitors
314</h3>
315
316I plugin possono dichiarare monitor in background che Claude Code avvia automaticamente quando il plugin è attivo. Ogni monitor esegue un comando shell per la durata della sessione e fornisce ogni riga stdout a Claude come notifica, in modo che Claude possa reagire alle voci di log, ai cambiamenti di stato o agli eventi sondati senza essere chiesto di avviare il watch stesso.
317
318I monitor del plugin utilizzano lo stesso meccanismo dello [strumento Monitor](/docs/it/tools-reference#monitor-tool) e condividono i suoi vincoli di disponibilità. Vengono eseguiti solo in sessioni CLI interattive, vengono eseguiti senza sandbox allo stesso livello di fiducia degli [hook](#hooks) e vengono saltati su host dove lo strumento Monitor non è disponibile.
319
320**Posizione**: `monitors/monitors.json` nella radice del plugin, oppure inline in `plugin.json`
321
322**Formato**: Array JSON di voci di monitor
323
324Il seguente `monitors/monitors.json` osserva un endpoint di stato di distribuzione e un log di errore locale:
325
326```json theme={null}
327[
328 {
329 "name": "deploy-status",
330 "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/poll-deploy.sh",
331 "description": "Deployment status changes"
332 },
333 {
334 "name": "error-log",
335 "command": "tail -F ./logs/error.log",
336 "description": "Application error log",
337 "when": "on-skill-invoke:debug"
338 }
339]
340```
341
342Per dichiarare monitor inline, impostare `experimental.monitors` in `plugin.json` sullo stesso array. Per caricare da un percorso non predefinito, impostare `experimental.monitors` su una stringa di percorso relativo come `"./config/monitors.json"`. I monitor sono un [componente sperimentale](#experimental-components).
343
344**Campi obbligatori:**
345
346| Field | Description |
347| :------------ | :------------------------------------------------------------------------------------------------------------------------------------------ |
348| `name` | Identificatore univoco all'interno del plugin. Previene processi duplicati quando il plugin si ricarica o uno skill viene invocato di nuovo |
349| `command` | Comando shell eseguito come processo in background persistente nella directory di lavoro della sessione |
350| `description` | Breve riepilogo di ciò che viene osservato. Mostrato nel pannello attività e nei riepiloghi delle notifiche |
351
352**Campi opzionali:**
353
354| Field | Description |
355| :----- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
356| `when` | Controlla quando il monitor si avvia. `"always"` lo avvia all'avvio della sessione e al ricaricamento del plugin, ed è il predefinito. `"on-skill-invoke:<skill-name>"` lo avvia la prima volta che lo skill denominato in questo plugin viene inviato |
357
358Il valore `command` supporta le [sostituzioni di percorso](#environment-variables) `${CLAUDE_PLUGIN_ROOT}`, `${CLAUDE_PLUGIN_DATA}` e `${CLAUDE_PROJECT_DIR}`, più qualsiasi `${ENV_VAR}` dall'ambiente. Prefisso il comando con `cd "${CLAUDE_PLUGIN_ROOT}" && ` se lo script deve essere eseguito dalla directory del plugin stesso.
359
360Un `command` di monitor non può fare riferimento ai valori [`${user_config.*}`](#user-configuration). Il comando viene eseguito attraverso una shell, quindi Claude Code rifiuta il monitor con un [errore](/docs/it/errors#plugin-command-references-user-config) invece di sostituire il valore. I processi di monitor non ricevono variabili di ambiente `CLAUDE_PLUGIN_OPTION_<KEY>`, quindi fai in modo che lo script di monitor legga il valore da un file di configurazione che possiede.
361
362Se disabiliti un plugin a metà sessione, Claude Code non interrompe i monitor che sono già in esecuzione; si fermano quando la sessione termina.
363
364<h3 id="themes">
365 Themes
366</h3>
367
368I plugin possono fornire temi di colore che vengono visualizzati in `/theme` insieme ai preset integrati e ai temi locali dell'utente. Un tema è un file JSON in `themes/` con un preset `base` e una mappa sparsa `overrides` di token di colore. I temi sono un [componente sperimentale](#experimental-components).
369
370```json theme={null}
371{
372 "name": "Dracula",
373 "base": "dark",
374 "overrides": {
375 "claude": "#bd93f9",
376 "error": "#ff5555",
377 "success": "#50fa7b"
378 }
379}
380```
381
382Quando un utente seleziona un tema del plugin, Claude Code salva `custom:<plugin-name>:<slug>` nella sua configurazione. I temi del plugin sono di sola lettura: quando un utente preme `Ctrl+E` su uno in `/theme`, Claude Code lo copia in `~/.claude/themes/` in modo che possano modificare la copia.
383
384***
385
386<h2 id="plugin-installation-scopes">
387 Ambiti di installazione dei plugin
388</h2>
389
390Quando installi un plugin, scegli un **ambito** che determina dove il plugin è disponibile e chi altro può utilizzarlo:
391
392| Ambito | File di configurazione | Caso d'uso |
393| :-------- | :--------------------------------------- | :---------------------------------------------------------------------------------------------- |
394| `user` | `~/.claude/settings.json` | Plugin personali disponibili in tutti i progetti (predefinito) |
395| `project` | `.claude/settings.json` | Plugin del team condivisi tramite controllo versione |
396| `local` | `.claude/settings.local.json` | Plugin specifici del progetto, ignorati da git quando Claude Code salva un'impostazione in esso |
397| `managed` | [Managed settings](/docs/it/managed-settings) | Plugin gestiti (sola lettura, solo aggiornamento) |
398
399I plugin utilizzano lo stesso sistema di ambiti di altre configurazioni di Claude Code. Per le istruzioni di installazione e i flag di ambito, vedi [Install plugins](/docs/it/discover-plugins#install-plugins). Per una spiegazione completa degli ambiti, vedi [Configuration scopes](/docs/it/settings#where-settings-live).
400
401***
402
403<h2 id="skills-directory-plugins">
404 Plugin della directory skills
405</h2>
406
407Qualsiasi cartella sotto una directory skills che contiene un manifest `.claude-plugin/plugin.json` viene caricata come plugin denominato `<name>@skills-dir` nella sessione successiva, senza marketplace e senza passaggio di installazione. Creane uno con [`plugin init`](#plugin-init). A differenza di un'installazione marketplace copiata, il plugin viene scoperto sul posto piuttosto che copiato nella cache dei plugin.
408
409Un albero di directory skills supporta tre cose distinte:
410
411| Quello che hai | Che cosa è |
412| :-------------------------------------------- | :--------------------------------------------------------------------------------------- |
413| `<skills-dir>/foo/SKILL.md` senza manifest | Una semplice [skill](/docs/it/skills) denominata `foo` |
414| `<skills-dir>/foo/.claude-plugin/plugin.json` | Un plugin `foo@skills-dir`, che può raggruppare le proprie skills, agenti, hooks e altro |
415| `<plugin>/skills/bar/SKILL.md` | Una skill `bar` inclusa in un plugin |
416
417<h3 id="choose-where-the-plugin-loads-from">
418 Scegli da dove il plugin viene caricato
419</h3>
420
421| Directory skills | Ambito | Carica |
422| :---------------------- | :-------- | :------------------------------------------------------------------------------------------------------------------------------- |
423| `~/.claude/skills/` | personale | In ogni progetto, poiché la posizione è solo tua |
424| `<cwd>/.claude/skills/` | progetto | Solo dopo che accetti la [finestra di dialogo di trust](/docs/it/permissions#what-runs-before-you-trust-a-folder) per quella cartella |
425
426Un plugin con ambito progetto viene archiviato nel repository e raggiunge ogni collaboratore che lo clona. Poiché quel contenuto proviene dal repository piuttosto che da te, viene caricato solo dopo lo stesso gate di trust che governa le regole di autorizzazione del progetto in `.claude/settings.json`, quindi fidarsi di una cartella padre o eseguire con `-p` non è sufficiente, e i componenti che eseguono codice sono ulteriormente limitati:
427
428* I server MCP che dichiara passano attraverso la [stessa approvazione per server](/docs/it/mcp) di un `.mcp.json` del progetto
429* I server LSP si avviano solo dopo che hai fiducia nell'area di lavoro
430* I [monitor in background](#monitors) non vengono caricati
431
432I plugin con ambito personale non hanno nessuna di queste restrizioni.
433
434<Warning>
435 I plugin `@skills-dir` con ambito progetto vengono caricati solo da `.claude/skills/` della [directory di lavoro primaria](/docs/it/permissions#working-directories) della sessione. Non [risalgono alla radice del repository](/docs/it/skills#discovery-from-parent-and-nested-directories) come fanno le skill e i comandi semplici, quindi l'avvio da una sottodirectory non trova un plugin che si trova alla radice del repository. Avvia dalla radice del repository, o [sposta la sessione lì con `/cd`](/docs/it/permissions#move-the-session-to-another-directory) su v2.1.246 o successivo.
436</Warning>
437
438<h3 id="edit-reload-and-disable-a-skills-directory-plugin">
439 Modifica, ricarica e disabilita un plugin della directory skills
440</h3>
441
442Le modifiche che apporti al `SKILL.md` di una skill hanno effetto immediato nella sessione corrente. Le modifiche agli altri componenti del plugin, come `hooks/`, `.mcp.json`, `agents/` e `output-styles/`, non lo fanno. Esegui `/reload-plugins` o riavvia Claude Code per caricarli. Vedi [Live change detection](/docs/it/skills#live-change-detection).
443
444Per smettere di caricare un plugin della directory skills, elimina la sua cartella o disabilitalo per nome. Non c'è un passaggio `uninstall` perché nulla è stato installato da un marketplace.
445
446```bash theme={null}
447claude plugin disable my-tool@skills-dir
448```
449
450***
451
452<h2 id="synced-plugins">
453 Plugin sincronizzati da claude.ai
454</h2>
455
456Claude Code carica i plugin abilitati per il vostro account claude.ai, inclusi i plugin che la vostra organizzazione attiva per i suoi membri, insieme ai plugin che installate dai marketplace. Li scarica in `~/.claude/plugins/synced/` e carica ciascuno come `<name>@synced`, senza marketplace e senza record di installazione. Un plugin sincronizzato viene eseguito con la stessa fiducia di un plugin marketplace che avete installato: le sue skills, gli agenti, gli hooks, i server MCP e i server LSP si caricano tutti.
457
458Il luogo in cui Claude Code sincronizza questi plugin dipende dalla sessione:
459
460* In [Cowork](https://claude.com/product/cowork) e [sessioni cloud](/docs/it/cloud-environments#what-carries-over-from-your-setup), Claude Code li scarica nell'ambiente della sessione stessa quando la sessione inizia. Prima della v2.1.239, Claude Code caricava questi plugin come `<name>@inline`, l'identità che i plugin `--plugin-dir` utilizzano.
461* Nelle sessioni di terminale in cui vi accedete con il vostro account claude.ai, Claude Code controlla il vostro account una volta ogni volta che si avvia, quindi scarica i plugin nuovi e aggiornati e rimuove quelli che voi o la vostra organizzazione avete disabilitato, il tutto in background. La sincronizzazione nelle sessioni di terminale richiede Claude Code v2.1.273 o successivo.
462
463Il controllo di avvio viene eseguito in background, quindi può terminare dopo che la vostra sessione è iniziata. Quando aggiunge, aggiorna o rimuove un plugin sincronizzato in una sessione interattiva, Claude Code mostra `Plugins changed. Run /reload-plugins to activate.` Eseguite [`/reload-plugins`](/docs/it/discover-plugins#apply-plugin-changes-without-restarting) per caricare la modifica in quella sessione, oppure lasciatela per la prossima volta che avviate Claude Code. Se abilitate un plugin su claude.ai mentre una sessione è in esecuzione, Claude Code lo scarica la prossima volta che si avvia.
464
465La sincronizzazione dei plugin nelle sessioni di terminale viene eseguita nelle stesse condizioni di accesso delle [skills sincronizzate da claude.ai](/docs/it/skills#where-synced-skills-load). Richiede anche un accesso che conceda a Claude Code l'accesso ai plugin del vostro account.
466
467Un accesso da una versione precedente di Claude Code acquisisce l'accesso ai plugin la prossima volta che Claude Code rinnova quell'accesso in background, entro poche ore, o subito se eseguite di nuovo `/login`. La sincronizzazione dei plugin inizia la prossima volta che avviate Claude Code dopo di ciò.
468
469`claude plugin list` mostra i plugin sincronizzati sotto un'intestazione `Synced from claude.ai`, e la scheda **Installed** di `/plugin` li elenca con `synced` come loro fonte. Gestite un plugin sincronizzato tramite l'ID `<name>@synced` che `claude plugin list` stampa:
470
471* **Disabilitarne uno**: eseguite `claude plugin disable <name>@synced`, oppure disabilitatelo dalla scheda **Installed** di `/plugin`. Claude Code salva la scelta come `"<name>@synced": false` nel vostro [`enabledPlugins`](/docs/it/settings-reference#enabledplugins) a livello di utente. Per riabilitare il plugin, eseguite `claude plugin enable <name>@synced`.
472* **Mantenerlo fuori ovunque**: [disabilitate il plugin per il vostro account claude.ai](/docs/it/desktop#extend-claude-code). Per mantenerlo fuori da un progetto in ogni ambiente, impostate `"<name>@synced": false` sotto `enabledPlugins` nel `.claude/settings.json` committato di quel progetto.
473* **Gestite il plugin stesso su claude.ai**: `claude plugin install`, `update` e `uninstall` non si applicano a un plugin sincronizzato. Claude Code scarica gli aggiornamenti di un plugin alla prossima sincronizzazione. Per rimuoverne uno, disabilitate il plugin per il vostro account claude.ai, e Claude Code lo rimuove alla prossima sincronizzazione.
474* **Interrompere la sincronizzazione su una macchina**: impostate [`syncClaudeAiPlugins`](/docs/it/settings-reference#syncclaudeaiplugins) a `false` nelle vostre impostazioni utente. Claude Code smette di scaricare, e la prossima volta che si avvia sposta i plugin che ha già sincronizzato in `~/.claude/plugins/.trash/` e non li carica più. La vostra organizzazione può impostare la stessa chiave nelle [impostazioni gestite](/docs/it/managed-settings), oppure disabilitare Skills su claude.ai, il che interrompe anche la sincronizzazione dei plugin.
475
476Non potete disabilitare un plugin che la vostra organizzazione contrassegna come obbligatorio su claude.ai. Claude Code lo carica anche se lo avete disabilitato in precedenza, e `claude plugin disable` rifiuta con `Plugin "<name>@synced" is required by your organization and can't be disabled here. Contact your admin to change it.` In `claude plugin list`, questi plugin sono contrassegnati `required by your org`.
477
478Quando un plugin abilitato da qualsiasi altra fonte corrisponde al nome di un plugin sincronizzato, Claude Code carica quel plugin e segnala la copia sincronizzata come non caricata. Le altre fonti includono installazioni da marketplace, plugin [skills-directory](#skills-directory-plugins), plugin `--plugin-dir` e plugin integrati in Claude Code. Per utilizzare la copia da claude.ai, disabilitate la vostra copia. Prima della v2.1.239, Claude Code caricava la copia sincronizzata al posto di un'installazione da marketplace con lo stesso nome.
479
480***
481
482<h2 id="plugin-manifest-schema">
483 Schema del manifest del plugin
484</h2>
485
486Il file `.claude-plugin/plugin.json` definisce i metadati e la configurazione del plugin.
487
488Il manifest è facoltativo. Se omesso, Claude Code scopre automaticamente i componenti nelle [posizioni predefinite](#file-locations-reference) e deriva il nome del plugin dal nome della directory. Utilizza un manifest quando hai bisogno di fornire metadati o percorsi di componenti personalizzati.
489
490<h3 id="complete-schema">
491 Schema completo
492</h3>
493
494```json theme={null}
495{
496 "name": "plugin-name",
497 "displayName": "Plugin Name",
498 "version": "1.2.0",
499 "description": "Brief plugin description",
500 "author": {
501 "name": "Author Name",
502 "email": "author@example.com",
503 "url": "https://github.com/author"
504 },
505 "homepage": "https://docs.example.com/plugin",
506 "repository": "https://github.com/author/plugin",
507 "license": "MIT",
508 "keywords": ["keyword1", "keyword2"],
509 "metadata": { "catalogId": "cat-123", "tier": "pro" },
510 "skills": "./custom/skills/",
511 "commands": ["./custom/commands/special.md"],
512 "agents": ["./custom/agents/reviewer.md"],
513 "hooks": "./config/hooks.json",
514 "mcpServers": "./mcp-config.json",
515 "outputStyles": "./styles/",
516 "lspServers": "./.lsp.json",
517 "experimental": {
518 "themes": "./themes/",
519 "monitors": "./monitors.json",
520 "evals": "quality/evals"
521 },
522 "dependencies": [
523 "helper-lib",
524 { "name": "secrets-vault", "version": "~2.1.0" }
525 ]
526}
527```
528
529<h3 id="required-fields">
530 Campi obbligatori
531</h3>
532
533Se includi un manifest, `name` è l'unico campo obbligatorio.
534
535| Campo | Tipo | Descrizione | Esempio |
536| :----- | :----- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------- |
537| `name` | string | Identificatore univoco in kebab-case, senza spazi, caratteri di controllo o caratteri di formattazione bidirezionali. Quando una [voce del marketplace](/docs/it/plugin-marketplaces#plugin-entries) elenca il plugin con un nome diverso, il nome della voce del marketplace è quello che `enabledPlugins` e `/plugin` utilizzano | `"deployment-tools"` |
538
539Questo nome viene utilizzato per lo spazio dei nomi dei componenti. Ad esempio, nell'interfaccia utente, l'agente `agent-creator` per il plugin con nome `plugin-dev` apparirà come `plugin-dev:agent-creator`.
540
541<h3 id="unrecognized-fields">
542 Campi non riconosciuti
543</h3>
544
545Claude Code ignora i campi di primo livello che non riconosce. Puoi mantenere i metadati da un altro ecosistema in `plugin.json` e il plugin si carica comunque. Questo rende pratico mantenere un manifest che funge anche da manifest di estensione VS Code o Cursor, da `package.json` npm, o da manifest bundle MCPB/DXT.
546
547`claude plugin validate` segnala i campi non riconosciuti come avvisi, non come errori. Se un campo è uno o due caratteri diverso da uno riconosciuto, l'avviso suggerisce il nome probabilmente inteso. Un plugin con solo avvisi di campi non riconosciuti passa comunque la convalida e si carica al runtime.
548
549Il modo in cui Claude Code gestisce un campo riconosciuto il cui valore ha il tipo sbagliato dipende dal campo:
550
551* **La maggior parte dei campi**: il plugin non si carica. Ad esempio, un valore `keywords` che è una stringa invece di un array è un errore di caricamento, e `claude plugin validate` lo segnala come tale.
552* **`experimental` e `metadata`**: Claude Code ignora un valore non-oggetto, e `claude plugin validate` segnala un avviso.
553
554Passa `--strict` per trattare gli avvisi come errori. Usalo in CI per rilevare un nome di campo scritto male o un campo rimasto da un manifest di un altro strumento prima della pubblicazione, anche se il plugin si caricherà al runtime.
555
556```bash theme={null}
557claude plugin validate ./my-plugin --strict
558```
559
560<h3 id="metadata-fields">
561 Campi di metadati
562</h3>
563
564| Campo | Tipo | Descrizione | Esempio |
565| :--------------- | :------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
566| `$schema` | string | URL dello schema JSON per l'autocompletamento e la convalida dell'editor. Claude Code ignora questo campo al momento del caricamento. | `"https://json.schemastore.org/claude-code-plugin-manifest.json"` |
567| `displayName` | string | Nome leggibile mostrato nel selettore `/plugin` e in altre superfici dell'interfaccia utente. Per un plugin installato dal marketplace, un `displayName` sulla [voce del marketplace](/docs/it/plugin-marketplaces#optional-plugin-fields) ha la precedenza su questo valore. Quando nessun nome visualizzato è impostato in nessuno dei due posti, gli utenti vedono `name`. A differenza di `name`, può contenere spazi e qualsiasi maiuscola/minuscola. Non utilizzato per lo spazio dei nomi o la ricerca. | `"Deployment Tools"` |
568| `version` | string | Facoltativo. Versione semantica. L'impostazione di questa opzione fissa il plugin a quella stringa di versione, quindi gli utenti ricevono aggiornamenti solo quando la aumenti, tranne per una [`command` source](/docs/it/plugin-marketplaces#command-sources) o un plugin [caricato in place](#plugin-caching-and-file-resolution); vedi [Gestione delle versioni](#version-management). Se impostato anche nella voce del marketplace, `plugin.json` vince. Se omesso, la versione proviene dalla prossima fonte in [Gestione delle versioni](#version-management). | `"2.1.0"` |
569| `description` | string | Breve spiegazione dello scopo del plugin | `"Deployment automation tools"` |
570| `author` | object | Informazioni sull'autore | `{"name": "Dev Team", "email": "dev@company.com"}` |
571| `homepage` | string | URL della documentazione | `"https://docs.example.com"` |
572| `repository` | string | URL del codice sorgente | `"https://github.com/user/plugin"` |
573| `license` | string | Identificatore della licenza | `"MIT"`, `"Apache-2.0"` |
574| `keywords` | array | Tag di scoperta | `["deployment", "ci-cd"]` |
575| `metadata` | object | Oggetto in forma libera per i tuoi dati, come campi di diritto o catalogo. Claude Code non lo legge, quindi i valori non influenzano mai il comportamento del plugin. Claude Code ignora un valore non-oggetto, e `claude plugin validate` lo segnala come avviso. Prima della v2.1.222, Claude Code trattava la chiave come un [campo non riconosciuto](#unrecognized-fields). | `{"catalogId": "cat-123"}` |
576| `defaultEnabled` | boolean | Se il plugin inizia in uno stato abilitato quando l'utente non ne ha impostato uno. Predefinito su `true`. Vedi [Abilitazione predefinita](#default-enablement). | `false` |
577
578<h3 id="default-enablement">
579 Abilitazione predefinita
580</h3>
581
582Imposta `defaultEnabled: false` in `plugin.json` per distribuire un plugin che si installa disabilitato. L'utente lo attiva con `claude plugin enable <plugin>` o l'interfaccia `/plugin`. Usalo per i plugin che aggiungono costi o ambito a cui un utente dovrebbe acconsentire, come uno che si connette a un servizio esterno.
583
584`defaultEnabled` è il fallback quando nient'altro ha deciso lo stato del plugin. L'impostazione dell'utente e un requisito di dipendenza hanno la precedenza su di esso:
585
586* **L'impostazione dell'utente**: una voce per il plugin in `enabledPlugins` a qualsiasi ambito di impostazioni. Una volta scritta, persiste negli aggiornamenti e reinstallazioni del plugin, quindi modificare `defaultEnabled` in una versione successiva non capovolge un utente esistente.
587* **Un requisito di dipendenza**: quando un plugin è richiesto da un altro che è attivo, Claude Code scrive `true` per esso al momento dell'installazione o dell'abilitazione. Questo gli dà un'impostazione esplicita, quindi il suo default non si applica più. Vedi [Abilitare o disabilitare un plugin con dipendenze](/docs/it/plugin-dependencies#enable-or-disable-a-plugin-with-dependencies).
588
589Lo stesso campo può apparire nella voce del marketplace di un plugin, dove ha la precedenza sul valore in `plugin.json`. Vedi [Campi plugin facoltativi](/docs/it/plugin-marketplaces#optional-plugin-fields).
590
591<h3 id="component-path-fields">
592 Campi del percorso del componente
593</h3>
594
595| Campo | Tipo | Descrizione | Esempio |
596| :---------------------- | :-------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------- |
597| `skills` | string\|array | Directory di skill personalizzate contenenti `<name>/SKILL.md`. Si aggiunge alla scansione predefinita `skills/`. Vedi [Regole del comportamento del percorso](#path-behavior-rules) per l'eccezione della radice del marketplace | `"./custom/skills/"` |
598| `commands` | string\|array | File skill `.md` flat personalizzati o directory (sostituisce il valore predefinito `commands/`) | `"./custom/cmd.md"` o `["./cmd1.md"]` |
599| `agents` | string\|array | File agente personalizzati (sostituisce il valore predefinito `agents/`) | `"./custom/agents/reviewer.md"` |
600| `workflows` | string\|array | File script [workflow](/docs/it/workflows) personalizzati o directory (sostituisce il valore predefinito `workflows/`) | `"./custom/workflows/"` |
601| `hooks` | string\|array\|object | Percorsi di configurazione hook o configurazione inline | `"./my-extra-hooks.json"` |
602| `mcpServers` | string\|array\|object | Percorsi di configurazione MCP o configurazione inline | `"./my-extra-mcp-config.json"` |
603| `outputStyles` | string\|array | File/directory di stile di output personalizzati (sostituisce il valore predefinito `output-styles/`) | `"./styles/"` |
604| `lspServers` | string\|array\|object | Configurazioni [Language Server Protocol](https://microsoft.github.io/language-server-protocol/) per l'intelligenza del codice (vai a definizione, trova riferimenti, ecc.) | `"./.lsp.json"` |
605| `experimental.themes` | string\|array | File/directory di tema colore (sostituisce il valore predefinito `themes/`). Vedi [Temi](#themes) | `"./themes/"` |
606| `experimental.monitors` | string\|array | Configurazioni [Monitor](/docs/it/tools-reference#monitor-tool) di background che si avviano automaticamente quando il plugin è attivo. Vedi [Monitor](#monitors) | `"./monitors.json"` |
607| `experimental.evals` | string\|array | Directory sotto la radice del plugin che contiene i [casi eval](/docs/it/plugin-evals#use-a-different-eval-directory) del plugin, quando non è il valore predefinito `evals/`. `claude plugin eval --eval-dir` lo sostituisce | `"quality/evals"` |
608| `userConfig` | object | Valori configurabili dall'utente richiesti al momento dell'abilitazione. Vedi [Configurazione utente](#user-configuration) | |
609| `channels` | array | Dichiarazioni di canale per l'iniezione di messaggi (stile Telegram, Slack, Discord). Vedi [Canali](#channels) | |
610| `dependencies` | array | Altri plugin richiesti da questo plugin, facoltativamente con vincoli di versione semver. Vedi [Vincolare le versioni di dipendenza del plugin](/docs/it/plugin-dependencies) | `[{ "name": "secrets-vault", "version": "~2.1.0" }]` |
611
612<h3 id="experimental-components">
613 Componenti sperimentali
614</h3>
615
616I componenti sotto la chiave `experimental`, `themes` e `monitors`, hanno uno schema di manifest che potrebbe cambiare tra le versioni mentre si stabilizzano. Dove li dichiari è una migrazione separata: il livello superiore funziona ancora, `claude plugin validate` avverte, e una versione futura richiederà `experimental.*`.
617
618<h3 id="user-configuration">
619 Configurazione utente
620</h3>
621
622Il campo `userConfig` dichiara valori per i quali Claude Code richiede all'utente quando il plugin è abilitato. Usalo invece di richiedere agli utenti di modificare manualmente `settings.json`.
623
624```json theme={null}
625{
626 "userConfig": {
627 "api_endpoint": {
628 "type": "string",
629 "title": "API endpoint",
630 "description": "Your team's API endpoint"
631 },
632 "api_token": {
633 "type": "string",
634 "title": "API token",
635 "description": "API authentication token",
636 "sensitive": true
637 }
638 }
639}
640```
641
642Le chiavi devono essere identificatori validi. Ogni opzione supporta questi campi:
643
644| Campo | Obbligatorio | Descrizione |
645| :------------ | :----------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
646| `type` | Sì | Uno di `string`, `number`, `boolean`, `directory`, o `file` |
647| `title` | Sì | Etichetta mostrata nella finestra di dialogo di configurazione |
648| `description` | Sì | Testo di aiuto mostrato sotto il campo |
649| `sensitive` | No | Se `true`, maschera l'input e memorizza il valore nell'archiviazione sicura invece di `settings.json` |
650| `required` | No | Se `true`, la convalida fallisce quando il campo è vuoto |
651| `default` | No | Valore utilizzato quando l'utente non fornisce nulla |
652| `options` | No | Per il tipo `string`, i valori che il campo accetta, mostrati in `/config` come un selettore su di essi. Vedi [Limitare un campo a opzioni fisse](#limit-a-field-to-fixed-options). Richiede Claude Code v2.1.271 o successivo |
653| `multiple` | No | Per il tipo `string`, consenti un array di stringhe |
654| `min` / `max` | No | Limiti per il tipo `number` |
655
656Tranne i campi `sensitive` e gli elenchi `multiple`, ogni campo di ogni plugin abilitato appare anche come una riga nel pannello `/config`. Le righe richiedono Claude Code v2.1.269 o successivo.
657
658Ogni valore è disponibile per la sostituzione come `${user_config.KEY}` nelle configurazioni del server MCP e LSP e nei comandi hook. I valori non sensibili possono anche essere sostituiti nel contenuto di skill e agente. Tutti i valori vengono esportati ai processi hook come variabili di ambiente `CLAUDE_PLUGIN_OPTION_<KEY>`, dove `<KEY>` è la chiave dell'opzione in maiuscolo.
659
660I campi che vengono eseguiti in una shell rifiutano `${user_config.*}`: sostituire un valore configurato in un comando shell consentirebbe alla shell di eseguire qualsiasi cosa contenga quel valore, quindi il componente fallisce con un [errore](/docs/it/errors#plugin-command-references-user-config) invece. Ogni campo rifiutato ha un modo alternativo per passare il valore:
661
662| Campo rifiutato | Come passare il valore |
663| :--------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------- |
664| Comandi hook in forma shell | Usa [forma exec](/docs/it/hooks#exec-form-and-shell-form) con `args`, o leggi `CLAUDE_PLUGIN_OPTION_<KEY>` dall'ambiente del hook |
665| Comandi [Monitor](#monitors) | Leggi il valore da un file di configurazione nello script |
666| MCP [`headersHelper`](/docs/it/mcp#use-dynamic-headers-for-custom-authentication) | Leggi il valore da un file di configurazione nello script |
667
668Prima della v2.1.207, questi campi sostituivano i valori `${user_config.KEY}`; aggiorna i plugin che si basavano su questo.
669
670I valori non sensibili vengono memorizzati sotto la chiave [`pluginConfigs`](/docs/it/settings-reference#pluginconfigs) nel tuo `settings.json` utente come `pluginConfigs[<plugin-id>].options`.
671
672Su macOS, Claude Code memorizza i valori sensibili nel Portachiavi macOS, ricadendo su `~/.claude/.credentials.json` quando il Portachiavi rifiuta la scrittura. Su piattaforme senza un portachiavi supportato, li memorizza in `~/.claude/.credentials.json`. L'archiviazione del Portachiavi è condivisa con i token OAuth e ha un limite totale approssimativo di 2 KB, quindi mantieni i valori sensibili piccoli.
673
674Claude Code legge tutti i valori `pluginConfigs` da solo tre fonti di impostazioni:
675
676* **Impostazioni utente**: `~/.claude/settings.json`, il file che il prompt al momento dell'abilitazione scrive
677* **`--settings`**: il flag CLI o le impostazioni inline SDK
678* **Impostazioni gestite**: [politica controllata dall'organizzazione](/docs/it/permissions#managed-settings)
679
680Quando più di una fonte imposta la stessa chiave, le impostazioni gestite hanno la precedenza, quindi `--settings`, quindi le impostazioni utente. L'unica fonte che puoi rimuovere da questo elenco è le impostazioni utente: passa [`--setting-sources`](/docs/it/cli-reference#cli-flags) senza `user` e Claude Code le salta. Le impostazioni gestite e `--settings` rimangono qualsiasi cosa tu passi. L'opzione [`settingSources`](/docs/it/agent-sdk/claude-code-features#what-settingsources-does-not-control) dell'SDK imposta lo stesso elenco.
681
682Le voci nel `.claude/settings.json` o `.claude/settings.local.json` di un progetto vengono ignorate. Entrambi i file vivono nell'area di lavoro, quindi un repository clonato potrebbe fornire valori lì, e quei valori fluirebbero nei comandi hook del plugin, nelle configurazioni del server MCP, nei comandi LSP e nei comandi monitor. Prima della v2.1.207, queste voci venivano lette. La restrizione è specifica per `pluginConfigs`: [`enabledPlugins`](/docs/it/settings-reference#enabledplugins) onora ancora le impostazioni del progetto e locali.
683
684<h4 id="limit-a-field-to-fixed-options">
685 Limitare un campo a opzioni fisse
686</h4>
687
688Imposta `options` su un campo `userConfig` per fare in modo che gli utenti scelgano il suo valore da un elenco fisso.
689
690Per limitare un campo `tone` a tre opzioni, elencale in `options` e imposta `default` su una di esse:
691
692```json theme={null}
693{
694 "userConfig": {
695 "tone": {
696 "type": "string",
697 "title": "Tone",
698 "description": "Voice for generated replies",
699 "options": ["neutral", "warm", "formal"],
700 "default": "neutral"
701 }
702 }
703}
704```
705
706Se dichiari `options` su qualsiasi campo, gli utenti su versioni di Claude Code precedenti alla v2.1.271 non possono caricare il plugin.
707
708Quando imposti `options` su un campo, segui queste regole:
709
710* Imposta `type` su `string`
711* Non impostare `multiple` o `sensitive` su `true`
712* Imposta `default` su una delle opzioni
713* Se lasci `default` non impostato, imposta `required` su `true`
714* Elenca almeno un'opzione, ognuna da 1 a 64 caratteri
715* Non iniziare o terminare un'opzione con uno spazio
716* Non usare caratteri di controllo, caratteri invisibili, caratteri che cambiano la direzione del testo, o spazi diversi da uno spazio regolare in un'opzione
717* Non elencare la stessa opzione due volte, nemmeno in una diversa maiuscola/minuscola
718
719Se infrangi una di queste regole, il plugin non si carica. Esegui `claude plugin validate` per vedere quale campo infrange quale regola.
720
721<h3 id="channels">
722 Canali
723</h3>
724
725Il campo `channels` consente a un plugin di dichiarare uno o più canali di messaggi che iniettano contenuto nella conversazione. Ogni canale si associa a un server MCP fornito dal plugin.
726
727```json theme={null}
728{
729 "channels": [
730 {
731 "server": "telegram",
732 "userConfig": {
733 "bot_token": {
734 "type": "string",
735 "title": "Bot token",
736 "description": "Telegram bot token",
737 "sensitive": true
738 },
739 "owner_id": {
740 "type": "string",
741 "title": "Owner ID",
742 "description": "Your Telegram user ID"
743 }
744 }
745 }
746 ]
747}
748```
749
750Il campo `server` è obbligatorio e deve corrispondere a una chiave in `mcpServers` del plugin. Il `userConfig` facoltativo per canale utilizza lo stesso schema del campo di primo livello, consentendo al plugin di richiedere token bot o ID proprietario quando il plugin è abilitato.
751
752<h3 id="path-behavior-rules">
753 Regole del comportamento del percorso
754</h3>
755
756Se un percorso personalizzato sostituisce o estende la directory predefinita del plugin dipende dal campo:
757
758* **Sostituisce il valore predefinito**: `commands`, `agents`, `workflows`, `outputStyles`, `experimental.themes`, `experimental.monitors`. Ad esempio, quando il manifest specifica `commands`, la directory predefinita `commands/` non viene scansionata. Per mantenere il valore predefinito e aggiungerne altri, elencalo esplicitamente: `"commands": ["./commands/", "./extras/"]`
759* **Si aggiunge al valore predefinito**: `skills`. La directory predefinita `skills/` viene sempre scansionata, e le directory elencate in `skills` vengono caricate insieme ad essa. Eccezione: per una [voce del marketplace la cui `source` si risolve nella radice del marketplace](/docs/it/plugin-marketplaces#advanced-plugin-entries), dichiarare sottodirectory specifiche sostituisce la scansione predefinita `skills/`
760* **Regole di merge proprie**: [hooks](#hooks), [server MCP](#mcp-servers), e [server LSP](#lsp-servers). Vedi ogni sezione per come più fonti si combinano
761
762Quando un plugin ha sia una cartella predefinita che la chiave manifest corrispondente, Claude Code avverte sulla cartella ignorata in `claude plugin list` e nella vista dei dettagli `/plugin`. Il plugin si carica comunque utilizzando i percorsi del manifest. Claude Code non avverte quando la chiave manifest punta nella cartella predefinita, ad esempio `"commands": ["./commands/deploy.md"]`, perché quel percorso nomina la cartella esplicitamente.
763
764Per tutti i campi del percorso:
765
766* Tutti i percorsi devono essere relativi alla radice del plugin e iniziare con `./`, tranne che il campo `skills` accetta anche `"."`
767 * Sia `"."` che `"./"` denotano la radice del plugin stesso
768 * Prima della v2.1.221, `"."` falliva la convalida del manifest e il plugin non si caricava, quindi usa `"./"` per supportare versioni precedenti
769* I componenti da percorsi personalizzati utilizzano le stesse regole di denominazione e spazio dei nomi, tranne i file agente. Vedi [Agenti](#agents) per come funzionano i nomi degli agenti
770* Più percorsi possono essere specificati come array
771* Un percorso di skill può puntare a una directory che contiene direttamente un `SKILL.md`, ad esempio `"skills": ["."]` per la radice del plugin
772 * Claude Code prende il nome di invocazione della skill dal campo frontmatter `name` in `SKILL.md`, quindi il nome rimane stabile qualunque sia il nome della directory di installazione
773 * Se `name` non è impostato nel frontmatter, Claude Code ricade sul basename della directory
774
775Un plugin che ha un `SKILL.md` alla sua radice, nessuna sottodirectory `skills/`, e nessun campo manifest `skills` viene caricato automaticamente come plugin a skill singola. Non hai bisogno di impostare `"skills": ["./"]` in `plugin.json` per questo layout.
776
777**Esempi di percorso**:
778
779```json theme={null}
780{
781 "commands": [
782 "./specialized/deploy.md",
783 "./utilities/batch-process.md"
784 ],
785 "agents": [
786 "./custom-agents/reviewer.md",
787 "./custom-agents/tester.md"
788 ]
789}
790```
791
792<h3 id="environment-variables">
793 Variabili di ambiente
794</h3>
795
796Claude Code fornisce tre variabili per fare riferimento ai percorsi:
797
798| Variabile | Si risolve in | Usala per |
799| :---------------------- | :---------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------- |
800| `${CLAUDE_PLUGIN_ROOT}` | Percorso assoluto della directory di installazione del plugin | Script, binari e file di configurazione forniti con il plugin |
801| `${CLAUDE_PLUGIN_DATA}` | [Directory persistente](#persistent-data-directory) che sopravvive agli aggiornamenti del plugin, creata al primo riferimento | Dipendenze installate come `node_modules` o ambienti virtuali Python, codice generato e cache |
802| `${CLAUDE_PROJECT_DIR}` | La radice del progetto | Script e file di configurazione locali del progetto |
803
804Tutti e tre vengono esportati come variabili di ambiente ai processi hook e ai sottoprocessi del server MCP e LSP. Non sono presenti nell'ambiente dei comandi che Claude esegue attraverso lo strumento Bash, nella sessione principale o in un subagente. Nel contenuto del plugin, scrivi il placeholder invece, e Claude Code sostituisce il percorso inline quando carica il contenuto. Quali campi sostituiscono inline dipende dal componente del plugin:
805
806| Componente del plugin | Campi dove i placeholder si risolvono |
807| :----------------------------- | :------------------------------------------ |
808| Contenuto di skill e agente | Ovunque appaia il placeholder |
809| Comandi hook e monitor | Ovunque appaia il placeholder |
810| Server MCP `stdio` | `command`, `args`, `env` |
811| Server MCP `http`, `sse`, `ws` | `url`, `headers`, `headersHelper` |
812| Server LSP | `command`, `args`, `env`, `workspaceFolder` |
813
814Nei comandi hook, usa [forma exec](/docs/it/hooks#exec-form-and-shell-form) con `args` in modo che ogni percorso venga passato come un argomento senza virgolette. Negli hook in forma shell e nei comandi monitor, avvolgi le variabili tra virgolette doppie, come in `"${CLAUDE_PROJECT_DIR}/scripts/server.sh"`. Questo hook in forma shell esegue uno script fornito con un plugin:
815
816```json theme={null}
817{
818 "hooks": {
819 "PostToolUse": [
820 {
821 "hooks": [
822 {
823 "type": "command",
824 "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/process.sh"
825 }
826 ]
827 }
828 ]
829 }
830}
831```
832
833Per un plugin copiato, `${CLAUDE_PLUGIN_ROOT}` cambia quando il plugin si aggiorna. La directory della versione precedente rimane su disco per un periodo di grazia dopo un aggiornamento, ma trattala come effimera e non scrivere stato lì. Per un plugin caricato in place da un marketplace di directory locale, la variabile punta alla directory sorgente stabile. Vedi [plugin caching](#plugin-caching-and-file-resolution) per quali plugin vengono copiati e per la semantica di pulizia.
834
835Quando un plugin copiato si aggiorna a metà sessione, i comandi hook, i monitor, i server MCP e i server LSP continuano a utilizzare il percorso della versione precedente. Esegui `/reload-plugins` per passare hook, server MCP e server LSP al nuovo percorso; i monitor richiedono un riavvio della sessione. In una sessione senza un terminale interattivo, il ricaricamento lascia i server MCP del plugin sul vecchio percorso fino alla sessione successiva.
836
837Per un plugin con una `command` source, Claude Code [può ricaricare il plugin stesso](/docs/it/plugin-marketplaces#when-claude-code-re-runs-the-command).
838
839I server MCP possono anche chiamare la richiesta `roots/list` per leggere le directory di lavoro della sessione al runtime. Vedi [cosa restituisce `roots/list` e quando Claude Code notifica al server i cambiamenti](/docs/it/mcp#option-3-add-a-local-stdio-server).
840
841<h4 id="persistent-data-directory">
842 Directory di dati persistenti
843</h4>
844
845La directory `${CLAUDE_PLUGIN_DATA}` si risolve in `~/.claude/plugins/data/{id}/`, dove `{id}` è l'identificatore del plugin con caratteri al di fuori di `a-z`, `A-Z`, `0-9`, `_`, e `-` sostituiti da `-`. Per un plugin installato come `formatter@my-marketplace`, la directory è `~/.claude/plugins/data/formatter-my-marketplace/`.
846
847Un uso comune è installare dipendenze di linguaggio una volta e riutilizzarle tra sessioni e aggiornamenti di plugin. Usala per dipendenze Python, dipendenze bloccate con Yarn o pnpm, e pacchetti i cui script del ciclo di vita devono essere eseguiti. Per un plugin installato dal marketplace, potresti non averne bisogno affatto: Claude Code installa automaticamente le [dipendenze del pacchetto Node.js](#node-js-package-dependencies) idonee quando memorizza il plugin nella cache.
848
849Poiché la directory di dati sopravvive a qualsiasi singola versione del plugin, un controllo per l'esistenza della directory da solo non può rilevare quando un aggiornamento cambia il manifest di dipendenza del plugin. Il modello consigliato confronta il manifest fornito rispetto a una copia nella directory di dati e reinstalla quando differiscono.
850
851Questo hook `SessionStart` installa `node_modules` alla prima esecuzione e di nuovo ogni volta che un aggiornamento del plugin include un `package.json` modificato:
852
853```json theme={null}
854{
855 "hooks": {
856 "SessionStart": [
857 {
858 "hooks": [
859 {
860 "type": "command",
861 "command": "diff -q \"${CLAUDE_PLUGIN_ROOT}/package.json\" \"${CLAUDE_PLUGIN_DATA}/package.json\" >/dev/null 2>&1 || (cd \"${CLAUDE_PLUGIN_DATA}\" && cp \"${CLAUDE_PLUGIN_ROOT}/package.json\" . && npm install) || rm -f \"${CLAUDE_PLUGIN_DATA}/package.json\""
862 }
863 ]
864 }
865 ]
866 }
867}
868```
869
870Il `diff` esce con codice diverso da zero quando la copia memorizzata è mancante o differisce da quella fornita, coprendo sia la prima esecuzione che gli aggiornamenti che cambiano le dipendenze. Se `npm install` fallisce, il trailing `rm` rimuove il manifest copiato in modo che la sessione successiva riprovi.
871
872Gli script forniti in `${CLAUDE_PLUGIN_ROOT}` possono quindi essere eseguiti rispetto ai `node_modules` persistiti:
873
874```json theme={null}
875{
876 "mcpServers": {
877 "routines": {
878 "command": "node",
879 "args": ["${CLAUDE_PLUGIN_ROOT}/server.js"],
880 "env": {
881 "NODE_PATH": "${CLAUDE_PLUGIN_DATA}/node_modules"
882 }
883 }
884 }
885}
886```
887
888La directory di dati viene eliminata automaticamente quando disinstalli il plugin dall'ultimo ambito in cui è installato. L'interfaccia `/plugin` mostra la dimensione della directory e richiede conferma prima di eliminare. La CLI elimina per impostazione predefinita; passa [`--keep-data`](#plugin-uninstall) per preservarla.
889
890***
891
892<h2 id="plugin-caching-and-file-resolution">
893 Caching dei plugin e risoluzione dei file
894</h2>
895
896I plugin vengono specificati in uno di tre modi:
897
898* Tramite `claude --plugin-dir` o `claude --plugin-url`, per la durata di una sessione.
899* Tramite un marketplace, installato per sessioni future.
900* Tramite il vostro account claude.ai, [sincronizzato](#synced-plugins) in `~/.claude/plugins/synced/`.
901
902Per motivi di sicurezza e verifica, Claude Code copia i plugin del *marketplace* nella **cache dei plugin** locale dell'utente (`~/.claude/plugins/cache`), a meno che il plugin non si carichi sul posto. Una [`command` source in link mode](/docs/it/plugin-marketplaces#copy-mode-and-link-mode) si carica sul posto tramite link nella voce della cache. Una [relative path source](/docs/it/plugin-marketplaces#relative-paths) in un marketplace aggiunto da una directory locale si carica sul posto dalla cartella del marketplace.
903
904Per un plugin caricato sul posto da un marketplace di directory locale, le vostre modifiche alla directory di origine hanno effetto all'avvio della sessione successiva o `/reload-plugins`. Non avete bisogno di un bump di versione. I processi hook del plugin e i server MCP e LSP ricevono un `CLAUDE_PLUGIN_ROOT` che punta alla directory di origine. Claude Code non installa le [dipendenze dei pacchetti Node.js](#node-js-package-dependencies) del plugin nella directory di origine. Installatele lì voi stessi, o da un hook nella [directory dei dati persistenti](#persistent-data-directory).
905
906Per i plugin copiati, ogni versione installata è una directory separata nella cache, raggruppata per marketplace e plugin e denominata per la versione risolta, con la propria copia dei file del plugin e delle [dipendenze dei pacchetti Node.js](#node-js-package-dependencies). Una dipendenza risolta da un [release tag](/docs/it/plugin-dependencies#tag-plugin-releases-for-version-resolution) ottiene un nome di directory con un suffisso commit-SHA.
907
908Quando aggiornate o disinstallate un plugin, Claude Code contrassegna la directory della versione precedente come orfana e la rimuove in una scansione in background approssimativamente 14 giorni dopo. Il periodo di grazia consente alle sessioni di Claude Code concorrenti che hanno già caricato la versione precedente di continuare a funzionare senza errori. Claude Code esegue la scansione solo mentre è installato almeno un plugin; dopo aver disinstallato l'ultimo plugin, le directory orfane rimangono su disco fino a quando non installate di nuovo un plugin.
909
910Claude Code rimuove una cartella di plugin o marketplace dalla cache solo quando non contiene più alcuna directory o symlink. Se create un symlink di uno sviluppo locale nella cache come voce di versione di un plugin, Claude Code non contrassegna mai il link come orfano e non lo rimuove mai né le cartelle che lo contengono. Claude Code inoltre non scrive mai i suoi file di tracciamento delle versioni all'interno del checkout collegato.
911
912Gli strumenti Glob e Grep di Claude saltano le directory delle versioni orfane durante le ricerche, quindi i risultati dei file non includono codice di plugin obsoleto.
913
914<h3 id="node-js-package-dependencies">
915 Dipendenze dei pacchetti Node.js
916</h3>
917
918Quando Claude Code copia un plugin nella cache, installa anche le dipendenze dei pacchetti Node.js del plugin lì, in modo che gli hook e i server MCP del plugin possano caricarli. Questa sezione copre i pacchetti npm e Bun che un plugin dichiara nel suo `package.json`. Per i plugin che dipendono da altri plugin, vedere [versioni delle dipendenze dei plugin](/docs/it/plugin-dependencies).
919
920Claude Code esegue l'installazione all'interno della directory della versione copiata ogni volta che ne crea una: quando installate un plugin, quando Claude Code aggiorna un plugin a una nuova versione, e all'inizio della sessione quando un plugin abilitato non è ancora memorizzato nella cache, ad esempio su una nuova macchina. L'installazione viene eseguita solo quando la directory root del plugin contiene sia un `package.json` che un lockfile supportato:
921
922| Lockfile | Comando |
923| :------------------------------------------ | :----------------------------------------------- |
924| `bun.lock` o `bun.lockb` | `bun install --frozen-lockfile --ignore-scripts` |
925| `npm-shrinkwrap.json` o `package-lock.json` | `npm ci --ignore-scripts` |
926
927Se un plugin contiene più di uno di questi lockfile, Claude Code utilizza la prima corrispondenza, controllando in ordine: `bun.lock`, `bun.lockb`, `npm-shrinkwrap.json`, `package-lock.json`.
928
929Claude Code salta l'installazione in due casi, ognuno con la propria soluzione:
930
931* Se il vostro plugin contiene solo un `yarn.lock` o `pnpm-lock.yaml`, sostituiscilo con un lockfile npm.
932* Se un `bunfig.toml` si trova accanto al lockfile bun, rimuovete il `bunfig.toml`, o sostituite il lockfile bun con un lockfile npm.
933
934Fornite un lockfile npm per la portata più ampia. Claude Code esegue il gestore di pacchetti del lockfile corrispondente dal PATH dell'utente e non esegue il fallback all'altro lockfile se manca. Per un plugin distribuito tramite una fonte npm, utilizzate `npm-shrinkwrap.json`; npm esclude `package-lock.json` dai pacchetti pubblicati.
935
936Claude Code vincola questa installazione di dipendenze in modo che nessun codice dal plugin o dai suoi pacchetti venga eseguito durante essa, e limita quanto tempo può durare:
937
938* **Risoluzione congelata:** Bun e npm installano esattamente ciò che il lockfile fissa, e falliscono piuttosto che ri-risolvere le versioni quando `package.json` e il lockfile non concordano.
939* **Nessuno script del ciclo di vita:** `--ignore-scripts` impedisce l'esecuzione degli script `preinstall`, `install` e `postinstall`, in modo che le dipendenze che compilano moduli nativi in questi script scarichino ma non compilino durante questa installazione.
940* **Timeout di 60 secondi:** Claude Code interrompe un'installazione che dura più a lungo e la tratta come non riuscita.
941
942Claude Code recupera un plugin da fonte npm prima di questa installazione di dipendenze, e nessuno degli script di installazione del pacchetto stesso viene eseguito durante il recupero. Vedere [pacchetti npm](/docs/it/plugin-marketplaces#npm-packages).
943
944Un'installazione non riuscita o saltata non blocca mai il plugin. Quando l'installazione fallisce, o Claude Code salta un lockfile yarn o pnpm o un `bunfig.toml`, registra il motivo come avviso nell'[output di debug](#debugging-commands). Un plugin con un `package.json` e nessun lockfile viene saltato senza una voce di log. Un'installazione scaduta può lasciare un albero `node_modules` parziale nella copia memorizzata nella cache.
945
946Non potete disattivare l'installazione automatica; nessuna impostazione o variabile di ambiente la disabilita. In reti ristrette, vedere i [requisiti di accesso alla rete](/docs/it/network-config#network-access-requirements) per gli host da consentire.
947
948Per le dipendenze che l'installazione automatica non può fornire, come pacchetti che necessitano dei loro script del ciclo di vita per compilare, dipendenze Python, o un plugin bloccato con Yarn o pnpm, installatele da un hook nella [directory dei dati persistenti](#persistent-data-directory).
949
950<h3 id="path-traversal-limitations">
951 Limitazioni dell'attraversamento dei percorsi
952</h3>
953
954Claude Code non consente a un plugin di fare riferimento a file al di fuori della sua stessa directory. Rifiuta un percorso di componente che si risolve al di fuori della root del plugin, indipendentemente dal fatto che il percorso sia dichiarato in `plugin.json` o in una [voce del marketplace](/docs/it/plugin-marketplaces#plugin-entries). Ciò copre un percorso che punta al di fuori del plugin come scritto, come `../shared-utils`, e un symlink che porta al di fuori del plugin, ad eccezione dei [link all'interno di un marketplace](#share-files-within-a-marketplace-with-symlinks).
955
956Su macOS e Linux, Claude Code rifiuta anche un percorso di componente che contiene una barra rovesciata in qualsiasi punto, anche quando il percorso rimane all'interno del plugin. I componenti dichiarati con percorsi con barra rovesciata quindi si caricano solo su Windows. Scrivete i percorsi dei componenti con barre oblique, come `./commands/deploy.md`.
957
958Quando Claude Code rifiuta un percorso, segnala un errore [`path escapes plugin directory`](/docs/it/errors#path-escapes-plugin-directory) e carica il plugin senza quel componente.
959
960Claude Code inoltre non copia i file al di fuori della directory del plugin nella cache quando installa il plugin, quindi quando uno script all'interno di un plugin copiato legge un percorso sopra la root del plugin, non trova nemmeno quei file.
961
962<h3 id="share-files-within-a-marketplace-with-symlinks">
963 Condividere file all'interno di un marketplace con symlink
964</h3>
965
966Se il vostro plugin ha bisogno di condividere file con altre parti dello stesso marketplace, potete creare link simbolici all'interno della directory del vostro plugin. Il modo in cui un symlink viene gestito quando il plugin viene copiato nella cache dipende da dove si risolve il suo target:
967
968* **All'interno della directory del plugin:** il symlink viene preservato come symlink relativo nella cache, in modo che continui a risolvere il target copiato in fase di esecuzione.
969* **Altrove all'interno dello stesso marketplace:** il symlink viene dereferenziato. Il contenuto del target viene copiato nella cache al suo posto. Ciò consente alla directory `skills/` di un meta-plugin di collegarsi alle skill definite da altri plugin nel marketplace.
970* **Al di fuori del marketplace:** il symlink viene saltato per motivi di sicurezza. Ciò impedisce ai plugin di estrarre file host arbitrari come percorsi di sistema nella cache.
971
972Per i plugin installati con `--plugin-dir`, da un percorso locale, o da una [`command` source](/docs/it/plugin-marketplaces#copy-mode-and-link-mode) in copy mode, solo i symlink che si risolvono all'interno della directory del plugin stesso vengono preservati. Tutti gli altri vengono saltati.
973
974Il seguente comando crea un link dall'interno di un plugin del marketplace a una skill condivisa definita da un plugin sibling. Su Windows, utilizzate `mklink /D` da un Command Prompt elevato o abilitate Developer Mode:
975
976```bash theme={null}
977ln -s ../../shared-plugin/skills/foo ./skills/foo
978```
979
980***
981
982<h2 id="plugin-directory-structure">
983 Struttura della directory dei plugin
984</h2>
985
986<h3 id="standard-plugin-layout">
987 Layout standard dei plugin
988</h3>
989
990Un plugin completo segue questa struttura:
991
992```text theme={null}
993enterprise-plugin/
994├── .claude-plugin/ # Directory dei metadati (opzionale)
995│ └── plugin.json # plugin manifest
996├── skills/ # Skills
997│ ├── code-reviewer/
998│ │ └── SKILL.md
999│ └── pdf-processor/
1000│ ├── SKILL.md
1001│ └── scripts/
1002├── commands/ # Skills come file .md flat
1003│ ├── status.md
1004│ └── logs.md
1005├── agents/ # Definizioni dei subagent
1006│ ├── security-reviewer.md
1007│ ├── performance-tester.md
1008│ ├── compliance-checker.md
1009│ └── review/ # Gli agent qui si caricano come enterprise-plugin:review:<name>
1010│ └── accessibility.md
1011├── workflows/ # Script dei workflow
1012│ └── release-audit.js
1013├── output-styles/ # Definizioni dello stile di output
1014│ └── terse.md
1015├── themes/ # Definizioni dei temi colore
1016│ └── dracula.json
1017├── monitors/ # Configurazioni dei monitor in background
1018│ └── monitors.json
1019├── hooks/ # Configurazioni degli hook
1020│ ├── hooks.json # Configurazione principale degli hook
1021│ └── security-hooks.json # Hook aggiuntivi
1022├── bin/ # Eseguibili del plugin aggiunti a PATH
1023│ └── my-tool # Invocabile come comando bare in Bash tool
1024├── settings.json # Impostazioni predefinite per il plugin
1025├── .mcp.json # Definizioni dei server MCP
1026├── .lsp.json # Configurazioni dei server LSP
1027├── scripts/ # Script degli hook e script di utilità
1028│ ├── security-scan.sh
1029│ ├── format-code.py
1030│ └── deploy.js
1031├── LICENSE # File di licenza
1032└── CHANGELOG.md # Cronologia delle versioni
1033```
1034
1035<Warning>
1036 La directory `.claude-plugin/` contiene il file `plugin.json`. Tutte le altre directory (commands/, agents/, skills/, workflows/, output-styles/, themes/, monitors/, hooks/) devono trovarsi nella radice del plugin, non all'interno di `.claude-plugin/`.
1037</Warning>
1038
1039Un file `CLAUDE.md` nella radice del plugin non viene caricato come contesto del progetto. I plugin contribuiscono al contesto attraverso skills, agents e hooks piuttosto che tramite CLAUDE.md. Per fornire istruzioni che si carichino nel contesto di Claude, inseritele in una [skill](#skills).
1040
1041<h3 id="file-locations-reference">
1042 Riferimento delle posizioni dei file
1043</h3>
1044
1045| Componente | Posizione predefinita | Scopo |
1046| :---------------- | :--------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
1047| **Manifest** | `.claude-plugin/plugin.json` | Metadati e configurazione del plugin (opzionale) |
1048| **Skills** | `skills/` | Skills con struttura `<name>/SKILL.md` |
1049| **Commands** | `commands/` | Skills come file Markdown flat. Utilizzare `skills/` per i nuovi plugin |
1050| **Agents** | `agents/` | File Markdown dei subagent. Le sottocartelle fanno parte del [nome dell'agent](#agents) |
1051| **Workflows** | `workflows/` | File script dei [Workflow](/docs/it/workflows) |
1052| **Output styles** | `output-styles/` | Definizioni dello stile di output |
1053| **Themes** | `themes/` | Definizioni dei temi colore |
1054| **Hooks** | `hooks/hooks.json` | Configurazione degli hook |
1055| **Server MCP** | `.mcp.json` | Definizioni dei server MCP |
1056| **Server LSP** | `.lsp.json` | Configurazioni dei language server |
1057| **Monitors** | `monitors/monitors.json` | Configurazioni dei monitor in background |
1058| **Eseguibili** | `bin/` | Eseguibili aggiunti al `PATH` del Bash tool e invocabili come comandi bare mentre il plugin è abilitato. Non è possibile includere questa directory in un plugin che [distribuite attraverso le impostazioni dell'organizzazione claude.ai](/docs/it/plugin-marketplaces#keep-executables-out-of-the-top-level-bin-directory) |
1059| **Impostazioni** | `settings.json` | Configurazione predefinita applicata quando il plugin è abilitato. Sono supportate solo le chiavi [`agent`](/docs/it/sub-agents) e [`subagentStatusLine`](/docs/it/statusline#subagent-status-lines) |
1060
1061***
1062
1063<h2 id="cli-commands-reference">
1064 Riferimento dei comandi CLI
1065</h2>
1066
1067Claude Code fornisce comandi CLI per la gestione non interattiva dei plugin, utile per scripting e automazione.
1068
1069<h3 id="plugin-init">
1070 plugin init
1071</h3>
1072
1073Crea lo scaffolding di un nuovo plugin in `~/.claude/skills/<name>/`. Nella prossima sessione di Claude Code si carica automaticamente come `<name>@skills-dir` e appare in `/plugin` e `claude plugin list` senza alcun passaggio di installazione.
1074
1075Vedi [Skills-directory plugins](#skills-directory-plugins) per i requisiti di ambito e fiducia.
1076
1077```bash theme={null}
1078claude plugin init <name> [options]
1079```
1080
1081Il comando accetta questi argomenti:
1082
1083* `<name>`: Nome del plugin. Diventa lo spazio dei nomi della skill e il nome della directory sotto `~/.claude/skills/`, quindi non può contenere spazi o separatori di percorso.
1084
1085Il comando accetta queste opzioni:
1086
1087| Opzione | Descrizione | Predefinito |
1088| :----------------------- | :------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------- |
1089| `--description <text>` | Descrizione del manifest | |
1090| `--author <name>` | Nome dell'autore | `git config user.name` |
1091| `--author-email <email>` | Email dell'autore | `git config user.email` |
1092| `--with <components...>` | Crea anche lo scaffolding delle cartelle dei componenti. Valori validi: `skills`, `agents`, `hooks`, `mcp`, `lsp`, `output-style`, `channel` | |
1093| `-f, --force` | Sovrascrivi un `.claude-plugin/` esistente nel target | |
1094| `-h, --help` | Visualizza la guida per il comando | |
1095
1096`claude plugin new` è un alias per questo comando.
1097
1098Ogni valore `--with` aggiunge un file di avvio per quel componente, pronto per essere modificato:
1099
1100| Componente | Cosa crea lo scaffolding |
1101| :------------- | :-------------------------------------------------------------------------------------------------------------- |
1102| `skills` | Una skill aggiuntiva con spazio dei nomi `<name>:example` insieme a quella predefinita |
1103| `agents` | Una definizione di subagent in `agents/` |
1104| `hooks` | Un `hooks/hooks.json` con un gestore di eventi di esempio |
1105| `mcp` | Un `.mcp.json` con esempi di server HTTP e stdio |
1106| `lsp` | Un esempio di language-server `.lsp.json` |
1107| `output-style` | Un `output-styles/<name>.md` che si applica automaticamente mentre il plugin è abilitato |
1108| `channel` | Un [channel](/docs/it/channels) basato su MCP: un server stdio (`server.ts`), il suo `.mcp.json` e un `package.json` |
1109
1110Il plugin creato con lo scaffolding utilizza la fonte `@skills-dir` piuttosto che un marketplace. Gli amministratori possono bloccare questa fonte con `strictKnownMarketplaces` o aggiungendo `{"source": "skills-dir"}` a `blockedMarketplaces` nelle [impostazioni gestite](/docs/it/plugin-marketplaces#managed-marketplace-restrictions). Quando bloccato, `plugin init` fallisce prima di scrivere.
1111
1112Questi esempi mostrano invocazioni comuni:
1113
1114```bash theme={null}
1115# Crea lo scaffolding di un plugin minimo
1116claude plugin init my-helper
1117
1118# Crea lo scaffolding con cartelle skill e hook
1119claude plugin init my-helper --with skills hooks
1120
1121# Sovrascrivi uno scaffolding esistente
1122claude plugin init my-helper --force
1123```
1124
1125<h3 id="plugin-install">
1126 plugin install
1127</h3>
1128
1129Installa un plugin dai marketplace disponibili.
1130
1131```bash theme={null}
1132claude plugin install <plugin> [options]
1133```
1134
1135Il comando accetta questi argomenti:
1136
1137* `<plugin>`: Nome del plugin o `plugin-name@marketplace-name` per un marketplace specifico
1138
1139Il comando accetta queste opzioni:
1140
1141| Opzione | Descrizione | Predefinito |
1142| :-------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :---------- |
1143| `-s, --scope <scope>` | Ambito di installazione: `user`, `project` o `local` | `user` |
1144| `--config <key=value>` | Imposta un'opzione [`userConfig`](#user-configuration) dichiarata nel manifest del plugin. Ripeti il flag per impostare più opzioni | |
1145| `-y, --yes` | Accetta un comando che il marketplace del plugin dichiara, senza il prompt di conferma: il comando che produce un plugin con una [`command` source](/docs/it/plugin-marketplaces#command-sources), o l'[`headersHelper`](/docs/it/plugin-marketplaces#authenticate-archive-downloads) che autentica un download di archivio. Accettare un `headersHelper` richiede Claude Code v2.1.238 o successivo. Claude Code stampa comunque il comando per primo. Obbligatorio quando stdin o stdout non è un TTY, a meno che non passi `--accept-command`. Non ha effetto all'interno di una sessione di Claude Code, quindi esegui il comando dal tuo terminale | |
1146| `--accept-command <sha256>` | Accetta il comando dichiarato dal marketplace il cui `sha256` una precedente esecuzione [`--json`](#plugin-json-result) ha segnalato in `shownCommand`, al posto di `-y`. L'accettazione conta esattamente per quel comando, plugin e catalogo del marketplace. Se uno qualsiasi di essi è cambiato da quando il comando è stato visualizzato, incluso attraverso l'aggiornamento del marketplace della stessa esecuzione, Claude Code non accetta il digest e mostra di nuovo il comando. Non può essere combinato con `-y`. Non ha effetto all'interno di una sessione di Claude Code, quindi esegui il comando dal tuo terminale. Richiede Claude Code v2.1.271 o successivo | |
1147| `--json` | Stampa il risultato come un oggetto JSON sulla ultima riga di stdout invece del messaggio leggibile, per l'uso negli script. Vedi [Formato del risultato JSON](#plugin-json-result). Richiede Claude Code v2.1.268 o successivo | |
1148| `-h, --help` | Visualizza la guida per il comando | |
1149
1150L'ambito determina quale file di impostazioni il plugin installato viene aggiunto. Ad esempio, `--scope project` scrive in `enabledPlugins` in .claude/settings.json, rendendo il plugin disponibile a chiunque cloni il repository del progetto.
1151
1152<span id="plugin-json-result" />Con `--json`, l'ultima riga di stdout è un oggetto JSON. Analizza solo quella riga, perché Claude Code stampa qualsiasi comando che il marketplace dichiara prima di essa. Tre campi sono sempre presenti:
1153
1154* `command`: il sottocomando che è stato eseguito, come `install`
1155* `outcome`: `ok` o `failed`
1156* `message`: una descrizione leggibile del risultato
1157
1158Altri campi, come `pluginId`, `scope` e `failureCode`, appaiono solo quando applicabili. L'opzione `--json` su `plugin uninstall`, `plugin update`, `plugin enable` e `plugin disable` stampa lo stesso oggetto con i campi propri di quel sottocomando. Un errore di utilizzo, come uno `--scope` non valido, non stampa alcuna riga di risultato ed esce con 1 con il motivo su stderr.
1159
1160Quando un'esecuzione visualizza un comando dichiarato dal marketplace e non lo esegue, il risultato `failed` porta anche un oggetto `shownCommand` i cui campi includono il comando come visualizzato, il plugin a cui appartiene e lo `sha256` del comando. Per accettare esattamente quel comando, esegui di nuovo con quello `sha256` come `--accept-command`. Richiede Claude Code v2.1.271 o successivo.
1161
1162Se `shownCommand.acceptCommandMatched` è `false`, il digest che hai passato non corrisponde al comando ora visualizzato. Mostra quel comando a una persona prima di passare il suo `sha256`.
1163
1164Questi esempi mostrano invocazioni comuni:
1165
1166```bash theme={null}
1167# Installa nell'ambito utente (predefinito)
1168claude plugin install formatter@my-marketplace
1169
1170# Installa nell'ambito progetto (condiviso con il team)
1171claude plugin install formatter@my-marketplace --scope project
1172
1173# Installa nell'ambito locale (non condiviso con il team)
1174claude plugin install formatter@my-marketplace --scope local
1175```
1176
1177<h3 id="plugin-uninstall">
1178 plugin uninstall
1179</h3>
1180
1181Rimuovi un plugin installato.
1182
1183```bash theme={null}
1184claude plugin uninstall <plugin> [options]
1185```
1186
1187Il comando accetta questi argomenti:
1188
1189* `<plugin>`: Nome del plugin o `plugin-name@marketplace-name`
1190
1191Il comando accetta queste opzioni:
1192
1193| Opzione | Descrizione | Predefinito |
1194| :-------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------- |
1195| `-s, --scope <scope>` | Disinstalla dall'ambito: `user`, `project` o `local` | `user` |
1196| `--keep-data` | Preserva la [persistent data directory](#persistent-data-directory) del plugin | |
1197| `--prune` | Rimuovi anche le dipendenze auto-installate che nessun altro plugin richiede. Vedi [plugin prune](#plugin-prune) | |
1198| `-y, --yes` | Salta il prompt di conferma `--prune`. Obbligatorio quando stdin o stdout non è un TTY | |
1199| `--json` | Stampa il risultato come un oggetto JSON sulla ultima riga di stdout, nello [stesso formato di `plugin install --json`](#plugin-json-result). Non può essere combinato con `--prune`. Richiede Claude Code v2.1.268 o successivo | |
1200| `-h, --help` | Visualizza la guida per il comando | |
1201
1202`claude plugin remove` e `claude plugin rm` sono alias per questo comando.
1203
1204Per impostazione predefinita, la disinstallazione dall'ultimo ambito rimanente elimina anche la directory `${CLAUDE_PLUGIN_DATA}` del plugin. Usa `--keep-data` per preservarla, ad esempio quando reinstalli dopo aver testato una nuova versione.
1205
1206<Note>
1207 Quando i plugin installati da diversi marketplace condividono un nome, il modulo `plugin-name@marketplace-name` disinstalla solo il plugin dal marketplace denominato. Prima della v2.1.212, il modulo qualificato potrebbe corrispondere e disinstallare lo stesso plugin denominato da un marketplace diverso.
1208</Note>
1209
1210<h3 id="plugin-prune">
1211 plugin prune
1212</h3>
1213
1214Rimuovi le dipendenze dei plugin auto-installate che non sono più richieste da alcun plugin installato. Le dipendenze che Claude Code ha inserito per soddisfare il campo [`dependencies`](/docs/it/plugin-dependencies) di un altro plugin vengono rimosse; i plugin che hai installato direttamente non vengono mai toccati.
1215
1216```bash theme={null}
1217claude plugin prune [options]
1218```
1219
1220Il comando accetta queste opzioni:
1221
1222| Opzione | Descrizione | Predefinito |
1223| :-------------------- | :--------------------------------------------------------------------------- | :---------- |
1224| `-s, --scope <scope>` | Prune all'ambito: `user`, `project` o `local` | `user` |
1225| `--dry-run` | Elenca cosa verrebbe rimosso senza rimuovere nulla | |
1226| `-y, --yes` | Salta il prompt di conferma. Obbligatorio quando stdin o stdout non è un TTY | |
1227| `-h, --help` | Visualizza la guida per il comando | |
1228
1229`claude plugin autoremove` è un alias per questo comando.
1230
1231Il comando elenca le dipendenze orfane e chiede conferma prima di rimuoverle. Per rimuovere un plugin e pulire le sue dipendenze in un unico passaggio, esegui `claude plugin uninstall <plugin> --prune`.
1232
1233<h3 id="plugin-enable">
1234 plugin enable
1235</h3>
1236
1237Abilita un plugin disabilitato. Quando il target è installato da un marketplace e dichiara [dependencies](/docs/it/plugin-dependencies), Claude Code li abilita transitivamente nello stesso ambito. Il comando fallisce nelle condizioni che [Enable or disable a plugin with dependencies](/docs/it/plugin-dependencies#enable-or-disable-a-plugin-with-dependencies) elenca.
1238
1239```bash theme={null}
1240claude plugin enable <plugin> [options]
1241```
1242
1243Il comando accetta questi argomenti:
1244
1245* `<plugin>`: Nome del plugin, `plugin-name@marketplace-name` o `plugin-name@synced` per un [plugin sincronizzato da claude.ai](#synced-plugins)
1246
1247Il comando accetta queste opzioni:
1248
1249| Opzione | Descrizione | Predefinito |
1250| :-------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------- |
1251| `-s, --scope <scope>` | Ambito da abilitare: `user`, `project` o `local`. Quando omesso, Claude Code rileva l'ambito in cui il plugin è installato | Auto-detect |
1252| `--json` | Stampa il risultato come un oggetto JSON sulla ultima riga di stdout, nello [stesso formato di `plugin install --json`](#plugin-json-result). Richiede Claude Code v2.1.268 o successivo | |
1253| `-h, --help` | Visualizza la guida per il comando | |
1254
1255<h3 id="plugin-disable">
1256 plugin disable
1257</h3>
1258
1259Disabilita un plugin senza disinstallarlo.
1260
1261Quando il target è installato da un marketplace, il comando fallisce se un altro plugin abilitato [dipende da](/docs/it/plugin-dependencies#enable-or-disable-a-plugin-with-dependencies) esso. Il messaggio di errore include un comando concatenato che disabilita prima ogni dipendente.
1262
1263Per un [synced plugin](#synced-plugins) che la tua organizzazione richiede, il comando fallisce e non salva nulla.
1264
1265```bash theme={null}
1266claude plugin disable [plugin] [options]
1267```
1268
1269Il comando accetta questi argomenti:
1270
1271* `[plugin]`: Nome del plugin, `plugin-name@marketplace-name` o `plugin-name@synced` per un [plugin sincronizzato da claude.ai](#synced-plugins). Facoltativo quando si usa `--all`
1272
1273Il comando accetta queste opzioni:
1274
1275| Opzione | Descrizione | Predefinito |
1276| :-------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------- |
1277| `-a, --all` | Disabilita tutti i plugin abilitati. Non può essere combinato con `--scope` | |
1278| `-s, --scope <scope>` | Ambito da disabilitare: `user`, `project` o `local`. Quando omesso, Claude Code rileva l'ambito in cui il plugin è installato | Auto-detect |
1279| `--json` | Stampa il risultato come un oggetto JSON sulla ultima riga di stdout, nello [stesso formato di `plugin install --json`](#plugin-json-result). Richiede Claude Code v2.1.268 o successivo | |
1280| `-h, --help` | Visualizza la guida per il comando | |
1281
1282<h3 id="plugin-update">
1283 plugin update
1284</h3>
1285
1286Aggiorna un plugin all'ultima versione.
1287
1288```bash theme={null}
1289claude plugin update <plugin> [options]
1290```
1291
1292Il comando accetta questi argomenti:
1293
1294* `<plugin>`: Nome del plugin o `plugin-name@marketplace-name`
1295
1296Il comando accetta queste opzioni:
1297
1298| Opzione | Descrizione | Predefinito |
1299| :-------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :---------- |
1300| `-s, --scope <scope>` | Ambito da aggiornare: `user`, `project`, `local` o `managed` | `user` |
1301| `-y, --yes` | Accetta un comando che il marketplace del plugin dichiara, senza il prompt di conferma: il comando che produce un plugin con una [`command` source](/docs/it/plugin-marketplaces#command-sources), o l'[`headersHelper`](/docs/it/plugin-marketplaces#authenticate-archive-downloads) che autentica un download di archivio. Accettare un `headersHelper` richiede Claude Code v2.1.238 o successivo. Claude Code stampa comunque il comando per primo. Obbligatorio quando stdin o stdout non è un TTY, a meno che non passi `--accept-command`. Non ha effetto all'interno di una sessione di Claude Code, quindi esegui il comando dal tuo terminale | |
1302| `--accept-command <sha256>` | Accetta il comando dichiarato dal marketplace il cui `sha256` una precedente esecuzione [`--json`](#plugin-json-result) ha segnalato in `shownCommand`, al posto di `-y`. L'accettazione conta esattamente per quel comando, plugin e catalogo del marketplace. Se uno qualsiasi di essi è cambiato da quando il comando è stato visualizzato, incluso attraverso l'aggiornamento del marketplace della stessa esecuzione, Claude Code non accetta il digest e mostra di nuovo il comando. Non può essere combinato con `-y`. Non ha effetto all'interno di una sessione di Claude Code, quindi esegui il comando dal tuo terminale. Richiede Claude Code v2.1.271 o successivo | |
1303| `--json` | Stampa il risultato come un oggetto JSON sulla ultima riga di stdout, nello [stesso formato di `plugin install --json`](#plugin-json-result). Richiede Claude Code v2.1.268 o successivo | |
1304| `-h, --help` | Visualizza la guida per il comando | |
1305
1306<Note>
1307 Claude Code risolve un nome di plugin semplice rispetto ai plugin installati. Quando i plugin installati da diversi marketplace condividono il nome, Claude Code rifiuta l'aggiornamento ed elenca i comandi `plugin-name@marketplace-name` qualificati da eseguire invece. Prima della v2.1.246, Claude Code accettava solo il modulo qualificato e rifiutava un nome semplice come non trovato.
1308</Note>
1309
1310***
1311
1312<h3 id="plugin-list">
1313 plugin list
1314</h3>
1315
1316Elenca i plugin installati con la loro versione, il marketplace di origine e lo stato di abilitazione.
1317
1318```bash theme={null}
1319claude plugin list [options]
1320```
1321
1322Il comando accetta queste opzioni:
1323
1324| Opzione | Descrizione | Predefinito |
1325| :------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------- |
1326| `--json` | Output come JSON. Una riga di plugin con problemi di caricamento o avvisi di authoring porta array di stringhe `errors` o `notes`. Su Claude Code v2.1.268 o successivo, array paralleli `errorDetails` e `noteDetails` forniscono il `type` diagnostico di ogni voce e i nomi a cui si riferisce, come il plugin, il marketplace, il server o il file | |
1327| `--available` | Includi i plugin disponibili dai marketplace. Richiede `--json` | |
1328| `-h, --help` | Visualizza la guida per il comando | |
1329
1330All'interno di una sessione interattiva, `/plugin list` stampa un elenco simile inline, ma copre solo i plugin installati dal marketplace:
1331
1332* I plugin caricati dalle directory delle skill appaiono nell'interfaccia `/plugin` e in `claude plugin list`, ma non nell'output inline `/plugin list`.
1333* I [plugin sincronizzati da claude.ai](#synced-plugins) appaiono in `claude plugin list` su Claude Code v2.1.239 o successivo e nell'interfaccia `/plugin`, ma non nell'output inline `/plugin list`.
1334* I plugin caricati per la sessione con `--plugin-dir` o `--plugin-url` appaiono nell'interfaccia `/plugin` e in `claude plugin list` solo quando lo stesso flag precede il sottocomando, come in `claude --plugin-dir <dir> plugin list`. Solo il nome del flag identifica la loro posizione, quindi un semplice `claude plugin list` non può trovarli, a differenza dei plugin sincronizzati e dei plugin della directory delle skill, le cui directory fisse Claude Code scansiona.
1335
1336Il modulo interattivo accetta `--enabled` o `--disabled` per mostrare solo i plugin in quello stato, e `ls` come abbreviazione per `list`.
1337
1338<h3 id="plugin-details">
1339 plugin details
1340</h3>
1341
1342Mostra l'inventario dei componenti di un plugin e il costo del token previsto. L'output elenca tutti i componenti che il plugin contribuisce, raggruppati come Skills, Agents, Hooks, server MCP e server LSP, insieme a una stima di quanti token aggiunge a ogni sessione. Il gruppo Skills include sia le voci `skills/` che `commands/`.
1343
1344```bash theme={null}
1345claude plugin details <name>
1346```
1347
1348Il comando accetta questi argomenti:
1349
1350* `<name>`: Nome del plugin o `plugin-name@marketplace-name`
1351
1352Il comando accetta queste opzioni:
1353
1354| Opzione | Descrizione | Predefinito |
1355| :----------- | :--------------------------------- | :---------- |
1356| `-h, --help` | Visualizza la guida per il comando | |
1357
1358L'output mostra due cifre di costo per ogni componente:
1359
1360* **Always-on:** token aggiunti a ogni sessione dal testo dell'elenco del plugin, come descrizioni delle skill, descrizioni degli agent e nomi dei comandi, indipendentemente dal fatto che un componente si attivi.
1361* **On-invoke:** token che un componente costa quando si attiva. Mostrato per componente, non come totale del plugin, perché una sessione tipica invoca solo un sottoinsieme di componenti.
1362
1363Questo esempio mostra come appare l'output per un plugin con due skill:
1364
1365```
1366dependency-guard 1.2.0
1367 Dependency analysis for Claude Code sessions
1368 Source: dependency-guard@example-marketplace
1369
1370Component inventory
1371 Skills (2) scan-dependencies, review-changes
1372 Agents (0)
1373 Hooks (1) SessionStart (harness-only — no model context cost)
1374 MCP servers (0)
1375 LSP servers (0)
1376
1377Projected token cost
1378 Always-on: ~180 tok added to every session
1379
1380Per-component (rounded)
1381 component always-on on-invoke
1382 scan-dependencies ~100 ~2400
1383 review-changes ~80 ~1800
1384
1385 On-invoke cost is paid each time a skill or agent fires.
1386 Token counts are estimates and may differ from actual usage.
1387```
1388
1389Il totale always-on viene calcolato tramite l'API `count_tokens` per il tuo modello attivo. I numeri per componente sono proporzionalmente scalati da quel totale. Se l'API non è raggiungibile, il comando ricade su una stima basata su caratteri.
1390
1391<h3 id="plugin-validate">
1392 plugin validate
1393</h3>
1394
1395Controlla un plugin o un marketplace per errori di sintassi e schema prima della pubblicazione.
1396
1397Il comando esce con 0 quando la convalida passa, 1 quando fallisce e 2 quando l'esecuzione della convalida stessa fallisce, ad esempio quando il percorso che passi non è leggibile.
1398
1399```bash theme={null}
1400claude plugin validate <path> [options]
1401```
1402
1403Il comando accetta questi argomenti:
1404
1405* `<path>`: Percorso a una directory di plugin o una directory di marketplace. Vedi [Validate a plugin or a directory without a manifest](/docs/it/plugin-marketplaces#validate-a-plugin-or-a-directory-without-a-manifest) per quali file una esecuzione di plugin copre.
1406
1407Il comando accetta queste opzioni:
1408
1409| Opzione | Descrizione | Predefinito |
1410| :----------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------- |
1411| `--strict` | Tratta gli avvisi come errori ed esce con 1 su di essi. Usa in CI per catturare problemi che il runtime tollera, come [unrecognized fields](#unrecognized-fields) | |
1412| `--json` | Output il rapporto di convalida come un oggetto JSON con gli stessi codici di uscita. Richiede Claude Code v2.1.259 o successivo | |
1413| `-h, --help` | Visualizza la guida per il comando | |
1414
1415Con `--json`, Claude Code scrive il rapporto su stdout come un oggetto JSON con questi campi di livello superiore:
1416
1417* `success`: lo stesso verdetto che il codice di uscita fornisce
1418* `strict`: se l'esecuzione ha trattato gli avvisi come errori
1419* `target`: il percorso risolto che Claude Code ha convalidato
1420* `manifest`: il risultato del manifest stesso, o `null` per un'[esecuzione senza manifest](/docs/it/plugin-marketplaces#validate-a-plugin-or-a-directory-without-a-manifest)
1421* `contents`: risultati per file, ognuno nominando il suo `file` e portando array `errors`, `warnings` e `notes`
1422
1423All'uscita 2, il comando non scrive nulla su stdout; il messaggio di errore va su stderr.
1424
1425All'interno di una sessione interattiva, `/plugin validate <path>` esegue gli stessi controlli inline.
1426
1427<h3 id="plugin-eval">
1428 plugin eval
1429</h3>
1430
1431Esegui i [eval cases](/docs/it/plugin-evals) di un plugin e segnala i risultati valutati. Richiede Claude Code v2.1.269 o successivo. Ogni caso è un prompt più grader; Claude Code lo esegue più volte in una sessione isolata con solo il plugin target caricato, e per impostazione predefinita anche senza il plugin in modo che il rapporto mostri la differenza. Vedi [Test plugins with evals](/docs/it/plugin-evals) per il formato del caso, i grader, i risultati e l'utilizzo in CI.
1432
1433```bash theme={null}
1434claude plugin eval [target] [options]
1435```
1436
1437Il `target` facoltativo è una directory di plugin, un singolo file `prompt.md` o `case.yaml`, un plugin installato come `name` o `name@marketplace`, o `name@skills-dir`, e predefinito è la directory corrente. Mettilo prima di `--tag`, `--allow-tools` e `--json`.
1438
1439Questa tabella elenca le opzioni che la maggior parte delle esecuzioni utilizza. Esegui `claude plugin eval --help` per l'insieme completo, inclusi `--case`, `--tag`, `--output-dir`, `--report`, `--allow-real-servers`, `--keep-temp` e `--verbose`.
1440
1441| Opzione | Descrizione | Predefinito |
1442| :------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------- |
1443| `--runs <n>` | Esecuzioni per caso per braccio | Ogni `runs` del caso, altrimenti 3 |
1444| `-j, --concurrency <n>` | Sessioni di agent da eseguire contemporaneamente, da 1 a 8. Condividono il tuo limite di velocità | `1` |
1445| `--model <model>` | Modello per l'agent in test | Ogni `model` del caso, altrimenti `ANTHROPIC_MODEL` se impostato, altrimenti il predefinito di Claude Code |
1446| `--judge-model <model>` | Modello per i grader `llm` e `baseline` | Un modello piccolo e veloce |
1447| `--ablation <mode>` | `none` o `with-without`. Vedi [Compare against a no-plugin baseline](/docs/it/plugin-evals#compare-against-a-no-plugin-baseline) | `with-without` quando un plugin si risolve, altrimenti `none` |
1448| `--threshold <0..1>` | Esci con 1 se un caso qualsiasi punteggia al di sotto di questo | `1.0` |
1449| `--max-cost-usd <usd>` | Interrompi prima della prossima esecuzione una volta che la spesa raggiunge questo, esci con 2 e segnala risultati parziali | Nessun limite |
1450| `--allow-tools <tools...>` | Concedi strumenti oltre l'insieme di sola lettura, come `Bash`, `Write`, `Edit` o `"mcp__plugin_<plugin>_<server>__*"`. Vedi [Grant tools](/docs/it/plugin-evals#grant-tools) | |
1451| `--scaffold` | Esegui lo [`scaffold_script`](/docs/it/plugin-evals#add-setup-or-history-with-case-yaml) di ogni caso | Off |
1452| `--trust-plugin` | Salta il prompt di fiducia della prima esecuzione, per CI. Vedi [What a run can access](/docs/it/plugin-evals#security) | Off |
1453| `--mocks <mode>` | `record` o `off`. Vedi [Mock MCP servers](/docs/it/plugin-evals#mock-mcp-servers) | `record` |
1454| `--eval-dir <dir>` | Directory sotto il plugin che contiene i casi | Il `experimental.evals` del manifest, altrimenti `evals` |
1455| `--json [path]` | Stampa il [result document](/docs/it/plugin-evals#json-result) su stdout, o scrivilo in un percorso `.json` | |
1456| `--no-publish` | Mantieni il rapporto HTML locale | |
1457| `-h, --help` | Visualizza la guida per il comando | |
1458
1459Il comando esce con 0 quando ogni caso soddisfa la soglia, 1 su un caso fallito, un errore di caricamento o una directory di plugin non attendibile, 2 su un'esecuzione parziale, 130 quando interrotto e 143 quando terminato. Vedi [Run evals in CI](/docs/it/plugin-evals#run-evals-in-ci).
1460
1461<h3 id="plugin-eval-init">
1462 plugin eval init
1463</h3>
1464
1465Crea una suite di eval per il plugin nella directory corrente. Richiede Claude Code v2.1.269 o successivo. In un terminale questo avvia un'intervista di authoring che legge il plugin, propone casi e grader, li pilota e scrive i file. Con `--bare`, o senza un terminale, scrive invece un modello di singolo caso vuoto. Esegui da dentro una sessione interattiva di Claude Code, stampa le istruzioni dell'intervista per quella sessione da seguire piuttosto che scrivere un modello. Vedi [Create your first eval suite](/docs/it/plugin-evals#create-your-first-eval-suite).
1466
1467```bash theme={null}
1468claude plugin eval init [name] [options]
1469```
1470
1471Il `name` facoltativo è un nome di caso: l'intervista non ne ha bisogno, mentre `--bare` e il percorso del modello senza terminale lo richiedono. Accetta queste opzioni:
1472
1473| Opzione | Descrizione | Predefinito |
1474| :------------------ | :----------------------------------------------------------------------------------------------- | :------------------------------------------------------- |
1475| `--bare` | Scrivi un `prompt.md` vuoto e `graders/criteria.md` per `<name>` invece di eseguire l'intervista | |
1476| `-i, --interactive` | Richiedi l'intervista. Fallisce senza un terminale invece di scrivere un modello | |
1477| `--eval-dir <dir>` | Directory sotto la directory corrente in cui scrivere i casi | Il `experimental.evals` del manifest, altrimenti `evals` |
1478| `-h, --help` | Visualizza la guida per il comando | |
1479
1480<h3 id="plugin-tag">
1481 plugin tag
1482</h3>
1483
1484Crea un tag git di rilascio per un plugin. Per impostazione predefinita il comando etichetta il plugin nella directory corrente; passa un percorso per etichettare un plugin altrove. Vedi [Tag plugin releases](/docs/it/plugin-dependencies#tag-plugin-releases-for-version-resolution).
1485
1486```bash theme={null}
1487claude plugin tag [path] [options]
1488```
1489
1490Il comando accetta questi argomenti:
1491
1492* `[path]`: Percorso alla directory del plugin. Predefinito è la directory corrente.
1493
1494Il comando accetta queste opzioni:
1495
1496| Opzione | Descrizione | Predefinito |
1497| :-------------------- | :------------------------------------------------------------------------- | :---------- |
1498| `--push` | Spinge il tag al remote dopo averlo creato | |
1499| `--dry-run` | Stampa cosa verrebbe etichettato senza creare il tag | |
1500| `-f, --force` | Crea il tag anche se l'albero di lavoro è sporco o il tag esiste già | |
1501| `-m, --message <msg>` | Messaggio di annotazione del tag. Usa `%s` come segnaposto per la versione | |
1502| `--remote <name>` | Remote a cui spingere con `--push` | `origin` |
1503| `-h, --help` | Visualizza la guida per il comando | |
1504
1505***
1506
1507<h2 id="debugging-and-development-tools">
1508 Strumenti di debug e sviluppo
1509</h2>
1510
1511<h3 id="debugging-commands">
1512 Comandi di debug
1513</h3>
1514
1515Utilizzare `claude --debug` per visualizzare i dettagli del caricamento dei plugin:
1516
1517Questo mostra:
1518
1519* Quali plugin vengono caricati
1520* Eventuali errori nei manifest dei plugin
1521* Registrazione di skill, agent e hook
1522* Inizializzazione del server MCP
1523
1524<h3 id="common-issues">
1525 Problemi comuni
1526</h3>
1527
1528| Problema | Causa | Soluzione |
1529| :---------------------------------- | :------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
1530| Plugin non caricato | `plugin.json` non valido | Eseguire `claude plugin validate ./my-plugin` o `/plugin validate ./my-plugin`, dove `./my-plugin` è la directory del plugin, per controllare `plugin.json`, `hooks/hooks.json` e il frontmatter delle skill, degli agent e dei comandi nelle directory predefinite del plugin per errori di sintassi e schema. Vedere [Validate a plugin or a directory without a manifest](/docs/it/plugin-marketplaces#validate-a-plugin-or-a-directory-without-a-manifest) per informazioni su cosa copre un'esecuzione |
1531| Skill non visualizzate | Struttura di directory errata | Assicurarsi che `skills/` o `commands/` sia nella radice del plugin, non dentro `.claude-plugin/` |
1532| Hook non attivati | Script non eseguibile | Eseguire `chmod +x script.sh` |
1533| Server MCP non funziona | `${CLAUDE_PLUGIN_ROOT}` mancante | Utilizzare la variabile per tutti i percorsi dei plugin |
1534| Errori di percorso | Percorsi assoluti utilizzati | Rendere i percorsi relativi, iniziando con `./`; vedere [Path behavior rules](#path-behavior-rules), che coprono l'eccezione `"."` del campo `skills` |
1535| LSP `Executable not found in $PATH` | Language server non installato | Installare il binario (ad es., `npm install -g typescript-language-server typescript`) |
1536
1537<h3 id="example-error-messages">
1538 Messaggi di errore di esempio
1539</h3>
1540
1541**Errori di convalida del manifest**:
1542
1543* `Invalid JSON syntax: Unexpected token } in JSON at position 142`: controllare la presenza di virgole mancanti, virgole extra o stringhe non quotate
1544* `Plugin <name> has an invalid manifest file at .claude-plugin/plugin.json. Validation errors: name: Invalid input: expected string, received undefined`: un campo obbligatorio è mancante
1545* `Plugin <name> has a corrupt manifest file at .claude-plugin/plugin.json. JSON parse error: ...`: errore di sintassi JSON. Prima della versione 2.1.246, Claude Code produceva anche questo errore per un `plugin.json` salvato come UTF-8 con un byte order mark (BOM) iniziale, anche quando il JSON era altrimenti valido.
1546
1547**Errori di caricamento del plugin**:
1548
1549* `Warning: No commands found in plugin my-plugin custom directory: ./cmds. Expected .md files or SKILL.md in subdirectories.`: il percorso del comando esiste ma non contiene file di comando validi
1550* `Plugin directory not found at path: ./plugins/my-plugin. Check that the marketplace entry has the correct path.`: il percorso `source` in marketplace.json punta a una directory inesistente
1551* `Plugin my-plugin has conflicting manifests: both plugin.json and marketplace entry specify components.`: rimuovere le definizioni di componenti duplicate o rimuovere `strict: false` nella voce del marketplace
1552
1553<h3 id="hook-troubleshooting">
1554 Risoluzione dei problemi degli hook
1555</h3>
1556
1557**Script hook non in esecuzione**:
1558
15591. Verificare che lo script sia eseguibile: `chmod +x ./scripts/your-script.sh`
15602. Verificare la riga shebang: La prima riga deve essere `#!/bin/bash` o `#!/usr/bin/env bash`
15613. Verificare che il percorso utilizzi `${CLAUDE_PLUGIN_ROOT}`: `"command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/your-script.sh"`
15624. Testare lo script manualmente: `./scripts/your-script.sh`
1563
1564**Hook non attivato su eventi previsti**:
1565
15661. Verificare che il nome dell'evento sia corretto (sensibile alle maiuscole): `PostToolUse`, non `postToolUse`
15672. Verificare che il pattern del matcher corrisponda ai vostri strumenti: `"matcher": "Write|Edit"` per le operazioni su file
15683. Confermare che il tipo di hook sia valido: `command`, `http`, `mcp_tool`, `prompt` o `agent`
1569
1570<h3 id="mcp-server-troubleshooting">
1571 Risoluzione dei problemi del server MCP
1572</h3>
1573
1574**Server non avviato**:
1575
15761. Verificare che il comando esista e sia eseguibile
15772. Verificare che tutti i percorsi utilizzino la variabile `${CLAUDE_PLUGIN_ROOT}`
15783. Controllare i log del server MCP: `claude --debug` mostra gli errori di inizializzazione
15794. Testare il server manualmente al di fuori di Claude Code
1580
1581**Strumenti del server non visualizzati**:
1582
15831. Assicurarsi che il server sia configurato correttamente in `.mcp.json` o `plugin.json`
15842. Verificare che il server implementi correttamente il protocollo MCP
15853. Controllare i timeout di connessione nell'output di debug
1586
1587<h3 id="directory-structure-mistakes">
1588 Errori di struttura della directory
1589</h3>
1590
1591**Sintomi**: Il plugin viene caricato ma i componenti (skill, agent, hook) sono mancanti.
1592
1593**Struttura corretta**: I componenti devono essere nella radice del plugin, non dentro `.claude-plugin/`. Solo `plugin.json` appartiene a `.claude-plugin/`.
1594
1595**Elenco di controllo del debug**:
1596
15971. Eseguire `claude --debug` e cercare i messaggi "loading plugin"
15982. Verificare che ogni directory di componenti sia elencata nell'output di debug
15993. Verificare che i permessi dei file consentano la lettura dei file del plugin
1600
1601***
1602
1603<h2 id="distribution-and-versioning-reference">
1604 Riferimento di distribuzione e versioning
1605</h2>
1606
1607<h3 id="version-management">
1608 Gestione delle versioni
1609</h3>
1610
1611Claude Code utilizza la versione del plugin come chiave di cache che determina se un aggiornamento è disponibile. Quando esegui `/plugin update` o l'aggiornamento automatico si attiva, Claude Code calcola la versione corrente e salta l'aggiornamento se corrisponde a quella già installata. Un plugin [caricato in place](#plugin-caching-and-file-resolution) da un marketplace di directory locale carica i suoi file sorgente correnti all'inizio di ogni sessione, indipendentemente da ciò che dice la sua stringa di versione.
1612
1613Per ogni tipo di sorgente eccetto `command`, Claude Code risolve la versione dal primo di questi che è impostato:
1614
16151. Il campo `version` nel `plugin.json` del plugin
16162. Il campo `version` nella voce del plugin nel marketplace in `marketplace.json`
16173. Lo SHA del commit git della sorgente del plugin, per le sorgenti `github`, `url`, `git-subdir` e relative-path in un marketplace ospitato su git
16184. Il digest SHA-256, per le [sorgenti `archive`](/docs/it/plugin-marketplaces#zip-archives): il pin `sha256` nella voce del marketplace, o il digest del file scaricato quando non imposti alcun pin. Claude Code lo accorcia ai primi 12 caratteri
16195. `unknown`, per le sorgenti `npm` o le directory locali quando né la directory del plugin né il suo marketplace è un repository git. Claude Code non prende la versione da un repository che racchiude il percorso di installazione, come un `~/.claude` gestito da git
1620
1621Per una [sorgente `command`](/docs/it/plugin-marketplaces#command-sources), Claude Code deriva sempre la versione da ciò che il comando ha prodotto: un hash di contenuto di 12 caratteri da solo, o aggiunto alla versione `plugin.json` come `<version>-<hash>` quando uno è impostato. Claude Code ignora il campo `version` della voce del marketplace per le sorgenti command. Un comando il cui output con hash cambia produce quindi una nuova versione, anche quando la stringa di versione creata rimane la stessa. In [link mode](/docs/it/plugin-marketplaces#copy-mode-and-link-mode), l'hash copre il percorso reale della directory stampata e le sue voci di primo livello piuttosto che i contenuti dei file.
1622
1623Per questi tipi di sorgente, questo ti dà tre modi per versioning di un plugin:
1624
1625| Approccio | Come | Comportamento dell'aggiornamento | Migliore per |
1626| :---------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------- |
1627| **Versione esplicita** | Imposta `"version": "2.1.0"` in `plugin.json` | Gli utenti ricevono aggiornamenti solo quando aumenti questo campo. Spingere nuovi commit senza aumentarlo non ha effetto, e `/plugin update` segnala "already at the latest version". Per un plugin [caricato in place](#plugin-caching-and-file-resolution), il nuovo contenuto si carica comunque. | Plugin pubblicati con cicli di rilascio stabili |
1628| **Versione Commit-SHA** | Ometti `version` sia da `plugin.json` che dalla voce del marketplace | Gli utenti ricevono aggiornamenti ogni volta che il commit risolto della sorgente cambia | Plugin interni o di team in sviluppo attivo |
1629| **Versione Digest** | Utilizza una [sorgente `archive`](/docs/it/plugin-marketplaces#zip-archives) e ometti `version` sia da `plugin.json` che dalla voce del marketplace | Con un pin `sha256`, gli utenti ricevono aggiornamenti quando cambi il pin. Senza uno, gli utenti ricevono aggiornamenti ogni volta che i byte del file zip ospitato cambiano | Plugin pubblicati come file zip su un server statico o repository di artefatti |
1630
1631Se utilizzi versioni esplicite, segui il [semantic versioning](https://semver.org) (`MAJOR.MINOR.PATCH`): aumenta MAJOR per i cambiamenti che rompono la compatibilità, MINOR per le nuove funzionalità, PATCH per le correzioni di bug. Documenta i cambiamenti in un `CHANGELOG.md`.
1632
1633***
1634
1635<h2 id="see-also">
1636 Vedi anche
1637</h2>
1638
1639* [Plugin](/docs/it/plugins) - Tutorial e utilizzo pratico
1640* [Marketplace dei plugin](/docs/it/plugin-marketplaces) - Creazione e gestione dei marketplace
1641* [Skills](/docs/it/skills) - Dettagli dello sviluppo delle skill
1642* [Subagents](/docs/it/sub-agents) - Configurazione e capacità dell'agent
1643* [Hooks](/docs/it/hooks) - Gestione degli eventi e automazione
1644* [MCP](/docs/it/mcp) - Integrazione di strumenti esterni
1645* [Impostazioni](/docs/it/settings) - Opzioni di configurazione per i plugin
