> ## Documentation Index > Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt > Use this file to discover all available pages before exploring further. # Riferimento comandi plugin > Riferimento per i comandi shell del plugin claude, /plugin e /reload-plugins in una sessione, e i flag che caricano un plugin per una sola sessione. Esegui i comandi plugin come `claude plugin` dalla tua shell o da uno script, oppure come `/plugin` e `/reload-plugins` all'interno di una sessione Claude Code. Questo riferimento fornisce i flag, i valori predefiniti, l'output e i codici di uscita di ogni comando, insieme ai due flag che caricano un plugin per una sola sessione. Le tabelle seguenti elencano le opzioni di uso comune di ogni sottocomando, non tutte le opzioni. Esegui `claude plugin --help` nella tua shell per vedere quali sottocomandi ha la tua versione, e `claude plugin --help` per l'elenco completo delle opzioni di un sottocomando. Questi casi sono trattati su altre pagine: * **Installa e gestisci i passaggi, e dove `/plugin` viene eseguito**: vedi [Installa e gestisci i plugin](/docs/it/plugins/install) * **Cosa un comando cambia su disco e quale ambito ha la precedenza**: vedi [Riferimento caricamento plugin](/docs/it/plugins/loading) * **Cosa significa un messaggio di errore**: vedi [Risolvi i problemi dei plugin](/docs/it/plugins/troubleshooting)

Comandi claude plugin

