plugins.md +0 −527 deleted
File Deleted View Diff
1> ## Documentation Index
2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
3> Use this file to discover all available pages before exploring further.
4
5# Criar plugins
6
7> Crie plugins personalizados para estender Claude Code com skills, agents, hooks e MCP servers.
8
9Plugins permitem que você estenda Claude Code com funcionalidade personalizada que pode ser compartilhada entre projetos e equipes. Este guia cobre a criação de seus próprios plugins com skills, agents, hooks e MCP servers.
10
11Procurando instalar plugins existentes? Veja [Descobrir e instalar plugins](/docs/pt/discover-plugins). Para especificações técnicas completas, veja [Referência de plugins](/docs/pt/plugins-reference).
12
13<h2 id="when-to-use-plugins-vs-standalone-configuration">
14 Quando usar plugins vs configuração independente
15</h2>
16
17Claude Code suporta duas maneiras de adicionar skills, agents e hooks personalizados:
18
19| Abordagem | Nomes de skills | Melhor para |
20| :-------------------------------------------------------- | :------------------- | :------------------------------------------------------------------------------------------------------------------------ |
21| **Independente** (diretório `.claude/`) | `/hello` | Fluxos de trabalho pessoais, personalizações específicas do projeto, experimentos rápidos |
22| **Plugins** (diretórios com `.claude-plugin/plugin.json`) | `/plugin-name:hello` | Compartilhamento com colegas de equipe, distribuição para a comunidade, lançamentos versionados, reutilizável em projetos |
23
24<Tip>
25 Comece com configuração independente em `.claude/` para iteração rápida, depois [converta para um plugin](#convert-existing-configurations-to-plugins) quando estiver pronto para compartilhar.
26</Tip>
27
28<h2 id="quickstart">
29 Início rápido
30</h2>
31
32Este início rápido o guia através da criação de um plugin com um skill personalizado. Você criará um manifesto (o arquivo de configuração que define seu plugin), adicionará um skill e o testará localmente usando a flag `--plugin-dir`.
33
34<h3 id="prerequisites">
35 Pré-requisitos
36</h3>
37
38* Claude Code [instalado e autenticado](/docs/pt/quickstart#step-1-install-claude-code)
39
40<h3 id="create-your-first-plugin">
41 Crie seu primeiro plugin
42</h3>
43
44<Steps>
45 <Step title="Crie o diretório do plugin">
46 Cada plugin vive em seu próprio diretório contendo seus skills, agents ou hooks, opcionalmente ao lado de um manifesto `.claude-plugin/plugin.json`. A localização não importa para este início rápido porque você apontará Claude Code para o diretório com `--plugin-dir` na etapa de teste. Crie-o em qualquer lugar conveniente, como uma pasta de rascunho ou um diretório de projetos:
47
48 ```bash theme={null}
49 mkdir my-first-plugin
50 ```
51
52 As etapas restantes são executadas a partir do diretório pai e fazem referência a caminhos como `my-first-plugin/...` relativos a ele.
53 </Step>
54
55 <Step title="Crie o manifesto do plugin">
56 O arquivo de manifesto em `.claude-plugin/plugin.json` define a identidade do seu plugin: seu nome, descrição e versão. Claude Code usa esses metadados para exibir seu plugin no gerenciador de plugins.
57
58 Crie o diretório `.claude-plugin` dentro da pasta do seu plugin:
59
60 ```bash theme={null}
61 mkdir my-first-plugin/.claude-plugin
62 ```
63
64 Depois crie `my-first-plugin/.claude-plugin/plugin.json` com este conteúdo:
65
66 ```json my-first-plugin/.claude-plugin/plugin.json theme={null}
67 {
68 "name": "my-first-plugin",
69 "description": "A greeting plugin to learn the basics",
70 "version": "1.0.0",
71 "author": {
72 "name": "Your Name"
73 }
74 }
75 ```
76
77 | Campo | Propósito |
78 | :------------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
79 | `name` | Identificador único e namespace de skill. Skills são prefixados com isso (ex: `/my-first-plugin:hello`). |
80 | `description` | Mostrado no gerenciador de plugins ao navegar ou instalar plugins. |
81 | `version` | Opcional. Se definido, os usuários recebem atualizações apenas quando você incrementa este campo, exceto para uma [fonte `command`](/docs/pt/plugin-marketplaces#command-sources) ou um plugin [carregado no local](/docs/pt/plugins-reference#plugin-caching-and-file-resolution); veja [gerenciamento de versão](/docs/pt/plugins-reference#version-management). Se omitido, a versão vem da próxima fonte em [gerenciamento de versão](/docs/pt/plugins-reference#version-management). |
82 | `author` | Opcional. Útil para atribuição. |
83
84 Para campos adicionais como `homepage`, `repository` e `license`, veja o [esquema de manifesto completo](/docs/pt/plugins-reference#plugin-manifest-schema).
85 </Step>
86
87 <Step title="Adicione um skill">
88 Skills vivem no diretório `skills/`. Cada skill é uma pasta contendo um arquivo `SKILL.md`. O nome da pasta se torna o nome do skill, prefixado com o namespace do plugin (`hello/` em um plugin nomeado `my-first-plugin` cria `/my-first-plugin:hello`).
89
90 Crie um diretório de skill na pasta do seu plugin:
91
92 ```bash theme={null}
93 mkdir -p my-first-plugin/skills/hello
94 ```
95
96 Depois crie `my-first-plugin/skills/hello/SKILL.md` com este conteúdo:
97
98 ```markdown my-first-plugin/skills/hello/SKILL.md theme={null}
99 ---
100 description: Greet the user with a friendly message
101 disable-model-invocation: true
102 ---
103
104 Greet the user warmly and ask how you can help them today.
105 ```
106 </Step>
107
108 <Step title="Teste seu plugin">
109 Execute Claude Code com a flag `--plugin-dir` para carregar seu plugin:
110
111 ```bash theme={null}
112 claude --plugin-dir ./my-first-plugin
113 ```
114
115 Uma vez que Claude Code inicia, tente seu novo skill:
116
117 ```shell theme={null}
118 /my-first-plugin:hello
119 ```
120
121 Você verá Claude responder com uma saudação. Execute `/help` e abra a aba **Custom commands** para ver seu skill listado sob o namespace do plugin.
122
123 <Note>
124 **Por que namespacing?** Plugin skills são sempre com namespace (como `/my-first-plugin:hello`) para prevenir conflitos quando múltiplos plugins têm skills com o mesmo nome.
125
126 Para mudar o prefixo de namespace, atualize o campo `name` em `plugin.json`.
127 </Note>
128 </Step>
129
130 <Step title="Adicione argumentos de skill">
131 Torne seu skill dinâmico aceitando entrada do usuário. O placeholder `$ARGUMENTS` captura qualquer texto que o usuário fornece após o nome do skill.
132
133 Atualize seu arquivo `SKILL.md`:
134
135 ```markdown my-first-plugin/skills/hello/SKILL.md theme={null}
136 ---
137 description: Greet the user with a personalized message
138 ---
139
140 # Hello Skill
141
142 Greet the user named "$ARGUMENTS" warmly and ask how you can help them today. Make the greeting personal and encouraging.
143 ```
144
145 Execute `/reload-plugins` para pegar as mudanças. Depois tente o skill com seu nome:
146
147 ```shell theme={null}
148 /my-first-plugin:hello Alex
149 ```
150
151 Claude o saudará pelo nome. Para mais sobre passar argumentos para skills, veja [Skills](/docs/pt/skills#pass-arguments-to-skills).
152 </Step>
153</Steps>
154
155<Tip>
156 A flag `--plugin-dir` é útil para desenvolvimento e testes. Quando estiver pronto para compartilhar seu plugin com outros, veja [Criar e distribuir um marketplace de plugins](/docs/pt/plugin-marketplaces).
157</Tip>
158
159<h2 id="develop-a-plugin-in-your-skills-directory">
160 Desenvolva um plugin em seu diretório de skills
161</h2>
162
163Em vez de passar `--plugin-dir` em cada inicialização, você pode manter um plugin em seu diretório de skills e fazer com que Claude Code o carregue automaticamente. `claude plugin init` cria um:
164
165```bash theme={null}
166claude plugin init my-tool
167```
168
169Isso cria `~/.claude/skills/my-tool/` com um manifesto `.claude-plugin/plugin.json` e um `SKILL.md` inicial. Na próxima sessão ele carrega como `my-tool@skills-dir` sem nenhuma etapa de marketplace ou instalação.
170
171Para as regras de carregamento automático, escopo pessoal vs. projeto, o requisito de confiança do workspace e como atualizar ou remover um, veja [Plugins do diretório de skills](/docs/pt/plugins-reference#skills-directory-plugins).
172
173<h2 id="plugin-structure-overview">
174 Visão geral da estrutura do plugin
175</h2>
176
177Você criou um plugin com um skill, mas plugins podem incluir muito mais: agents personalizados, hooks, MCP servers, LSP servers e monitores de background.
178
179<Warning>
180 **Erro comum**: Não coloque `commands/`, `agents/`, `skills/` ou `hooks/` dentro do diretório `.claude-plugin/`. Apenas `plugin.json` vai dentro de `.claude-plugin/`. Todos os outros diretórios devem estar no nível raiz do plugin.
181
182 A raiz do plugin é o diretório individual do próprio plugin, como `my-first-plugin/` do [guia de início rápido](#quickstart). Nunca é `~/.claude/`. Por exemplo, Claude Code não lê um `.mcp.json` colocado em `~/.claude/.mcp.json`.
183</Warning>
184
185| Diretório | Localização | Propósito |
186| :---------------- | :------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
187| `.claude-plugin/` | Raiz do plugin | Contém manifesto `plugin.json` (opcional se componentes usam localizações padrão) |
188| `skills/` | Raiz do plugin | Skills como diretórios `<name>/SKILL.md` |
189| `commands/` | Raiz do plugin | Skills como arquivos Markdown simples. Use `skills/` para novos plugins |
190| `agents/` | Raiz do plugin | Definições de agent personalizadas |
191| `hooks/` | Raiz do plugin | Manipuladores de eventos em `hooks.json` |
192| `.mcp.json` | Raiz do plugin | Configurações de MCP server |
193| `.lsp.json` | Raiz do plugin | Configurações de LSP server para inteligência de código |
194| `monitors/` | Raiz do plugin | Configurações de monitor de background em `monitors.json` |
195| `bin/` | Raiz do plugin | Executáveis adicionados ao `PATH` da ferramenta Bash enquanto o plugin está habilitado. Você não pode incluir este diretório em um plugin que você [distribui através das configurações da organização claude.ai](/docs/pt/plugin-marketplaces#keep-executables-out-of-the-top-level-bin-directory) |
196| `settings.json` | Raiz do plugin | [Configurações](/docs/pt/settings) padrão aplicadas quando o plugin é habilitado |
197
198Um plugin que fornece exatamente um skill pode colocar `SKILL.md` diretamente na raiz do plugin em vez de criar um diretório `skills/`. Claude Code o carrega como um único skill e usa o campo `name` do frontmatter para o nome de invocação. Use o layout `skills/` para plugins que podem crescer para mais de um skill.
199
200<h2 id="develop-more-complex-plugins">
201 Desenvolver plugins mais complexos
202</h2>
203
204Uma vez que você está confortável com plugins básicos, você pode criar extensões mais sofisticadas.
205
206<h3 id="add-skills-to-your-plugin">
207 Adicione Skills ao seu plugin
208</h3>
209
210Plugins podem incluir [Agent Skills](/docs/pt/skills) para estender as capacidades do Claude. Skills são invocados por modelo: Claude os usa automaticamente com base no contexto da tarefa.
211
212Adicione um diretório `skills/` na raiz do seu plugin com pastas de Skill contendo arquivos `SKILL.md`:
213
214```text theme={null}
215my-plugin/
216├── .claude-plugin/
217│ └── plugin.json
218└── skills/
219 └── code-review/
220 └── SKILL.md
221```
222
223Cada `SKILL.md` contém frontmatter YAML e instruções. Inclua uma `description` para que Claude saiba quando usar o skill:
224
225```yaml theme={null}
226description: Reviews code for best practices and potential issues. Use when reviewing code, checking PRs, or analyzing code quality.
227
228When reviewing code, check for:
2291. Code organization and structure
2302. Error handling
2313. Security concerns
2324. Test coverage
233```
234
235Após instalar o plugin, verifique o resumo de instalação: se ele relatar `Run /reload-plugins to activate.`, veja [Aplicar mudanças de plugin sem reiniciar](/docs/pt/discover-plugins#apply-plugin-changes-without-restarting) para carregar os Skills em sua sessão atual. Para orientação completa de autoria de Skill incluindo divulgação progressiva e restrições de ferramentas, veja [Agent Skills](/docs/pt/skills).
236
237<h3 id="add-lsp-servers-to-your-plugin">
238 Adicione LSP servers ao seu plugin
239</h3>
240
241<Tip>
242 Para linguagens comuns como TypeScript, Python e Rust, instale os plugins LSP pré-construídos do marketplace oficial. Crie plugins LSP personalizados apenas quando você precisar de suporte para linguagens não cobertas.
243</Tip>
244
245Plugins LSP (Language Server Protocol) dão ao Claude inteligência de código em tempo real. Se você precisar suportar uma linguagem que não tem um plugin LSP oficial, você pode criar um próprio adicionando um arquivo `.lsp.json` ao seu plugin:
246
247```json .lsp.json theme={null}
248{
249 "go": {
250 "command": "gopls",
251 "args": ["serve"],
252 "extensionToLanguage": {
253 ".go": "go"
254 }
255 }
256}
257```
258
259Usuários instalando seu plugin devem ter o binário do language server instalado em sua máquina.
260
261Para confirmar que o servidor inicia, inicie Claude Code com o plugin habilitado e verifique a aba `/plugin` Errors: um language server que falha ao iniciar aparece lá, por exemplo com `Executable not found in $PATH` quando o binário não está instalado. Uma entrada com uma configuração inválida é ignorada; execute `claude --debug` para ver por quê.
262
263Para opções de configuração LSP completas, veja [LSP servers](/docs/pt/plugins-reference#lsp-servers).
264
265<h3 id="add-background-monitors-to-your-plugin">
266 Adicione monitores de background ao seu plugin
267</h3>
268
269Monitores de background permitem que seu plugin observe logs, arquivos ou status externo em background e notifique Claude conforme eventos chegam. Claude Code inicia cada monitor automaticamente quando o plugin está ativo, então você não precisa instruir Claude a iniciar a observação.
270
271Adicione um arquivo `monitors/monitors.json` na raiz do plugin com um array de entradas de monitor:
272
273```json monitors/monitors.json theme={null}
274[
275 {
276 "name": "error-log",
277 "command": "tail -F ./logs/error.log",
278 "description": "Application error log"
279 }
280]
281```
282
283Cada linha de stdout do `command` é entregue ao Claude como uma notificação durante a sessão. Para o esquema completo, incluindo o trigger `when` e substituição de variáveis, veja [Monitors](/docs/pt/plugins-reference#monitors).
284
285<h3 id="ship-default-settings-with-your-plugin">
286 Envie configurações padrão com seu plugin
287</h3>
288
289Plugins podem incluir um arquivo `settings.json` na raiz do plugin para aplicar configuração padrão quando o plugin é habilitado. Atualmente, apenas as chaves `agent` e `subagentStatusLine` são suportadas.
290
291Definir `agent` ativa um dos [agents personalizados](/docs/pt/sub-agents) do plugin como a thread principal, aplicando seu prompt de sistema, restrições de ferramentas e modelo. Isso permite que um plugin mude como Claude Code se comporta por padrão quando habilitado.
292
293```json settings.json theme={null}
294{
295 "agent": "security-reviewer"
296}
297```
298
299Este exemplo ativa o agent `security-reviewer` definido no diretório `agents/` do plugin. Configurações de `settings.json` têm prioridade sobre `settings` declarados em `plugin.json`. Chaves desconhecidas são silenciosamente ignoradas.
300
301<h3 id="organize-complex-plugins">
302 Organize plugins complexos
303</h3>
304
305Para plugins com muitos componentes, organize sua estrutura de diretório por funcionalidade. Para layouts de diretório completos e padrões de organização, veja [Estrutura de diretório do plugin](/docs/pt/plugins-reference#plugin-directory-structure).
306
307<h3 id="test-your-plugins-locally">
308 Teste seus plugins localmente
309</h3>
310
311Use a flag `--plugin-dir` para testar plugins durante o desenvolvimento. Isso carrega seu plugin diretamente sem exigir instalação.
312
313```bash theme={null}
314claude --plugin-dir ./my-plugin
315```
316
317A flag também aceita um arquivo `.zip` do diretório do plugin.
318
319```bash theme={null}
320claude --plugin-dir ./my-plugin.zip
321```
322
323Quando um plugin `--plugin-dir` tem o mesmo nome que um plugin marketplace instalado, a cópia local tem precedência para essa sessão. Isso permite que você teste mudanças em um plugin que você já tem instalado sem desinstalá-lo primeiro. A exceção é plugins que configurações gerenciadas forçadamente habilitam ou desabilitam: `--plugin-dir` não pode substituir aqueles.
324
325Conforme você faz mudanças no seu plugin, execute `/reload-plugins` para pegar as atualizações sem reiniciar. Isso recarrega plugins, skills, agents, hooks, plugin MCP servers e plugin LSP servers; em uma sessão sem um terminal interativo, mudanças de plugin MCP server [aguardam sua próxima sessão](/docs/pt/discover-plugins#apply-plugin-changes-without-restarting). Teste seus componentes de plugin:
326
327* Tente seus skills com `/plugin-name:skill-name`
328* Verifique que agents aparecem em `/context` sob Custom Agents, ou @-mencione um pelo seu nome com escopo
329* Dispare o evento que cada hook corresponde, como pedir ao Claude para editar um arquivo para um hook `PostToolUse`, e confirme seu efeito. Claude Code registra quais hooks corresponderam, seus códigos de saída e sua saída no [log de depuração](/docs/pt/hooks#debug-hooks)
330
331<Tip>
332 Você pode carregar múltiplos plugins de uma vez especificando a flag múltiplas vezes:
333
334 ```bash theme={null}
335 claude --plugin-dir ./plugin-one --plugin-dir ./plugin-two
336 ```
337
338 Para testar um plugin junto com um plugin do qual ele depende, veja [Teste um plugin e sua dependência localmente](/docs/pt/plugin-dependencies#test-a-plugin-and-its-dependency-locally).
339</Tip>
340
341Para carregar plugins em uma sessão onde você não pode adicionar a flag, liste seus caminhos absolutos na variável de ambiente [`CLAUDE_CODE_PLUGIN_DIRS`](/docs/pt/env-vars#variables) em vez disso. Claude Code carrega cada caminho conforme carrega um caminho `--plugin-dir`. Esses plugins carregam além de qualquer um que você passar com `--plugin-dir`. [Configurações de projeto e local não podem definir essa variável](/docs/pt/settings-reference#variables-claude-code-ignores-in-env). `CLAUDE_CODE_PLUGIN_DIRS` requer Claude Code v2.1.280 ou posterior.
342
343Tentar o plugin com `--plugin-dir` diz a você que ele pode funcionar. Para descobrir com que frequência Claude realmente o alcança e obtém o resultado correto, execute-o contra um conjunto de prompts de teste com [`claude plugin eval`](/docs/pt/plugin-evals). Cada prompt é executado várias vezes com e sem o plugin carregado, para que você possa ver o que o plugin contribui e detectar regressões quando você o altera ou um novo modelo é lançado.
344
345Para carregar vários plugins de um único lugar, passe uma pasta que os contém, como `--plugin-dir ./plugins`. Carregar uma pasta de plugins requer Claude Code v2.1.265 ou posterior. Claude Code lê o nível superior da pasta para decidir quais plugins carregam, e em uma sessão interativa também observa a pasta para mudanças posteriores:
346
347* **O que carrega**: se a pasta não tem um manifesto ou componentes de plugin em seu nível superior, Claude Code a trata como uma pasta de plugins. Cada subpasta imediata que tem um manifesto `.claude-plugin/plugin.json` carrega como um plugin separado. Claude Code ignora tudo mais na pasta sem relatar um erro, incluindo plugins que não têm um manifesto.
348* **Mudanças durante uma sessão interativa**: uma subpasta que você adiciona carrega como um novo plugin uma vez que seu manifesto está em lugar, e quando você remove uma subpasta, seu plugin descarrega. Claude Code imprime uma linha na sessão para cada mudança. Se aplicar uma mudança no meio da conversa [invalidaria o prompt cache](/docs/pt/prompt-caching#enabling-or-disabling-a-plugin), Claude Code a mantém, e a linha diz para executar `/reload-plugins` para aplicá-la.
349
350Para testar um plugin que já está empacotado como um arquivo `.zip` e hospedado em uma URL, como um artefato de compilação de CI, use `--plugin-url` em vez disso. Claude Code busca o arquivo no início e o carrega apenas para essa sessão. Se Claude Code não conseguir buscar o arquivo, ou o arquivo for inválido, ele inicia sem o plugin e registra um erro de carregamento de plugin que você pode revisar na aba **Errors** do gerenciador `/plugin`. As mesmas [considerações de confiança](/docs/pt/discover-plugins#security) se aplicam como para qualquer fonte de plugin: apenas aponte esse flag para arquivos que você controla ou confia.
351
352Para carregar múltiplos plugins, repita a flag para cada URL:
353
354```bash theme={null}
355claude --plugin-url https://example.com/my-plugin.zip --plugin-url https://example.com/other.zip
356```
357
358Ou passe URLs separadas por espaço como um argumento entre aspas:
359
360```bash theme={null}
361claude --plugin-url "https://example.com/my-plugin.zip https://example.com/other.zip"
362```
363
364<h3 id="debug-plugin-issues">
365 Depure problemas de plugin
366</h3>
367
368Se seu plugin não está funcionando como esperado:
369
3701. **Verifique a estrutura**: Certifique-se de que seus diretórios estão na raiz do plugin, não dentro de `.claude-plugin/`
3712. **Teste componentes individualmente**: Verifique cada skill, agent e hook separadamente
3723. **Use ferramentas de validação e depuração**: Veja [Ferramentas de depuração e desenvolvimento](/docs/pt/plugins-reference#debugging-and-development-tools) para comandos CLI e técnicas de troubleshooting
373
374<h3 id="share-your-plugins">
375 Compartilhe seus plugins
376</h3>
377
378Quando seu plugin estiver pronto para compartilhar:
379
3801. **Adicione documentação**: Inclua um `README.md` com instruções de instalação e uso
3812. **Escolha uma estratégia de versionamento**: Decida se deve definir uma `version` explícita ou confiar no fallback descrito em [gerenciamento de versão](/docs/pt/plugins-reference#version-management).
3823. **Crie ou use um marketplace**: Distribua através de [marketplaces de plugins](/docs/pt/plugin-marketplaces) para instalação
3834. **Teste com outros**: Tenha membros da equipe testarem o plugin antes de distribuição mais ampla
384
385Uma vez que seu plugin está em um marketplace, outros podem instalá-lo usando as instruções em [Descobrir e instalar plugins](/docs/pt/discover-plugins). Para manter um plugin interno à sua equipe, hospede o marketplace em um [repositório privado](/docs/pt/plugin-marketplaces#private-repositories).
386
387<h3 id="submit-your-plugin-to-the-community-marketplace">
388 Envie seu plugin para o marketplace da comunidade
389</h3>
390
391A Anthropic mantém dois marketplaces públicos para plugins do Claude Code:
392
393* **`claude-plugins-official`**: um conjunto curado de plugins mantidos pela Anthropic. Claude Code o registra automaticamente na primeira vez que você inicia Claude Code interativamente. Se você executar Claude Code não-interativamente antes desse primeiro lançamento interativo, ou uma [política de marketplace](/docs/pt/plugin-marketplaces#managed-marketplace-restrictions) bloqueou uma tentativa anterior, registre-o você mesmo com `claude plugin marketplace add anthropics/claude-plugins-official`.
394* **`claude-community`**: o marketplace público da comunidade onde envios de terceiros chegam após revisão. Os usuários o adicionam com `/plugin marketplace add anthropics/claude-plugins-community` e instalam a partir dele como `@claude-community`.
395
396Para enviar seu plugin para revisão do marketplace da comunidade, use um dos formulários no aplicativo:
397
398* **claude.ai**: [claude.ai/admin-settings/directory/submissions/plugins/new](https://claude.ai/admin-settings/directory/submissions/plugins/new)
399* **Console**: [platform.claude.com/plugins/submit](https://platform.claude.com/plugins/submit)
400
401O formulário claude.ai requer uma organização Team ou Enterprise e acesso ao gerenciamento de diretório; proprietários de organização têm esse acesso por padrão. Autores individuais que não fazem parte de uma organização Team ou Enterprise podem usar o formulário Console em vez disso.
402
403Execute `claude plugin validate ./your-plugin` localmente antes de enviar, substituindo `./your-plugin` pelo caminho para seu diretório de plugin. O pipeline de revisão executa a mesma verificação em cada envio, junto com triagem de segurança automatizada. Quando a validação passa, Claude Code imprime `✔ Validation passed`, ou `✔ Validation passed with warnings` se houver avisos. Avisos não falham na validação; adicione `--strict` para tratá-los como erros.
404
405Plugins aprovados são fixados a um SHA de commit específico no catálogo [`anthropics/claude-plugins-community`](https://github.com/anthropics/claude-plugins-community), e CI aumenta o pino automaticamente conforme você envia novos commits para seu repositório. O catálogo público sincroniza todas as noites a partir do pipeline de revisão, então pode haver um atraso entre aprovação e seu plugin aparecer em `marketplace.json`. Para verificar se seu plugin já é instalável, procure por seu nome no [catálogo da comunidade](https://github.com/anthropics/claude-plugins-community/blob/main/.claude-plugin/marketplace.json).
406
407O marketplace oficial, `claude-plugins-official`, é curado separadamente. A Anthropic decide quais plugins incluir a seu critério. Não há processo de aplicação, e o formulário de envio não adiciona plugins ao marketplace oficial.
408
409Se a Anthropic listar seu plugin no marketplace oficial, seu CLI pode solicitar aos usuários do Claude Code que o instalem. Veja [Recomende seu plugin a partir de seu CLI](/docs/pt/plugin-hints).
410
411<h2 id="convert-existing-configurations-to-plugins">
412 Converta configurações existentes para plugins
413</h2>
414
415Se você já tem skills ou hooks em seu diretório `.claude/`, você pode convertê-los em um plugin para compartilhamento e distribuição mais fáceis.
416
417<h3 id="migration-steps">
418 Passos de migração
419</h3>
420
421<Steps>
422 <Step title="Crie a estrutura do plugin">
423 Crie um novo diretório de plugin na raiz do seu projeto, ao lado da pasta `.claude/` existente, para que os caminhos relativos `cp` na próxima etapa sejam resolvidos:
424
425 ```bash theme={null}
426 mkdir -p my-plugin/.claude-plugin
427 ```
428
429 Crie o arquivo de manifesto em `my-plugin/.claude-plugin/plugin.json`:
430
431 ```json my-plugin/.claude-plugin/plugin.json theme={null}
432 {
433 "name": "my-plugin",
434 "description": "Migrated from standalone configuration",
435 "version": "1.0.0"
436 }
437 ```
438 </Step>
439
440 <Step title="Copie seus arquivos existentes">
441 Copie cada diretório de configuração que você tem para a raiz do plugin. Você pode não ter todos os três: se um diretório não existir, `cp` imprime `No such file or directory` e não copia nada, então pule esse comando ou ignore o erro.
442
443 ```bash theme={null}
444 cp -r .claude/commands my-plugin/
445
446 cp -r .claude/agents my-plugin/
447
448 cp -r .claude/skills my-plugin/
449 ```
450
451 Seu plugin agora contém cópias dos diretórios que você tinha sob `.claude/`. Execute `ls my-plugin` para confirmar: você deve ver cada diretório que copiou.
452 </Step>
453
454 <Step title="Migre hooks">
455 Se você tem hooks em suas configurações, crie um diretório de hooks:
456
457 ```bash theme={null}
458 mkdir my-plugin/hooks
459 ```
460
461 Crie `my-plugin/hooks/hooks.json` com sua configuração de hooks. Copie o objeto `hooks` de seu `.claude/settings.json` ou `settings.local.json`, já que o formato é o mesmo. O comando recebe entrada de hook como JSON em stdin, então use `jq` para extrair o caminho do arquivo:
462
463 ```json my-plugin/hooks/hooks.json theme={null}
464 {
465 "hooks": {
466 "PostToolUse": [
467 {
468 "matcher": "Write|Edit",
469 "hooks": [{ "type": "command", "command": "jq -r '.tool_input.file_path' | xargs npm run lint:fix" }]
470 }
471 ]
472 }
473 }
474 ```
475 </Step>
476
477 <Step title="Teste seu plugin migrado">
478 Carregue seu plugin para verificar se tudo funciona:
479
480 ```bash theme={null}
481 claude --plugin-dir ./my-plugin
482 ```
483
484 Teste cada componente: execute seus comandos, verifique que agents aparecem em `/context`, e dispare o evento que cada hook corresponde para confirmar seu efeito. Claude Code registra quais hooks corresponderam e como saíram no [log de depuração](/docs/pt/hooks#debug-hooks).
485 </Step>
486</Steps>
487
488<h3 id="what-changes-when-migrating">
489 O que muda ao migrar
490</h3>
491
492| Independente (`.claude/`) | Plugin |
493| :---------------------------------------- | :-------------------------------------- |
494| Disponível apenas em um projeto | Pode ser compartilhado via marketplaces |
495| Arquivos em `.claude/commands/` | Arquivos em `plugin-name/commands/` |
496| Hooks em `settings.json` | Hooks em `hooks/hooks.json` |
497| Deve copiar manualmente para compartilhar | Instale com `/plugin install` |
498
499<Note>
500 Após migrar, remova os arquivos originais de `.claude/` para evitar duplicatas. As definições de agents em `.claude/agents/` do projeto e do usuário substituem agents com o mesmo nome do plugin, portanto a versão do plugin só entra em vigor uma vez que os originais são removidos. Skills de plugin são nomeados como `/plugin-name:skill-name`, portanto o `/skill-name` original e a cópia do plugin permanecem disponíveis em vez de um substituir o outro.
501</Note>
502
503<h2 id="next-steps">
504 Próximos passos
505</h2>
506
507Agora que você entende o sistema de plugins do Claude Code, aqui estão caminhos sugeridos para diferentes objetivos:
508
509<h3 id="for-plugin-users">
510 Para usuários de plugins
511</h3>
512
513* [Descobrir e instalar plugins](/docs/pt/discover-plugins): navegue em marketplaces e instale plugins
514* [Configurar marketplaces de equipe](/docs/pt/discover-plugins#configure-team-marketplaces): configure plugins no nível do repositório para sua equipe
515
516<h3 id="for-plugin-developers">
517 Para desenvolvedores de plugins
518</h3>
519
520* [Testar plugins com evals](/docs/pt/plugin-evals): meça o que seu plugin muda e gate CI nele
521* [Criar e distribuir um marketplace](/docs/pt/plugin-marketplaces): empacote e compartilhe seus plugins
522* [Referência de plugins](/docs/pt/plugins-reference): especificações técnicas completas
523* Mergulhe mais fundo em componentes específicos do plugin:
524 * [Skills](/docs/pt/skills): detalhes de desenvolvimento de skill
525 * [Subagents](/docs/pt/sub-agents): configuração e capacidades de agent
526 * [Hooks](/docs/pt/hooks): manipulação de eventos e automação
527 * [MCP](/docs/pt/mcp): integração de ferramentas externas