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# Crear plugins
6
7> Crea plugins personalizados para extender Claude Code con skills, agentes, hooks y servidores MCP.
8
9Los plugins le permiten extender Claude Code con funcionalidad personalizada que se puede compartir entre proyectos y equipos. Esta guía cubre la creación de sus propios plugins con skills, agentes, hooks y servidores MCP.
10
11¿Buscando instalar plugins existentes? Consulte [Descubrir e instalar plugins](/docs/es/discover-plugins). Para especificaciones técnicas completas, consulte [Referencia de plugins](/docs/es/plugins-reference).
12
13<h2 id="when-to-use-plugins-vs-standalone-configuration">
14 Cuándo usar plugins versus configuración independiente
15</h2>
16
17Claude Code admite dos formas de agregar skills, agentes y hooks personalizados:
18
19| Enfoque | Nombres de skills | Mejor para |
20| :------------------------------------------------------------------------------------------------ | :------------------- | :--------------------------------------------------------------------------------------------------------------------------- |
21| **Independiente** (directorio `.claude/`) | `/hello` | Flujos de trabajo personales, personalizaciones específicas del proyecto, experimentos rápidos |
22| **Plugins** (directorios con skills, agentes, hooks o un manifiesto `.claude-plugin/plugin.json`) | `/plugin-name:hello` | Compartir con compañeros de equipo, distribuir a la comunidad, lanzamientos versionados, reutilizable en múltiples proyectos |
23
24<Tip>
25 Comience con configuración independiente en `.claude/` para iteración rápida, luego [convierta a un plugin](#convert-existing-configurations-to-plugins) cuando esté listo para compartir.
26</Tip>
27
28<h2 id="quickstart">
29 Inicio rápido
30</h2>
31
32Este inicio rápido le guía a través de la creación de un plugin con un skill personalizado. Creará un manifiesto (el archivo de configuración que define su plugin), agregará un skill y lo probará localmente usando la bandera `--plugin-dir`.
33
34<h3 id="prerequisites">
35 Requisitos previos
36</h3>
37
38* Claude Code [instalado y autenticado](/docs/es/quickstart#step-1-install-claude-code)
39
40<h3 id="create-your-first-plugin">
41 Cree su primer plugin
42</h3>
43
44<Steps>
45 <Step title="Cree el directorio del plugin">
46 Cada plugin vive en su propio directorio que contiene sus skills, agentes o hooks, opcionalmente junto con un manifiesto `.claude-plugin/plugin.json`. La ubicación no importa para este inicio rápido porque apuntará Claude Code al directorio con `--plugin-dir` en el paso de prueba. Créelo en cualquier lugar conveniente, como una carpeta temporal o un directorio de proyectos:
47
48 ```bash theme={null}
49 mkdir my-first-plugin
50 ```
51
52 Los pasos restantes se ejecutan desde el directorio padre y hacen referencia a rutas como `my-first-plugin/...` relativas a él.
53 </Step>
54
55 <Step title="Cree el manifiesto del plugin">
56 El archivo de manifiesto en `.claude-plugin/plugin.json` define la identidad de su plugin: su nombre, descripción y versión. Claude Code usa estos metadatos para mostrar su plugin en el administrador de plugins.
57
58 Cree el directorio `.claude-plugin` dentro de su carpeta de plugin:
59
60 ```bash theme={null}
61 mkdir my-first-plugin/.claude-plugin
62 ```
63
64 Luego cree `my-first-plugin/.claude-plugin/plugin.json` con este contenido:
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 y espacio de nombres de skill. Los skills tienen este prefijo (por ejemplo, `/my-first-plugin:hello`). |
80 | `description` | Se muestra en el administrador de plugins al examinar o instalar plugins. |
81 | `version` | Opcional. Si se establece, los usuarios solo reciben actualizaciones cuando usted incrementa este campo, excepto para una [fuente `command`](/docs/es/plugin-marketplaces#command-sources) o un plugin [cargado en su lugar](/docs/es/plugins-reference#plugin-caching-and-file-resolution); consulte [gestión de versiones](/docs/es/plugins-reference#version-management). Si se omite, la versión proviene de la siguiente fuente en [gestión de versiones](/docs/es/plugins-reference#version-management). |
82 | `author` | Opcional. Útil para atribución. |
83
84 Para campos adicionales como `homepage`, `repository` y `license`, consulte el [esquema de manifiesto completo](/docs/es/plugins-reference#plugin-manifest-schema).
85 </Step>
86
87 <Step title="Agregue un skill">
88 Los skills viven en el directorio `skills/`. Cada skill es una carpeta que contiene un archivo `SKILL.md`. El nombre de la carpeta se convierte en el nombre del skill, con el prefijo del espacio de nombres del plugin (`hello/` en un plugin llamado `my-first-plugin` crea `/my-first-plugin:hello`).
89
90 Cree un directorio de skill en su carpeta de plugin:
91
92 ```bash theme={null}
93 mkdir -p my-first-plugin/skills/hello
94 ```
95
96 Luego cree `my-first-plugin/skills/hello/SKILL.md` con este contenido:
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="Pruebe su plugin">
109 Ejecute Claude Code con la bandera `--plugin-dir` para cargar su plugin:
110
111 ```bash theme={null}
112 claude --plugin-dir ./my-first-plugin
113 ```
114
115 Una vez que Claude Code se inicie, pruebe su nuevo skill:
116
117 ```shell theme={null}
118 /my-first-plugin:hello
119 ```
120
121 Verá que Claude responde con un saludo. Ejecute `/help` y abra la pestaña **Comandos personalizados** para ver su skill listado bajo el espacio de nombres del plugin.
122
123 <Note>
124 **¿Por qué espacios de nombres?** Los skills de plugin siempre tienen espacios de nombres (como `/my-first-plugin:hello`) para prevenir conflictos cuando múltiples plugins tienen skills con el mismo nombre.
125
126 Para cambiar el prefijo del espacio de nombres, actualice el campo `name` en `plugin.json`.
127 </Note>
128 </Step>
129
130 <Step title="Agregue argumentos de skill">
131 Haga su skill dinámico aceptando entrada del usuario. El marcador de posición `$ARGUMENTS` captura cualquier texto que el usuario proporcione después del nombre del skill.
132
133 Actualice su archivo `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 Ejecute `/reload-plugins` para recoger los cambios. Luego pruebe el skill con su nombre:
146
147 ```shell theme={null}
148 /my-first-plugin:hello Alex
149 ```
150
151 Claude le saludará por su nombre. Para más información sobre pasar argumentos a skills, consulte [Skills](/docs/es/skills#pass-arguments-to-skills).
152 </Step>
153</Steps>
154
155<Tip>
156 La bandera `--plugin-dir` es útil para desarrollo y pruebas. Cuando esté listo para compartir su plugin con otros, consulte [Crear y distribuir un marketplace de plugins](/docs/es/plugin-marketplaces).
157</Tip>
158
159<h2 id="develop-a-plugin-in-your-skills-directory">
160 Desarrolle un plugin en su directorio de skills
161</h2>
162
163En lugar de pasar `--plugin-dir` en cada lanzamiento, puede mantener un plugin en su directorio de skills y hacer que Claude Code lo cargue automáticamente. `claude plugin init` lo estructura:
164
165```bash theme={null}
166claude plugin init my-tool
167```
168
169Esto crea `~/.claude/skills/my-tool/` con un manifiesto `.claude-plugin/plugin.json` y un `SKILL.md` inicial. En la siguiente sesión se carga como `my-tool@skills-dir` sin necesidad de marketplace o paso de instalación.
170
171Para las reglas de carga automática, alcance personal versus de proyecto, el requisito de confianza del espacio de trabajo y cómo actualizar o eliminar uno, consulte [Plugins del directorio de skills](/docs/es/plugins-reference#skills-directory-plugins).
172
173<h2 id="plugin-structure-overview">
174 Descripción general de la estructura del plugin
175</h2>
176
177Ha creado un plugin con un skill, pero los plugins pueden incluir mucho más: agentes personalizados, hooks, servidores MCP, servidores LSP y monitores de fondo.
178
179<Warning>
180 **Error común**: No ponga `commands/`, `agents/`, `skills/` o `hooks/` dentro del directorio `.claude-plugin/`. Solo `plugin.json` va dentro de `.claude-plugin/`. Todos los otros directorios deben estar en el nivel raíz del plugin.
181
182 La raíz del plugin es el directorio propio del plugin individual, como `my-first-plugin/` del [inicio rápido](#quickstart). Nunca es `~/.claude/`. Por ejemplo, Claude Code no lee un `.mcp.json` colocado en `~/.claude/.mcp.json`.
183</Warning>
184
185| Directorio | Ubicación | Propósito |
186| :---------------- | :-------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
187| `.claude-plugin/` | Raíz del plugin | Contiene el manifiesto `plugin.json` (opcional si los componentes usan ubicaciones predeterminadas) |
188| `skills/` | Raíz del plugin | Skills como directorios `<name>/SKILL.md` |
189| `commands/` | Raíz del plugin | Skills como archivos Markdown planos. Use `skills/` para plugins nuevos |
190| `agents/` | Raíz del plugin | Definiciones de agentes personalizados |
191| `hooks/` | Raíz del plugin | Manejadores de eventos en `hooks.json` |
192| `.mcp.json` | Raíz del plugin | Configuraciones de servidor MCP |
193| `.lsp.json` | Raíz del plugin | Configuraciones de servidor LSP para inteligencia de código |
194| `monitors/` | Raíz del plugin | Configuraciones de monitor de fondo en `monitors.json` |
195| `bin/` | Raíz del plugin | Ejecutables agregados a la `PATH` de la herramienta Bash mientras el plugin está habilitado. No puede incluir este directorio en un plugin que [distribuya a través de la configuración de la organización de claude.ai](/docs/es/plugin-marketplaces#keep-executables-out-of-the-top-level-bin-directory) |
196| `settings.json` | Raíz del plugin | [Configuraciones](/docs/es/settings) predeterminadas aplicadas cuando el plugin está habilitado |
197
198Un plugin que incluye exactamente un skill puede colocar `SKILL.md` directamente en la raíz del plugin en lugar de crear un directorio `skills/`. Claude Code lo carga como un único skill y utiliza el campo `name` del frontmatter para el nombre de invocación. Use el diseño `skills/` para plugins que pueden crecer a más de un skill.
199
200<h2 id="develop-more-complex-plugins">
201 Desarrollar plugins más complejos
202</h2>
203
204Una vez que se sienta cómodo con plugins básicos, puede crear extensiones más sofisticadas.
205
206<h3 id="add-skills-to-your-plugin">
207 Agregue Skills a su plugin
208</h3>
209
210Los plugins pueden incluir [Agent Skills](/docs/es/skills) para extender las capacidades de Claude. Los skills son invocados por el modelo: Claude los usa automáticamente basándose en el contexto de la tarea.
211
212Agregue un directorio `skills/` en la raíz de su plugin con carpetas de Skill que contengan archivos `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` contiene frontmatter YAML e instrucciones. Incluya una `description` para que Claude sepa cuándo usar el 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
235Después de instalar el plugin, verifique el resumen de instalación: si reporta `Run /reload-plugins to activate.`, consulte [Aplicar cambios de plugin sin reiniciar](/docs/es/discover-plugins#apply-plugin-changes-without-restarting) para cargar los Skills en su sesión actual. Para orientación completa sobre la autoría de Skills incluyendo divulgación progresiva y restricciones de herramientas, consulte [Agent Skills](/docs/es/skills).
236
237<h3 id="add-lsp-servers-to-your-plugin">
238 Agregue servidores LSP a su plugin
239</h3>
240
241<Tip>
242 Para lenguajes comunes como TypeScript, Python y Rust, instale los plugins LSP precompilados desde el marketplace oficial. Cree plugins LSP personalizados solo cuando necesite soporte para lenguajes que aún no están cubiertos.
243</Tip>
244
245Los plugins LSP (Language Server Protocol) dan a Claude inteligencia de código en tiempo real. Si necesita soportar un lenguaje que no tiene un plugin LSP oficial, puede crear uno propio agregando un archivo `.lsp.json` a su 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
259Los usuarios que instalen su plugin deben tener el binario del servidor de lenguaje instalado en su máquina.
260
261Para confirmar que el servidor se inicia, inicie Claude Code con el plugin habilitado y verifique la pestaña Errores de `/plugin`: un servidor de lenguaje que no se inicia aparece allí, por ejemplo con `Executable not found in $PATH` cuando el binario no está instalado. Una entrada con una configuración inválida se omite en su lugar; ejecute `claude --debug` para ver por qué.
262
263Para opciones de configuración LSP completas, consulte [Servidores LSP](/docs/es/plugins-reference#lsp-servers).
264
265<h3 id="add-background-monitors-to-your-plugin">
266 Agregue monitores de fondo a su plugin
267</h3>
268
269Los monitores de fondo permiten que su plugin observe registros, archivos o estado externo en el fondo y notifique a Claude cuando lleguen eventos. Claude Code inicia cada monitor automáticamente cuando el plugin está activo, por lo que no necesita instruir a Claude para que inicie la observación.
270
271Agregue un archivo `monitors/monitors.json` en la raíz del plugin con una matriz 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 línea de stdout del `command` se entrega a Claude como una notificación durante la sesión. Para el esquema completo, incluyendo el disparador `when` y la sustitución de variables, consulte [Monitors](/docs/es/plugins-reference#monitors).
284
285<h3 id="ship-default-settings-with-your-plugin">
286 Envíe configuraciones predeterminadas con su plugin
287</h3>
288
289Los plugins pueden incluir un archivo `settings.json` en la raíz del plugin para aplicar configuración predeterminada cuando el plugin está habilitado. Actualmente, solo se admiten las claves `agent` y `subagentStatusLine`.
290
291Establecer `agent` activa uno de los [agentes personalizados](/docs/es/sub-agents) del plugin como el hilo principal, aplicando su indicación del sistema, restricciones de herramientas y modelo. Esto permite que un plugin cambie cómo se comporta Claude Code por defecto cuando está habilitado.
292
293```json settings.json theme={null}
294{
295 "agent": "security-reviewer"
296}
297```
298
299Este ejemplo activa el agente `security-reviewer` definido en el directorio `agents/` del plugin. Las configuraciones de `settings.json` tienen prioridad sobre `settings` declarados en `plugin.json`. Las claves desconocidas se ignoran silenciosamente.
300
301<h3 id="organize-complex-plugins">
302 Organice plugins complejos
303</h3>
304
305Para plugins con muchos componentes, organice su estructura de directorios por funcionalidad. Para diseños de directorios completos y patrones de organización, consulte [Estructura de directorios del plugin](/docs/es/plugins-reference#plugin-directory-structure).
306
307<h3 id="test-your-plugins-locally">
308 Pruebe sus plugins localmente
309</h3>
310
311Use la bandera `--plugin-dir` para probar plugins durante el desarrollo. Esto carga su plugin directamente sin requerir instalación.
312
313```bash theme={null}
314claude --plugin-dir ./my-plugin
315```
316
317La bandera también acepta un archivo `.zip` del directorio del plugin.
318
319```bash theme={null}
320claude --plugin-dir ./my-plugin.zip
321```
322
323Cuando un plugin `--plugin-dir` tiene el mismo nombre que un plugin de marketplace instalado, la copia local tiene prioridad para esa sesión. Esto le permite probar cambios en un plugin que ya tiene instalado sin desinstalarlo primero. La excepción son los plugins cuyas configuraciones administradas fuerzan la habilitación o deshabilitación: `--plugin-dir` no puede anular esos.
324
325A medida que haga cambios en su plugin, ejecute `/reload-plugins` para recoger las actualizaciones sin reiniciar. Esto recarga plugins, skills, agentes, hooks, servidores MCP de plugin y servidores LSP de plugin; en una sesión sin una terminal interactiva, los cambios del servidor MCP de plugin [esperan su próxima sesión](/docs/es/discover-plugins#apply-plugin-changes-without-restarting). Pruebe los componentes de su plugin:
326
327* Pruebe sus skills con `/plugin-name:skill-name`
328* Verifique que los agentes aparezcan en `/context` bajo Agentes Personalizados, o mencione uno con @-mention por su nombre con alcance
329* Dispare el evento que cada hook coincide, como pedirle a Claude que edite un archivo para un hook `PostToolUse`, y confirme su efecto. Claude Code registra qué hooks coincidieron, sus códigos de salida y su salida en el [registro de depuración](/docs/es/hooks#debug-hooks)
330
331<Tip>
332 Puede cargar múltiples plugins a la vez especificando la bandera varias veces:
333
334 ```bash theme={null}
335 claude --plugin-dir ./plugin-one --plugin-dir ./plugin-two
336 ```
337
338 Para probar un plugin junto con un plugin del que depende, consulte [Pruebe un plugin y su dependencia localmente](/docs/es/plugin-dependencies#test-a-plugin-and-its-dependency-locally).
339</Tip>
340
341Para cargar plugins en una sesión donde no puede agregar la bandera, liste sus rutas absolutas en la variable de entorno [`CLAUDE_CODE_PLUGIN_DIRS`](/docs/es/env-vars#variables). Claude Code carga cada ruta como carga una ruta `--plugin-dir`. Estos plugins se cargan además de cualquiera que pase con `--plugin-dir`. [Las configuraciones de proyecto y local no pueden establecer esta variable](/docs/es/settings-reference#variables-claude-code-ignores-in-env). `CLAUDE_CODE_PLUGIN_DIRS` requiere Claude Code v2.1.280 o posterior.
342
343Probar el plugin con `--plugin-dir` le indica que puede funcionar. Para averiguar con qué frecuencia Claude realmente lo utiliza y obtiene el resultado correcto, ejecútelo contra un conjunto de indicaciones de prueba con [`claude plugin eval`](/docs/es/plugin-evals). Cada indicación se ejecuta varias veces con y sin el plugin cargado, para que pueda ver qué contribuye el plugin y detectar regresiones cuando lo cambia o se envía un nuevo modelo.
344
345Para cargar varios plugins desde un lugar, pase una carpeta que los contenga, como `--plugin-dir ./plugins`. Cargar una carpeta de plugins requiere Claude Code v2.1.265 o posterior. Claude Code lee el nivel superior de la carpeta para decidir qué plugins se cargan, y en una sesión interactiva también observa la carpeta para cambios posteriores:
346
347* **Lo que se carga**: si la carpeta no tiene un manifiesto o componentes de plugin en su nivel superior, Claude Code la trata como una carpeta de plugins. Cada subcarpeta inmediata que tenga un manifiesto `.claude-plugin/plugin.json` se carga como un plugin separado. Claude Code omite todo lo demás en la carpeta sin reportar un error, incluyendo plugins que no tienen manifiesto.
348* **Cambios durante una sesión interactiva**: una subcarpeta que agregue se carga como un nuevo plugin una vez que su manifiesto esté en su lugar, y cuando elimine una subcarpeta, su plugin se descarga. Claude Code imprime una línea en la sesión para cada cambio. Si aplicar un cambio a mitad de la conversación [invalidaría el caché de indicaciones](/docs/es/prompt-caching#enabling-or-disabling-a-plugin), Claude Code lo retiene, y la línea dice ejecutar `/reload-plugins` para aplicarlo.
349
350Para probar un plugin que ya está empaquetado como un archivo `.zip` y alojado en una URL, como un artefacto de compilación de CI, use `--plugin-url` en su lugar. Claude Code obtiene el archivo al inicio y lo carga solo para esa sesión. Si Claude Code no puede obtener el archivo, o el archivo no es válido, se inicia sin el plugin y registra un error de carga de plugin que puede revisar en la pestaña **Errores** del administrador `/plugin`. Las mismas [consideraciones de confianza](/docs/es/discover-plugins#security) se aplican como para cualquier fuente de plugin: solo apunte esta bandera a archivos que controle o en los que confíe.
351
352Para cargar múltiples plugins, repita la bandera 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
358O pase URLs separadas por espacios como un argumento entrecomillado:
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 del plugin
366</h3>
367
368Si su plugin no funciona como se espera:
369
3701. **Verifique la estructura**: Asegúrese de que sus directorios estén en la raíz del plugin, no dentro de `.claude-plugin/`
3712. **Pruebe componentes individualmente**: Verifique cada skill, agente y hook por separado
3723. **Use herramientas de validación y depuración**: Consulte [Herramientas de depuración y desarrollo](/docs/es/plugins-reference#debugging-and-development-tools) para comandos CLI y técnicas de solución de problemas
373
374<h3 id="share-your-plugins">
375 Comparta sus plugins
376</h3>
377
378Cuando su plugin esté listo para compartir:
379
3801. **Agregue documentación**: Incluya un `README.md` con instrucciones de instalación y uso
3812. **Elija una estrategia de versionado**: Decida si establecer una `version` explícita o confiar en la descrita en [gestión de versiones](/docs/es/plugins-reference#version-management).
3823. **Cree o use un marketplace**: Distribuya a través de [marketplaces de plugins](/docs/es/plugin-marketplaces) para instalación
3834. **Pruebe con otros**: Haga que los miembros del equipo prueben el plugin antes de una distribución más amplia
384
385Una vez que su plugin esté en un marketplace, otros pueden instalarlo usando las instrucciones en [Descubrir e instalar plugins](/docs/es/discover-plugins). Para mantener un plugin interno en su equipo, aloje el marketplace en un [repositorio privado](/docs/es/plugin-marketplaces#private-repositories).
386
387<h3 id="submit-your-plugin-to-the-community-marketplace">
388 Envíe su plugin al marketplace de la comunidad
389</h3>
390
391Anthropic mantiene dos marketplaces públicos para plugins de Claude Code:
392
393* **`claude-plugins-official`**: un conjunto curado de plugins mantenidos por Anthropic. Claude Code lo registra automáticamente la primera vez que inicia Claude Code de forma interactiva. Si ejecuta Claude Code de forma no interactiva antes de ese primer lanzamiento interactivo, o una [política de marketplace](/docs/es/plugin-marketplaces#managed-marketplace-restrictions) bloqueó un intento anterior, regístrelo usted mismo con `claude plugin marketplace add anthropics/claude-plugins-official`.
394* **`claude-community`**: el marketplace público de la comunidad donde los envíos de terceros llegan después de la revisión. Los usuarios lo agregan con `/plugin marketplace add anthropics/claude-plugins-community` e instalan desde él como `@claude-community`.
395
396Para enviar su plugin para revisión del marketplace de la comunidad, use uno de los formularios en la aplicación:
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
401El formulario de claude.ai requiere una organización de Team o Enterprise y acceso a la gestión de directorios; los Propietarios de la organización tienen este acceso por defecto. Los autores individuales que no forman parte de una organización de Team o Enterprise pueden usar el formulario de Console en su lugar.
402
403Ejecute `claude plugin validate ./your-plugin` localmente antes de enviar, reemplazando `./your-plugin` con la ruta a su directorio de plugin. La canalización de revisión ejecuta la misma verificación en cada envío, junto con el análisis de seguridad automatizado. Cuando la validación pasa, Claude Code imprime `✔ Validation passed`, o `✔ Validation passed with warnings` si hay advertencias. Las advertencias no fallan la validación; agregue `--strict` para tratarlas como errores.
404
405Los plugins aprobados se fijan a un SHA de commit específico en el catálogo [`anthropics/claude-plugins-community`](https://github.com/anthropics/claude-plugins-community), y CI actualiza el pin automáticamente a medida que envía nuevos commits a su repositorio. El catálogo público se sincroniza cada noche desde la canalización de revisión, por lo que puede haber un retraso entre la aprobación y que su plugin aparezca en `marketplace.json`. Para verificar si su plugin ya es instalable, busque su nombre en el [catálogo de la comunidad](https://github.com/anthropics/claude-plugins-community/blob/main/.claude-plugin/marketplace.json).
406
407El marketplace oficial, `claude-plugins-official`, se cura por separado. Anthropic decide qué plugins incluir a su discreción. No hay un proceso de solicitud, y el formulario de envío no agrega plugins al marketplace oficial.
408
409Si Anthropic lista su plugin en el marketplace oficial, su CLI puede solicitar a los usuarios de Claude Code que lo instalen. Consulte [Recomienda su plugin desde su CLI](/docs/es/plugin-hints).
410
411<h2 id="convert-existing-configurations-to-plugins">
412 Convierta configuraciones existentes en plugins
413</h2>
414
415Si ya tiene skills o hooks en su directorio `.claude/`, puede convertirlos en un plugin para compartir y distribución más fácil.
416
417<h3 id="migration-steps">
418 Pasos de migración
419</h3>
420
421<Steps>
422 <Step title="Cree la estructura del plugin">
423 Cree un nuevo directorio de plugin en la raíz de su proyecto, junto a la carpeta `.claude/` existente, para que las rutas relativas de `cp` en el siguiente paso se resuelvan:
424
425 ```bash theme={null}
426 mkdir -p my-plugin/.claude-plugin
427 ```
428
429 Cree el archivo de manifiesto en `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 sus archivos existentes">
441 Copie cada directorio de configuración que tenga al directorio raíz del plugin. Es posible que no tenga los tres: si un directorio no existe, `cp` imprime `No such file or directory` y no copia nada, así que omita ese comando o ignore el error.
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 Su plugin ahora contiene copias de los directorios que tenía bajo `.claude/`. Ejecute `ls my-plugin` para confirmar: debería ver cada directorio que copió.
452 </Step>
453
454 <Step title="Migre hooks">
455 Si tiene hooks en su configuración, cree un directorio de hooks:
456
457 ```bash theme={null}
458 mkdir my-plugin/hooks
459 ```
460
461 Cree `my-plugin/hooks/hooks.json` con su configuración de hooks. Copie el objeto `hooks` de su `.claude/settings.json` o `settings.local.json`, ya que el formato es el mismo. El comando recibe entrada de hook como JSON en stdin, así que use `jq` para extraer la ruta del archivo:
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="Pruebe su plugin migrado">
478 Cargue su plugin para verificar que todo funciona:
479
480 ```bash theme={null}
481 claude --plugin-dir ./my-plugin
482 ```
483
484 Pruebe cada componente: ejecute sus comandos, verifique que los agentes aparezcan en `/context`, y active el evento que cada hook coincida para confirmar su efecto. Claude Code registra qué hooks coincidieron y cómo salieron en el [registro de depuración](/docs/es/hooks#debug-hooks).
485 </Step>
486</Steps>
487
488<h3 id="what-changes-when-migrating">
489 Qué cambia al migrar
490</h3>
491
492| Independiente (`.claude/`) | Plugin |
493| :------------------------------------- | :------------------------------------------ |
494| Solo disponible en un proyecto | Se puede compartir a través de marketplaces |
495| Archivos en `.claude/commands/` | Archivos en `plugin-name/commands/` |
496| Hooks en `settings.json` | Hooks en `hooks/hooks.json` |
497| Debe copiar manualmente para compartir | Instalar con `/plugin install` |
498
499<Note>
500 Después de migrar, elimine los archivos originales de `.claude/` para evitar duplicados. Las definiciones de `.claude/agents/` a nivel de proyecto y usuario anulan los agentes del plugin con el mismo nombre, por lo que la versión del plugin solo tiene efecto una vez que se eliminan los originales. Las skills del plugin se espacian de nombres como `/plugin-name:skill-name`, por lo que tanto el `/skill-name` original como la copia del plugin permanecen disponibles en lugar de que uno anule al otro.
501</Note>
502
503<h2 id="next-steps">
504 Próximos pasos
505</h2>
506
507Ahora que entiende el sistema de plugins de Claude Code, aquí hay caminos sugeridos para diferentes objetivos:
508
509<h3 id="for-plugin-users">
510 Para usuarios de plugins
511</h3>
512
513* [Descubrir e instalar plugins](/docs/es/discover-plugins): examine marketplaces e instale plugins
514* [Configure marketplaces de equipo](/docs/es/discover-plugins#configure-team-marketplaces): configure plugins a nivel de repositorio para su equipo
515
516<h3 id="for-plugin-developers">
517 Para desarrolladores de plugins
518</h3>
519
520* [Pruebe plugins con evals](/docs/es/plugin-evals): mida qué cambia su plugin y controle CI en ello
521* [Crear y distribuir un marketplace](/docs/es/plugin-marketplaces): empaquete y comparta sus plugins
522* [Referencia de plugins](/docs/es/plugins-reference): especificaciones técnicas completas
523* Profundice en componentes específicos del plugin:
524 * [Skills](/docs/es/skills): detalles de desarrollo de skills
525 * [Subagents](/docs/es/sub-agents): configuración y capacidades del agente
526 * [Hooks](/docs/es/hooks): manejo de eventos y automatización
527 * [MCP](/docs/es/mcp): integración de herramientas externas