Esegui `claude plugin ` dalla tua shell o da uno script, al di fuori di una sessione Claude Code. Questi sottocomandi installano e gestiscono i plugin senza aprire il pannello [`/plugin`](#plugin-in-a-session). `claude plugins` è un alias per `claude plugin`. Ogni sottocomando condivide questi codici di uscita, argomenti plugin e valori di ambito: * **Codici di uscita**: `0` in caso di successo e `1` in caso di errore. `validate` aggiunge l'uscita `2` per un errore inaspettato, e `eval` aggiunge i codici elencati nella [sua sezione](#plugin-eval). * **Argomenti plugin**: un argomento `` è un plugin `name` o `name@marketplace`. Quando due marketplace offrono lo stesso nome, usa la forma qualificata. `configure` accetta solo la forma qualificata. * **Ambiti**: `--scope` accetta `user`, `project` o `local`, e nomina il file di impostazioni in cui il comando scrive. `update` accetta anche `managed`.

plugin init

Crea lo scaffolding di un nuovo plugin in `~/.claude/skills//`. Si carica nella tua prossima sessione come `@skills-dir` senza alcun passaggio di installazione. `new` è un alias per `init`. Per il workflow di creazione, test e modifica che inizia con questo comando, vedi [Crea un plugin](/docs/it/plugins/create). ```bash theme={null} claude plugin init [options] ``` `` diventa il nome della directory sotto `~/.claude/skills/` e il `name` del plugin nel suo manifest. Il comando non ha un flag per un'altra posizione. Per creare lo scaffolding all'interno di un progetto, vedi [Crea un plugin](/docs/it/plugins/create). | Flag | Descrizione | | :- | :- | | `--description ` | Descrizione del manifest | | `--author ` | Nome dell'autore. Predefinito a `git config user.name` | | `--author-email ` | Email dell'autore. Predefinito a `git config user.email` | | `--with ` | Crea anche file starter per `skills`, `agents`, `hooks`, `mcp`, `lsp`, `output-style` o `channel` | | `-f, --force` | Sovrascrivi un `.claude-plugin/` esistente al target | Crea lo scaffolding di un plugin con file skill e hook starter: ```bash theme={null} claude plugin init my-helper --with skills hooks ``` Claude Code convalida ciò che ha scritto e stampa `Created plugin "my-helper" at ~/.claude/skills/my-helper`, seguito dall'id con cui si carica e dal comando `claude plugin disable` che lo disattiva. Claude Code esce con `1` senza scrivere quando non può creare lo scaffolding in sicurezza, e il messaggio nomina il motivo. Questi sono motivi comuni: * Un valore `--with` sconosciuto * Uno scaffolding esistente al target senza `--force` * Un'impostazione gestita che blocca i plugin della directory skills

plugin install

Installa un plugin da uno dei tuoi marketplace. `i` è un alias per `install`. ```bash theme={null} claude plugin install [options] ``` La maggior parte dei plugin si installa senza un prompt. Per un plugin il cui entry del marketplace [esegue un comando per installarlo](/docs/it/plugins/host-marketplace) o [imposta un `headersHelper` per il suo download](/docs/it/plugins/host-marketplace#how-users-accept-a-headershelper-command), Claude Code prima stampa il comando e chiede `Run this command now? [y/N]`. | Flag | Descrizione | | :- | :- | | `-s, --scope ` | Ambito di installazione: `user`, `project` o `local`. Predefinito a `user` | | `--config ` | Imposta un'opzione [`userConfig`](/docs/it/plugins/manifest-reference) che il manifest del plugin dichiara. Ripeti il flag per ogni opzione. Una chiave scritta `.` imposta un'impostazione che un [server MCP in bundle](/docs/it/plugins/components#include-a-packaged-mcpb-server) dichiara nel suo stesso `user_config`, per un file bundle spedito all'interno del plugin. La forma `.` richiede Claude Code v2.1.285 o successivo | | `-y, --yes` | Accetta il comando di installazione visualizzato senza il prompt `Run this command now?`. Ignorato quando il comando viene eseguito all'interno di una sessione Claude Code, ad esempio dallo strumento Bash o da un hook. Richiede Claude Code v2.1.229 o successivo | | `--accept-command ` | Accetta il comando di installazione visualizzato il cui `sha256` un'esecuzione precedente [`--json`](#plugin-json-result) ha riportato in `shownCommand`, al posto di `-y`. Non può essere combinato con `-y`. Vedi [Accetta un comando di installazione visualizzato](#accept-a-displayed-install-command). Richiede Claude Code v2.1.271 o successivo | | `--json` | Stampa il risultato come un oggetto JSON sull'ultima riga di stdout invece del messaggio leggibile, per l'uso negli script. Vedi [Formato risultato JSON](#plugin-json-result). Richiede Claude Code v2.1.268 o successivo | | `--marketplace ` | Installa ``, indicato con il suo nome semplice, dal marketplace in ``, aggiungendo prima il marketplace se non l'hai ancora aggiunto. Vedi [Aggiungi un marketplace e installa con un solo comando](/docs/it/plugins/install#add-a-marketplace-and-install-in-one-command). Richiede Claude Code v2.1.292 o successivo | Esegui `claude plugin install --help` nella tua shell per vedere ogni opzione che la tua versione supporta. Passa `-y` dal tuo terminale per accettare il comando visualizzato senza il prompt. Ecco cosa succede senza un TTY e quando Claude esegue il comando: * **stdin o stdout non è un TTY, e non passi né `-y` né `--accept-command`**: l'installazione viene rifiutata. L'output dice che il comando è stato solo visualizzato, e il codice di uscita è `1` * **Claude esegue il comando attraverso il suo strumento Bash**: `-y` viene ignorato. Esegui il comando dal tuo terminale invece Installa un plugin per tutti coloro che clonano il progetto: ```bash theme={null} claude plugin install formatter@my-marketplace --scope project ``` Claude Code stampa `Successfully installed plugin: formatter@my-marketplace (scope: project)`. Quando nulla di nuovo viene installato, l'output dice perché: * **Già installato a quell'ambito**: l'output è `Plugin "formatter@my-marketplace" is already installed (scope: project)` e il codice di uscita è `0` * **Rifiuti un prompt di origine comando**: l'output è `Aborted.` e il codice di uscita è `1` * **Rifiuti un prompt `headersHelper`, o non può essere confermato senza un TTY**: l'output è `Aborted — the command was not run.` e il codice di uscita è `1`

Formato risultato JSON

Quando passi `--json` a `plugin install`, 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: * `command`: il sottocomando che è stato eseguito, ad esempio `install` * `outcome`: `ok` o `failed` * `message`: una descrizione leggibile del risultato Altri campi, come `pluginId`, `scope` e `failureCode`, appaiono solo quando si applicano. 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.

Risultato JSON per i comandi marketplace

Su `plugin marketplace add`, `plugin marketplace remove` e `plugin marketplace update`, `--json` stampa un oggetto JSON sull'ultima riga di stdout con i campi `command`, `outcome` e `message`. Quanto segue è il risultato di `claude plugin marketplace remove your-marketplace --json`: ```json theme={null} {"command":"marketplace-remove","outcome":"ok","marketplace":"your-marketplace","message":"Successfully removed marketplace: your-marketplace"} ``` Il valore di `command` è `marketplace-add`, `marketplace-remove` o `marketplace-update`. I campi seguenti appaiono solo quando si applicano: * `marketplace`: il nome del marketplace su cui il comando ha agito * `failureCode`: un codice che indica perché il comando è fallito, come `invalid_source` `plugin marketplace add` e `plugin marketplace remove` possono non stampare alcuna riga di risultato quando l'argomento è il [nome riservato](/docs/it/plugins/marketplace-reference#reserved-names) `anthropic-plugin-directory`, quindi controlla il codice di uscita per quel nome.

Accetta un comando di installazione visualizzato

Quando un'esecuzione `--json` visualizza un comando dichiarato dal marketplace e non lo esegue, il risultato `failed` porta anche un oggetto `shownCommand`. I suoi 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` dal tuo terminale, perché il flag non ha effetto all'interno di una sessione Claude Code. Richiede Claude Code v2.1.271 o successivo. Lo `sha256` conta come accettazione per esattamente quel comando, plugin e catalogo marketplace. Se uno di essi è cambiato dal momento in cui il comando è stato visualizzato, Claude Code non accetta lo `sha256` e mostra di nuovo il comando. Un cambiamento che l'aggiornamento del marketplace della stessa esecuzione recupera conta anche come tale cambiamento. Se `shownCommand.acceptCommandMatched` è `false`, lo `sha256` che hai passato non corrisponde al comando ora visualizzato. Rivedi quel comando prima di eseguire di nuovo con il suo `sha256`.

plugin uninstall

Rimuovi un plugin installato da un ambito. `remove` e `rm` sono alias per `uninstall`. ```bash theme={null} claude plugin uninstall [options] ``` | Flag | Descrizione | | :- | :- | | `-s, --scope ` | Disinstalla dall'ambito: `user`, `project` o `local`. Predefinito a `user` | | `--keep-data` | Preserva la directory di dati persistenti del plugin, `~/.claude/plugins/data//` | | `--prune` | Rimuovi anche le [dipendenze](/docs/it/plugins/dependencies) auto-installate che nessun plugin rimanente necessita | | `-y, --yes` | Salta il prompt di conferma `--prune`. Richiesto con `--prune` quando stdin o stdout non è un TTY | | `--json` | Stampa il risultato come un oggetto JSON sull'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 | Disinstalla un plugin dall'ambito del progetto: ```bash theme={null} claude plugin uninstall formatter@my-marketplace --scope project ``` Claude Code stampa `Successfully uninstalled plugin: formatter (scope: project)`. Quando il plugin non è installato a quell'ambito, il comando stampa una riga che inizia con `Failed to uninstall plugin "formatter@my-marketplace":` ed esce con `1`. Se la riga di errore continua con `"formatter" was not uninstalled:` e nomina un file di impostazioni, Claude Code non ha potuto confermare che le impostazioni dell'ambito non attivano più il plugin, quindi il plugin rimane installato con tutto ciò che ha salvato. Con `--json`, il risultato porta `failureCode: "settings_still_on"`. Questo controllo delle impostazioni richiede Claude Code v2.1.282 o successivo.

Cosa una disinstallazione elimina e conserva

Quando disinstalli un plugin dall'ultimo ambito in cui è installato, Claude Code elimina anche le [opzioni e i segreti](/docs/it/plugins/manifest-reference#user-configuration) memorizzati del plugin e la sua directory di dati, `~/.claude/plugins/data//`. Ci sono tre eccezioni: * Con `--keep-data`, la directory di dati rimane * Quando un altro plugin installato usa la stessa cartella, come uno il cui ID differisce da questo solo per maiuscole/minuscole, la directory di dati rimane * Quando Claude Code non può leggere l'elenco dei plugin installati dopo che rimuove il plugin da quell'ambito, le opzioni, i segreti e la directory di dati rimangono tutti, perché il plugin potrebbe essere ancora installato a un altro ambito. La disinstallazione ha comunque successo. Il messaggio elenca cosa è rimasto e come eliminarlo, e con `--json` il risultato porta `savedKept: "install_records_unreadable"` Con `--json`, `keptData` riporta se la directory è rimasta, e `/plugin` mostra `· data preserved` quando lo ha fatto. Per una directory che rimane senza `--keep-data`, questo rapporto richiede Claude Code v2.1.281 o successivo. Il campo `savedKept` richiede Claude Code v2.1.282 o successivo.

plugin enable

Abilita un plugin disabilitato. Per un [plugin sincronizzato da claude.ai](/docs/it/plugins/loading#synced-plugins), passa `@synced` come plugin. ```bash theme={null} claude plugin enable [options] ``` | Flag | Descrizione | | :- | :- | | `-s, --scope ` | Ambito in cui abilitare: `user`, `project` o `local`. Auto-rilevato quando omesso | | `--json` | Stampa il risultato come un oggetto JSON sull'ultima riga di stdout, nello [stesso formato di `plugin install --json`](#plugin-json-result). Richiede Claude Code v2.1.268 o successivo | Senza `--scope`, il comando controlla i tuoi file di impostazioni nell'ordine local, project, user, e usa il primo ambito che menziona il plugin. Se passi uno `--scope` dove il plugin non è dichiarato, il comando scrive un override o fallisce: * **Un ambito che [ha precedenza](/docs/it/plugins/loading) su quello dichiarante**: Claude Code scrive un override all'ambito che hai passato. Ad esempio, `claude plugin disable formatter --scope local` disattiva un plugin abilitato a livello di progetto solo per te * **Qualsiasi altro ambito**: il comando fallisce con `Plugin "formatter" is installed at project scope, not user. Use --scope project or omit --scope to auto-detect.` Se il plugin è già abilitato all'ambito risolto, il comando stampa `Plugin "formatter" is already enabled` ed esce con `1`. Con `--json`, il risultato ha `"failureCode": "already_in_goal_state"` e `"alreadyInGoalState": true`, quindi uno script può trattare quel caso come successo. Quando il plugin dichiara [dipendenze](/docs/it/plugins/dependencies), Claude Code le abilita anche. Il comando fallisce in questi casi: * **Una dipendenza non è installata**: enable fallisce e stampa il comando `claude plugin install` per ogni dipendenza mancante * **Una dipendenza è bloccata dalla politica dei plugin della tua organizzazione**: enable fallisce e nomina la dipendenza bloccata * **Una dipendenza è impostata a `false` a un ambito con precedenza più alta dell'ambito target**: enable fallisce. Abilita la dipendenza a quell'ambito, o passa `--scope` per scrivere lì Riabilita un plugin ovunque sia dichiarato: ```bash theme={null} claude plugin enable formatter ``` Claude Code stampa `Successfully enabled plugin: formatter (scope: project)`, nominando l'ambito che ha rilevato.

plugin disable

Disabilita un plugin senza disinstallarlo. Per un [plugin sincronizzato da claude.ai](/docs/it/plugins/loading#synced-plugins), passa `@synced` come plugin. ```bash theme={null} claude plugin disable [plugin] [options] ``` | Flag | Descrizione | | :- | :- | | `-a, --all` | Disabilita ogni plugin abilitato. Non può essere combinato con un nome di plugin o `--scope` | | `-s, --scope ` | Ambito in cui disabilitare: `user`, `project` o `local`. Auto-rilevato quando omesso | | `--json` | Stampa il risultato come un oggetto JSON sull'ultima riga di stdout, nello [stesso formato di `plugin install --json`](#plugin-json-result). Richiede Claude Code v2.1.268 o successivo | Senza `--scope`, l'ambito è auto-rilevato nello stesso ordine local, project, user di [`plugin enable`](#plugin-enable). Se non passi né un nome di plugin né `--all`, Claude Code stampa `Please specify a plugin name or use --all to disable all plugins` ed esce con `1`. Disabilitare un plugin che è già disabilitato stampa `Plugin "formatter" is already disabled` ed esce con `1`, come [`plugin enable`](#plugin-enable) fa per un plugin già abilitato. Il comando fallisce per un plugin che è ancora richiesto: * **Un altro plugin abilitato [dipende da](/docs/it/plugins/dependencies) esso**: il comando fallisce e nomina i dipendenti da disabilitare prima * **La tua organizzazione lo richiede come plugin sincronizzato**: il comando fallisce e non salva nulla Disabilita un plugin: ```bash theme={null} claude plugin disable formatter ``` Claude Code stampa `Successfully disabled plugin: formatter (scope: project)`.

plugin update

Aggiorna un plugin all'ultima versione che il suo marketplace offre. La nuova versione si carica nella tua prossima sessione, o dopo che esegui `/reload-plugins` in una sessione in esecuzione. ```bash theme={null} claude plugin update [options] ``` | Flag | Descrizione | | :- | :- | | `-s, --scope ` | Ambito da aggiornare: `user`, `project`, `local` o `managed`. Auto-rilevato quando omesso | | `-y, --yes` | Accetta un comando di installazione modificato da un plugin [command-source](/docs/it/plugins/host-marketplace), senza il prompt. Richiesto quando stdin o stdout non è un TTY, a meno che non passi `--accept-command`. Richiede Claude Code v2.1.229 o successivo | | `--accept-command ` | Accetta il comando dichiarato dal marketplace il cui `sha256` un'esecuzione precedente [`--json`](#plugin-json-result) ha riportato in `shownCommand`, al posto di `-y`. Non può essere combinato con `-y`. Richiede Claude Code v2.1.271 o successivo | | `--json` | Stampa il risultato come un oggetto JSON sull'ultima riga di stdout, nello [stesso formato di `plugin install --json`](#plugin-json-result). Richiede Claude Code v2.1.268 o successivo | Aggiorna un plugin: ```bash theme={null} claude plugin update formatter@my-marketplace ``` Claude Code stampa `Checking for updates for plugin "formatter@my-marketplace"…`, poi il risultato. Quando nulla è più recente, stampa `formatter is already at the latest version (1.0.0).` ed esce con `0`, a meno che non [riprovi l'installazione delle dipendenze del plugin](#retry-an-unfinished-dependency-install) e quell'installazione fallisca.

Quale ambito aggiorna il comando

Se ometti `--scope`, il comando aggiorna il plugin all'ambito più specifico in cui è installato per il tuo progetto corrente, controllando local, project, user, quindi managed. Prima della v2.1.281, il comando usava `user` quando omettevi `--scope`, quindi aggiornare un plugin installato solo all'ambito project o local falliva con `Plugin "" is not installed at scope user`. Su quelle versioni, passa `--scope`. `managed` è l'unico ambito che puoi aggiornare ma non installare. Per i plugin installati dall'amministratore, vedi [Gestisci i plugin per la tua organizzazione](/docs/it/plugins/org).

Aggiorna per nome semplice

Puoi passare un nome di plugin semplice, che il comando abbina ai tuoi plugin installati. Quando i plugin installati da diversi marketplace condividono il nome, il comando rifiuta l'aggiornamento ed elenca i comandi `plugin-name@marketplace-name` qualificati da eseguire invece. L'aggiornamento per nome semplice richiede Claude Code v2.1.246 o successivo.

Riprova un'installazione delle dipendenze non completata

Quando il plugin è già alla sua ultima versione, il comando può anche riprovare un'installazione delle dipendenze non completata nella sua copia in cache. Per i casi in cui quel nuovo tentativo viene eseguito o saltato, vedi [I pacchetti che elenca non sono installati](/docs/it/plugins/troubleshooting#the-packages-it-lists-are-not-installed). Se il nuovo tentativo fallisce, l'output è `Failed to update plugin "formatter@my-marketplace"` con il motivo e il codice di uscita è `1`. Prima della v2.1.287, il comando riportava il plugin alla sua ultima versione senza riprovare l'installazione.

plugin list

Elenca i plugin installati con la loro versione, ambito e stato. ```bash theme={null} claude plugin list [options] ``` | Flag | Descrizione | | :- | :- | | `--json` | Stampa l'elenco come JSON | | `--available` | Elenca anche i plugin che i tuoi marketplace offrono che non hai installato. Non ha effetto senza `--json` | | `--data-size [plugin]` | Misura la [directory di dati salvati](#what-an-uninstall-deletes-and-keeps) di ogni plugin installato, o solo quella del plugin denominato, dato come `name@marketplace`. Non ha effetto senza `--json`. Se il nome non ha un record di installazione, il comando stampa `--data-size names a plugin that is not installed` ed esce con `1` invece di stampare l'elenco. Richiede Claude Code v2.1.285 o successivo | Claude Code raggruppa l'output leggibile per come ogni plugin si carica: * **`Installed plugins:`**: plugin che hai installato da un marketplace * **`Session-only plugins (--plugin-dir / --plugin-url):`**: plugin caricati da quei flag nello stesso comando, come in `claude --plugin-dir ./my-plugin plugin list` * **`Skills-directory plugins (.claude/skills/*):`**: plugin che Claude Code ha trovato in una directory skills * **`Synced from claude.ai`**: [plugin sincronizzati dal tuo account claude.ai](/docs/it/plugins/loading#synced-plugins) Con nulla in nessun gruppo, Claude Code stampa ``No plugins installed. Use `claude plugin install` to install a plugin.``

Output JSON

Con `--json`, Claude Code stampa un array con un oggetto per installazione. Ogni oggetto porta i campi sottostanti. `id`, `version`, `scope`, `enabled` e `installPath` sono sempre presenti, e gli altri appaiono solo quando si applicano. | Campo | Tipo | Descrizione | | :- | :- | :- | | `id` | string | `name@marketplace` per installazioni, `name@inline` per plugin solo sessione, `name@skills-dir` per plugin della directory skills, `name@synced` per plugin sincronizzati da claude.ai | | `version` | string | Per un'installazione marketplace, la [versione che Claude Code ha calcolato](/docs/it/plugins/loading#versions-and-updates) all'installazione. Per un plugin solo sessione, della directory skills o sincronizzato, il `version` del manifest, o `unknown` quando non ne dichiara uno | | `scope` | string | `user`, `project`, `local` o `managed` per installazioni; `user` o `project` per plugin della directory skills; `session` per plugin solo sessione; `synced` per plugin sincronizzati da claude.ai | | `enabled` | boolean | Se il plugin è abilitato nelle tue impostazioni unite | | `installPath` | string | Directory da cui il plugin si carica, tranne per un plugin che le sessioni [caricano sul posto](/docs/it/plugins/loading#in-place-and-copied-plugins) dalla cartella del suo marketplace | | `readFromFolder` | string | Per un plugin che le sessioni [caricano sul posto](/docs/it/plugins/loading#in-place-and-copied-plugins) dalla cartella del suo marketplace, la directory di origine del plugin all'interno di quella cartella. Richiede Claude Code v2.1.289 o successivo | | `folderVersion` | string | Con `readFromFolder`, il `version` del plugin così come Claude Code lo ha caricato da quella cartella, che può differire dal campo `version` sopra. Assente quando il plugin non si è caricato o non dichiara alcuna versione. Richiede Claude Code v2.1.289 o successivo | | `installedAt` | string | Timestamp ISO dell'installazione. Solo installazioni marketplace | | `lastUpdated` | string | Timestamp ISO dell'ultimo aggiornamento. Solo installazioni marketplace | | `projectPath` | string | Progetto a cui appartiene l'installazione. Solo ambito `project` e `local` | | `mcpServers` | object | Le definizioni del server MCP del plugin, quando un plugin installato marketplace ne ha | | `errors` | array of strings | Errori di caricamento, quando il plugin non è riuscito a caricarsi | | `notes` | array of strings | Avvertimenti che non sono errori di caricamento, come problemi di authoring o [pacchetti che non sono installati](/docs/it/plugins/loading#when-the-dependency-install-fails-or-is-skipped) | | `errorDetails` | array of objects | Un oggetto per voce `errors`, fornendo il suo `type` diagnostico e i nomi a cui si riferisce, come il plugin, marketplace, server o file. Richiede Claude Code v2.1.268 o successivo | | `noteDetails` | array of objects | Gli stessi oggetti di dettaglio per ogni voce `notes`. Richiede Claude Code v2.1.268 o successivo | | `hasUserConfig` | boolean | Presente e `true` quando il plugin si è caricato e il suo manifest dichiara opzioni [`userConfig`](/docs/it/plugins/manifest-reference#user-configuration). Assente per un plugin che non è riuscito a caricarsi, qualunque cosa il suo manifest dichiari. I valori salvati non sono mai inclusi. Richiede Claude Code v2.1.285 o successivo | | `projectEnabled` | boolean | Se il `.claude/settings.json` condiviso del progetto attiva il plugin. Solo installazioni marketplace. Richiede Claude Code v2.1.285 o successivo | | `dataDirSize` | object | Con `--data-size`, la dimensione della [directory di dati salvati](#what-an-uninstall-deletes-and-keeps) del plugin come `bytes` e `human`; assente quando la directory è mancante o vuota. Solo installazioni marketplace. Richiede Claude Code v2.1.285 o successivo | | `dataDirUnreadable` | boolean | Con `--data-size`, `true` quando la directory di dati salvati esiste ma non ha potuto essere misurata. Solo installazioni marketplace. Richiede Claude Code v2.1.285 o successivo | Con `--json --available`, Claude Code stampa un oggetto invece di un array. Il suo campo `installed` contiene l'array di oggetti plugin installati, e il suo campo `available` contiene un oggetto per plugin marketplace non installato con i campi sottostanti. | Campo | Tipo | Descrizione | | :- | :- | :- | | `pluginId` | string | `name@marketplace` | | `name` | string | Il nome del plugin nel marketplace | | `marketplaceName` | string | Il marketplace che lo offre | | `source` | string or object | La [source](/docs/it/plugins/marketplace-reference) dell'entry del marketplace: una stringa per un percorso relativo, un oggetto altrimenti | | `description` | string | La descrizione dell'entry, quando ne ha una | | `version` | string | La versione dell'entry, quando ne dichiara una | | `installCount` | number | Conteggio delle installazioni, quando Claude Code ne ha uno per il plugin |

plugin details

Mostra l'inventario dei componenti di un plugin e il suo costo token previsto. Il plugin deve essere caricato: installato, trovato in una directory skills, o passato con `--plugin-dir` o `--plugin-url` nello stesso comando. Il `` è un plugin `name` o `name@marketplace`. ```bash theme={null} claude plugin details ``` Il comando non accetta flag oltre a `--help`. Mostra cosa contribuisce un plugin installato: ```bash theme={null} claude plugin details formatter ``` Claude Code stampa il nome, la versione, la descrizione e la source del plugin, poi queste sezioni: * **`Component inventory`**: le skill, gli agenti, gli hook, i server MCP e i server LSP del plugin * **`Projected token cost`**: i token sempre attivi che il plugin aggiunge a ogni sessione * **`Per-component (rounded)`**: stime sempre attive e on-invoke per ogni skill, agente e comando. Omesso quando il plugin non ne ha Per cosa significano le due figure di costo, vedi [Misura il costo e l'utilizzo del plugin](/docs/it/plugins/measure). Per un plugin che non è caricato, Claude Code stampa ``Plugin "formatter" not found. Run `claude plugin list` to see installed plugins, or pass --plugin-dir to load one from disk.`` ed esce con `1`.

plugin configure

Mostra le opzioni [`userConfig`](/docs/it/plugins/manifest-reference#user-configuration) di un plugin installato e quali sono impostate, o salva i valori inviati su stdin. Richiede Claude Code v2.1.285 o successivo. ```bash theme={null} claude plugin configure ``` | Flag | Descrizione | | :- | :- | | `--values-stdin` | Leggi i valori delle opzioni da stdin come un oggetto JSON di stringhe a riga singola e salvali. Le opzioni che ometti mantengono i loro valori salvati | | `--json` | Stampa il risultato come un oggetto JSON su stdout. Senza `--values-stdin`, l'oggetto porta lo `schema` e le `choices` delle opzioni, i loro `inputs` iniziali, e i nomi delle opzioni `configured` e `unconfigured`. Con `--values-stdin`, porta i nomi delle opzioni `saved` e, quando possono essere letti di nuovo, quelli `unconfigured` | Senza flag, il comando elenca ogni opzione con fino a tre etichette: `required` o `optional`, poi `sensitive` per un'opzione che il manifest dichiara sensibile, poi `set` o `not set`. Non stampa valori salvati. Con `--json`, l'output include i valori salvati delle opzioni che non sono sensibili, e mai il testo di una sensibile. Per salvare i valori, scrivili in un file come un oggetto JSON che mappa le chiavi delle opzioni ai valori stringa, poi passa il file su stdin. Sostituisci `formatter@my-marketplace` con l'id del tuo plugin come `claude plugin list` lo mostra. Questo esempio imposta un'opzione denominata `api_url` da un file `values.json` che contiene `{"api_url": "https://example.com"}`: ```bash theme={null} claude plugin configure formatter@my-marketplace --values-stdin < values.json ``` Claude Code convalida ogni valore rispetto al tipo dichiarato dell'opzione e stampa `Configuration saved. Restart Claude Code to apply it.` Se passi una chiave che il manifest non dichiara, o un valore che fallisce la convalida, il comando non salva nulla, stampa `Failed to save configuration:` con il motivo, ed esce con `1`. Con `--json`, un valore rifiutato stampa anche un oggetto su stdout il cui campo `refused` porta il `message` e, quando un'opzione è responsabile, la sua chiave `option`. Passa l'id completo `name@marketplace` del plugin, come `claude plugin list` lo mostra. `configure` non accetta un `name` semplice. Quando nessun plugin caricato ha quell'id, il comando stampa `No installed plugin has the id "".` ed esce con `1`. Per le impostazioni di un server MCP in bundle, vedi [`plugin install --config`](#plugin-install) o l'elemento **Configure** in `/plugin`.

plugin prune

Rimuovi le [dipendenze](/docs/it/plugins/dependencies) auto-installate che nessun plugin installato necessita più. Il comando non rimuove mai un plugin che hai installato tu stesso. `autoremove` è un alias per `prune`. ```bash theme={null} claude plugin prune [options] ``` | Flag | Descrizione | | :- | :- | | `-s, --scope ` | Prune all'ambito: `user`, `project` o `local`. Predefinito a `user` | | `--dry-run` | Elenca cosa verrebbe rimosso senza rimuoverlo | | `-y, --yes` | Salta il prompt di conferma. Richiesto quando stdin o stdout non è un TTY | Anteprima cosa un prune rimuoverebbe: ```bash theme={null} claude plugin prune --dry-run ``` Claude Code elenca le dipendenze orfane e termina con `(dry run — nothing removed)`. Con nulla da rimuovere, stampa una riga che inizia con `Nothing to prune`. Senza `--dry-run`, il comando rimuove le dipendenze orfane solo dopo che confermi al prompt o passi `-y`. Il codice di uscita è `0` qualunque sia la tua risposta al prompt. Cosa fa `prune` dipende dal fatto che un terminale sia collegato e se passi `-y`: | Terminale e flag | Cosa succede | | :- | :- | | Terminale interattivo, no `-y` | Elenca le dipendenze orfane e chiede `Remove? [y/N]` | | Qualsiasi terminale, `-y` | Le rimuove e stampa `Removed N auto-installed plugins: ` | | stdin o stdout non-TTY, no `-y` | Stampa l'elenco e ``Not a TTY — run `claude plugin prune -y` to remove.``, non rimuovendo nulla |

plugin eval

Esegui i [casi eval](/docs/it/plugin-evals) di un plugin e riporta 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 [Testa i plugin con evals](/docs/it/plugin-evals) per il formato del caso, i grader, i risultati e l'utilizzo in CI. ```bash theme={null} claude plugin eval [target] [options] ``` Il `target` opzionale predefinito è la directory corrente e accetta uno di questi moduli: * Una directory plugin * Un singolo file `prompt.md` o `case.yaml` * Un plugin installato come `name` o `name@marketplace` * `name@skills-dir` Metti il target prima di `--tag`, `--allow-tools` e `--json`. Ognuna di queste opzioni prende le parole che la seguono come suo valore, quindi un target scritto dopo una di esse viene letto come un tag, un nome di strumento o il percorso di output JSON invece che come target. Questa tabella elenca le opzioni che la maggior parte delle esecuzioni usa. Esegui `claude plugin eval --help` per l'insieme completo, inclusi `--case`, `--tag`, `--output-dir`, `--report`, `--allow-real-servers`, `--keep-temp` e `--verbose`. | Opzione | Descrizione | Predefinito | | :- | :- | :- | | `--runs ` | Esecuzioni per caso in ogni [arm](/docs/it/plugin-evals#compare-against-a-no-plugin-baseline) | Il `runs` di ogni caso, altrimenti 3 | | `-j, --concurrency ` | Sessioni di agente da eseguire contemporaneamente, da 1 a 8. Condividono il tuo rate limit | `1` | | `--model ` | Modello per l'agente in test | Il `model` di ogni caso, altrimenti `ANTHROPIC_MODEL` se impostato, altrimenti il predefinito di Claude Code | | `--judge-model ` | Modello per i grader `llm` e `baseline` | Il modello per le [attività in background](/docs/it/plugin-evals#grade-the-result) | | `--ablation ` | `none` o `with-without`. Vedi [Valuta rispetto alla baseline senza plugin](/docs/it/plugin-evals#compare-against-a-no-plugin-baseline) | Deciso per caso, come quella sezione descrive | | `--threshold <0..1>` | Esci con 1 se un caso qualsiasi punteggia sotto questo | `1.0` | | `--max-cost-usd ` | Ferma prima della prossima esecuzione una volta che la spesa raggiunge questo, esci con 2 e riporta risultati parziali | Nessun limite | | `--allow-tools ` | Concedi strumenti oltre al set di sola lettura, come `Bash`, `Write`, `Edit` o `"mcp__plugin____*"`. Vedi [Concedi strumenti](/docs/it/plugin-evals#grant-tools) | | | `--scaffold` | Esegui lo [`scaffold_script`](/docs/it/plugin-evals#add-setup-or-history-with-case-yaml) di ogni caso | Off | | `--trust-plugin` | Salta il prompt di fiducia della prima esecuzione, per CI. Vedi [Cosa può accedere un'esecuzione](/docs/it/plugin-evals#security) | Off | | `--mocks ` | `record` o `off`. Vedi [Mock dei server MCP](/docs/it/plugin-evals#mock-mcp-servers) | `record` | | `--eval-dir ` | Directory sotto il plugin che contiene i casi | L'`experimental.evals` del manifest, altrimenti `evals` | | `--json [path]` | Stampa il [documento risultato](/docs/it/plugin-evals#json-result) su stdout, o scrivilo in un percorso `.json` | | | `--no-publish` | Mantieni il rapporto HTML locale | | Il codice di uscita riporta come è terminata l'esecuzione. Per agire su di esso in una pipeline, vedi [Esegui evals in CI](/docs/it/plugin-evals#run-evals-in-ci). | Codice di uscita | Significato | | :- | :- | | `0` | La suite è stata superata: ogni caso soddisfa la soglia e nient'altro ha fatto fallire l'esecuzione | | `1` | Un caso fallito, un errore di caricamento, una directory plugin non attendibile, un'esecuzione che [è terminata con un errore API](/docs/it/plugin-evals#runs-ended-on-an-api-error), o un'altra causa elencata in [Esegui evals in CI](/docs/it/plugin-evals#run-evals-in-ci) | | `2` | Un'esecuzione parziale | | `130` | Interrotto | | `143` | Terminato |

plugin eval init

Crea una suite eval per il plugin nella directory corrente. Richiede Claude Code v2.1.269 o successivo. Vedi [Crea la tua prima suite eval](/docs/it/plugin-evals#create-your-first-eval-suite). ```bash theme={null} claude plugin eval init [name] [options] ``` Esegui il comando dalla cartella root del plugin, la directory che contiene `.claude-plugin/plugin.json` o il `SKILL.md` della skill. Per creare lo scaffolding della suite in un'altra directory di proposito, passa `--eval-dir`. In un terminale, il comando apre una sessione Claude Code interattiva per un'intervista di authoring. Nell'intervista, Claude fa quanto segue: 1. Legge il plugin 2. Ti chiede cosa dovrebbe fare bene 3. Propone casi e grader 4. Scrive i file dei casi 5. Esegue i casi e rivede i voti con te per verificare che i grader puntino come faresti tu Con `--bare`, o senza un terminale, il comando scrive un template di caso singolo vuoto. Quando Claude esegue il comando dall'interno di una sessione Claude Code, il comando stampa le istruzioni dell'intervista per quella sessione da seguire piuttosto che scrivere un template. Il `name` opzionale è un nome di caso. È richiesto con `--bare` o senza un terminale, perché il comando scrive il template vuoto per quel caso. Un nome di caso inizia con una lettera o una cifra e contiene solo lettere, cifre, `.`, `_` e `-`. Su ogni piattaforma, il comando rifiuta anche nomi che Windows non può memorizzare, come `con` o un nome che termina con `.`. Il comando accetta queste opzioni: | Opzione | Descrizione | Predefinito | | :- | :- | :- | | `--bare` | Scrivi un `prompt.md` e `graders/criteria.md` vuoti per `` invece di eseguire l'intervista | | | `-i, --interactive` | Richiedi l'intervista. Fallisce senza un terminale invece di scrivere un template | | | `--eval-dir ` | Directory sotto la directory corrente in cui scrivere i casi | L'`experimental.evals` del manifest, altrimenti `evals` |

plugin tag

Crea un tag git annotato denominato `--v` per un rilascio di plugin. Prima di taggare, il comando controlla che il `plugin.json` del plugin e qualsiasi entry del marketplace che lo elenca siano d'accordo sulla versione. Per quando taggare un rilascio, vedi [Pubblica un plugin](/docs/it/plugins/publish). ```bash theme={null} claude plugin tag [path] [options] ``` Il `[path]` è la directory del plugin, predefinito alla directory corrente. Il comando trova l'entry del marketplace camminando su da quella directory a un `.claude-plugin/marketplace.json` che elenca il plugin. | Flag | Descrizione | | :- | :- | | `--push` | Spingi il tag a `--remote` dopo averlo creato | | `--dry-run` | Stampa cosa verrebbe taggato senza creare il tag | | `-f, --force` | Salta i controlli dell'albero di lavoro sporco e del tag già esistente | | `-m, --message ` | Messaggio di annotazione del tag. `%s` sta per la versione. Predefinito a ` ` | | `--remote ` | Remote a cui spingere con `--push`. Predefinito a `origin` | Anteprima il tag per un plugin in un checkout marketplace: ```bash theme={null} claude plugin tag plugins/formatter --dry-run ``` Claude Code stampa il piano: * Il nome del plugin * La versione e da quale file proviene * L'entry del marketplace corrispondente, quando ce n'è uno * Il nome del tag * I comandi `git tag` e `git push` che eseguirebbe Senza `--dry-run`, Claude Code stampa `Created tag formatter--v1.0.0` e sia `Pushed to origin` o il comando push da eseguire tu stesso. Se il push fallisce, il tag è ancora creato localmente e il comando esce con un errore. Il comando esce con `1` e stampa il motivo quando non può taggare in sicurezza. I motivi comuni sono: * Nessun `version` in `plugin.json` o nell'entry del marketplace * Il tag esiste già * L'albero di lavoro è sporco

plugin test

Esegui i test per un [mod](/docs/it/plugins/mods/overview), un plugin il cui codice registra gestori di eventi. Il comando non richiede alcuna sessione, accesso o rete. Per come scrivere un test, vedi [Testa un mod](/docs/it/plugins/mods/test). ```bash theme={null} claude plugin test [directory] ``` La `[directory]` è la directory del mod, predefinita alla directory corrente. Il comando esegue ogni file al suo interno il cui nome termina con `.test.ts` o `.test.tsx`, ed esce con stato 1 quando un test fallisce. Esegui i test per un mod in `./first-mod`: ```bash theme={null} claude plugin test ./first-mod ```

plugin validate

Convalida un manifest plugin, un manifest marketplace, o le skill, gli agenti e i comandi in una directory, ed esci con un codice su cui un lavoro CI può agire. Per il workflow di creazione, test e modifica, vedi [Crea un plugin](/docs/it/plugins/create). Per cosa il validatore controlla in ogni manifest, vedi il [riferimento manifest plugin](/docs/it/plugins/manifest-reference) e il [riferimento marketplace](/docs/it/plugins/marketplace-reference). ```bash theme={null} claude plugin validate [options] ``` | Flag | Descrizione | | :- | :- | | `--strict` | Tratta gli avvertimenti come errori, quindi i campi non riconosciuti e i metadati mancanti che il runtime tollera falliscono l'esecuzione | | `--json` | Stampa il rapporto di convalida come un oggetto JSON con gli stessi codici di uscita. Richiede Claude Code v2.1.259 o successivo | Convalida un plugin prima di eseguirne il commit: ```bash theme={null} claude plugin validate ./my-plugin --strict ```

Convalida una directory

Il `` è un file manifest o una directory. Data una directory, Claude Code sceglie cosa convalidare da quello che trova lì: * `.claude-plugin/marketplace.json`, quando esiste * Altrimenti `.claude-plugin/plugin.json` * Altrimenti i file dei componenti, scelti dal nome della directory. La convalida dei file dei componenti senza un manifest richiede Claude Code v2.1.233 o successivo: * Una directory denominata `skills`, `agents` o `commands`: i file al suo interno * Una directory denominata `.claude`: le directory `skills`, `agents` e `commands` al suo interno * Qualsiasi altra directory: quelle tre directory sotto il suo `.claude` Quando la directory contiene sia un `.claude-plugin/marketplace.json` sia un `.claude-plugin/plugin.json`, Claude Code convalida il marketplace e anche il manifest e i file dei componenti del plugin. Questo richiede Claude Code v2.1.289 o successivo. Claude Code non segue i collegamenti simbolici all'interno della directory che nomini. Cosa fa dipende da dove si trova il collegamento: * **Una directory `skills`, `agents` o `commands` collegata sotto la root del plugin o `.claude`**: Claude Code avverte che nulla in essa è stato letto. * **Un'entry collegata all'interno di una directory `skills`, `agents` o `commands`**: Claude Code la salta e avverte, per directory, quante entry ha saltato che una sessione caricherebbe. * **La directory `skills`, `agents` o `commands` che nomini è essa stessa un collegamento simbolico, o lo è la sua directory padre `.claude`**: Claude Code riporta un errore e non controlla nulla in essa. Nomina la directory reale invece. Alcuni file non vengono letti da un'esecuzione di convalida: * **Un `SKILL.md` alla root del plugin**: quando esegui `claude plugin validate` su una directory plugin, Claude Code non controlla un `SKILL.md` alla root del plugin * **Un `CLAUDE.md` alla root del plugin**: in un'esecuzione plugin, Claude Code avverte anche di un `CLAUDE.md` alla root del plugin * **File plugin in un'esecuzione marketplace**: da una directory marketplace, Claude Code non apre i file skill, agente, comando o hook dei plugin che il marketplace elenca in altre directory, né i file dei server MCP che includono. Per trovare errori in quei file, convalida ogni directory plugin

Output e codici di uscita

Claude Code stampa il file che ha convalidato, eventuali errori e avvertimenti con i loro percorsi, e una riga di verdetto. Il codice di uscita segue il verdetto: | Codice di uscita | Riga di verdetto | Significato | | :- | :- | :- | | `0` | `Validation passed` o `Validation passed with warnings` | Il manifest si carica. Con `--strict`, nemmeno avvertimenti | | `1` | `Validation failed` o `Validation failed (--strict treats warnings as errors)` | Un errore, o un avvertimento sotto `--strict` | | `2` | `Unexpected error during validation: ` | Il validatore stesso ha fallito, come su un percorso illeggibile | Con `--json`, Claude Code scrive il rapporto su stdout come un oggetto JSON con questi campi di livello superiore: * `success`: lo stesso verdetto che il codice di uscita fornisce * `strict`: se l'esecuzione ha trattato gli avvertimenti come errori * `target`: il percorso risolto che Claude Code ha convalidato * `manifest`: il risultato del manifest stesso, o `null` per un'esecuzione senza manifest * `contents`: risultati per file, ognuno nominando il suo `file` e portando array `errors`, `warnings` e `notes` * `gatingHooks`: se ogni hook del [mod](/docs/it/plugins/mods/overview) che può rifiutare un'azione, come un hook `tool.call`, ha un [gestore `.catch`](/docs/it/plugins/mods/events#handle-a-hook-that-fails). Ogni elemento fornisce `module`, `pattern`, `hook` e `hasCatch`. Richiede Claude Code v2.1.290 o successivo All'uscita `2`, il comando non scrive nulla su stdout. Il messaggio di errore va su stderr.

Comandi claude plugin marketplace

Esegui `claude plugin marketplace ` dalla tua shell per aggiungere, elencare, aggiornare e rimuovere i marketplace da cui installi i plugin. * **Codici di uscita**: questi sottocomandi seguono la [convenzione del codice di uscita](#claude-plugin-commands) dei comandi plugin * **Ambiti**: il loro flag `--scope` non ha una forma breve `-s` Per cosa è un marketplace e come Claude Code lo memorizza nella cache, vedi [Riferimento caricamento plugin](/docs/it/plugins/loading).

plugin marketplace add

Aggiungi un marketplace da un repository GitHub, un URL git, un `marketplace.json` ospitato o un percorso locale, e dichiaralo in un file di impostazioni. Dopo averlo aggiunto, Claude Code installa qualsiasi [dipendenza](/docs/it/plugins/dependencies) che mancava ai tuoi plugin installati. ```bash theme={null} claude plugin marketplace add [options] ``` | Flag | Descrizione | | :- | :- | | `--scope ` | File di impostazioni in cui dichiarare il marketplace: `user`, `project` o `local`. Predefinito a `user` | | `--sparse ` | Limita il checkout git a queste directory, per monorepo. Solo fonti `github` e `git` | | `--claudeai` | Leggi l'argomento come il nome di un [marketplace ospitato su claude.ai](/docs/it/plugins/install#add-from-claude-ai) invece di una fonte. Richiede Claude Code v2.1.273 o successivo | | `--json` | Stampa se il comando è riuscito, e il relativo messaggio, come un unico oggetto JSON sull'ultima riga di stdout, nel [formato di risultato JSON](#plugin-json-result). Non ha effetto con `--claudeai`. Richiede Claude Code v2.1.287 o successivo | `` accetta uno qualsiasi dei moduli nella tabella sottostante, e il suo modulo decide il tipo di fonte e come Claude Code recupera il marketplace. Per l'oggetto source risultante, vedi il [riferimento marketplace](/docs/it/plugins/marketplace-reference). | Digiti | Tipo di fonte | Come Claude Code lo recupera | | :- | :- | :- | | `owner/repo`, `owner/repo#ref` o `owner/repo@ref` | `github` | Clona il repository GitHub, fissato a `ref` quando fornito. Owner e repo devono seguire le regole di denominazione GitHub | | `user@host:path[.git][#ref]` | `git` | Clona su SSH | | Un URL `http://` o `https://` che termina in `.git[#ref]` o contiene `/_git/`, come `https://example.com/repo.git` | `git` | Clona l'URL, inclusi gli URL di Azure DevOps | | `https://github.com/owner/repo` o `https://gitlab.com/namespace/project`, o lo stesso su `http://` | `git` | Clona l'URL dopo aver aggiunto `.git` | | Qualsiasi altro URL `http://` o `https://`, incluso un host git auto-ospitato senza `.git` | `url` | Recupera l'URL come `marketplace.json`. Per clonare un repository lì, aggiungi `.git` | | `./path`, `../path`, `/path` o `~/path` a una directory | `directory` | Legge la directory in posizione. Su Windows, anche i moduli `.\`, `..\` e `C:\` funzionano | | Gli stessi moduli di percorso, a un file `.json` | `file` | Legge il file in posizione | Per un host i cui URL di clone non portano il suffisso `.git`, come AWS CodeCommit, aggiungi il marketplace come entry git in [`extraKnownMarketplaces`](/docs/it/settings-reference#extraknownmarketplaces). Claude Code clona un'entry git indipendentemente dal fatto che il suo URL termini in `.git`. Claude Code clona anche un URL `gitlab.com` con sottogruppi annidati, come `https://gitlab.com/group/subgroup/project`. Aggiungi un marketplace e condividilo con il progetto: ```bash theme={null} claude plugin marketplace add your-org/your-marketplace --scope project ``` Claude Code stampa `Successfully added marketplace: your-marketplace (declared in project settings)`, usando il `name` dal manifest del marketplace stesso. Un'aggiunta ripetuta o una fonte non valida stampa uno di questi risultati: * **Marketplace già su disco**: l'output è `Marketplace 'your-marketplace' already on disk — declared in project settings` e il codice di uscita è `0` * **Fonte non riconosciuta**: l'output è `Invalid marketplace source format. Try: owner/repo, https://..., or ./path` e il codice di uscita è `1` * **Host semplice come `gitlab.example.com/team/plugins`**: l'aggiunta fallisce come una scorciatoia `owner/repo` non valida, e il messaggio ti dice di aggiungere `https://` o usare un percorso locale Aggiungi un [marketplace ospitato su claude.ai](/docs/it/plugins/install#add-from-claude-ai) per il nome stampato nella sezione `From claude.ai:` di `claude plugin marketplace list`: ```bash theme={null} claude plugin marketplace add --claudeai claudeai-organization-library ``` Con `--claudeai`, il comando rifiuta `--scope` e `--sparse`. Il marketplace è ospitato per il tuo account, non dichiarato in un file di impostazioni, quindi non puoi condividerlo attraverso il `.claude/settings.json` di un progetto.

plugin marketplace list

Elenca ogni marketplace che hai aggiunto, con la sua fonte. ```bash theme={null} claude plugin marketplace list [options] ``` | Flag | Descrizione | | :- | :- | | `--json` | Stampa l'elenco come JSON | Claude Code stampa `Configured marketplaces:` e una riga `Source:` per marketplace, o `No marketplaces configured`. Con `--json`, Claude Code stampa un array con un oggetto per marketplace, portando i campi sottostanti. Ogni campo è una stringa. | Campo | Descrizione | | :- | :- | | `name` | Il nome del marketplace | | `source` | `github`, `git`, `url`, `directory`, `file` o `claudeai` | | `repo` | `owner/repo`. Solo fonti `github` | | `url` | L'URL di clone o recupero. Solo fonti `git` e `url` | | `path` | Il percorso locale. Solo fonti `directory` e `file` | | `ref` | Il branch o tag fissato. Fonti `github` e `git`, solo quando fissato | | `installLocation` | Dove Claude Code ha memorizzato nella cache il marketplace | Un marketplace [claude.ai](/docs/it/plugins/install#add-from-claude-ai) aggiunto non ha un clone locale, quindi la sua entry porta i suoi identificatori claude.ai, `marketplaceId` e `organizationUuid`, al posto di `installLocation`. Porta anche `scope` quando uno è registrato, e `status`. Se le tue sessioni di terminale [sincronizzano i plugin dal tuo account claude.ai](/docs/it/plugins/loading#synced-plugins), l'elenco di testo termina con una sezione `From claude.ai:`. Quella sezione nomina i marketplace che claude.ai elenca per il tuo account che non hai aggiunto, sia basati su git che ospitati. Richiede Claude Code v2.1.273 o successivo. Per aggiungere un marketplace da quella sezione, vedi [Aggiungi un marketplace da claude.ai](/docs/it/plugins/install#add-from-claude-ai). L'output `--json` copre solo i marketplace configurati e lascia la sezione fuori.

plugin marketplace remove

Rimuovi la dichiarazione di un marketplace dalle tue impostazioni. `rm` è un alias per `remove`. Quando rimuovi un marketplace dall'ultimo ambito che lo dichiara, Claude Code elimina anche la sua cache e disinstalla ogni plugin che hai installato da esso. Elimina anche le loro [opzioni e segreti](/docs/it/plugins/manifest-reference#user-configuration) salvati e i [dati](/docs/it/plugins/components#path-variables-and-persistent-data) dove può. Per aggiornare un marketplace senza perdere i suoi plugin, esegui `plugin marketplace update` invece. ```bash theme={null} claude plugin marketplace remove [options] ``` Il `` è il nome del marketplace che `plugin marketplace list` mostra, non la fonte che hai passato a `add`. | Flag | Descrizione | | :- | :- | | `--scope ` | Rimuovi la dichiarazione da un ambito di impostazioni: `user`, `project` o `local`. Senza di esso, Claude Code rimuove la dichiarazione da ogni ambito | | `--json` | Stampa se il comando è riuscito, e il relativo messaggio, come un unico oggetto JSON sull'ultima riga di stdout, nel [formato di risultato JSON](#plugin-json-result). Richiede Claude Code v2.1.287 o successivo | Rimuovi un marketplace da ogni ambito: ```bash theme={null} claude plugin marketplace remove your-marketplace ``` Claude Code stampa `Successfully removed marketplace: your-marketplace`. Quando il comando disinstalla i plugin, l'output li elenca sotto una riga come `Also uninstalled 2 plugins from this marketplace:`. Per usarne uno di nuovo, aggiungi il marketplace di nuovo e reinstalla il plugin. Se limiti il comando a un file di impostazioni che non dichiara il marketplace, il comando fallisce con `Marketplace 'your-marketplace' is not declared in project settings. Omit --scope to remove it from all scopes.`

plugin marketplace update

Aggiorna un marketplace, o ogni marketplace, dalla sua fonte per recuperare nuovi plugin e versioni. Un marketplace aggiunto con un branch o tag `ref` si aggiorna al commit più recente di quel ref, non al branch predefinito del repository. ```bash theme={null} claude plugin marketplace update [name] [options] ``` | Flag | Descrizione | | :- | :- | | `--json` | Stampa se il comando è riuscito, e il relativo messaggio, come un unico oggetto JSON sull'ultima riga di stdout, nel [formato di risultato JSON](#plugin-json-result). Senza un nome, il comando rifiuta `--json` ed esce con `1`. Richiede Claude Code v2.1.287 o successivo | Aggiorna un marketplace: ```bash theme={null} claude plugin marketplace update your-marketplace ``` Claude Code stampa `Successfully updated marketplace: your-marketplace`. Quando ometti il nome, stampa un conteggio come `Successfully updated 2 marketplaces`.

/plugin in una sessione

All'interno di una sessione interattiva, `/plugin` apre il pannello plugin. Ogni sottocomando apre il pannello su una scheda, esegue un'azione lì, o stampa un risultato inline. `/plugins` e `/marketplace` sono alias per `/plugin`. Puoi eseguire questi comandi solo in una sessione di terminale interattiva. In un'esecuzione non interattiva come `claude -p`, Claude Code risponde che `/plugin` non è disponibile in questo ambiente. Per quali superfici hanno `/plugin`, come installare senza di esso, e cosa mostra ogni scheda del pannello, vedi [Installa e gestisci i plugin](/docs/it/plugins/install). Un `` è un plugin `name` o `name@marketplace`. La tabella sottostante elenca ogni forma di sessione. I sottocomandi shell `init`, `update`, `details`, `prune`, `eval`, `eval init` e `test` non hanno una forma di sessione. | Comando | Alias | Cosa fa | | :- | :- | :- | | `/plugin` | | Apre il pannello sulla scheda **Discover**. Qualsiasi prima parola non riconosciuta dopo `/plugin` fa lo stesso | | `/plugin help` | `/plugin --help`, `/plugin -h` | Mostra l'elenco di utilizzo dei sottocomandi `/plugin` | | `/plugin list [--enabled\|--disabled]` | `ls` | Stampa i tuoi plugin installati da marketplace inline, con versione, ambito e stato. Un flag di filtro mostra solo quello stato. Un plugin il cui stato di abilitazione non è stato ancora applicato è contrassegnato `— run /reload-plugins to apply` | | `/plugin install` | `i` | Apre la scheda **Discover** | | `/plugin install ` | `i` | Apre i dettagli del plugin nella scheda **Discover**. Con `name@marketplace`, li apre nell'elenco di quel marketplace | | `/plugin install ` | `i` | Segnala un errore [marketplace non trovato](/docs/it/plugins/troubleshooting#marketplace-not-found) e non installa nulla quando il target è un percorso, URL, o `owner/repo`, anche una fonte che hai già aggiunto. Per installare da una fonte, vedi [Aggiungi un marketplace e installa in un comando](/docs/it/plugins/install#add-a-marketplace-and-install-in-one-command) | | `/plugin install --marketplace ` | `i` | Aggiunge il marketplace a `` quando non l'hai ancora aggiunto, chiedendoti di confermare prima, poi apre i dettagli del plugin. Vedi [Aggiungi un marketplace e installa in un comando](/docs/it/plugins/install#add-a-marketplace-and-install-in-one-command). Richiede Claude Code v2.1.275 o successivo | | `/plugin manage` | | Apre la scheda **Installed** | | `/plugin stats` | | Apre la scheda **Stats**, in sessioni dove [`/skill-doctor`](/docs/it/skills#find-unused-skills) è disponibile. Altrove apre il pannello sulla scheda **Discover** | | `/plugin enable ` | | Apre la scheda **Installed** al plugin e lo abilita | | `/plugin disable ` | | Apre la scheda **Installed** al plugin e lo disabilita | | `/plugin uninstall ` | | Apre la scheda **Installed** al plugin e lo disinstalla | | `/plugin configure ` | `config` | Apre la finestra di dialogo [`userConfig`](/docs/it/plugins/manifest-reference) del plugin, o riporta che il plugin non ne dichiara nessuno | | `/plugin validate ` | | Stampa lo stesso rapporto di `claude plugin validate`, inline | | `/plugin tag [path] [--push] [--dry-run] [--force]` | | Crea il tag di rilascio come `claude plugin tag` fa. Accetta `--push`, `--dry-run` e `--force` o `-f`; con qualsiasi altro flag o un argomento extra, Claude Code stampa l'utilizzo | | `/plugin marketplace` | `market` | Non fa nulla di visibile. Passa `add`, `list`, `update` o `remove` | | `/plugin marketplace add [source]` | `market add` | Con una fonte, la aggiunge e riporta il risultato. Senza una, apre l'input **Add marketplace** | | `/plugin marketplace list` | `market list` | Stampa i nomi dei tuoi marketplace inline | | `/plugin marketplace update [name]` | `market update` | Apre la scheda **Marketplaces**. Con un nome, aggiorna quel marketplace lì | | `/plugin marketplace remove [name]` | `market remove`, `market rm`, `marketplace rm` | Apre la scheda **Marketplaces**. Con un nome, rimuove quel marketplace lì | Se nomini un plugin che non è installato nel progetto corrente in `/plugin enable`, `disable`, `uninstall` o `configure`, Claude Code stampa `Plugin "" is not installed in this project` invece di agire.

/reload-plugins

Applica le modifiche ai plugin in sospeso alla sessione in esecuzione senza riavviarla. Le modifiche in sospeso sono plugin che hai installato, aggiornato, abilitato, disabilitato o modificato su disco da quando la sessione è iniziata. Quando chiudi il pannello `/plugin` con modifiche in sospeso che hai fatto in esso, Claude Code esegue `/reload-plugins` per te. Eseguilo tu stesso dopo le modifiche ai plugin che accadono al di fuori del pannello, come un comando `claude plugin` che hai eseguito in un altro terminale. ```text theme={null} /reload-plugins [--force] ``` | Flag | Descrizione | | :- | :- | | `--force` | Applica il ricaricamento anche quando invaliderebbe la cache del prompt. `force` senza trattini funziona anche |

Riepilogo ricaricamento

Claude Code ricarica ogni plugin attivo e stampa una riga di riepilogo, `Reloaded: N plugins · N skills · N agents · N hooks · N plugin MCP servers · N plugin LSP servers`, omettendo il conteggio del server MCP del plugin in una sessione senza un terminale interattivo. Quando un plugin qualsiasi ha fallito, il riepilogo aggiunge `N errors during load. Run /plugin for details.` Il conteggio delle skills copre ogni skill che un plugin fornisce, sia le sue entry `commands/` che le skills `SKILL.md`. Il conteggio degli agents è il numero di agent caricati nella sessione, inclusi quelli che non provengono da plugin. Quando le [dipendenze](/docs/it/plugins/dependencies) di un plugin ricaricato sono mancanti, Claude Code le installa, ricarica di nuovo, e aggiunge `(+ N dependencies: ) resolved` al riepilogo.

Ricaricamenti che cambiano gli strumenti MCP

Quando il ricaricamento aggiungerebbe o rimuoverebbe un server MCP del plugin o lo strumento `LSP`, e quel cambiamento invaliderebbe la [cache del prompt](/docs/it/prompt-caching#enabling-or-disabling-a-plugin), Claude Code non applica il ricaricamento. Stampa una riga come `This reload changes MCP tools () — your next message will re-read the whole conversation instead of using the cache. Run /reload-plugins --force to apply.` Passa `--force` per applicarlo comunque.

Sessioni senza un terminale interattivo

`/reload-plugins` viene eseguito anche in sessioni senza un terminale interattivo, come l'app desktop, l'Agent SDK e la [modalità non interattiva](/docs/it/headless) con `-p`. Richiede Claude Code v2.1.260 o successivo. In quelle sessioni, il comando viene eseguito solo quando lo digiti nella sessione tu stesso, come nel prompt `-p` o nella casella del prompt dell'app desktop. Quando arriva in un altro modo, come attraverso [Remote Control](/docs/it/remote-control) o un messaggio inoltrato da Slack, il comando risponde `/reload-plugins isn't available over a remote connection in this session.` e non ricarica nulla. Il ricaricamento in quelle sessioni non connette o disconnette i server MCP del plugin. Quei cambiamenti hanno effetto nella tua prossima sessione.

Flag che caricano un plugin per una sola sessione

Due flag `claude` caricano un plugin per una sola sessione, senza installarlo. Entrambi sono ripetibili. Gli autori di plugin li usano per testare un plugin prima di pubblicarlo. Per il flusso di lavoro carica-modifica-ricarica, vedi [Sviluppa senza un marketplace](/docs/it/plugins/create#develop-without-a-marketplace). | Flag | Descrizione | Esempio | | :- | :- | :- | | `--plugin-dir ` | Carica un plugin da una directory o un archivio `.zip` di uno. Una cartella di plugin carica ogni cartella figlio che contiene un `.claude-plugin/plugin.json`. Ogni flag accetta un percorso | `claude --plugin-dir ./my-plugin --plugin-dir ./other.zip` | | `--plugin-url ` | Recupera un archivio `.zip` plugin da un URL. Ripeti il flag, o passa più URL separati da spazi in un valore tra virgolette | `claude --plugin-url "https://example.com/a.zip https://example.com/b.zip"` | Un plugin che uno di questi flag carica è un plugin solo sessione. [`claude plugin list`](#plugin-list) lo mostra solo quando lo stesso flag precede il sottocomando, come in `claude --plugin-dir ./my-plugin plugin list`. Il plugin appare come `@inline` sotto un'intestazione che inizia con `Session-only plugins`, e `--json` riporta il suo `scope` come `session`. Quando un plugin solo sessione condivide un nome con un plugin installato, Claude Code carica la copia solo sessione per quella sessione e salta quella installata. La copia installata si carica invece se hai disabilitato la copia solo sessione con `claude plugin disable @inline`, o se le impostazioni gestite bloccano quel nome di plugin. Per la precedenza, vedi [Riferimento caricamento plugin](/docs/it/plugins/loading). Un amministratore può rifiutare entrambi i flag, e le cartelle nominate nella variabile [`CLAUDE_CODE_PLUGIN_DIRS`](/docs/it/env-vars#variables), con l'impostazione gestita [`disableSideloadFlags`](/docs/it/settings-reference#disablesideloadflags). Claude Code stampa che il flag è disabilitato dalle impostazioni gestite della tua organizzazione ed esce con `1` senza avviare. Dall'Agent SDK, l'opzione [`plugins`](/docs/it/agent-sdk/plugins) è l'equivalente di `--plugin-dir`.

Passaggi successivi

* [Installa e gestisci i plugin](/docs/it/plugins/install): le stesse operazioni dei passaggi, con quello che vedi in ognuno * [Riferimento caricamento plugin](/docs/it/plugins/loading): cosa ogni comando cambia su disco e quale ambito ha effetto * [Risolvi i problemi dei plugin](/docs/it/plugins/troubleshooting): messaggi di errore di installazione, marketplace, caricamento e convalida con le loro correzioni * [Riferimento manifest plugin](/docs/it/plugins/manifest-reference): i campi che `claude plugin validate` controlla