Vai al contenuto principale

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.

Un plugin marketplace è un catalogo che ti consente di distribuire plugin ad altri. I marketplace forniscono scoperta centralizzata, tracciamento delle versioni, aggiornamenti automatici e supporto per più tipi di fonte (repository git, percorsi locali e altro). Questa guida ti mostra come creare il tuo marketplace per condividere plugin con il tuo team o comunità. Stai cercando di installare plugin da un marketplace esistente? Vedi Scopri e installa plugin precostruiti.

Panoramica

La creazione e la distribuzione di un marketplace comporta:
  1. Creazione di plugin: crea uno o più plugin con skills, agenti, hooks, server MCP o server LSP. Questa guida presuppone che tu abbia già plugin da distribuire; vedi Crea plugin per i dettagli su come crearli.
  2. Creazione di un file marketplace: definisci un marketplace.json che elenca i tuoi plugin e dove trovarli (vedi Crea il file marketplace).
  3. Ospita il marketplace: esegui il push su GitHub, GitLab o un altro host git (vedi Ospita e distribuisci marketplace).
  4. Condividi con gli utenti: gli utenti aggiungono il tuo marketplace con /plugin marketplace add e installano singoli plugin (vedi Scopri e installa plugin).
Una volta che il tuo marketplace è attivo, puoi aggiornarlo eseguendo il push delle modifiche al tuo repository. Gli utenti aggiornano la loro copia locale con /plugin marketplace update.

Procedura dettagliata: creare un marketplace locale

Questo esempio crea un marketplace con un plugin: una skill quality-review per le revisioni del codice. Creerai la struttura delle directory, aggiungerai una skill, creerai il manifest del plugin e il catalogo del marketplace, quindi lo installerai e lo testerai.
1

Crea la struttura delle directory

mkdir -p my-marketplace/.claude-plugin
mkdir -p my-marketplace/plugins/quality-review-plugin/.claude-plugin
mkdir -p my-marketplace/plugins/quality-review-plugin/skills/quality-review
2

Crea la skill

Crea un file SKILL.md che definisce cosa fa la skill quality-review.
my-marketplace/plugins/quality-review-plugin/skills/quality-review/SKILL.md
---
description: Rivedi il codice per bug, sicurezza e prestazioni
disable-model-invocation: true
---

Rivedi il codice che ho selezionato o i cambiamenti recenti per:
- Potenziali bug o casi limite
- Problemi di sicurezza
- Problemi di prestazioni
- Miglioramenti di leggibilità

Sii conciso e pratico.
3

Crea il manifest del plugin

Crea un file plugin.json che descrive il plugin. Il manifest va nella directory .claude-plugin/.
my-marketplace/plugins/quality-review-plugin/.claude-plugin/plugin.json
{
  "name": "quality-review-plugin",
  "description": "Aggiunge una skill quality-review per revisioni rapide del codice",
  "version": "1.0.0"
}
Impostare version significa che gli utenti ricevono aggiornamenti solo quando modifichi questo campo, quindi incrementalo ad ogni rilascio. Se ometti version e ospiti questo marketplace in git, ogni commit conta automaticamente come una nuova versione. Vedi Risoluzione della versione per scegliere l’approccio giusto.
4

Crea il file marketplace

Crea il catalogo marketplace che elenca il tuo plugin.
my-marketplace/.claude-plugin/marketplace.json
{
  "name": "my-plugins",
  "owner": {
    "name": "Your Name"
  },
  "plugins": [
    {
      "name": "quality-review-plugin",
      "source": "./plugins/quality-review-plugin",
      "description": "Aggiunge una skill quality-review per revisioni rapide del codice"
    }
  ]
}
5

Aggiungi e installa

Aggiungi il marketplace e installa il plugin.
/plugin marketplace add ./my-marketplace
/plugin install quality-review-plugin@my-plugins
6

Provalo

Seleziona del codice nel tuo editor ed esegui la tua nuova skill. Le skill dei plugin sono associate allo spazio dei nomi del nome del plugin.
/quality-review-plugin:quality-review
Per saperne di più su cosa possono fare i plugin, inclusi hooks, agenti, server MCP e server LSP, vedi Plugins.
Come vengono installati i plugin: Quando gli utenti installano un plugin, Claude Code copia la directory del plugin in una posizione cache. Ciò significa che i plugin non possono fare riferimento a file al di fuori della loro directory utilizzando percorsi come ../shared-utils, perché quei file non verranno copiati.Se hai bisogno di condividere file tra plugin, usa symlink. Vedi Plugin caching and file resolution per i dettagli.

Crea il file marketplace

Crea .claude-plugin/marketplace.json nella radice del tuo repository. Questo file definisce il nome del tuo marketplace, le informazioni del proprietario e un elenco di plugin con le loro fonti. Ogni voce di plugin ha bisogno almeno di un name e di una source (da dove recuperarla). Vedi lo schema completo di seguito per tutti i campi disponibili.
{
  "name": "company-tools",
  "owner": {
    "name": "DevTools Team",
    "email": "devtools@example.com"
  },
  "plugins": [
    {
      "name": "code-formatter",
      "source": "./plugins/formatter",
      "description": "Formattazione automatica del codice al salvataggio",
      "version": "2.1.0",
      "author": {
        "name": "DevTools Team"
      }
    },
    {
      "name": "deployment-tools",
      "source": {
        "source": "github",
        "repo": "company/deploy-plugin"
      },
      "description": "Strumenti di automazione della distribuzione"
    }
  ]
}

Schema del marketplace

Campi obbligatori

CampoTipoDescrizioneEsempio
namestringIdentificatore del marketplace (kebab-case, senza spazi). Questo è pubblico: gli utenti lo vedono quando installano plugin (ad esempio, /plugin install my-tool@your-marketplace)."acme-tools"
ownerobjectInformazioni sul manutentore del marketplace (vedi i campi di seguito)
pluginsarrayElenco dei plugin disponibiliVedi di seguito
Nomi riservati: I seguenti nomi di marketplace sono riservati per uso ufficiale di Anthropic e non possono essere utilizzati da marketplace di terze parti: claude-code-marketplace, claude-code-plugins, claude-plugins-official, anthropic-marketplace, anthropic-plugins, agent-skills, anthropic-agent-skills, knowledge-work-plugins, life-sciences. Anche i nomi che impersonano marketplace ufficiali, come official-claude-plugins o anthropic-tools-v2, sono bloccati.

Campi del proprietario

CampoTipoObbligatorioDescrizione
namestringNome del manutentore o del team
emailstringNoEmail di contatto per il manutentore

Campi opzionali

CampoTipoDescrizione
$schemastringURL dello schema JSON per l’autocompletamento dell’editor e la convalida. Claude Code ignora questo campo al momento del caricamento.
descriptionstringBreve descrizione del marketplace
versionstringVersione del manifest del marketplace
metadata.pluginRootstringDirectory di base anteposta ai percorsi di fonte del plugin relativo (ad esempio, "./plugins" ti consente di scrivere "source": "formatter" invece di "source": "./plugins/formatter")
allowCrossMarketplaceDependenciesOnarrayAltri marketplace su cui i plugin in questo marketplace possono dipendere. Le dipendenze da un marketplace non elencato qui sono bloccate all’installazione. Vedi Dipendi da un plugin di un altro marketplace.
description e version sono accettati anche sotto metadata per compatibilità con le versioni precedenti.

Voci di plugin

Ogni voce di plugin nell’array plugins descrive un plugin e dove trovarlo. Puoi includere qualsiasi campo dallo schema del manifest del plugin (come description, version, author, commands, hooks, ecc.), più questi campi specifici del marketplace: source, category, tags e strict.

Campi obbligatori

CampoTipoDescrizione
namestringIdentificatore del plugin (kebab-case, senza spazi). Questo è pubblico: gli utenti lo vedono quando installano (ad esempio, /plugin install my-plugin@marketplace).
sourcestring|objectDa dove recuperare il plugin (vedi Plugin sources di seguito)

Campi di plugin opzionali

Campi di metadati standard:
CampoTipoDescrizione
displayNamestringNome leggibile mostrato nelle superfici dell’interfaccia utente. Ritorna a name quando omesso. Può contenere spazi e qualsiasi maiuscola/minuscola. Non utilizzato per il namespacing o la ricerca. Richiede Claude Code v2.1.143 o successivo.
descriptionstringBreve descrizione del plugin
versionstringVersione del plugin. Se impostato (qui o in plugin.json), il plugin è bloccato a questa stringa e gli utenti ricevono aggiornamenti solo quando cambia. Ometti per tornare allo SHA del commit git. Vedi Version resolution.
authorobjectInformazioni sull’autore del plugin (name obbligatorio, email opzionale)
homepagestringURL della homepage o della documentazione del plugin
repositorystringURL del repository del codice sorgente
licensestringIdentificatore di licenza SPDX (ad esempio, MIT, Apache-2.0)
keywordsarrayTag per la scoperta e la categorizzazione dei plugin
categorystringCategoria del plugin per l’organizzazione
tagsarrayTag per la ricercabilità
strictbooleanControlla se plugin.json è l’autorità per le definizioni dei componenti (predefinito: true). Vedi Strict mode di seguito.
Campi di configurazione dei componenti:
CampoTipoDescrizione
skillsstring|arrayPercorsi personalizzati alle directory delle skill contenenti <name>/SKILL.md
commandsstring|arrayPercorsi personalizzati ai file di skill flat .md o alle directory
agentsstring|arrayPercorsi personalizzati ai file degli agenti
hooksstring|objectConfigurazione degli hook personalizzati o percorso al file degli hook
mcpServersstring|objectConfigurazioni del server MCP o percorso alla configurazione MCP
lspServersstring|objectConfigurazioni del server LSP o percorso alla configurazione LSP

Plugin sources

Le plugin sources indicano a Claude Code dove recuperare ogni singolo plugin elencato nel tuo marketplace. Questi sono impostati nel campo source di ogni voce di plugin in marketplace.json. Una volta che un plugin viene clonato o copiato nella macchina locale, viene copiato nella cache del plugin locale con versione in ~/.claude/plugins/cache.
SourceTipoCampiNote
Percorso relativostring (ad es. "./my-plugin")nessunoDirectory locale all’interno del repository del marketplace. Deve iniziare con ./. Risolto relativamente alla radice del marketplace, non alla directory .claude-plugin/
githubobjectrepo, ref?, sha?
urlobjecturl, ref?, sha?Fonte URL Git
git-subdirobjecturl, path, ref?, sha?Sottodirectory all’interno di un repository git. Clona in modo sparso per ridurre al minimo la larghezza di banda per i monorepo
npmobjectpackage, version?, registry?Installato tramite npm install
Marketplace sources vs plugin sources: Questi sono concetti diversi che controllano cose diverse.
  • Marketplace source — dove recuperare il catalogo marketplace.json stesso. Impostato quando gli utenti eseguono /plugin marketplace add o nelle impostazioni extraKnownMarketplaces. Supporta ref (branch/tag) ma non sha.
  • Plugin source — dove recuperare un singolo plugin elencato nel marketplace. Impostato nel campo source di ogni voce di plugin all’interno di marketplace.json. Supporta sia ref (branch/tag) che sha (commit esatto).
Ad esempio, un marketplace ospitato in acme-corp/plugin-catalog (marketplace source) può elencare un plugin recuperato da acme-corp/code-formatter (plugin source). La marketplace source e la plugin source puntano a repository diversi e sono fissate indipendentemente.

Percorsi relativi

Per i plugin nello stesso repository, usa un percorso che inizia con ./:
{
  "name": "my-plugin",
  "source": "./plugins/my-plugin"
}
I percorsi si risolvono relativamente alla radice del marketplace, che è la directory contenente .claude-plugin/. Nell’esempio sopra, ./plugins/my-plugin punta a <repo>/plugins/my-plugin, anche se marketplace.json si trova in <repo>/.claude-plugin/marketplace.json. Non usare ../ per fare riferimento a percorsi al di fuori della radice del marketplace.
I percorsi relativi funzionano solo quando gli utenti aggiungono il tuo marketplace tramite Git (GitHub, GitLab o URL git). Se gli utenti aggiungono il tuo marketplace tramite un URL diretto al file marketplace.json, i percorsi relativi non si risolveranno correttamente. Per la distribuzione basata su URL, usa invece GitHub, npm o fonti URL git. Vedi Troubleshooting per i dettagli.

Repository GitHub

{
  "name": "github-plugin",
  "source": {
    "source": "github",
    "repo": "owner/plugin-repo"
  }
}
Puoi fissare a un branch, tag o commit specifico:
{
  "name": "github-plugin",
  "source": {
    "source": "github",
    "repo": "owner/plugin-repo",
    "ref": "v2.0.0",
    "sha": "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0"
  }
}
CampoTipoDescrizione
repostringObbligatorio. Repository GitHub nel formato owner/repo
refstringOpzionale. Branch o tag Git (predefinito al branch predefinito del repository)
shastringOpzionale. SHA del commit git completo a 40 caratteri per fissare a una versione esatta

Repository Git

{
  "name": "git-plugin",
  "source": {
    "source": "url",
    "url": "https://gitlab.com/team/plugin.git"
  }
}
Puoi fissare a un branch, tag o commit specifico:
{
  "name": "git-plugin",
  "source": {
    "source": "url",
    "url": "https://gitlab.com/team/plugin.git",
    "ref": "main",
    "sha": "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0"
  }
}
CampoTipoDescrizione
urlstringObbligatorio. URL completo del repository git (https:// o git@). Il suffisso .git è opzionale, quindi gli URL di Azure DevOps e AWS CodeCommit senza il suffisso funzionano
refstringOpzionale. Branch o tag Git (predefinito al branch predefinito del repository)
shastringOpzionale. SHA del commit git completo a 40 caratteri per fissare a una versione esatta

Sottodirectory Git

Usa git-subdir per puntare a un plugin che si trova all’interno di una sottodirectory di un repository git. Claude Code utilizza un clone parziale e sparso per recuperare solo la sottodirectory, riducendo al minimo la larghezza di banda per i grandi monorepo.
{
  "name": "my-plugin",
  "source": {
    "source": "git-subdir",
    "url": "https://github.com/acme-corp/monorepo.git",
    "path": "tools/claude-plugin"
  }
}
Puoi fissare a un branch, tag o commit specifico:
{
  "name": "my-plugin",
  "source": {
    "source": "git-subdir",
    "url": "https://github.com/acme-corp/monorepo.git",
    "path": "tools/claude-plugin",
    "ref": "v2.0.0",
    "sha": "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0"
  }
}
Il campo url accetta anche una scorciatoia GitHub (owner/repo) o URL SSH (git@github.com:owner/repo.git).
CampoTipoDescrizione
urlstringObbligatorio. URL del repository Git, scorciatoia GitHub owner/repo o URL SSH
pathstringObbligatorio. Percorso della sottodirectory all’interno del repo contenente il plugin (ad esempio, "tools/claude-plugin")
refstringOpzionale. Branch o tag Git (predefinito al branch predefinito del repository)
shastringOpzionale. SHA del commit git completo a 40 caratteri per fissare a una versione esatta

Pacchetti npm

I plugin distribuiti come pacchetti npm vengono installati utilizzando npm install. Questo funziona con qualsiasi pacchetto nel registro npm pubblico o in un registro privato ospitato dal tuo team.
{
  "name": "my-npm-plugin",
  "source": {
    "source": "npm",
    "package": "@acme/claude-plugin"
  }
}
Per fissare a una versione specifica, aggiungi il campo version:
{
  "name": "my-npm-plugin",
  "source": {
    "source": "npm",
    "package": "@acme/claude-plugin",
    "version": "2.1.0"
  }
}
Per installare da un registro privato o interno, aggiungi il campo registry:
{
  "name": "my-npm-plugin",
  "source": {
    "source": "npm",
    "package": "@acme/claude-plugin",
    "version": "^2.0.0",
    "registry": "https://npm.example.com"
  }
}
CampoTipoDescrizione
packagestringObbligatorio. Nome del pacchetto o pacchetto con scope (ad esempio, @org/plugin)
versionstringOpzionale. Versione o intervallo di versione (ad esempio, 2.1.0, ^2.0.0, ~1.5.0)
registrystringOpzionale. URL del registro npm personalizzato. Predefinito al registro npm del sistema (tipicamente npmjs.org)

Voci di plugin avanzate

Questo esempio mostra una voce di plugin che utilizza molti dei campi opzionali, inclusi percorsi personalizzati per comandi, agenti, hooks e server MCP:
{
  "name": "enterprise-tools",
  "source": {
    "source": "github",
    "repo": "company/enterprise-plugin"
  },
  "description": "Strumenti di automazione del flusso di lavoro aziendale",
  "version": "2.1.0",
  "author": {
    "name": "Enterprise Team",
    "email": "enterprise@example.com"
  },
  "homepage": "https://docs.example.com/plugins/enterprise-tools",
  "repository": "https://github.com/company/enterprise-plugin",
  "license": "MIT",
  "keywords": ["enterprise", "workflow", "automation"],
  "category": "productivity",
  "commands": [
    "./commands/core/",
    "./commands/enterprise/",
    "./commands/experimental/preview.md"
  ],
  "agents": ["./agents/security-reviewer.md", "./agents/compliance-checker.md"],
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "${CLAUDE_PLUGIN_ROOT}/scripts/validate.sh"
          }
        ]
      }
    ]
  },
  "mcpServers": {
    "enterprise-db": {
      "command": "${CLAUDE_PLUGIN_ROOT}/servers/db-server",
      "args": ["--config", "${CLAUDE_PLUGIN_ROOT}/config.json"]
    }
  },
  "strict": false
}
Cose importanti da notare:
  • commands e agents: Puoi specificare più directory o singoli file. I percorsi sono relativi alla radice del plugin.
  • ${CLAUDE_PLUGIN_ROOT}: Usa questa variabile nelle configurazioni degli hook e del server MCP per fare riferimento ai file all’interno della directory di installazione del plugin. Questo è necessario perché i plugin vengono copiati in una posizione cache quando installati. Per le dipendenze o lo stato che dovrebbe sopravvivere agli aggiornamenti dei plugin, usa ${CLAUDE_PLUGIN_DATA} invece.
  • strict: false: Poiché è impostato su false, il plugin non ha bisogno del suo plugin.json. La voce del marketplace definisce tutto. Vedi Strict mode di seguito.

Strict mode

Il campo strict controlla se plugin.json è l’autorità per le definizioni dei componenti (skills, agenti, hooks, server MCP, stili di output).
ValoreComportamento
true (predefinito)plugin.json è l’autorità. La voce del marketplace può integrarla con componenti aggiuntivi e entrambe le fonti vengono unite.
falseLa voce del marketplace è la definizione completa. Se il plugin ha anche un plugin.json che dichiara componenti, è un conflitto e il plugin non riesce a caricarsi.
Quando usare ogni modalità:
  • strict: true: il plugin ha il suo plugin.json e gestisce i suoi componenti. La voce del marketplace può aggiungere skill o hook extra in cima. Questo è il predefinito e funziona per la maggior parte dei plugin.
  • strict: false: l’operatore del marketplace vuole il controllo completo. Il repository del plugin fornisce file grezzi e la voce del marketplace definisce quali di questi file sono esposti come skill, agenti, hook, ecc. Utile quando il marketplace ristruttura o cura i componenti di un plugin diversamente da quanto previsto dall’autore del plugin.

Ospita e distribuisci marketplace

Ospita su GitHub (consigliato)

GitHub fornisce il metodo di distribuzione più semplice:
  1. Crea un repository: Configura un nuovo repository per il tuo marketplace
  2. Aggiungi il file marketplace: Crea .claude-plugin/marketplace.json con le tue definizioni di plugin
  3. Condividi con i team: Gli utenti aggiungono il tuo marketplace con /plugin marketplace add owner/repo
Vantaggi: Controllo della versione integrato, tracciamento dei problemi e funzionalità di collaborazione del team.

Ospita su altri servizi git

Qualsiasi servizio di hosting git funziona, come GitLab, Bitbucket e server self-hosted. Gli utenti aggiungono con l’URL completo del repository:
/plugin marketplace add https://gitlab.com/company/plugins.git

Repository privati

Claude Code supporta l’installazione di plugin da repository privati. Per l’installazione manuale e gli aggiornamenti, Claude Code utilizza i tuoi helper di credenziali git esistenti, quindi l’accesso HTTPS tramite gh auth login, Keychain di macOS o git-credential-store funziona come nel tuo terminale. L’accesso SSH funziona finché l’host è già nel tuo file known_hosts e la chiave è caricata in ssh-agent, poiché Claude Code sopprime i prompt SSH interattivi per l’impronta digitale dell’host e la passphrase della chiave. Gli aggiornamenti automatici in background vengono eseguiti all’avvio senza helper di credenziali, poiché i prompt interattivi bloccherebbero l’avvio di Claude Code. Per abilitare gli aggiornamenti automatici per i marketplace privati, imposta il token di autenticazione appropriato nel tuo ambiente:
ProviderVariabili di ambienteNote
GitHubGITHUB_TOKEN o GH_TOKENToken di accesso personale o token di GitHub App
GitLabGITLAB_TOKEN o GL_TOKENToken di accesso personale o token di progetto
BitbucketBITBUCKET_TOKENPassword dell’app o token di accesso al repository
Imposta il token nella configurazione della tua shell (ad esempio, .bashrc, .zshrc) o passalo quando esegui Claude Code:
export GITHUB_TOKEN=ghp_xxxxxxxxxxxxxxxxxxxx
Per gli ambienti CI/CD, configura il token come variabile di ambiente segreta. GitHub Actions fornisce automaticamente GITHUB_TOKEN per i repository nella stessa organizzazione.

Testa localmente prima della distribuzione

Testa il tuo marketplace localmente prima di condividerlo:
/plugin marketplace add ./my-local-marketplace
/plugin install test-plugin@my-local-marketplace
Per l’intera gamma di comandi add (GitHub, URL Git, percorsi locali, URL remoti), vedi Aggiungi marketplace.

Richiedi marketplace per il tuo team

Puoi configurare il tuo repository in modo che i membri del team vengano automaticamente invitati a installare il tuo marketplace quando fidano della cartella del progetto. Aggiungi il tuo marketplace a .claude/settings.json:
{
  "extraKnownMarketplaces": {
    "company-tools": {
      "source": {
        "source": "github",
        "repo": "your-org/claude-plugins"
      }
    }
  }
}
Puoi anche specificare quali plugin devono essere abilitati per impostazione predefinita:
{
  "enabledPlugins": {
    "code-formatter@company-tools": true,
    "deployment-tools@company-tools": true
  }
}
Per le opzioni di configurazione complete, vedi Plugin settings.
Se usi una fonte locale directory o file con un percorso relativo, il percorso si risolve rispetto al checkout principale del tuo repository. Quando esegui Claude Code da un git worktree, il percorso punta ancora al checkout principale, quindi tutti i worktree condividono la stessa posizione del marketplace. Lo stato del marketplace viene archiviato una volta per utente in ~/.claude/plugins/known_marketplaces.json, non per progetto.

Pre-popola plugin per i container

Per le immagini container e gli ambienti CI, puoi pre-popolare una directory di plugin al momento della compilazione in modo che Claude Code si avvii con marketplace e plugin già disponibili, senza clonare nulla al runtime. Imposta la variabile di ambiente CLAUDE_CODE_PLUGIN_SEED_DIR per puntare a questa directory. Per stratificare più directory seed, separa i percorsi con : su Unix o ; su Windows. Claude Code cerca ogni directory in ordine e il primo seed che contiene un determinato marketplace o cache di plugin vince. La directory seed rispecchia la struttura di ~/.claude/plugins:
$CLAUDE_CODE_PLUGIN_SEED_DIR/
  known_marketplaces.json
  marketplaces/<name>/...
  cache/<marketplace>/<plugin>/<version>/...
Per costruire una directory seed, esegui Claude Code una volta durante la compilazione dell’immagine, installa i plugin di cui hai bisogno, quindi copia la directory ~/.claude/plugins risultante nella tua immagine e punta CLAUDE_CODE_PLUGIN_SEED_DIR ad essa. Per saltare il passaggio di copia, imposta CLAUDE_CODE_PLUGIN_CACHE_DIR sul tuo percorso seed di destinazione durante la compilazione in modo che i plugin si installino direttamente lì:
CLAUDE_CODE_PLUGIN_CACHE_DIR=/opt/claude-seed claude plugin marketplace add your-org/plugins
CLAUDE_CODE_PLUGIN_CACHE_DIR=/opt/claude-seed claude plugin install my-tool@your-plugins
Quindi imposta CLAUDE_CODE_PLUGIN_SEED_DIR=/opt/claude-seed nell’ambiente di runtime del tuo container in modo che Claude Code legga dal seed all’avvio. All’avvio, Claude Code registra i marketplace trovati nel known_marketplaces.json del seed nella configurazione primaria e utilizza le cache dei plugin trovate sotto cache/ al posto senza ri-clonare. Questo funziona sia in modalità interattiva che in modalità non interattiva con il flag -p. Dettagli del comportamento:
  • Sola lettura: la directory seed non viene mai scritta. Gli aggiornamenti automatici sono disabilitati per i marketplace seed poiché git pull fallirebbe su un filesystem di sola lettura.
  • Le voci seed hanno precedenza: i marketplace dichiarati nel seed sovrascrivono qualsiasi voce corrispondente nella configurazione dell’utente ad ogni avvio. Per rinunciare a un plugin seed, usa /plugin disable piuttosto che rimuovere il marketplace.
  • Risoluzione del percorso: Claude Code individua il contenuto del marketplace sondando $CLAUDE_CODE_PLUGIN_SEED_DIR/marketplaces/<name>/ al runtime, non fidandosi dei percorsi archiviati all’interno del JSON del seed. Ciò significa che il seed funziona correttamente anche quando montato in un percorso diverso da dove è stato compilato.
  • La mutazione è bloccata: l’esecuzione di /plugin marketplace remove o /plugin marketplace update su un marketplace gestito da seed non riesce con una guida per chiedere al tuo amministratore di aggiornare l’immagine seed.
  • Compone con le impostazioni: se extraKnownMarketplaces o enabledPlugins dichiarano un marketplace che esiste già nel seed, Claude Code utilizza la copia del seed invece di clonare.

Restrizioni del marketplace gestito

Per le organizzazioni che richiedono un controllo rigoroso sulle fonti dei plugin, gli amministratori possono limitare quali marketplace di plugin gli utenti possono aggiungere utilizzando l’impostazione strictKnownMarketplaces nelle impostazioni gestite. Quando strictKnownMarketplaces è configurato nelle impostazioni gestite, il comportamento della restrizione dipende dal valore:
ValoreComportamento
Non definito (predefinito)Nessuna restrizione. Gli utenti possono aggiungere qualsiasi marketplace
Array vuoto []Blocco completo. Gli utenti non possono aggiungere nuovi marketplace
Elenco di fontiGli utenti possono aggiungere solo marketplace che corrispondono esattamente all’elenco di autorizzazione

Configurazioni comuni

Disabilita tutti gli aggiunte di marketplace:
{
  "strictKnownMarketplaces": []
}
Consenti solo marketplace specifici:
{
  "strictKnownMarketplaces": [
    {
      "source": "github",
      "repo": "acme-corp/approved-plugins"
    },
    {
      "source": "github",
      "repo": "acme-corp/security-tools",
      "ref": "v2.0"
    },
    {
      "source": "url",
      "url": "https://plugins.example.com/marketplace.json"
    }
  ]
}
Consenti tutti i marketplace da un server git interno utilizzando la corrispondenza del modello regex sull’host. Questo è l’approccio consigliato per GitHub Enterprise Server o istanze GitLab self-hosted:
{
  "strictKnownMarketplaces": [
    {
      "source": "hostPattern",
      "hostPattern": "^github\\.example\\.com$"
    }
  ]
}
Consenti marketplace basati su filesystem da una directory specifica utilizzando la corrispondenza del modello regex sul percorso:
{
  "strictKnownMarketplaces": [
    {
      "source": "pathPattern",
      "pathPattern": "^/opt/approved/"
    }
  ]
}
Usa ".*" come pathPattern per consentire qualsiasi percorso del filesystem controllando comunque le fonti di rete con hostPattern.
strictKnownMarketplaces limita ciò che gli utenti possono aggiungere, ma non registra i marketplace di per sé. Per rendere i marketplace consentiti disponibili automaticamente senza che gli utenti eseguano /plugin marketplace add, abbinalo a extraKnownMarketplaces nello stesso managed-settings.json. Vedi Usare entrambi insieme.

Come funzionano le restrizioni

Le restrizioni vengono convalidate prima di qualsiasi operazione di rete o del filesystem. Il controllo viene eseguito all’aggiunta del marketplace e all’installazione, aggiornamento, aggiornamento e auto-aggiornamento del plugin. Se un marketplace è stato aggiunto prima della configurazione della policy e la sua fonte non corrisponde più all’elenco di autorizzazione, Claude Code rifiuta di installare o aggiornare i plugin da esso. Lo stesso controllo si applica a blockedMarketplaces. L’elenco di autorizzazione utilizza la corrispondenza esatta per la maggior parte dei tipi di fonte. Affinché un marketplace sia consentito, tutti i campi specificati devono corrispondere esattamente:
  • Per le fonti GitHub: repo è obbligatorio e ref o path devono corrispondere anche se specificati nell’elenco di autorizzazione
  • Per le fonti URL: l’URL completo deve corrispondere esattamente
  • Per le fonti hostPattern: l’host del marketplace viene confrontato con il modello regex
  • Per le fonti pathPattern: il percorso del filesystem del marketplace viene confrontato con il modello regex
La corrispondenza esatta non normalizza gli URL: una barra finale, il suffisso .git o il modulo ssh:// rispetto a https:// vengono trattati come valori diversi. Se il marketplace della tua organizzazione può essere clonato da più di una forma di URL, preferisci una voce hostPattern rispetto a un URL letterale in modo che tutte le forme corrispondano. Poiché strictKnownMarketplaces è impostato nelle impostazioni gestite, le configurazioni individuali degli utenti e dei progetti non possono ignorare queste restrizioni. Per i dettagli di configurazione completi inclusi tutti i tipi di fonte supportati e il confronto con extraKnownMarketplaces, vedi il riferimento strictKnownMarketplaces.

Risoluzione della versione e canali di rilascio

Le versioni dei plugin determinano i percorsi della cache e il rilevamento degli aggiornamenti: se la versione risolta corrisponde a quella che un utente ha già, /plugin update e l’auto-aggiornamento saltano il plugin. Claude Code risolve la versione di un plugin dal primo di questi che è impostato:
  1. version nel plugin.json del plugin
  2. version nella voce del marketplace del plugin
  3. Lo SHA del commit git della fonte del plugin
Per i tipi di fonte basati su git github, url, git-subdir e i percorsi relativi all’interno di un marketplace ospitato su git, puoi omettere completamente version e ogni nuovo commit viene trattato come una nuova versione. Questa è la configurazione più semplice per i plugin interni o in fase di sviluppo attivo.
Impostare version fissa il plugin. Se plugin.json dichiara "version": "1.0.0", spingere nuovi commit senza cambiare quella stringa non fa nulla per gli utenti esistenti, perché Claude Code vede la stessa versione e mantiene la copia in cache. Aumenta il campo ad ogni rilascio, o omettilo per usare lo SHA del commit.Evita di impostare version sia in plugin.json che nella voce del marketplace. Il valore plugin.json vince sempre silenziosamente, quindi una versione del manifest obsoleta può mascherare una versione che hai impostato in marketplace.json.

Configura i canali di rilascio

Per supportare i canali di rilascio “stable” e “latest” per i tuoi plugin, puoi configurare due marketplace che puntano a diversi ref o SHA dello stesso repo. Puoi quindi assegnare i due marketplace a diversi gruppi di utenti tramite impostazioni gestite.
Ogni canale deve risolversi a una versione diversa. Se usi versioni esplicite, plugin.json deve dichiarare una version diversa in ogni ref fissato. Se ometti version, gli SHA dei commit distinti già distinguono i canali. Se due ref si risolvono alla stessa stringa di versione, Claude Code li tratta come identici e salta l’aggiornamento.
Esempio
{
  "name": "stable-tools",
  "plugins": [
    {
      "name": "code-formatter",
      "source": {
        "source": "github",
        "repo": "acme-corp/code-formatter",
        "ref": "stable"
      }
    }
  ]
}
{
  "name": "latest-tools",
  "plugins": [
    {
      "name": "code-formatter",
      "source": {
        "source": "github",
        "repo": "acme-corp/code-formatter",
        "ref": "latest"
      }
    }
  ]
}
Assegna i canali ai gruppi di utenti
Assegna ogni marketplace al gruppo di utenti appropriato tramite impostazioni gestite. Ad esempio, il gruppo stabile riceve:
{
  "extraKnownMarketplaces": {
    "stable-tools": {
      "source": {
        "source": "github",
        "repo": "acme-corp/stable-tools"
      }
    }
  }
}
Il gruppo early-access riceve invece latest-tools:
{
  "extraKnownMarketplaces": {
    "latest-tools": {
      "source": {
        "source": "github",
        "repo": "acme-corp/latest-tools"
      }
    }
  }
}

Fissa le versioni delle dipendenze

Un plugin può vincolare le sue dipendenze a un intervallo semver in modo che gli aggiornamenti a una dipendenza non interrompano il plugin dipendente. Vedi Vincola le versioni delle dipendenze dei plugin per la convenzione del tag git {plugin-name}--v{version}, la sintassi dell’intervallo e come più vincoli sulla stessa dipendenza vengono combinati.

Validazione e test

Testa il tuo marketplace prima di condividerlo. Valida la sintassi JSON del tuo marketplace:
claude plugin validate .
O da Claude Code:
/plugin validate .
Aggiungi il marketplace per il test:
/plugin marketplace add ./path/to/marketplace
Installa un plugin di test per verificare che tutto funzioni:
/plugin install test-plugin@marketplace-name
Per i flussi di lavoro di test completi dei plugin, vedi Testa i tuoi plugin localmente. Per la risoluzione dei problemi tecnici, vedi Plugins reference.

Gestisci marketplace dalla CLI

Claude Code fornisce sottocomandi claude plugin marketplace non interattivi per lo scripting e l’automazione. Questi sono equivalenti ai comandi /plugin marketplace disponibili in una sessione interattiva.

Plugin marketplace add

Aggiungi un marketplace da un repository GitHub, URL git, URL remoto o percorso locale.
claude plugin marketplace add <source> [options]
Argomenti:
  • <source>: Scorciatoia GitHub owner/repo, URL git, URL remoto a un file marketplace.json o percorso di directory locale. Per fissare a un branch o tag, aggiungi @ref alla scorciatoia GitHub o #ref a un URL git
Opzioni:
OpzioneDescrizionePredefinito
--scope <scope>Dove dichiarare il marketplace: user, project o local. Vedi Plugin installation scopesuser
--sparse <paths...>Limita il checkout a directory specifiche tramite git sparse-checkout. Utile per i monorepo
Aggiungi un marketplace da GitHub utilizzando la scorciatoia owner/repo:
claude plugin marketplace add acme-corp/claude-plugins
Fissa a un branch o tag specifico con @ref:
claude plugin marketplace add acme-corp/claude-plugins@v2.0
Aggiungi da un URL git su un host non-GitHub:
claude plugin marketplace add https://gitlab.example.com/team/plugins.git
Aggiungi da un URL remoto che serve il file marketplace.json direttamente:
claude plugin marketplace add https://example.com/marketplace.json
Aggiungi da una directory locale per il test:
claude plugin marketplace add ./my-marketplace
Dichiara il marketplace a livello di progetto in modo che sia condiviso con il tuo team tramite .claude/settings.json:
claude plugin marketplace add acme-corp/claude-plugins --scope project
Per un monorepo, limita il checkout alle directory che contengono il contenuto del plugin:
claude plugin marketplace add acme-corp/monorepo --sparse .claude-plugin plugins

Plugin marketplace list

Elenca tutti i marketplace configurati.
claude plugin marketplace list [options]
Opzioni:
OpzioneDescrizione
--jsonOutput come JSON

Plugin marketplace remove

Rimuovi un marketplace configurato. L’alias rm è accettato anche.
claude plugin marketplace remove <name>
Argomenti:
  • <name>: nome del marketplace da rimuovere, come mostrato da claude plugin marketplace list. Questo è il name da marketplace.json, non la fonte che hai passato a add
La rimozione di un marketplace disinstalla anche tutti i plugin che hai installato da esso. Per aggiornare un marketplace senza perdere i plugin installati, usa claude plugin marketplace update invece.

Plugin marketplace update

Aggiorna i marketplace dalle loro fonti per recuperare nuovi plugin e cambiamenti di versione.
claude plugin marketplace update [name]
Argomenti:
  • [name]: nome del marketplace da aggiornare, come mostrato da claude plugin marketplace list. Aggiorna tutti i marketplace se omesso
Sia remove che update non riescono quando eseguiti su un marketplace gestito da seed, che è di sola lettura. Quando si aggiornano tutti i marketplace, le voci gestite da seed vengono saltate e gli altri marketplace si aggiornano comunque. Per modificare i plugin forniti da seed, chiedi al tuo amministratore di aggiornare l’immagine seed. Vedi Pre-popola plugin per i container.

Troubleshooting

Marketplace non carica

Sintomi: Non riesci ad aggiungere il marketplace o a vedere i plugin da esso Soluzioni:
  • Verifica che l’URL del marketplace sia accessibile
  • Controlla che .claude-plugin/marketplace.json esista nel percorso specificato
  • Assicurati che la sintassi JSON sia valida e che il frontmatter sia ben formato utilizzando claude plugin validate o /plugin validate
  • Per i repository privati, conferma di avere i permessi di accesso

Errori di validazione del marketplace

Esegui claude plugin validate . o /plugin validate . dalla directory del tuo marketplace per verificare i problemi. Il validatore controlla plugin.json, il frontmatter di skill/agente/comando e hooks/hooks.json per errori di sintassi e schema. Errori comuni:
ErroreCausaSoluzione
File not found: .claude-plugin/marketplace.jsonManifest mancanteCrea .claude-plugin/marketplace.json con i campi obbligatori
Invalid JSON syntax: Unexpected token...Errore di sintassi JSON in marketplace.jsonControlla le virgole mancanti, le virgole extra o le stringhe non quotate
Duplicate plugin name "x" found in marketplaceDue plugin condividono lo stesso nomeDai a ogni plugin un valore name univoco
plugins[0].source: Path contains ".."Il percorso di fonte contiene ..Usa percorsi relativi alla radice del marketplace senza ... Vedi Percorsi relativi
YAML frontmatter failed to parse: ...YAML non valido in un file di skill, agente o comandoCorreggi la sintassi YAML nel blocco frontmatter. Al runtime questo file si carica senza metadati.
Invalid JSON syntax: ... (hooks.json)hooks/hooks.json malformatoCorreggi la sintassi JSON. Un hooks/hooks.json malformato impedisce al plugin intero di caricarsi.
Avvisi (non bloccanti):
  • Marketplace has no plugins defined: aggiungi almeno un plugin all’array plugins
  • No marketplace description provided: aggiungi una description di livello superiore per aiutare gli utenti a comprendere il tuo marketplace
  • Plugin name "x" is not kebab-case: il nome del plugin contiene lettere maiuscole, spazi o caratteri speciali. Rinomina in lettere minuscole, cifre e trattini solo (ad esempio, my-plugin). Claude Code accetta altre forme, ma la sincronizzazione del marketplace Claude.ai le rifiuta.

Errori di installazione del plugin

Sintomi: Il marketplace appare ma l’installazione del plugin non riesce Soluzioni:
  • Verifica che gli URL di fonte del plugin siano accessibili
  • Controlla che le directory dei plugin contengano i file richiesti
  • Per le fonti GitHub, assicurati che i repository siano pubblici o che tu abbia accesso
  • Testa manualmente le fonti dei plugin clonando/scaricando

L’autenticazione del repository privato non riesce

Sintomi: Errori di autenticazione durante l’installazione di plugin da repository privati Soluzioni: Per l’installazione manuale e gli aggiornamenti:
  • Verifica di essere autenticato con il tuo provider git (ad esempio, esegui gh auth status per GitHub)
  • Controlla che il tuo helper di credenziali sia configurato correttamente: git config --global credential.helper
  • Prova a clonare il repository manualmente per verificare che le tue credenziali funzionino
Per gli aggiornamenti automatici in background:
  • Imposta il token appropriato nel tuo ambiente: echo $GITHUB_TOKEN
  • Controlla che il token abbia i permessi richiesti (accesso in lettura al repository)
  • Per GitHub, assicurati che il token abbia lo scope repo per i repository privati
  • Per GitLab, assicurati che il token abbia almeno lo scope read_repository
  • Verifica che il token non sia scaduto

Gli aggiornamenti del marketplace non riescono in ambienti offline

Sintomi: Il git pull del marketplace non riesce e Claude Code cancella la cache esistente, causando l’indisponibilità dei plugin. Causa: Per impostazione predefinita, quando un git pull non riesce, Claude Code rimuove il clone obsoleto e tenta di ri-clonare. In ambienti offline o airgapped, la ri-clonazione non riesce allo stesso modo, lasciando la directory del marketplace vuota. Soluzione: Imposta CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE=1 per mantenere la cache esistente quando il pull non riesce invece di cancellarla:
export CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE=1
Con questa variabile impostata, Claude Code mantiene il clone obsoleto del marketplace in caso di fallimento di git pull e continua a utilizzare lo stato ultimo noto come buono. Per distribuzioni completamente offline in cui il repository non sarà mai raggiungibile, utilizza CLAUDE_CODE_PLUGIN_SEED_DIR per pre-popolare la directory dei plugin al momento della compilazione.

Le operazioni Git scadono

Sintomi: L’installazione del plugin o gli aggiornamenti del marketplace non riescono con un errore di timeout come “Git clone timed out after 120s” o “Git pull timed out after 120s”. Causa: Claude Code utilizza un timeout di 120 secondi per tutte le operazioni git, inclusa la clonazione dei repository dei plugin e il pull degli aggiornamenti del marketplace. I repository di grandi dimensioni o le connessioni di rete lente possono superare questo limite. Soluzione: Aumenta il timeout utilizzando la variabile di ambiente CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS. Il valore è in millisecondi:
export CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS=300000  # 5 minuti

I plugin con percorsi relativi non riescono nei marketplace basati su URL

Sintomi: Hai aggiunto un marketplace tramite URL (come https://example.com/marketplace.json), ma i plugin con fonti di percorso relativo come "./plugins/my-plugin" non riescono a installare con errori “path not found”. Causa: I marketplace basati su URL scaricano solo il file marketplace.json stesso. Non scaricano i file dei plugin dal server. I percorsi relativi nella voce del marketplace fanno riferimento a file sul server remoto che non sono stati scaricati. Soluzioni:
  • Usa fonti esterne: Cambia le voci dei plugin per usare GitHub, npm o fonti URL git invece di percorsi relativi:
    { "name": "my-plugin", "source": { "source": "github", "repo": "owner/repo" } }
    
  • Usa un marketplace basato su Git: Ospita il tuo marketplace in un repository Git e aggiungilo con l’URL git. I marketplace basati su Git clonano l’intero repository, rendendo i percorsi relativi funzionanti correttamente.

File non trovati dopo l’installazione

Sintomi: Il plugin si installa ma i riferimenti ai file non riescono, specialmente i file al di fuori della directory del plugin Causa: I plugin vengono copiati in una directory cache piuttosto che utilizzati in-place. I percorsi che fanno riferimento a file al di fuori della directory del plugin (come ../shared-utils) non funzioneranno perché quei file non vengono copiati. Soluzioni: Vedi Plugin caching and file resolution per le soluzioni alternative inclusi symlink e ristrutturazione delle directory. Per ulteriori strumenti di debug e problemi comuni, vedi Debugging and development tools.

Vedi anche