> ## Documentation Index
> Fetch the complete documentation index at: https://cli.fuxicode.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Configuración de Fuxi Code
> Configure Fuxi Code con configuraciones globales y a nivel de proyecto, y variables de entorno.
Fuxi Code ofrece una variedad de configuraciones para personalizar su comportamiento según sus necesidades. Puede configurar Fuxi Code ejecutando el comando `/config`, que abre una interfaz de Configuración con pestañas donde puede ver información de estado y modificar opciones de configuración. {/* min-version: 2.1.181 */}A partir de v2.1.181, puede cambiar una única opción sin abrir la interfaz pasando `key=value` a `/config`, por ejemplo `/config verbose=true`.
Ámbitos de configuración
Fuxi Code utiliza un sistema de ámbitos para determinar dónde se aplican las configuraciones y quién las comparte. Comprender los ámbitos le ayuda a decidir cómo configurar Fuxi Code para uso personal, colaboración en equipo o implementación empresarial.
Ámbitos disponibles
| Ámbito | Ubicación | A quién afecta | ¿Se comparte con el equipo? |
| :---------- | :--------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------- |
| **Managed** | Configuraciones administradas por servidor, plist / registro, o `managed-settings.json` a nivel de sistema | Todos los miembros de la organización para entrega administrada por servidor; todos los usuarios en la máquina para plist, registro HKLM y entrega de archivos; el usuario actual para entrega de registro HKCU | Sí (implementado por TI) |
| **User** | Directorio `~/.fuxi/` | Usted, en todos los proyectos | No |
| **Project** | `.fuxi/` en el repositorio | Todos los colaboradores en este repositorio | Sí (confirmado en git) |
| **Local** | `.fuxi/settings.local.json` | Usted, solo en este repositorio | No (ignorado por git cuando Fuxi Code lo crea) |
Cuándo usar cada ámbito
El **ámbito Managed** es para:
* Políticas de seguridad que deben aplicarse en toda la organización
* Requisitos de cumplimiento que no se pueden anular
* Configuraciones estandarizadas implementadas por TI/DevOps
El **ámbito User** es mejor para:
* Preferencias personales que desea en todas partes (temas, configuración del editor)
* Herramientas y plugins que utiliza en todos los proyectos
* Claves API y autenticación (almacenadas de forma segura)
El **ámbito Project** es mejor para:
* Configuraciones compartidas por el equipo (permisos, hooks, MCP servers)
* Plugins que todo el equipo debe tener
* Estandarizar herramientas entre colaboradores
El **ámbito Local** es mejor para:
* Anulaciones personales para un proyecto específico
* Probar configuraciones antes de compartirlas con el equipo
* Configuraciones específicas de la máquina que no funcionarán para otros
Cómo interactúan los ámbitos
Cuando la misma configuración aparece en múltiples ámbitos, Fuxi Code las aplica en orden de prioridad:
1. **Managed** (más alto): no puede ser anulado por nada
2. **Argumentos de línea de comandos**: anulaciones de sesión temporal
3. **Local**: anula configuraciones de proyecto y usuario
4. **Project**: anula configuraciones de usuario
5. **User** (más bajo): se aplica cuando nada más especifica la configuración
Por ejemplo, si la configuración de usuario establece `spinnerTipsEnabled` en `true` y la configuración de proyecto lo establece en `false`, se aplica el valor del proyecto. Las reglas de permisos se comportan de manera diferente porque se fusionan en todos los ámbitos en lugar de anular. Consulte [Precedencia de configuración](#settings-precedence).
Qué usa ámbitos
Los ámbitos se aplican a muchas características de Fuxi Code:
| Característica | Ubicación de usuario | Ubicación de proyecto | Ubicación local |
| :-------------- | :------------------------ | :-------------------------------- | :------------------------------ |
| **Settings** | `~/.fuxi/settings.json` | `.fuxi/settings.json` | `.fuxi/settings.local.json` |
| **Subagents** | `~/.fuxi/agents/` | `.fuxi/agents/` | Ninguno |
| **MCP servers** | `~/.fuxi.json` | `.mcp.json` | `~/.fuxi.json` (por proyecto) |
| **Plugins** | `~/.fuxi/settings.json` | `.fuxi/settings.json` | `.fuxi/settings.local.json` |
| **FUXI.md** | `~/.fuxi/FUXI.md` | `FUXI.md` o `.fuxi/FUXI.md` | `FUXI.local.md` |
En Windows, las rutas mostradas como `~/.fuxi` se resuelven en `%USERPROFILE%\.fuxi`.
***
Archivos de configuración
El archivo `settings.json` es el mecanismo oficial para configurar Fuxi Code a través de configuraciones jerárquicas:
* **Configuraciones de usuario** se definen en `~/.fuxi/settings.json` y se aplican a todos los proyectos.
* **Configuraciones de proyecto** se guardan en su directorio de proyecto:
* `.fuxi/settings.json` para configuraciones que se verifican en el control de código fuente y se comparten con su equipo
* `.fuxi/settings.local.json` para configuraciones que no se verifican, útil para preferencias personales y experimentación. Cuando Fuxi Code crea `.fuxi/settings.local.json`, configura git para ignorar el archivo. Si crea el archivo usted mismo, agréguelo a su gitignore manualmente.
Debido a que este archivo es suyo en lugar del repositorio, sus reglas de permiso `allow` entran en vigor sin el paso de [confianza del espacio de trabajo](/es/permissions#project-allow-rules-and-workspace-trust) que requieren las reglas de permiso `allow` de `.fuxi/settings.json`. Si el repositorio suministra el archivo, por ejemplo al confirmarlo, la confianza del espacio de trabajo aún se aplica.
* **Configuraciones administradas**: Para organizaciones que necesitan control centralizado, Fuxi Code admite múltiples mecanismos de entrega para configuraciones administradas. Todos utilizan el mismo formato JSON y no pueden ser anulados por configuraciones de usuario o proyecto:
* **Configuraciones administradas por servidor**: entregadas remotamente al iniciar sesión, ya sea desde los servidores de Anthropic a través de la consola de administración de fuxi.ai o desde una [puerta de aplicaciones Fuxi](/es/fuxi-apps-gateway) autohospedada. Consulte [configuraciones administradas por servidor](/es/server-managed-settings).
* **Políticas de MDM/nivel de SO**: entregadas a través de administración de dispositivos nativa en macOS y Windows:
* macOS: dominio de preferencias administradas `com.anthropic.fuxicode`. Las claves de nivel superior del plist reflejan `managed-settings.json`, con configuraciones anidadas como diccionarios y matrices como matrices de plist. Implemente a través de perfiles de configuración en Jamf, Iru (Kandji) u herramientas MDM similares.
* Windows: clave de registro `HKLM\SOFTWARE\Policies\FuxiCode` con un valor `Settings` (REG\_SZ o REG\_EXPAND\_SZ) que contiene JSON (implementado a través de Política de grupo o Intune)
* Windows (nivel de usuario): `HKCU\SOFTWARE\Policies\FuxiCode` (prioridad de política más baja, solo se usa cuando no existe una fuente a nivel de administrador)
* **Basado en archivos**: `managed-settings.json` y `managed-mcp.json` implementados en directorios del sistema:
* macOS: `/Library/Application Support/FuxiCode/`
* Linux y WSL: `/etc/fuxi-code/`
* Windows: `C:\Program Files\FuxiCode\`
La ruta heredada de Windows `C:\ProgramData\FuxiCode\managed-settings.json` ya no se admite a partir de v2.1.75. Los administradores que implementaron configuraciones en esa ubicación deben migrar archivos a `C:\Program Files\FuxiCode\managed-settings.json`.
Las configuraciones administradas basadas en archivos también admiten un directorio de entrega en `managed-settings.d/` en el mismo directorio del sistema junto a `managed-settings.json`. Esto permite que equipos separados implementen fragmentos de política independientes sin coordinar ediciones a un único archivo.
Siguiendo la convención de systemd, `managed-settings.json` se fusiona primero como base, luego todos los archivos `*.json` en el directorio de entrega se ordenan alfabéticamente y se fusionan encima. Los archivos posteriores anulan los anteriores para valores escalares; las matrices se concatenan y se deduplicán; los objetos se fusionan profundamente. Se ignoran los archivos ocultos que comienzan con `.`.
Use prefijos numéricos para controlar el orden de fusión, por ejemplo `10-telemetry.json` y `20-security.json`.
Consulte [configuraciones administradas](/es/permissions#managed-only-settings) y [Configuración de MCP administrada](/es/managed-mcp) para obtener detalles.
Este [repositorio](https://github.com/anthropics/fuxi-code/tree/main/examples/mdm) incluye plantillas de implementación de inicio para Jamf, Iru (Kandji), Intune y Política de grupo. Use estas como puntos de partida y ajústelas para que se adapten a sus necesidades.
Las implementaciones administradas también pueden restringir **adiciones de marketplace de plugins** usando `strictKnownMarketplaces`. Para obtener más información, consulte [Restricciones de marketplace administradas](/es/plugin-marketplaces#managed-marketplace-restrictions).
* **Otra configuración** se almacena en `~/.fuxi.json`. Este archivo contiene su sesión OAuth, configuraciones de [MCP server](/es/mcp) para ámbitos de usuario y local, estado por proyecto (herramientas permitidas, configuración de confianza) y varios cachés. Los MCP servers con ámbito de proyecto se almacenan por separado en `.mcp.json`.
Fuxi Code crea automáticamente copias de seguridad con marca de tiempo de archivos de configuración y retiene las cinco copias de seguridad más recientes para prevenir pérdida de datos.
```JSON Ejemplo settings.json theme={null}
{
"$schema": "https://json.schemastore.org/fuxi-code-settings.json",
"permissions": {
"allow": [
"Bash(npm run lint)",
"Bash(npm run test *)",
"Read(~/.zshrc)"
],
"deny": [
"Bash(curl *)",
"Read(./.env)",
"Read(./.env.*)",
"Read(./secrets/**)"
]
},
"env": {
"FUXI_CODE_ENABLE_TELEMETRY": "1",
"OTEL_METRICS_EXPORTER": "otlp"
},
"companyAnnouncements": [
"Welcome to Acme Corp! Review our code guidelines at docs.acme.com",
"Reminder: Code reviews required for all PRs",
"New security policy in effect"
]
}
```
La línea `$schema` en el ejemplo anterior apunta al [esquema JSON oficial](https://json.schemastore.org/fuxi-code-settings.json) para configuraciones de Fuxi Code. Agregarlo a su `settings.json` habilita autocompletado y validación en línea en VS Code, Cursor y cualquier otro editor que admita validación de esquema JSON.
El esquema publicado se actualiza periódicamente y puede no incluir configuraciones agregadas en los lanzamientos de CLI más recientes, por lo que una advertencia de validación en un campo documentado recientemente no necesariamente significa que su configuración sea inválida.
Cuándo entran en vigor las ediciones
Fuxi Code observa sus archivos de configuración y los recarga cuando cambian, por lo que las ediciones en la mayoría de las claves se aplican a la sesión en ejecución sin necesidad de reinicio. Esto incluye `permissions`, `hooks` y asistentes de credenciales como `apiKeyHelper`. La recarga cubre configuraciones de usuario, proyecto, local y administradas, y el [hook `ConfigChange`](/es/hooks#configchange) se activa para cada cambio detectado.
Algunas claves se leen una sola vez al inicio de la sesión y se aplican en el siguiente reinicio:
* `model`: use [`/model`](/es/model-config#setting-your-model) para cambiar en mitad de sesión
* [`outputStyle`](/es/output-styles): parte del indicador del sistema, que se reconstruye en `/clear` o reinicio
Entradas inválidas en configuraciones administradas
Las configuraciones administradas se analizan con tolerancia. Cuando una configuración administrada contiene una entrada que falla la validación del esquema, Fuxi Code elimina esa entrada, registra una advertencia y aplica cada política válida restante. Un único error tipográfico no puede deshabilitar el resto de la política de su organización.
Este comportamiento es consistente en los tres mecanismos de entrega: [configuraciones administradas por servidor](/es/server-managed-settings), políticas de plist y registro implementadas a través de MDM, y archivos `managed-settings.json`. Requiere Fuxi Code v2.1.169 o posterior.
Los campos de aplicación de seguridad se manejan por campo en lugar de ser eliminados al por mayor cuando están presentes pero son inválidos:
| Campo | Comportamiento cuando está presente pero es inválido |
| :--------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `allowedMcpServers` | Aplicado como una lista blanca vacía, por lo que no se admiten MCP servers hasta que se corrija el valor. Una entrada individual inválida se elimina y se aplica el subconjunto válido. |
| `allowManagedMcpServersOnly` | Tratado como `true`. |
| `availableModels` | {/* min-version: 2.1.175 */}Aplicado como una lista blanca vacía, por lo que solo el modelo Predeterminado está disponible hasta que se corrija el valor. Una entrada individual que no es cadena se elimina y se aplica el subconjunto válido. Se aplica en v2.1.175 y posterior. |
| `enforceAvailableModels` | {/* min-version: 2.1.175 */}Tratado como `true`. Se aplica en v2.1.175 y posterior. |
| `forceLoginOrgUUID` | No se permite que ninguna organización inicie sesión hasta que se corrija el valor. |
| `deniedMcpServers` | Una entrada individual inválida se elimina y se aplica el subconjunto válido. Un valor completamente inválido se descarta con una advertencia, ya que denegar cada servidor bloquearía servidores que la política nunca nombró. |
| `sandbox.credentials` | {/* min-version: 2.1.191 */}Una entrada individual inválida en `files` o `envVars` se elimina con una advertencia y se aplica el subconjunto válido. Un valor completamente inválido de `credentials` se descarta con una advertencia mientras el resto de `sandbox` aún se aplica. Se aplica en v2.1.191 y posterior. |
`requiredMinimumVersion` y `requiredMaximumVersion` fallan abiertos por diseño: un valor inválido se elimina en lugar de aplicarse, por lo que un empuje de política defectuoso no puede evitar que Fuxi Code se inicie.
Los errores de validación aparecen en tres lugares:
* Las sesiones interactivas muestran un diálogo al inicio que enumera las entradas inválidas.
* Las ejecuciones sin interfaz con `-p` imprimen un resumen en stderr.
* [`fuxi doctor`](/es/debug-your-config) enumera cada entrada inválida con su fuente y campo.
Valide cambios de política ejecutando `fuxi doctor` en una máquina de prueba antes de implementarlos en toda la flota.
Esta tolerancia se aplica solo a configuraciones administradas. Los archivos de configuración de usuario, proyecto y local permanecen estrictos: un archivo que falla la validación se rechaza en su totalidad y se reporta.
Configuraciones disponibles
`settings.json` admite varias opciones:
| Clave | Descripción | Ejemplo |
| :-------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------ |
| `advisorModel` | Modelo para la [herramienta advisor](/es/advisor) del lado del servidor. Acepta un alias de modelo como `"opus"`, `"sonnet"`, o `"fable"` ({/* min-version: 2.1.170 */}v2.1.170+), o un ID de modelo completo. Se escribe automáticamente cuando ejecuta `/advisor`. Desactive para deshabilitar el advisor | `"opus"` |
| `agent` | Ejecutar el hilo principal como un subagent nombrado, y establecer el agente predeterminado para sesiones despachadas desde `fuxi agents`. Aplica el indicador del sistema del subagent, restricciones de herramientas y modelo. Consulte [Invocar subagents explícitamente](/es/sub-agents#invoke-subagents-explicitly) | `"code-reviewer"` |
| `agentPushNotifEnabled` | {/* min-version: 2.1.119 */}**Predeterminado**: `false`. Cuando [Remote Control](/es/remote-control) está conectado, permitir que Fuxi envíe notificaciones push proactivas a su teléfono, por ejemplo cuando una tarea larga finaliza. Aparece en `/config` como **Push when Fuxi decides**. Consulte [Notificaciones push móviles](/es/remote-control#mobile-push-notifications). Requiere Fuxi Code v2.1.119 o posterior | `true` |
| `allowAllFuxiAiMcps` | (Solo configuraciones administradas) Cargar conectores de fuxi.ai junto con un `managed-mcp.json` implementado, que de otra manera toma control exclusivo y los suprime. Consulte [Configuración de MCP administrada](/es/managed-mcp) | `true` |
| `allowedChannelPlugins` | (Solo configuraciones administradas) Lista blanca de plugins de canal que pueden enviar mensajes. Reemplaza la lista blanca predeterminada de Anthropic cuando se establece. Sin definir = recurrir a la predeterminada, matriz vacía = bloquear todos los plugins de canal. Requiere `channelsEnabled: true`. Consulte [Restringir qué plugins de canal pueden ejecutarse](/es/channels#restrict-which-channel-plugins-can-run) | `[{ "marketplace": "fuxi-plugins-official", "plugin": "telegram" }]` |
| `allowedHttpHookUrls` | Lista blanca de patrones de URL que los hooks HTTP pueden dirigirse. Admite `*` como comodín. Cuando se establece, los hooks con URLs que no coinciden se bloquean. Sin definir = sin restricción, matriz vacía = bloquear todos los hooks HTTP. Las matrices se fusionan entre fuentes de configuración. Consulte [Configuración de hooks](#hook-configuration) | `["https://hooks.example.com/*"]` |
| `allowedMcpServers` | Cuando se establece en managed-settings.json, lista blanca de MCP servers que los usuarios pueden configurar. Sin definir = sin restricciones, matriz vacía = bloqueo. Se aplica a todos los ámbitos. La lista de denegación tiene precedencia. Consulte [Configuración de MCP administrada](/es/managed-mcp) | `[{ "serverName": "github" }]` |
| `allowManagedHooksOnly` | (Solo configuraciones administradas) Solo se cargan hooks administrados, hooks SDK y hooks de plugins forzadamente habilitados en la configuración administrada `enabledPlugins`. Se bloquean hooks de usuario, proyecto y todos los demás plugins. Consulte [Configuración de hooks](#hook-configuration) | `true` |
| `allowManagedMcpServersOnly` | (Solo configuraciones administradas) Solo se respetan `allowedMcpServers` de configuraciones administradas. `deniedMcpServers` aún se fusiona desde todas las fuentes. Los usuarios aún pueden agregar MCP servers, pero solo se aplica la lista blanca definida por el administrador. Consulte [Configuración de MCP administrada](/es/managed-mcp) | `true` |
| `allowManagedPermissionRulesOnly` | (Solo configuraciones administradas) Evitar que configuraciones de usuario y proyecto definan reglas de permiso `allow`, `ask` o `deny`. Solo se aplican las reglas en configuraciones administradas. Consulte [Configuraciones solo administradas](/es/permissions#managed-only-settings) | `true` |
| `alwaysThinkingEnabled` | Habilitar [pensamiento extendido](/es/model-config#extended-thinking) de forma predeterminada para todas las sesiones. Típicamente configurado a través del comando `/config` en lugar de editar directamente. Para forzar el pensamiento desactivado independientemente de esta configuración, establezca [`MAX_THINKING_TOKENS=0`](/es/env-vars) en `env`, que deshabilita el pensamiento en la API de Anthropic excepto en Fable 5, que no puede tener el pensamiento desactivado. En [proveedores de terceros](/es/third-party-integrations) esto omite el parámetro `thinking` en su lugar, y los modelos de razonamiento adaptativo aún pueden pensar | `true` |
| `apiKeyHelper` | Script personalizado, a ejecutarse a través del shell del sistema (`/bin/sh` en macOS y Linux, `cmd` en Windows), para generar un valor de autenticación. Este valor se enviará como encabezados `X-Api-Key` y `Authorization: Bearer` para solicitudes de modelo. Establezca el intervalo de actualización con [`FUXI_CODE_API_KEY_HELPER_TTL_MS`](/es/env-vars) | `/bin/generate_temp_api_key.sh` |
| `askUserQuestionTimeout` | {/* min-version: 2.1.200 */}**Predeterminado**: `"never"`. Tiempo de inactividad antes de que un diálogo [`AskUserQuestion`](/es/tools-reference) sin respuesta continúe automáticamente con las opciones que ya había seleccionado. Acepta `"60s"`, `"5m"`, `"10m"`, o `"never"`. Con el predeterminado, las preguntas esperan hasta que responda. Aparece en `/config` como **Question auto-continue timeout**, que escribe esta clave en configuraciones de usuario. No se lee desde configuraciones de proyecto o local. Requiere Fuxi Code v2.1.200 o posterior | `"5m"` |
| `attribution` | Personalizar atribución para commits de git y solicitudes de extracción. Consulte [Configuración de atribución](#attribution-settings) | `{"commit": "🤖 Generated with Fuxi Code", "pr": ""}` |
| `autoCompactEnabled` | {/* min-version: 2.1.119 */}**Predeterminado**: `true`. Compactar automáticamente la conversación cuando el contexto se acerca al límite. Aparece en `/config` como **Auto-compact**. Para deshabilitar a través de variable de entorno, establezca [`DISABLE_AUTO_COMPACT`](/es/env-vars) en `env` | `false` |
| `autoMemoryDirectory` | Directorio personalizado para almacenamiento de [memoria automática](/es/memory#storage-location). Acepta una ruta absoluta o una ruta con prefijo `~/`. Se honra desde configuraciones de proyecto o local solo después de aceptar el diálogo de confianza del espacio de trabajo, ya que un repositorio clonado puede proporcionar este archivo | `"~/my-memory-dir"` |
| `autoMemoryEnabled` | **Predeterminado**: `true`. Habilitar [memoria automática](/es/memory#enable-or-disable-auto-memory). Cuando es `false`, Fuxi no lee ni escribe en el directorio de memoria automática. También puede alternar esto con `/memory` durante una sesión. Para deshabilitar a través de variable de entorno, establezca [`FUXI_CODE_DISABLE_AUTO_MEMORY`](/es/env-vars) en `env` | `false` |
| `autoMode` | Personalizar qué bloquea y permite el clasificador de [modo automático](/es/permission-modes#eliminate-prompts-with-auto-mode). Contiene matrices `environment`, `allow`, `soft_deny` y `hard_deny` de reglas en prosa. Incluya la cadena literal `"$defaults"` en una matriz para heredar las reglas integradas en esa posición. Consulte [Configurar modo automático](/es/auto-mode-config). No se lee desde configuraciones de proyecto compartidas | `{"soft_deny": ["$defaults", "Never run terraform apply"]}` |
| `autoMode.classifyAllShell` | {/* min-version: 2.1.193 */}**Predeterminado**: `false`. Cuando es `true`, suspende cada regla de permiso de Bash y PowerShell mientras el modo automático está activo para que todos los comandos de shell se enruten a través del clasificador, no solo reglas que coincidan con patrones de ejecución de código arbitrario. Consulte [Enrutar todos los comandos de shell a través del clasificador](/es/auto-mode-config#route-all-shell-commands-through-the-classifier). Requiere Fuxi Code v2.1.193 o posterior | `true` |
| `autoScrollEnabled` | **Predeterminado**: `true`. En [renderizado de pantalla completa](/es/fullscreen), seguir la nueva salida hasta el final de la conversación. Aparece en `/config` como **Auto-scroll**. Los avisos de permiso aún se desplazan a la vista cuando esto está desactivado | `false` |
| `autoUpdatesChannel` | **Predeterminado**: `"latest"`. Canal de lanzamiento a seguir para actualizaciones. Use `"stable"` para una versión que típicamente tiene aproximadamente una semana de antigüedad y omite versiones con regresiones importantes, o `"latest"` para el lanzamiento más reciente. Para deshabilitar completamente las actualizaciones automáticas, establezca [`DISABLE_AUTOUPDATER`](/es/setup#disable-auto-updates) en `env` | `"stable"` |
| `availableModels` | Restringir qué modelos pueden seleccionar los usuarios para la sesión principal, [subagents](/es/sub-agents), [skills](/es/skills) y el [advisor](/es/advisor). No afecta la opción Predeterminado a menos que `enforceAvailableModels` también esté establecido. Consulte [Restringir selección de modelo](/es/model-config#restrict-model-selection) | `["sonnet", "haiku"]` |
| `awaySummaryEnabled` | Mostrar un resumen de sesión de una línea cuando regresa a la terminal después de estar ausente unos minutos. Establezca en `false` o desactive Resumen de sesión en `/config` para deshabilitar. Igual que [`FUXI_CODE_ENABLE_AWAY_SUMMARY`](/es/env-vars) | `true` |
| `awsAuthRefresh` | Script personalizado que modifica el directorio `.aws` (consulte [configuración avanzada de credenciales](/es/amazon-bedrock#advanced-credential-configuration)) | `aws sso login --profile myprofile` |
| `awsCredentialExport` | Script personalizado que genera JSON con credenciales de AWS (consulte [configuración avanzada de credenciales](/es/amazon-bedrock#advanced-credential-configuration)) | `/bin/generate_aws_grant.sh` |
| `axScreenReader` | {/* min-version: 2.1.181 */}Renderizar salida amigable con lector de pantalla: texto plano sin bordes decorativos ni animaciones. El modo de lector de pantalla siempre usa el renderizador clásico, por lo que la configuración `tui` no tiene efecto mientras está activo. Las sesiones de fondo adjuntas [](/es/agent-view) aún se renderizan en pantalla completa. La variable de entorno [`FUXI_AX_SCREEN_READER`](/es/env-vars) y la bandera [`--ax-screen-reader`](/es/cli-reference#cli-flags) tienen precedencia. Requiere Fuxi Code v2.1.181 o posterior | `true` |
| `blockedMarketplaces` | (Solo configuraciones administradas) Lista negra de fuentes de marketplace. Aplicada en adición de marketplace y en instalación, actualización, actualización y auto-actualización de plugins, por lo que un marketplace agregado antes de que se estableciera la política no puede usarse para obtener plugins. Las fuentes bloqueadas se verifican antes de descargar, por lo que nunca tocan el sistema de archivos. Consulte [Restricciones de marketplace administradas](/es/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "source": "github", "repo": "untrusted/plugins" }]` |
| `browserExternalPageTools` | (Solo configuraciones administradas) Establecer en `"disabled"` para evitar que Fuxi use herramientas para leer o actuar en páginas externas en el panel [Browser](/es/desktop#browse-external-sites) de la aplicación de escritorio. Los usuarios aún pueden navegar a sitios externos por sí mismos, y las vistas previas del servidor de desarrollo local no se ven afectadas | `"disabled"` |
| `channelsEnabled` | (Solo configuraciones administradas) Permitir [canales](/es/channels) para la organización. En planes de Fuxi.ai Team y Enterprise, los canales se bloquean cuando esto no está definido o es `false`. Para cuentas de [Anthropic Console](/es/authentication#fuxi-console-authentication) que usan autenticación de clave API, los canales se permiten de forma predeterminada a menos que su organización implemente configuraciones administradas, en cuyo caso esta clave debe establecerse en `true` | `true` |
| `fuxiMd` | (Solo configuraciones administradas) Instrucciones de estilo FUXI.md inyectadas como memoria administrada por la organización. Solo se honra cuando se establece en configuraciones administradas o de política e ignorado en configuraciones de usuario, proyecto y local. Consulte [FUXI.md en toda la organización](/es/memory#deploy-organization-wide-fuxi-md) | `"Always run make lint before committing."` |
| `fuxiMdExcludes` | Patrones Glob o rutas absolutas de archivos `FUXI.md` a omitir al cargar [memoria](/es/memory). Los patrones coinciden con rutas de archivo absolutas. Solo se aplica a memoria de usuario, proyecto y local; los archivos de política administrada no pueden excluirse | `["**/vendor/**/FUXI.md"]` |
| `cleanupPeriodDays` | **Predeterminado**: `30` días, mínimo `1`. Fuxi Code elimina [archivos de sesión y otros datos de aplicación](/es/fuxi-directory#cleaned-up-automatically) más antiguos que este período al inicio. Establecer `0` falla con un error de validación. El mismo corte de edad se aplica a la eliminación automática de [worktrees huérfanos](/es/worktrees#clean-up-worktrees) al inicio. {/* min-version: 2.1.203 */}Si Fuxi Code no puede leer o analizar un archivo de configuración, pausa el barrido de limpieza de retención y muestra una advertencia en `/status` hasta que corrija el archivo, a menos que [configuraciones administradas](/es/server-managed-settings) proporcionen `cleanupPeriodDays`, en cuyo caso el barrido se ejecuta en el valor administrado. Antes de v2.1.203, la limpieza se ejecutaba en el predeterminado de 30 días en ese estado y podría eliminar transcripciones que un `cleanupPeriodDays` más largo estaba destinado a mantener; los archivos más nuevos que 30 días nunca se eliminaban. Para deshabilitar completamente las escrituras de transcripción, establezca la variable de entorno [`FUXI_CODE_SKIP_PROMPT_HISTORY`](/es/env-vars). En modo no interactivo, pase `--no-session-persistence` junto con `-p` o establezca `persistSession: false` en el Agent SDK. | `20` |
| `companyAnnouncements` | Anuncio a mostrar a los usuarios al inicio. Si se proporcionan múltiples anuncios, se alternarán aleatoriamente. | `["Welcome to Acme Corp! Review our code guidelines at docs.acme.com"]` |
| `defaultShell` | **Predeterminado**: `"bash"`, o `"powershell"` en Windows cuando Bash no está disponible. Shell predeterminado para comandos `!` de cuadro de entrada. Acepta `"bash"` o `"powershell"`. Establecer `"powershell"` enruta comandos `!` interactivos a través de PowerShell en Windows. Requiere `FUXI_CODE_USE_POWERSHELL_TOOL=1`. Consulte [herramienta PowerShell](/es/tools-reference#powershell-tool) | `"powershell"` |
| `deniedMcpServers` | Cuando se establece en managed-settings.json, lista negra de MCP servers que están explícitamente bloqueados. Se aplica a todos los ámbitos incluyendo servers administrados. La lista de denegación tiene precedencia sobre la lista blanca. Consulte [Configuración de MCP administrada](/es/managed-mcp) | `[{ "serverName": "filesystem" }]` |
| `disableAgentView` | Establecer en `true` para desactivar [agentes de fondo y vista de agentes](/es/agent-view): `fuxi agents`, `--bg`, `/background` y el supervisor bajo demanda. Típicamente establecido en [configuraciones administradas](/es/permissions#managed-settings). Equivalente a establecer `FUXI_CODE_DISABLE_AGENT_VIEW` en `1` | `true` |
| `disableAllHooks` | Deshabilitar todos los [hooks](/es/hooks) y cualquier [línea de estado](/es/statusline) personalizada | `true` |
| `disableArtifact` | Establecer en `true` para deshabilitar la herramienta [Artifact](/es/artifacts), que publica la salida de sesión como una página web privada en fuxi.ai. Equivalente a establecer `FUXI_CODE_DISABLE_ARTIFACT` en `1` | `true` |
| `disableAutoMode` | Establecer en `"disable"` para evitar que se active el [modo automático](/es/permission-modes#eliminate-prompts-with-auto-mode). Elimina `auto` del ciclo `Shift+Tab` y rechaza `--permission-mode auto` al inicio. Más útil en [configuraciones administradas](/es/permissions#managed-settings) donde los usuarios no pueden anularlo | `"disable"` |
| `disableBundledSkills` | Establecer en `true` para deshabilitar los [skills](/es/skills) y flujos de trabajo que se envían con Fuxi Code: los skills agrupados y flujos de trabajo se eliminan completamente, mientras que los comandos de barra inclinada integrados como `/init` permanecen escribibles pero se ocultan del modelo. `/doctor` permanece escribible como los comandos integrados; ocúltelo con [`DISABLE_DOCTOR_COMMAND`](/es/env-vars) en su lugar. Los skills de plugins, `.fuxi/skills/` y `.fuxi/commands/` no se ven afectados. Equivalente a establecer `FUXI_CODE_DISABLE_BUNDLED_SKILLS` en `1` | `true` |
| `disableFuxiAiConnectors` | {/* min-version: 2.1.182 */}Deshabilitar [conectores MCP de fuxi.ai](/es/mcp#use-mcp-servers-from-fuxi-ai) para que no se obtengan automáticamente ni se conecten. Establezca en cualquier ámbito de configuración. `true` en cualquier fuente tiene precedencia, por lo que un `.fuxi/settings.json` de proyecto verificado puede optar por un repositorio fuera de conectores en la nube, pero un proyecto-nivel `false` no puede anular un nivel de usuario o política `true`. Los servidores pasados explícitamente a través de `--mcp-config` no se ven afectados. Para denegar conectores individuales en lugar de todos ellos, use [`deniedMcpServers`](/es/managed-mcp). Requiere Fuxi Code v2.1.182 o posterior | `true` |
| `disableDeepLinkRegistration` | Establecer en `"disable"` para evitar que Fuxi Code registre el controlador de protocolo `fuxi-cli://` con el sistema operativo al inicio. Los [enlaces profundos](/es/deep-links) permiten que herramientas externas abran una sesión de Fuxi Code con un indicador rellenado previamente. Útil en entornos donde el registro del controlador de protocolo está restringido o se gestiona por separado | `"disable"` |
| `disabledMcpjsonServers` | Lista de MCP servers específicos de archivos `.mcp.json` para rechazar | `["filesystem"]` |
| `disableRemoteControl` | {/* min-version: 2.1.128 */}Deshabilitar [Control Remoto](/es/remote-control): bloquea `fuxi remote-control`, la bandera `--remote-control`, auto-inicio y el toggle en sesión. Típicamente colocado en [configuraciones administradas](/es/permissions#managed-settings) para aplicación de MDM por dispositivo, pero funciona desde cualquier ámbito. Requiere Fuxi Code v2.1.128 o posterior | `true` |
| `disableSideloadFlags` | {/* min-version: 2.1.193 */}(Solo configuraciones administradas) Rechazar las banderas CLI `--plugin-dir`, `--plugin-url`, `--agents` y `--mcp-config` al inicio, que los usuarios podrían pasar de otra manera para eludir [`strictKnownMarketplaces`](#strictknownmarketplaces) para una única ejecución. También rechaza estas banderas desde cualquier superficie que genere la CLI con ellas internamente, actualmente sesiones locales de [Cowork](/es/desktop) en la aplicación de escritorio. Un `--mcp-config` cuyos servidores son todas entradas `type: "sdk"` en proceso aún se acepta, por lo que el Agent SDK y la extensión de VS Code siguen funcionando. No bloquea `fuxi mcp add`, `.mcp.json`, o SDK `setMcpServers()`; empareje con [`allowedMcpServers`](/es/managed-mcp) para control de MCP por servidor. Requiere Fuxi Code v2.1.193 o posterior | `true` |
| `disableSkillShellExecution` | Deshabilitar la ejecución de shell en línea para bloques `` !`...` `` y ` ```! ` en [skills](/es/skills) y comandos personalizados de fuentes de usuario, proyecto, plugin o directorio adicional. Los comandos se reemplazan con `[shell command execution disabled by policy]` en lugar de ejecutarse. Los skills agrupados y administrados no se ven afectados. Más útil en [configuraciones administradas](/es/permissions#managed-settings) donde los usuarios no pueden anularlo | `true` |
| `disableWorkflows` | **Predeterminado**: `false`. Deshabilitar [flujos de trabajo dinámicos](/es/workflows#turn-workflows-off) y los comandos de flujo de trabajo agrupados. Equivalente a establecer `FUXI_CODE_DISABLE_WORKFLOWS` en `1` | `true` |
| `editorMode` | **Predeterminado**: `"normal"`. Modo de atajos de teclado para el indicador de entrada: `"normal"` o `"vim"`. Aparece en `/config` como **Editor mode** | `"vim"` |
| `effortLevel` | Persistir el [nivel de esfuerzo](/es/model-config#adjust-effort-level) entre sesiones. Acepta `"low"`, `"medium"`, `"high"`, o `"xhigh"`. Se escribe automáticamente cuando ejecuta `/effort` con uno de esos valores. `--effort` y [`FUXI_CODE_EFFORT_LEVEL`](/es/env-vars) anulan esto para una sesión. Consulte [Ajustar nivel de esfuerzo](/es/model-config#adjust-effort-level) para modelos compatibles | `"xhigh"` |
| `enableAllProjectMcpServers` | Aprobar automáticamente todos los MCP servers definidos en archivos `.mcp.json` de proyecto. {/* min-version: 2.1.196 */}A partir de v2.1.196, `fuxi mcp list` y `fuxi mcp get` honran esta clave en una carpeta no confiable solo desde [archivos de configuración que no se verifican en el repositorio](/es/mcp#managing-your-servers) | `true` |
| `enableArtifact` | {/* min-version: 2.1.196 */}Habilitar o deshabilitar la herramienta [Artifact](/es/artifacts) para este usuario. Cuando no está definido, el predeterminado sigue la [disponibilidad](/es/artifacts#availability) de la característica para su cuenta. La fila **Artifacts** en `/config` escribe esta clave. Una `disableArtifact` administrada y la [configuración de administrador](/es/artifacts#manage-artifacts-for-your-organization) de su organización tienen precedencia, y la clave se ignora en configuraciones de proyecto y local (`.fuxi/settings.json`, `.fuxi/settings.local.json`), que un repositorio podría verificar de otra manera. Requiere Fuxi Code v2.1.196 o posterior | `true` |
| `enabledMcpjsonServers` | Lista de MCP servers específicos de archivos `.mcp.json` para aprobar. {/* min-version: 2.1.196 */}A partir de v2.1.196, `fuxi mcp list` y `fuxi mcp get` honran esta clave en una carpeta no confiable solo desde [archivos de configuración que no se verifican en el repositorio](/es/mcp#managing-your-servers) | `["memory", "github"]` |
| `enforceAvailableModels` | {/* min-version: 2.1.175 */}Extender la lista blanca `availableModels` al modelo Predeterminado. Cuando es `true` en configuraciones administradas y `availableModels` es una matriz no vacía, la opción Predeterminado recurre a la primera entrada en lista blanca que está disponible, pero solo cuando el modelo predeterminado para el tipo de cuenta del usuario no está en la lista blanca; un predeterminado en lista blanca se mantiene tal cual. No tiene efecto cuando `availableModels` no está definido o está vacío. Consulte [Aplicar la lista blanca al modelo Predeterminado](/es/model-config#enforce-the-allowlist-for-the-default-model). Requiere Fuxi Code v2.1.175 o posterior | `true` |
| `env` | Variables de entorno aplicadas a cada sesión y a subprocesos que Fuxi Code genera desde ella. {/* min-version: 2.1.143 */}A partir de v2.1.143, `NO_COLOR` y `FORCE_COLOR` establecidos aquí se pasan a subprocesos pero no cambian los colores de la interfaz propia de Fuxi Code. Establezca esos en su shell antes de lanzar `fuxi` para cambiar los colores de la interfaz. {/* min-version: 2.1.195 */}A partir de v2.1.195, variables de identidad que los entornos de alojamiento de Fuxi Code establecen, por ejemplo `FUXI_CODE_REMOTE` y `FUXI_CODE_ACCOUNT_UUID`, se ignoran cuando se establecen aquí | `{"FOO": "bar"}` |
| `fallbackModel` | Modelo(s) de respaldo a intentar en orden cuando el modelo principal está sobrecargado o no disponible. Fuxi Code cambia al siguiente modelo disponible en la cadena para el resto del turno y muestra un aviso. `"default"` se expande al modelo predeterminado. Las cadenas se limitan a tres modelos; las entradas adicionales se ignoran. A diferencia de la mayoría de configuraciones de matriz, esta clave no se fusiona entre archivos de configuración: el archivo de mayor precedencia que la define suministra toda la cadena. La bandera [`--fallback-model`](/es/cli-reference#cli-flags) anula esto para una sesión. Consulte [Cadenas de modelo de respaldo](/es/model-config#fallback-model-chains) | `["fuxi-sonnet-5", "fuxi-haiku-4-5"]` |
| `fastModePerSessionOptIn` | Cuando es `true`, el modo rápido no persiste entre sesiones. Cada sesión comienza con el modo rápido desactivado, requiriendo que los usuarios lo habiliten con `/fast`. La preferencia de modo rápido del usuario aún se guarda. Consulte [Requerir opt-in por sesión](/es/fast-mode#require-per-session-opt-in) | `true` |
| `feedbackSurveyRate` | Probabilidad (0–1) de que la [encuesta de calidad de sesión](/es/data-usage#session-quality-surveys) aparezca cuando sea elegible. Establecer en `0` para suprimir completamente, o establezca [`FUXI_CODE_DISABLE_FEEDBACK_SURVEY`](/es/env-vars) en `env`. Útil cuando se usa Amazon Bedrock, Google Cloud's Agent Platform, o Microsoft Foundry donde la tasa de muestreo predeterminada no se aplica | `0.05` |
| `fileCheckpointingEnabled` | {/* min-version: 2.1.119 */}**Predeterminado**: `true`. Capturar archivos antes de cada edición para que [`/rewind`](/es/checkpointing) pueda restaurarlos. Aparece en `/config` como **Rewind code (checkpoints)**. Para deshabilitar a través de variable de entorno, establezca [`FUXI_CODE_DISABLE_FILE_CHECKPOINTING`](/es/env-vars) en `env` | `false` |
| `fileSuggestion` | Configurar un script personalizado para autocompletado de archivo `@`. Consulte [Configuración de sugerencia de archivo](#file-suggestion-settings) | `{"type": "command", "command": "~/.fuxi/file-suggestion.sh"}` |
| `footerLinksRegexes` | {/* min-version: 2.1.176 */}Renderizar insignias clickeables adicionales en el pie de página cuando una regex coincide con la salida del turno. Cada entrada tiene un `pattern`, una plantilla de URL `url` con placeholders `{name}` rellenados desde grupos de captura nombrados, y una `label` opcional. Se lee desde configuraciones de usuario, bandera `--settings` y configuraciones administradas solamente. Consulte [Insignias de enlace de pie de página](#footer-link-badges) para restricciones de URL, lista blanca de esquemas y límites. Requiere Fuxi Code v2.1.176 o posterior | `[{"type": "regex", "pattern": "\\b(?PROJ-\\d+)\\b", "url": "https://issues.example.com/browse/{key}", "label": "{key}"}]` |
| `forceLoginMethod` | Use `fuxiai` para restringir el inicio de sesión a cuentas de Fuxi.ai, `console` para restringir el inicio de sesión a cuentas de Fuxi Console, o `gateway` para restringir el inicio de sesión a una puerta de enlace en la nube; consulte [puerta de aplicaciones Fuxi](/es/fuxi-apps-gateway). Cuando se establece en cualquier valor en configuraciones administradas, se bloquean sesiones autenticadas por `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, o `apiKeyHelper` al inicio, ya que una credencial de entorno no puede satisfacer el método de inicio de sesión requerido. Las sesiones de proveedores de terceros como Amazon Bedrock, Google Cloud's Agent Platform, y Microsoft Foundry no se bloquean: se autentican contra su proveedor de nube en lugar de Anthropic | `fuxiai` |
| `forceLoginGatewayUrl` | Rellena previamente y bloquea la URL de la puerta de enlace en la pantalla `/login` de puerta de enlace en la nube. Ya sea esta clave o `forceLoginMethod: "gateway"` muestra esa pantalla; establezca ambas para que la URL se rellene. Solo se honra en el nivel de política administrada; se ignora en configuraciones de usuario y proyecto. Consulte [puerta de aplicaciones Fuxi](/es/fuxi-apps-gateway#set-the-gateway-url) | `"https://fuxi-gateway.example.com"` |
| `forceLoginOrgUUID` | Requerir que el inicio de sesión pertenezca a una organización específica de Anthropic. Acepta una cadena UUID única, que también preselecciona esa organización durante el inicio de sesión, o una matriz de UUID donde se acepta cualquier organización listada sin preselección. Cuando se establece en configuraciones administradas, el inicio de sesión falla si la cuenta autenticada no pertenece a una organización listada, y sesiones autenticadas por `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, o `apiKeyHelper` se bloquean al inicio ya que la pertenencia a la organización no puede verificarse para ellas. Las sesiones de proveedores de terceros como Amazon Bedrock, Google Cloud's Agent Platform, y Microsoft Foundry no se bloquean: use su IAM de nube para restringir qué cuentas de nube pueden usarse. Una matriz vacía falla cerrada y bloquea el inicio de sesión con un mensaje de configuración incorrecta | `"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"` o `["xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy"]` |
| `forceRemoteSettingsRefresh` | (Solo configuraciones administradas) Bloquear el inicio de CLI hasta que se obtengan configuraciones administradas remotas recientemente del servidor. Si la obtención falla, la CLI se cierra en lugar de continuar con configuraciones en caché o sin configuraciones. Cuando no se establece, el inicio continúa sin esperar configuraciones remotas. Consulte [aplicación de cierre de falla](/es/server-managed-settings#enforce-fail-closed-startup) | `true` |
| `gcpAuthRefresh` | Script personalizado que actualiza las Credenciales Predeterminadas de Aplicación de GCP cuando expiran o no se pueden cargar. Consulte [configuración avanzada de credenciales](/es/google-vertex-ai#advanced-credential-configuration) | `gcloud auth application-default login` |
| `hooks` | Configurar comandos personalizados para ejecutarse en eventos del ciclo de vida. Consulte [documentación de hooks](/es/hooks) para el formato | Consulte [hooks](/es/hooks) |
| `httpHookAllowedEnvVars` | Lista blanca de nombres de variables de entorno que los hooks HTTP pueden interpolar en encabezados. Cuando se establece, el `allowedEnvVars` efectivo de cada hook es la intersección con esta lista. Sin definir = sin restricción. Las matrices se fusionan entre fuentes de configuración. Consulte [Configuración de hooks](#hook-configuration) | `["MY_TOKEN", "HOOK_SECRET"]` |
| `includeGitInstructions` | **Predeterminado**: `true`. Incluir instrucciones de flujo de trabajo de commit y PR integradas y la instantánea de estado de git en el indicador del sistema de Fuxi. Establecer en `false` para eliminar ambas, por ejemplo cuando se usan skills de flujo de trabajo de git personalizados. La variable de entorno `FUXI_CODE_DISABLE_GIT_INSTRUCTIONS` tiene precedencia sobre esta configuración cuando se establece | `false` |
| `inputNeededNotifEnabled` | {/* min-version: 2.1.119 */}**Predeterminado**: `false`. Cuando [Remote Control](/es/remote-control) está conectado, enviar una notificación push a su teléfono cuando un aviso de permiso o pregunta está esperando su entrada. Aparece en `/config` como **Push when actions required**. Consulte [Notificaciones push móviles](/es/remote-control#mobile-push-notifications). Requiere Fuxi Code v2.1.119 o posterior | `true` |
| `language` | Configurar el idioma de respuesta preferido de Fuxi (por ejemplo, `"japanese"`, `"spanish"`, `"french"`). Fuxi responderá en este idioma de forma predeterminada. También establece el idioma de [dictado de voz](/es/voice-dictation#change-the-dictation-language) y títulos de sesión generados automáticamente. {/* min-version: 2.1.176 */}A partir de v2.1.176, cuando no está definido, los títulos de sesión coinciden con el idioma de su conversación | `"japanese"` |
| `minimumVersion` | Piso que evita que las actualizaciones automáticas en segundo plano e `fuxi update` instalen una versión por debajo de esta. Cambiar del canal `"latest"` a `"stable"` a través de `/config` le solicita que permanezca en la versión actual o permita la degradación. Elegir permanecer establece este valor. También útil en [configuraciones administradas](/es/permissions#managed-settings) para fijar un mínimo en toda la organización. Para un piso duro que bloquea el inicio completamente, consulte `requiredMinimumVersion` | `"2.1.100"` |
| `model` | Anular el modelo predeterminado a usar para Fuxi Code. `--model` y [`ANTHROPIC_MODEL`](/es/model-config#environment-variables) anulan esto para una sesión | `"fuxi-sonnet-5"` |
| `modelOverrides` | Asignar IDs de modelo de Anthropic a IDs de modelo específicos del proveedor como ARNs de perfil de inferencia de Bedrock. Cada entrada del selector de modelo usa su valor asignado al llamar a la API del proveedor. Consulte [Anular IDs de modelo por versión](/es/model-config#override-model-ids-per-version) | `{"fuxi-opus-4-6": "arn:aws:bedrock:..."}` |
| `otelHeadersHelper` | Script para generar encabezados dinámicos de OpenTelemetry. Se ejecuta al inicio y periódicamente. Establezca el intervalo de actualización con [`FUXI_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`](/es/env-vars). Consulte [Encabezados dinámicos](/es/monitoring-usage#dynamic-headers) | `/bin/generate_otel_headers.sh` |
| `outputStyle` | Configurar un estilo de salida para ajustar el indicador del sistema. Consulte [documentación de estilos de salida](/es/output-styles) | `"Explanatory"` |
| `parentSettingsBehavior` | {/* min-version: 2.1.133 */}(Solo configuraciones administradas) **Predeterminado**: `"first-wins"`. Controla si las configuraciones administradas suministradas programáticamente por un proceso host de incrustación, como el Agent SDK o una extensión IDE, se aplican cuando también está presente un nivel administrado implementado por administrador. `"first-wins"`: las configuraciones suministradas por el padre se descartan y solo se aplica el nivel administrado. `"merge"`: las configuraciones suministradas por el padre se aplican bajo el nivel administrado, filtradas para que puedan restringir la política pero no flexibilizarla. No tiene efecto cuando no se implementa ningún nivel administrado. Requiere Fuxi Code v2.1.133 o posterior | `"merge"` |
| `permissions` | Consulte la tabla a continuación para la estructura de permisos. | |
| `plansDirectory` | **Predeterminado**: `~/.fuxi/plans`. Personalizar dónde se almacenan los archivos de plan. La ruta es relativa a la raíz del proyecto. | `"./plans"` |
| `pluginSuggestionMarketplaces` | (Solo configuraciones administradas) Nombres de marketplace cuyos plugins pueden aparecer como sugerencias de instalación contextual. No se muestran sugerencias declaradas por marketplace sin esta lista blanca; la sugerencia integrada de diseño de frontend de primera parte no se ve afectada. Las sugerencias provienen de la declaración `relevance` de cada plugin en su entrada de marketplace. Un nombre solo tiene efecto cuando el marketplace está registrado en la máquina y su fuente registrada también se declara en configuraciones administradas, ya sea como la entrada `extraKnownMarketplaces` para ese nombre o como una entrada de `strictKnownMarketplaces`. Un marketplace registrado desde una fuente diferente bajo un nombre en lista blanca se ignora. El marketplace oficial está exento del requisito de fuente: permitir su nombre solo es suficiente, ya que ese nombre solo puede registrarse desde la fuente oficial de Anthropic. | `["acme-corp-plugins"]` |
| `pluginTrustMessage` | (Solo configuraciones administradas) Mensaje personalizado agregado a la advertencia de confianza de plugin mostrada antes de la instalación. Use esto para agregar contexto específico de la organización, por ejemplo para confirmar que los plugins de su marketplace interno están verificados. | `"All plugins from our marketplace are approved by IT"` |
| `policyHelper` | {/* min-version: 2.1.136 */}Ejecutable implementado por administrador que calcula configuraciones administradas dinámicamente al inicio. Solo se honra desde MDM o un archivo `managed-settings.json` del sistema. Consulte [Calcular configuraciones administradas con un asistente de política](#compute-managed-settings-with-a-policy-helper). Requiere Fuxi Code v2.1.136 o posterior | `{"path": "/usr/local/bin/fuxi-policy"}` |
| `preferredNotifChannel` | **Predeterminado**: `"auto"`. Método para notificaciones de tarea completada y solicitud de permiso: `"auto"`, `"terminal_bell"`, `"iterm2"`, `"iterm2_with_bell"`, `"kitty"`, `"ghostty"`, o `"notifications_disabled"`. `"auto"` envía una notificación de escritorio en iTerm2, Ghostty y Kitty y no hace nada en otras terminales. Establezca `"terminal_bell"` para sonar el carácter de campana en cualquier terminal. Aparece en `/config` como **Notifications**. Consulte [Obtener una campana de terminal o notificación](/es/terminal-config#get-a-terminal-bell-or-notification) | `"terminal_bell"` |
| `prefersReducedMotion` | Reducir o deshabilitar animaciones de UI (spinners, shimmer, efectos flash) para accesibilidad | `true` |
| `prUrlTemplate` | Plantilla de URL para la insignia de PR mostrada en el pie de página y en resúmenes de resultados de herramientas. Sustituye `{host}`, `{owner}`, `{repo}`, `{number}` y `{url}` de la URL de PR reportada por `gh`. Use para apuntar enlaces de PR a una herramienta de revisión de código interna en lugar de `github.com`. No afecta autolinks `#123` en la prosa de Fuxi | `"https://reviews.example.com/{owner}/{repo}/pull/{number}"` |
| `remoteControlAtStartup` | {/* min-version: 2.1.119 */}Conectar [Remote Control](/es/remote-control) automáticamente cuando cada sesión interactiva comienza, en lugar de esperar `/remote-control`. Establezca en `true` para siempre auto-conectar, `false` para nunca auto-conectar, o deje sin definir para seguir el predeterminado de su organización. Aparece en `/config` como **Enable Remote Control for all sessions**. Consulte [Habilitar Remote Control para todas las sesiones](/es/remote-control#enable-remote-control-for-all-sessions) | `false` |
| `requiredMaximumVersion` | Solo configuraciones administradas. Versión máxima de Fuxi Code permitida para iniciar. Si la versión en ejecución es más nueva, Fuxi Code se cierra al inicio e instruye al usuario a instalar una versión aprobada a través del método aprobado de la organización; `fuxi install ` también puede funcionar. Las actualizaciones automáticas en segundo plano y `fuxi update` omiten versiones por encima del techo, por lo que una instalación en rango permanece en rango. `fuxi update`, `fuxi install` y `fuxi doctor` continúan funcionando por encima del techo para que los usuarios puedan recuperarse. Las versiones anteriores a esta configuración la ignoran | `"2.1.150"` |
| `requiredMinimumVersion` | Solo configuraciones administradas. Versión mínima de Fuxi Code requerida para iniciar. Si la versión en ejecución es más antigua, Fuxi Code se cierra al inicio e instruye al usuario a actualizar a través del método aprobado de la organización. `fuxi update`, `fuxi install` y `fuxi doctor` continúan funcionando por debajo del piso para que los usuarios puedan recuperarse. Difiere de `minimumVersion`, que evita degradaciones pero nunca bloquea el inicio. Las versiones anteriores a esta configuración la ignoran | `"2.1.150"` |
| `respectGitignore` | **Predeterminado**: `true`. Controlar si el selector de archivo `@` respeta patrones `.gitignore`. Cuando es `true`, los archivos que coinciden con patrones `.gitignore` se excluyen de las sugerencias | `false` |
| `respondToBashCommands` | {/* min-version: 2.1.186 */}**Predeterminado**: `true`. Si Fuxi responde después de que se ejecuta un comando shell `!` de cuadro de entrada. Establecer en `false` para agregar la salida del comando al contexto sin una respuesta. Consulte [Modo shell con prefijo `!`](/es/interactive-mode#shell-mode-with-prefix). Requiere Fuxi Code v2.1.186 o posterior | `false` |
| `showClearContextOnPlanAccept` | **Predeterminado**: `false`. Mostrar la opción "borrar contexto" en la pantalla de aceptación del plan. Establecer en `true` para restaurar la opción | `true` |
| `showThinkingSummaries` | **Predeterminado**: `false`. Mostrar resúmenes de [pensamiento extendido](/es/model-config#extended-thinking) en sesiones interactivas. Cuando no está definido o es `false`, los bloques de pensamiento se redactan por la API y se muestran como un stub contraído. La redacción solo cambia lo que ve, no lo que genera el modelo: para reducir el gasto de pensamiento, [baje el presupuesto o deshabilite el pensamiento](/es/model-config#extended-thinking) en su lugar. Esta configuración no tiene efecto en modo no interactivo (`-p`), el Agent SDK, o extensiones IDE como VS Code | `true` |
| `showTurnDuration` | **Predeterminado**: `true`. Mostrar mensajes de duración de turno después de respuestas, por ejemplo "Cooked for 1m 6s". Aparece en `/config` como **Show turn duration** | `false` |
| `skillListingBudgetFraction` | {/* min-version: 2.1.105 */}**Predeterminado**: `0.01`. Fracción del contexto del modelo reservada para el [listado de skills](/es/skills#skill-descriptions-are-cut-short) que Fuxi ve cada turno. Cuando el listado excede el presupuesto, las descripciones de los skills menos utilizados se contraen a nombres desnudos para que Fuxi aún pueda invocarlos pero no verá por qué. Aumente para mantener más descripciones visibles al costo de más contexto por turno. `/doctor` estima el costo del listado contra el presupuesto. Requiere Fuxi Code v2.1.105 o posterior | `0.02` |
| `skillListingMaxDescChars` | {/* min-version: 2.1.105 */}**Predeterminado**: `1536`. Límite de caracteres por skill en el texto combinado de `description` y `when_to_use` en el [listado de skills](/es/skills#skill-descriptions-are-cut-short) que Fuxi ve cada turno. El texto más largo que esto se trunca. Aumente para mantener descripciones largas intactas al costo de más contexto por turno; disminuya para ajustar más skills bajo [`skillListingBudgetFraction`](#available-settings). Requiere Fuxi Code v2.1.105 o posterior | `2048` |
| `skillOverrides` | {/* min-version: 2.1.129 */}Anulaciones de visibilidad por skill con clave de nombre de skill. El valor es `"on"`, `"name-only"`, `"user-invocable-only"`, u `"off"`. Permite ocultar o contraer un skill sin editar su SKILL.md. No se aplica a skills de plugin, que se gestionan a través de `/plugin`. El menú `/skills` escribe estos en `.fuxi/settings.local.json`. Consulte [Anular visibilidad de skill desde configuraciones](/es/skills#override-skill-visibility-from-settings). Requiere Fuxi Code v2.1.129 o posterior | `{"legacy-context": "name-only", "deploy": "off"}` |
| `skipWebFetchPreflight` | Omitir la [verificación de seguridad de dominio de WebFetch](/es/data-usage#webfetch-domain-safety-check) que envía cada nombre de host solicitado a `api.anthropic.com` antes de obtener. Establecer en `true` en entornos que bloquean tráfico a Anthropic, como implementaciones de Amazon Bedrock, Google Cloud's Agent Platform, o Microsoft Foundry con salida restrictiva. Cuando se omite, WebFetch intenta cualquier URL sin consultar la lista de bloqueos | `true` |
| `spinnerTipsEnabled` | **Predeterminado**: `true`. Mostrar consejos en el spinner mientras Fuxi está trabajando. Establecer en `false` para deshabilitar consejos | `false` |
| `spinnerTipsOverride` | Anular consejos del spinner con cadenas personalizadas. `tips`: matriz de cadenas de consejo. `excludeDefault`: si es `true`, mostrar solo consejos personalizados; si es `false` o está ausente, los consejos personalizados se fusionan con consejos integrados | `{ "excludeDefault": true, "tips": ["Use our internal tool X"] }` |
| `spinnerVerbs` | Personalizar los verbos de acción mostrados mientras un turno está en progreso. Establezca `mode` en `"replace"` para usar solo sus verbos, o `"append"` para agregarlos a los predeterminados | `{"mode": "append", "verbs": ["Pondering", "Crafting"]}` |
| `sshConfigs` | Conexiones SSH a mostrar en el menú desplegable de entorno de [Desktop](/es/desktop#pre-configure-ssh-connections-for-your-team). Cada entrada requiere `id`, `name` y `sshHost`; `sshPort`, `sshIdentityFile` y `startDirectory` son opcionales. Cuando se establece en configuraciones administradas, las conexiones son de solo lectura para los usuarios. Se lee desde configuraciones administradas y de usuario solamente | `[{"id": "dev-vm", "name": "Dev VM", "sshHost": "user@dev.example.com"}]` |
| `statusLine` | Configurar una línea de estado personalizada para mostrar contexto. Los campos opcionales del objeto `padding`, `refreshInterval` y `hideVimModeIndicator` controlan espaciado, re-ejecuciones periódicas y si el indicador de modo vim integrado debajo del indicador está oculto. Consulte [documentación de `statusLine`](/es/statusline#manually-configure-a-status-line) | `{"type": "command", "command": "~/.fuxi/statusline.sh"}` |
| `strictKnownMarketplaces` | (Solo configuraciones administradas) Lista blanca de fuentes de marketplace de plugins. Sin definir = sin restricciones, matriz vacía = bloqueo. Aplicada en adición de marketplace y en instalación, actualización, actualización y auto-actualización de plugins, por lo que un marketplace agregado antes de que se estableciera la política no puede usarse para obtener plugins. Consulte [Restricciones de marketplace administradas](/es/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "source": "github", "repo": "acme-corp/plugins" }]` |
| `strictPluginOnlyCustomization` | (Solo configuraciones administradas) Bloquear skills, agents, hooks y MCP servers de fuentes de usuario y proyecto, para que solo puedan provenir de plugins o configuraciones administradas. `true` bloquea las cuatro superficies; una matriz bloquea solo las nombradas. Consulte [`strictPluginOnlyCustomization`](#strictpluginonlycustomization) | `["skills", "hooks"]` |
| `syntaxHighlightingDisabled` | Deshabilitar resaltado de sintaxis en diffs, bloques de código y vistas previas de archivos | `true` |
| `teammateMode` | **Predeterminado**: `in-process`. Cómo se muestran los compañeros de [equipo de agentes](/es/agent-teams): `in-process`, `auto` (paneles divididos en tmux o iTerm2, en proceso de otra manera), `tmux` (paneles divididos usando tmux o iTerm2, detectado desde su terminal), o {/* min-version: 2.1.186 */}}`iterm2` (paneles divididos nativos de iTerm2 a través de la CLI `it2`, agregado en v2.1.186). El predeterminado cambió de `auto` en v2.1.179. `--teammate-mode` anula esto para una sesión. Consulte [elegir un modo de visualización](/es/agent-teams#choose-a-display-mode) | `"auto"` |
| `terminalProgressBarEnabled` | **Predeterminado**: `true`. Mostrar la barra de progreso del terminal en terminales compatibles: ConEmu, Ghostty 1.2.0+, e iTerm2 3.6.6+. Aparece en `/config` como **Terminal progress bar** | `false` |
| `theme` | {/* min-version: 2.1.119 */}**Predeterminado**: `"dark"`. Tema de color para la interfaz: `"auto"`, `"dark"`, `"light"`, `"dark-daltonized"`, `"light-daltonized"`, `"dark-ansi"`, `"light-ansi"`, o una referencia de tema personalizado como `"custom:"` o `"custom::"`. Consulte [Crear un tema personalizado](/es/terminal-config#create-a-custom-theme). Aparece en `/config` como **Theme** | `"dark"` |
| `tui` | Renderizador de interfaz de usuario de terminal. Use `"fullscreen"` para el renderizador [alt-screen](/es/fullscreen) sin parpadeos con scrollback virtualizado. Use `"default"` para el renderizador clásico de pantalla principal. Establezca a través de `/tui`. También puede establecer la variable de entorno [`FUXI_CODE_NO_FLICKER`](/es/env-vars). Las sesiones de fondo abiertas desde [vista de agentes](/es/agent-view) siempre usan el renderizador de pantalla completa independientemente de esta configuración | `"fullscreen"` |
| `ultracode` | Activar [ultracode](/es/workflows#let-fuxi-decide-with-ultracode) para la sesión actual. Esta clave no se lee desde `settings.json`. Establézcala a través de `/effort ultracode`, `--settings`, o una solicitud de control del Agent SDK. {/* min-version: 2.1.203 */}Para iniciar una sesión con ultracode ya activado, lance con `fuxi --effort ultracode`, que requiere Fuxi Code v2.1.203 o posterior | `true` |
| `useAutoModeDuringPlan` | **Predeterminado**: `true`. Si el modo de plan usa semántica de modo automático cuando el modo automático está disponible. No se lee desde configuraciones de proyecto compartidas. Aparece en `/config` como "Use auto mode during plan" | `false` |
| `verbose` | {/* min-version: 2.1.119 */}**Predeterminado**: `false`. Mostrar salida completa de herramientas en lugar de resúmenes truncados. Aparece en `/config` como **Verbose output**. La bandera `--verbose` anula esto para una sesión | `true` |
| `viewMode` | Modo de vista de transcripción predeterminado al inicio: `"default"`, `"verbose"`, o `"focus"`. Anula la selección pegajosa de `/focus` cuando se establece. La bandera `--verbose` anula esto para una sesión | `"verbose"` |
| `voice` | Configuración de [dictado de voz](/es/voice-dictation): `enabled` activa el dictado, `mode` selecciona `"hold"` o `"tap"`, y `autoSubmit` envía el indicador al soltar la tecla en modo hold. Se escribe automáticamente cuando ejecuta `/voice`. Requiere una cuenta de Fuxi.ai | `{ "enabled": true, "mode": "tap" }` |
| `voiceEnabled` | Alias heredado para `voice.enabled`. Prefiera el objeto `voice` | `true` |
| `wheelScrollAccelerationEnabled` | {/* min-version: 2.1.174 */}**Predeterminado**: `true`. En [renderizado de pantalla completa](/es/fullscreen#mouse-wheel-scrolling), acelerar la velocidad de desplazamiento de la rueda del ratón durante desplazamientos rápidos. Establezca en `false` para una velocidad de desplazamiento constante por muesca de rueda. Requiere Fuxi Code v2.1.174 o posterior | `false` |
| `workflowKeywordTriggerEnabled` | {/* min-version: 2.1.157 */}**Predeterminado**: `true`. Si la palabra clave `ultracode` en un indicador activa un [flujo de trabajo dinámico](/es/workflows#ask-for-a-workflow-in-your-prompt). Establecer en `false` para escribir la palabra sin activar uno. La configuración de esfuerzo ultracode, `/workflows` y comandos de flujo de trabajo guardados no se ven afectados. Aparece en `/config` como **Ultracode keyword trigger**. Agregado en v2.1.157; antes de v2.1.160 la palabra clave de activación era `workflow` | `false` |
| `wslInheritsWindowsSettings` | (Solo configuraciones administradas de Windows) Cuando es `true`, Fuxi Code en WSL lee configuraciones administradas de la cadena de política de Windows además de `/etc/fuxi-code`, con fuentes de Windows teniendo prioridad. Solo se honra cuando se establece en la clave de registro HKLM o `C:\Program Files\FuxiCode\managed-settings.json`, ambas requieren administrador de Windows para escribir. Para que la política HKCU también se aplique en WSL, la bandera debe establecerse además en HKCU mismo. No tiene efecto en Windows nativo | `true` |
Ajustes de config global
Estas configuraciones se almacenan en `~/.fuxi.json` en lugar de `settings.json`. Agregarlas a `settings.json` activará un error de validación de esquema.
Las versiones anteriores a v2.1.119 también almacenan varios números de preferencias de `/config` aquí en lugar de en `settings.json`, incluyendo `theme`, `verbose`, `editorMode`, `autoCompactEnabled` y `preferredNotifChannel`.
| Clave | Descripción | Ejemplo |
| :------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------- |
| `autoConnectIde` | **Predeterminado**: `false`. Conectarse automáticamente a un IDE en ejecución cuando Fuxi Code se inicia desde una terminal externa. Aparece en `/config` como **Auto-connect to IDE (external terminal)** cuando se ejecuta fuera de una terminal de VS Code o JetBrains. La variable de entorno [`FUXI_CODE_AUTO_CONNECT_IDE`](/es/env-vars) anula esto cuando se establece | `true` |
| `autoInstallIdeExtension` | **Predeterminado**: `true`. Instalar automáticamente la extensión de Fuxi Code IDE cuando se ejecuta desde una terminal de VS Code. Aparece en `/config` como **Auto-install IDE extension** cuando se ejecuta dentro de una terminal de VS Code o JetBrains. También puede establecer la variable de entorno [`FUXI_CODE_IDE_SKIP_AUTO_INSTALL`](/es/env-vars) en `1` | `false` |
| `externalEditorContext` | **Predeterminado**: `false`. Anteponer la respuesta anterior de Fuxi como contexto comentado con `#` cuando abre el editor externo con `Ctrl+G`. Aparece en `/config` como **Show last response in external editor** | `true` |
| `teammateDefaultModel` | Modelo predeterminado para compañeros de [equipo de agentes](/es/agent-teams) cuando el indicador de generación no especifica uno. Establezca en un alias de modelo como `"sonnet"`, o `null` para heredar la selección actual de `/model` del líder. Aparece en `/config` como **Default teammate model** | `"sonnet"` |
| `workflowSizeGuideline` | {/* min-version: 2.1.202 */}**Predeterminado**: `unrestricted`, que no envía ninguna directriz. Establece el [recuento de agentes que Fuxi apunta](/es/workflows#set-a-size-guideline) en los flujos de trabajo dinámicos que escribe. Fuxi Code envía el valor a Fuxi como consejo, no como un límite aplicado. Acepta `unrestricted`, `small`, `medium`, o `large`. Aparece en `/config` como **Dynamic workflow size**. También puede establecerlo directamente con `/config workflowSizeGuideline=small`. Requiere Fuxi Code v2.1.202 o posterior. {/* min-version: 2.1.203 */}La directriz de recuento de agentes también reemplaza el umbral predeterminado para la [advertencia de `Large workflow`](/es/workflows#cost); ese comportamiento requiere Fuxi Code v2.1.203 o posterior | `"small"` |
Configuración de worktrees
Configure cómo `--worktree` crea y gestiona git worktrees.
| Clave | Descripción | Ejemplo |
| :---------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------ |
| `worktree.baseRef` | Qué ref ramifican los nuevos worktrees. `"fresh"` (predeterminado) ramifica desde `origin/` para un árbol limpio que coincida con el remoto. `"head"` ramifica desde su `HEAD` local actual, por lo que los commits no enviados y el estado de rama de características están presentes en el worktree. Se aplica a `--worktree`, la herramienta `EnterWorktree` y el aislamiento de subagent | `"head"` |
| `worktree.symlinkDirectories` | Directorios a enlazar simbólicamente desde el repositorio principal en cada worktree para evitar duplicar directorios grandes en disco. No se enlazan directorios de forma predeterminada | `["node_modules", ".cache"]` |
| `worktree.sparsePaths` | Directorios a verificar en cada worktree a través de git sparse-checkout. Solo las rutas listadas más archivos de nivel raíz se escriben en disco, lo que es más rápido en monorepos grandes | `["packages/my-app", "shared/utils"]` |
| `worktree.bgIsolation` | {/* min-version: 2.1.143 */}Modo de aislamiento para [sesiones de fondo](/es/agent-view#how-file-edits-are-isolated). `"worktree"` (predeterminado) bloquea `Edit`/`Write` en el checkout principal hasta que se llame a `EnterWorktree`. {/* min-version: 2.1.203 */}Fuera de un repositorio de git, un [hook `WorktreeCreate`](/es/worktrees#non-git-version-control) que falla libera el bloqueo para que la sesión pueda editar el directorio de trabajo en su lugar; requiere Fuxi Code v2.1.203 o posterior. `"none"` permite que los trabajos de fondo editen la copia de trabajo directamente. Requiere Fuxi Code v2.1.143 o posterior | `"none"` |
Para copiar archivos ignorados por git como `.env` en nuevos worktrees, use un [archivo `.worktreeinclude`](/es/worktrees#copy-gitignored-files-into-worktrees) en la raíz de su proyecto en lugar de una configuración.
Configuración de permisos
| Claves | Descripción | Ejemplo |
| :---------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :--------------------------------------------------------------------- |
| `allow` | Matriz de reglas de permiso para permitir el uso de herramientas. Los globs de nombre de herramienta se admiten solo en la posición de herramienta después de un prefijo literal `mcp____`, como `mcp__github__get_*`; el segmento de servidor debe estar libre de glob. Consulte [Sintaxis de regla de permiso](#permission-rule-syntax) a continuación para detalles de coincidencia de patrones | `[ "Bash(git diff *)" ]` |
| `ask` | Matriz de reglas de permiso para pedir confirmación al usar herramientas. Consulte [Sintaxis de regla de permiso](#permission-rule-syntax) a continuación | `[ "Bash(git push *)" ]` |
| `deny` | Matriz de reglas de permiso para denegar el uso de herramientas. Use esto para excluir archivos sensibles del acceso de Fuxi Code. Los nombres de herramientas aceptan patrones glob: `"*"` deniega cada herramienta y `"mcp__*"` deniega todas las herramientas MCP. Consulte [Sintaxis de regla de permiso](#permission-rule-syntax) y [Limitaciones de permiso de Bash](/es/permissions#tool-specific-permission-rules) | `[ "WebFetch", "Bash(curl *)", "Read(./.env)", "Read(./secrets/**)" ]` |
| `additionalDirectories` | [Directorios de trabajo](/es/permissions#working-directories) adicionales para acceso a archivos. La mayoría de la configuración de `.fuxi/` [no se descubre](/es/permissions#additional-directories-grant-file-access-not-configuration) desde estos directorios | `[ "../docs/" ]` |
| `defaultMode` | [Modo de permiso](/es/permission-modes) predeterminado al abrir Fuxi Code. Valores válidos: `default`, `acceptEdits`, `plan`, `auto`, `dontAsk`, `bypassPermissions`, y {/* min-version: 2.1.200 */}}`manual` como alias para `default`, el modo etiquetado Manual en la CLI y las extensiones de VS Code y JetBrains. El alias `manual` requiere Fuxi Code v2.1.200 o posterior. {/* min-version: 2.1.142 */}A partir de Fuxi Code v2.1.142, `auto` se ignora cuando se establece en configuraciones de proyecto o local (`.fuxi/settings.json`, `.fuxi/settings.local.json`) para que un repositorio no pueda otorgarse a sí mismo modo automático. Establézcalo en `~/.fuxi/settings.json` en su lugar. Antes de v2.1.142, las configuraciones de proyecto podían establecer `auto`. La bandera CLI `--permission-mode` anula esta configuración para una única sesión | `"acceptEdits"` |
| `disableBypassPermissionsMode` | Establecer en `"disable"` para evitar que se active el modo `bypassPermissions`. Esto deshabilita la bandera de línea de comandos `--dangerously-skip-permissions`. Típicamente colocado en [configuraciones administradas](/es/permissions#managed-settings) para aplicar política organizacional, pero funciona desde cualquier ámbito | `"disable"` |
| `skipDangerousModePermissionPrompt` | Omitir el aviso de confirmación mostrado antes de entrar en modo de permisos de derivación a través de `--dangerously-skip-permissions` o `defaultMode: "bypassPermissions"`. Se ignora cuando se establece en configuraciones de proyecto (`.fuxi/settings.json`) para evitar que repositorios no confiables omitan automáticamente el aviso | `true` |
Sintaxis de regla de permiso
Las reglas de permiso siguen el formato `Tool` o `Tool(specifier)`. Las reglas se evalúan en orden: primero reglas de denegación, luego preguntar, luego permitir. La primera regla coincidente determina el resultado independientemente de la especificidad de la regla. Consulte [orden de evaluación de regla de permiso](/es/permissions#manage-permissions) para obtener detalles.
Ejemplos rápidos:
| Regla | Efecto |
| :----------------------------- | :------------------------------------------------- |
| `Bash` | Coincide con todos los comandos Bash |
| `Bash(npm run *)` | Coincide con comandos que comienzan con `npm run` |
| `Read(./.env)` | Coincide con la lectura del archivo `.env` |
| `WebFetch(domain:example.com)` | Coincide con solicitudes de búsqueda a example.com |
Para la referencia completa de sintaxis de regla, incluyendo comportamiento de comodín, patrones específicos de herramientas para Read, Edit, WebFetch, MCP, y reglas de Agent, y limitaciones de seguridad de patrones de Bash, consulte [Sintaxis de regla de permiso](/es/permissions#permission-rule-syntax).
Configuración de sandbox
Configure el comportamiento avanzado de sandboxing. El sandboxing aísla comandos bash de su sistema de archivos y red. Consulte [Sandboxing](/es/sandboxing) para obtener detalles.
| Claves | Descripción | Ejemplo |
| :------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :--------------------------------------------------- |
| `enabled` | Habilitar sandboxing de bash (macOS, Linux y WSL2). Predeterminado: false | `true` |
| `failIfUnavailable` | Salir con un error al inicio si `sandbox.enabled` es true pero el sandbox no puede iniciarse (dependencias faltantes o plataforma no compatible). Cuando es false (predeterminado), se muestra una advertencia y los comandos se ejecutan sin sandbox. Destinado a implementaciones de configuraciones administradas que requieren sandboxing como una puerta dura | `true` |
| `autoAllowBashIfSandboxed` | Aprobar automáticamente comandos bash cuando están en sandbox. Predeterminado: true | `true` |
| `excludedCommands` | Comandos que deben ejecutarse fuera del sandbox | `["docker *"]` |
| `allowUnsandboxedCommands` | Permitir que los comandos se ejecuten fuera del sandbox a través del parámetro `dangerouslyDisableSandbox`. Cuando se establece en `false`, el escape hatch `dangerouslyDisableSandbox` se deshabilita completamente y todos los comandos deben ejecutarse en sandbox (o estar en `excludedCommands`). Útil para políticas empresariales que requieren sandboxing estricto. Predeterminado: true | `false` |
| `filesystem.allowWrite` | Rutas adicionales donde los comandos en sandbox pueden escribir. Las matrices se fusionan en todos los ámbitos de configuración: las rutas de usuario, proyecto y administradas se combinan, no se reemplazan. También se fusionan con rutas de reglas de permiso `Edit(...)` permitidas. Consulte [prefijos de ruta de sandbox](#sandbox-path-prefixes) a continuación. | `["/tmp/build", "~/.kube"]` |
| `filesystem.denyWrite` | Rutas donde los comandos en sandbox no pueden escribir. Las matrices se fusionan en todos los ámbitos de configuración. También se fusionan con rutas de reglas de permiso `Edit(...)` denegadas. | `["/etc", "/usr/local/bin"]` |
| `filesystem.denyRead` | Rutas donde los comandos en sandbox no pueden leer. Las matrices se fusionan en todos los ámbitos de configuración. También se fusionan con rutas de reglas de permiso `Read(...)` denegadas. | `["~/.aws/credentials"]` |
| `filesystem.allowRead` | Rutas para permitir nuevamente la lectura dentro de regiones `denyRead`. Tiene precedencia sobre `denyRead`. Las matrices se fusionan en todos los ámbitos de configuración. Use esto para crear patrones de acceso de lectura solo para el espacio de trabajo. | `["."]` |
| `filesystem.allowManagedReadPathsOnly` | (Solo configuraciones administradas) Solo se respetan rutas `allowRead` de configuraciones administradas. Las entradas `denyRead` aún se fusionan desde todas las fuentes. Predeterminado: false | `true` |
| `credentials.files` | {/* min-version: 2.1.187 */}Archivos o directorios de credenciales que los comandos en sandbox no pueden leer. Aplica el mismo bloqueo de lectura que `filesystem.denyRead`; la clave separada mantiene las rutas de credenciales agrupadas con `credentials.envVars` y aparte de las reglas generales del sistema de archivos. Cada entrada es `{ "path": "...", "mode": "deny" }`, y `deny` es el único modo compatible para archivos. Las rutas usan los mismos [prefijos](#sandbox-path-prefixes) que configuraciones `filesystem.*`. Las matrices se fusionan en todos los ámbitos de configuración. Requiere Fuxi Code v2.1.187 o posterior. | `[{ "path": "~/.aws/credentials", "mode": "deny" }]` |
| `credentials.envVars` | {/* min-version: 2.1.187 */}Variables de entorno a [proteger de comandos en sandbox](/es/sandboxing#protect-credentials). Cada entrada tiene un `name` y un `mode`; el nombre debe comenzar con una letra o guion bajo y contener solo letras, dígitos y guiones bajos. `deny` elimina la variable del entorno de comandos en sandbox. Requiere Fuxi Code v2.1.187 o posterior. {/* min-version: 2.1.199 */}}`mask` reemplaza la variable con un valor centinela por sesión dentro del sandbox mientras el proxy del sandbox sustituye el valor real en solicitudes salientes a los `injectHosts` de esa entrada; requiere `network.tlsTerminate` y Fuxi Code v2.1.199 o posterior. Las entradas `mask` solo se honran desde configuraciones de usuario, administradas o CLI `--settings`, no desde `.fuxi/settings.json` o `.fuxi/settings.local.json`. Las matrices se fusionan en todos los ámbitos de configuración, y `deny` tiene precedencia cuando la misma variable aparece con ambos modos. | `[{ "name": "GITHUB_TOKEN", "mode": "deny" }]` |
| `credentials.envVars[].injectHosts` | Hosts donde el proxy del sandbox sustituye el valor real de una entrada `mask`. Cada host también debe estar cubierto por `network.allowedDomains`, ya sea exactamente o por un comodín. Cuando no está definido, el proxy sustituye el valor en solicitudes a cada host en `network.allowedDomains`. Se acepta pero se ignora cuando `mode` es `deny`. Requiere Fuxi Code v2.1.199 o posterior. {/* min-version: 2.1.199 */} | `["api.github.com"]` |
| `credentials.allowPlaintextInject` | Permitir sustitución `mask` en solicitudes HTTP simples así como HTTPS terminado por TLS. En HTTP simple la identidad ascendente no se verifica y la credencial viaja en texto plano, así que deje esto desactivado fuera de redes de prueba confiables. Solo se honra desde configuraciones de usuario, administradas o CLI `--settings`, no desde `.fuxi/settings.json` o `.fuxi/settings.local.json`. Predeterminado: false. Requiere Fuxi Code v2.1.199 o posterior. {/* min-version: 2.1.199 */} | `true` |
| `network.allowUnixSockets` | (Solo macOS) Rutas de socket Unix accesibles en sandbox. Se ignora en Linux y WSL2, donde el filtro seccomp no puede inspeccionar rutas de socket; use `allowAllUnixSockets` en su lugar. | `["~/.ssh/agent-socket"]` |
| `network.allowAllUnixSockets` | Permitir todas las conexiones de socket Unix en sandbox. En Linux y WSL2 esta es la única forma de permitir sockets Unix, ya que omite el filtro seccomp que de otra manera bloquea llamadas `socket(AF_UNIX, ...)`. Predeterminado: false | `true` |
| `network.allowLocalBinding` | Permitir vinculación a puertos localhost (solo macOS). Predeterminado: false | `true` |
| `network.allowMachLookup` | Nombres de servicio XPC/Mach adicionales que el sandbox puede buscar (solo macOS). Admite un único `*` final para coincidencia de prefijo. Necesario para herramientas que se comunican a través de XPC como el Simulador de iOS o Playwright. | `["com.apple.coresimulator.*"]` |
| `network.allowedDomains` | Matriz de dominios para permitir tráfico de red saliente. Admite comodines (por ejemplo, `*.example.com`). | `["github.com", "*.npmjs.org"]` |
| `network.deniedDomains` | Matriz de dominios para bloquear tráfico de red saliente. Admite la misma sintaxis de comodín que `allowedDomains`. Tiene precedencia sobre `allowedDomains` cuando ambos coinciden. Se fusiona desde todas las fuentes de configuración independientemente de `allowManagedDomainsOnly`. | `["sensitive.cloud.example.com"]` |
| `network.allowManagedDomainsOnly` | (Solo configuraciones administradas) Solo se respetan `allowedDomains` y reglas de permiso `WebFetch(domain:...)` permitidas de configuraciones administradas. Los dominios de configuraciones de usuario, proyecto y local se ignoran. Los dominios no permitidos se bloquean automáticamente sin solicitar al usuario. Los dominios denegados aún se respetan desde todas las fuentes. Predeterminado: false | `true` |
| `network.httpProxyPort` | Puerto de proxy HTTP usado si desea traer su propio proxy. Si no se especifica, Fuxi ejecutará su propio proxy. | `8080` |
| `network.socksProxyPort` | Puerto de proxy SOCKS5 usado si desea traer su propio proxy. Si no se especifica, Fuxi ejecutará su propio proxy. | `8081` |
| `network.tlsTerminate` | Experimental. Terminar TLS dentro del proxy del sandbox para que pueda leer el contenido de solicitudes HTTPS. Requerido para sustitución de credenciales `mask` [](/es/sandboxing#protect-credentials). Establezca `{}` para generar una autoridad de certificación efímera para la sesión, o establezca `caCertPath` y `caKeyPath` para usar la suya propia. Solo se honra desde configuraciones de usuario, administradas o CLI `--settings`, no desde `.fuxi/settings.json` o `.fuxi/settings.local.json`. Requiere Fuxi Code v2.1.199 o posterior. {/* min-version: 2.1.199 */} | `{}` |
| `enableWeakerNestedSandbox` | Habilitar sandbox más débil para entornos Docker sin privilegios (solo Linux y WSL2). **Reduce la seguridad.** Predeterminado: false | `true` |
| `enableWeakerNetworkIsolation` | (Solo macOS) Permitir acceso al servicio de confianza TLS del sistema (`com.apple.trustd.agent`) en el sandbox. Requerido para herramientas basadas en Go como `gh`, `gcloud` y `terraform` para verificar certificados TLS cuando se usa `httpProxyPort` con un proxy MITM y CA personalizada. **Reduce la seguridad** al abrir una posible ruta de exfiltración de datos. Predeterminado: false | `true` |
| `allowAppleEvents` | (Solo macOS) Permitir que comandos en sandbox envíen Apple Events. Requerido para `open`, `osascript` y herramientas que abren URLs en un navegador, que de otra manera fallan con error `-600`. **Elimina el aislamiento de ejecución de código.** Los comandos en sandbox pueden lanzar otras aplicaciones sin sandbox sin solicitud del usuario; también pueden enviar comandos AppleScript a aplicaciones en ejecución como Terminal, sujeto al aviso de consentimiento de automatización por aplicación de macOS (TCC). Solo se honra desde configuraciones de usuario, administradas o CLI, no desde configuraciones de proyecto. Predeterminado: false | `true` |
| `bwrapPath` | (Solo configuraciones administradas, Linux/WSL2) Ruta absoluta al binario bubblewrap (`bwrap`). Anula la detección automática a través de `PATH`. Solo se honra desde [configuraciones administradas](/es/settings#settings-files), no desde configuraciones de usuario o proyecto. Útil cuando `bwrap` se instala en una ubicación no estándar en entornos administrados. | `/opt/admin/bwrap` |
| `socatPath` | (Solo configuraciones administradas, Linux/WSL2) Ruta absoluta al binario `socat` usado para el proxy de red del sandbox. Anula la detección automática a través de `PATH`. Solo se honra desde configuraciones administradas. | `/opt/admin/socat` |
Prefijos de ruta de sandbox
Las rutas en `filesystem.allowWrite`, `filesystem.denyWrite`, `filesystem.denyRead`, `filesystem.allowRead` y `credentials.files` admiten estos prefijos:
| Prefijo | Significado | Ejemplo |
| :----------------- | :---------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------- |
| `/` | Ruta absoluta desde la raíz del sistema de archivos | `/tmp/build` se mantiene como `/tmp/build` |
| `~/` | Relativo al directorio de inicio | `~/.kube` se convierte en `$HOME/.kube` |
| `./` o sin prefijo | Relativo a la raíz del proyecto para configuraciones de proyecto, o a `~/.fuxi` para configuraciones de usuario | `./output` en `.fuxi/settings.json` se resuelve a `/output` |
El prefijo anterior `//path` para rutas absolutas aún funciona. Si anteriormente usó `/path` esperando resolución relativa al proyecto, cambie a `./path`. Esta sintaxis difiere de [reglas de permiso Read y Edit](/es/permissions#read-and-edit), que usan `//path` para absoluto y `/path` para relativo al proyecto. Las rutas del sistema de archivos de sandbox usan convenciones estándar: `/tmp/build` es una ruta absoluta.
**Ejemplo de configuración:**
```json theme={null}
{
"sandbox": {
"enabled": true,
"autoAllowBashIfSandboxed": true,
"excludedCommands": ["docker *"],
"filesystem": {
"allowWrite": ["/tmp/build", "~/.kube"],
"denyRead": ["~/.aws/credentials"]
},
"network": {
"allowedDomains": ["github.com", "*.npmjs.org", "registry.yarnpkg.com"],
"deniedDomains": ["uploads.github.com"],
"allowUnixSockets": [
"/var/run/docker.sock"
],
"allowLocalBinding": true
}
}
}
```
**Las restricciones de sistema de archivos y red** se pueden configurar de dos formas que se fusionan:
* **Configuraciones `sandbox.filesystem`** (mostradas arriba): Controlan rutas en el límite del sandbox a nivel de SO. Estas restricciones se aplican a todos los comandos de subproceso (por ejemplo, `kubectl`, `terraform`, `npm`), no solo a las herramientas de archivo de Fuxi.
* **Reglas de permiso**: Use reglas de permiso `Edit` permitidas/denegadas para controlar el acceso a la herramienta de archivo de Fuxi, reglas de denegación `Read` para bloquear lecturas, y reglas de permiso `WebFetch` permitidas/denegadas para controlar dominios de red. Las rutas de estas reglas también se fusionan en la configuración del sandbox.
Configuración de atribución
Fuxi Code agrega atribución a commits de git y solicitudes de extracción. Estos se configuran por separado:
* Los commits usan [git trailers](https://git-scm.com/docs/git-interpret-trailers) (como `Co-Authored-By`) de forma predeterminada, que se pueden personalizar o deshabilitar
* Las descripciones de solicitudes de extracción son texto sin formato
| Claves | Descripción |
| :----------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `commit` | Atribución para commits de git, incluyendo cualquier trailer. La cadena vacía oculta la atribución de commit |
| `pr` | Atribución para descripciones de solicitudes de extracción. La cadena vacía oculta la atribución de solicitud de extracción |
| `sessionUrl` | Si se debe agregar el enlace de sesión de fuxi.ai como un trailer `Fuxi-Session` en commits y un enlace en descripciones de solicitudes de extracción cuando se ejecuta desde una sesión web o Remote Control. Predeterminado: `true`. Establezca en `false` para omitir el enlace |
**Atribución de commit predeterminada:**
```text theme={null}
Co-Authored-By: Fuxi Sonnet 5
```
El nombre del modelo en el trailer refleja el modelo activo para la sesión.
**Atribución de solicitud de extracción predeterminada:**
```text theme={null}
🤖 Generated with [Fuxi Code](https://fuxi.com/fuxi-code)
```
**Ejemplo:**
```json theme={null}
{
"attribution": {
"commit": "Generated with AI\n\nCo-Authored-By: AI ",
"pr": ""
}
}
```
La configuración `attribution` tiene precedencia sobre la configuración `includeCoAuthoredBy` obsoleta. Para ocultar toda la atribución, establezca `commit` y `pr` en cadenas vacías y `sessionUrl` en `false`.
Configuración de sugerencia de archivo
Configure un comando personalizado para autocompletado de ruta de archivo `@`. La sugerencia de archivo integrada utiliza recorrido rápido del sistema de archivos, pero los monorepos grandes pueden beneficiarse de indexación específica del proyecto como un índice de archivo precompilado o herramientas personalizadas.
```json theme={null}
{
"fileSuggestion": {
"type": "command",
"command": "~/.fuxi/file-suggestion.sh"
}
}
```
El comando se ejecuta con las mismas variables de entorno que [hooks](/es/hooks), incluyendo `FUXI_PROJECT_DIR`. Recibe JSON a través de stdin con un campo `query`:
```json theme={null}
{"query": "src/comp"}
```
Genere rutas de archivo separadas por saltos de línea a stdout (actualmente limitado a 15):
```text theme={null}
src/components/Button.tsx
src/components/Modal.tsx
src/components/Form.tsx
```
**Ejemplo:**
```bash theme={null}
#!/bin/bash
query=$(cat | jq -r '.query')
# Replace your-repo-file-index with your own file search command
your-repo-file-index --query "$query" | head -20
```
La configuración `footerLinksRegexes` renderiza insignias clickeables adicionales en el pie de página debajo del cuadro de entrada. Use esto para convertir IDs impresos por CLI de proyecto, como herramientas de revisión e rastreadores de problemas, en enlaces de sesión.
Cada entrada `pattern` de regex se compara contra la salida del turno: resultados de herramientas, incluyendo contenidos de archivo y páginas obtenidas, y respuestas propias de Fuxi. Los placeholders `{name}` en `url` y `label` se rellenan desde grupos de captura nombrados en el patrón.
El siguiente ejemplo renderiza una insignia siempre que aparezca una clave de problema como `PROJ-1234` en la salida del turno. El grupo nombrado `(?...)` captura la clave, y `{key}` la sustituye en la URL y etiqueta:
```json ~/.fuxi/settings.json theme={null}
{
"footerLinksRegexes": [
{
"type": "regex",
"pattern": "\\b(?PROJ-\\d+)\\b",
"url": "https://issues.example.com/browse/{key}",
"label": "{key}"
}
]
}
```
Con esto configurado, cuando `PROJ-1234` aparece en un resultado de herramienta o en la respuesta de Fuxi, aparece una ficha `PROJ-1234` en el pie de página vinculada a `https://issues.example.com/browse/PROJ-1234`.
Las siguientes restricciones se aplican a cada entrada:
| Restricción | Comportamiento |
| :---------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Origen de URL | Los valores capturados se codifican en URL y la URL construida debe compartir el origen literal de la plantilla. Una captura puede rellenar un segmento de ruta o valor de consulta pero no puede cambiar a dónde apunta el enlace |
| Longitud de URL | Las URLs construidas más largas que 2048 caracteres se descartan |
| Esquema de URL | Debe ser `https`, `http`, o un esquema de enlace profundo reconocido de editor o espacio de trabajo: `vscode`, `vscode-insiders`, `cursor`, `windsurf`, `zed`, `jetbrains`, `idea`, `slack`, `linear`, `notion`, `figma` |
| Etiqueta | Predeterminado al texto coincidente y se trunca a 28 columnas de visualización |
| Recuento de insignias | Como máximo 5 insignias se renderizan. La más antigua se desplaza por coincidencias más nuevas y `/clear` las elimina |
| Ámbito de configuración | Se lee desde configuraciones de usuario, bandera `--settings` y configuraciones administradas solamente. Se ignora en `.fuxi/settings.json` de proyecto y `.fuxi/settings.local.json` local |
Cuando un turno se completa, Fuxi Code compara cada entrada `pattern` regex contra la salida del turno en el hilo principal, por lo que una regex lenta bloquea la UI hasta que finaliza. Las cuantificadores anidados como `(a+)+$` pueden tomar exponencialmente tiempo contra ciertas entradas y congelar la sesión, por lo que mantenga cada `pattern` lineal y evite anidar `+` o `*`.
Las insignias de pie de página se renderizan junto a una [línea de estado personalizada](/es/statusline) cuando se configura una; ninguna reemplaza a la otra. Use una línea de estado para una fila impulsada por script que calcula su propio contenido desde datos de sesión, e insignias de pie de página para convertir IDs de la conversación en enlaces sin un script.
Configuración de hooks
Estas configuraciones controlan qué hooks se pueden ejecutar y a qué pueden acceder los hooks HTTP. La configuración `allowManagedHooksOnly` solo se puede configurar en [configuraciones administradas](#settings-files). Las listas blancas de URL y variables de entorno se pueden establecer en cualquier nivel de configuración y se fusionan entre fuentes.
**Comportamiento cuando `allowManagedHooksOnly` es `true`:**
* Se cargan hooks administrados y hooks SDK
* Se cargan hooks de plugins forzadamente habilitados en la configuración administrada `enabledPlugins`. Esto permite que los administradores distribuyan hooks verificados a través de un marketplace de organización mientras bloquean todo lo demás. La confianza se otorga por ID completo de `plugin@marketplace`, por lo que un plugin con el mismo nombre de un marketplace diferente permanece bloqueado
* Se bloquean hooks de usuario, proyecto y todos los demás plugins
**Restringir URLs de hooks HTTP:**
Limitar qué URLs pueden dirigirse los hooks HTTP. Admite `*` como comodín para coincidencia. Cuando la matriz se define, los hooks HTTP que se dirigen a URLs que no coinciden se bloquean silenciosamente. La coincidencia de nombre de host no distingue entre mayúsculas y minúsculas e ignora un punto FQDN final, coincidiendo con la semántica de DNS.
```json theme={null}
{
"allowedHttpHookUrls": ["https://hooks.example.com/*", "http://localhost:*"]
}
```
**Restringir variables de entorno de hooks HTTP:**
Limitar qué nombres de variables de entorno pueden interpolar los hooks HTTP en valores de encabezado. El `allowedEnvVars` efectivo de cada hook es la intersección de su propia lista y esta configuración.
```json theme={null}
{
"httpHookAllowedEnvVars": ["MY_TOKEN", "HOOK_SECRET"]
}
```
Calcular configuraciones administradas con un asistente de política
La configuración `policyHelper` apunta a un ejecutable que calcula configuraciones administradas al inicio, para que los administradores puedan derivar política de postura de dispositivo, identidad, o un servicio remoto en lugar de un archivo estático. Configúrelo desde MDM o un archivo `managed-settings.json` del sistema. Fuxi Code ignora `policyHelper` cuando aparece en cualquier otro ámbito, incluyendo configuraciones de usuario, configuraciones de proyecto, el hive de registro HKCU, y [configuraciones administradas por servidor](/es/server-managed-settings).
La configuración acepta estas claves:
| Clave | Tipo | Descripción |
| ------------------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------- |
| `path` | string | Ruta absoluta al ejecutable del asistente |
| `timeoutMs` | number | Cuánto tiempo esperar al asistente antes de tratar la ejecución como fallida |
| `refreshIntervalMs` | number | Con qué frecuencia re-ejecutar el asistente en segundo plano. Establezca en `0` para deshabilitar la actualización, o en al menos `60000` |
El asistente escribe una envoltura JSON a stdout. Ponga las configuraciones bajo una clave `managedSettings` en lugar de en el nivel superior, ya que un objeto de configuraciones desnudo se analiza con `managedSettings` indefinido y no aplica nada:
```json theme={null}
{
"managedSettings": {
"permissions": { "deny": ["Read(//etc/secrets/**)"] }
},
"fuxiMd": "# Organization context\n...",
"appendSystemPrompt": "Always cite the internal style guide."
}
```
Cuando el asistente emite `managedSettings`, ese objeto se convierte en la única fuente de configuraciones administradas para la ejecución, tomando precedencia sobre fuentes remotas, MDM y basadas en archivos. Cuando el asistente sale con código no cero al inicio, Fuxi Code imprime el error y se niega a iniciar, por lo que un asistente que necesita resiliencia de interrupción debe servir desde su propio caché y salir con `0`.
Precedencia de configuración
Las configuraciones se aplican en orden de precedencia. De mayor a menor:
1. **Configuraciones administradas** ([administradas por servidor](/es/server-managed-settings), [políticas de MDM/nivel de SO](#configuration-scopes), o [configuraciones administradas](/es/settings#settings-files))
* Políticas implementadas por TI a través de entrega de servidor, perfiles de configuración MDM, políticas de registro o archivos de configuración administrados
* No pueden ser anuladas por ningún otro nivel, incluyendo argumentos de línea de comandos
* Dentro del nivel administrado, solo se usa una fuente y las otras se ignoran en lugar de fusionarse. Precedencia, de mayor a menor:
* Salida de [`policyHelper`](#compute-managed-settings-with-a-policy-helper): cuando se configura, esta es la única fuente administrada utilizada
* Remota (configuraciones administradas por servidor de fuxi.ai o políticas entregadas por [puerta de aplicaciones Fuxi](/es/fuxi-apps-gateway))
* Políticas de MDM/nivel de SO
* Basada en archivos (`managed-settings.d/*.json` y `managed-settings.json`, fusionadas juntas)
* Registro HKCU (solo Windows)
* Algunas claves son excepciones, honradas cuando cualquier fuente administrada controlada por administrador las establece en lugar de solo la fuente ganadora. La fuente de registro HKCU escribible por el usuario se excluye. Las claves de excepción son:
* las claves de bloqueo de sandbox `sandbox.network.allowManagedDomainsOnly` y `sandbox.filesystem.allowManagedReadPathsOnly`, con sus listas blancas asociadas
* `allowAllFuxiAiMcps`
* las rutas binarias de sandbox `sandbox.bwrapPath` y `sandbox.socatPath`
* [`forceRemoteSettingsRefresh`](/es/server-managed-settings)
* Los hosts de incrustación como Fuxi Desktop pueden suministrar política a través de la opción SDK `managedSettings`. De forma predeterminada, esto se ignora cuando está presente cualquier fuente administrada implementada por administrador: configuraciones administradas por servidor, una política de MDM o nivel de SO, o un archivo de configuración administrado. El fallback de registro HKCU escribible por el usuario no cuenta como una fuente administrada implementada por administrador. Los administradores pueden optar por establecer [`parentSettingsBehavior`](#available-settings) en `"merge"`. Los valores del incrustador se filtran para que puedan restringir la política administrada pero no flexibilizarla.
2. **Argumentos de línea de comandos**
* Anulaciones temporales para una sesión específica. JSON pasado a través de `--settings ` se fusiona con configuraciones basadas en archivos usando las mismas reglas que las otras capas: una clave establecida aquí anula la misma clave en configuraciones locales, de proyecto o de usuario, y omitir una clave deja el valor de capa inferior en su lugar
3. **Configuraciones de proyecto local** (`.fuxi/settings.local.json`)
* Configuraciones personales específicas del proyecto
4. **Configuraciones de proyecto compartidas** (`.fuxi/settings.json`)
* Configuraciones de proyecto compartidas por el equipo en control de código fuente
5. **Configuraciones de usuario** (`~/.fuxi/settings.json`)
* Configuraciones personales globales
Esta jerarquía asegura que las políticas organizacionales siempre se apliquen mientras aún permite que equipos e individuos personalicen su experiencia. La misma precedencia se aplica si ejecuta Fuxi Code desde la CLI, la [extensión de VS Code](/es/vs-code), o un [IDE de JetBrains](/es/jetbrains).
Por ejemplo, si su configuración de usuario establece `permissions.defaultMode` en `acceptEdits` y la configuración compartida de un proyecto la establece en `default`, el valor del proyecto se aplica. El ejemplo a continuación cubre cómo se combinan las configuraciones con valores de matriz como reglas de permiso en su lugar.
**Las configuraciones de matriz se fusionan entre ámbitos.** Cuando la misma configuración con valor de matriz (como `sandbox.filesystem.allowWrite` o `permissions.allow`) aparece en múltiples ámbitos, las matrices se **concatenan y se deduplicán**, no se reemplazan. Esto significa que los ámbitos de menor prioridad pueden agregar entradas sin anular las establecidas por ámbitos de mayor prioridad, y viceversa. Por ejemplo, si las configuraciones administradas establecen `allowWrite` en `["/opt/company-tools"]` y un usuario agrega `["~/.kube"]`, ambas rutas se incluyen en la configuración final.
Dos configuraciones de matriz no se fusionan de esta manera:
* [`fallbackModel`](#available-settings) es una cadena ordenada donde la posición tiene significado: el archivo de mayor precedencia que la define suministra el valor completo.
* [`availableModels`](#available-settings): {/* min-version: 2.1.175 */}cuando la [fuente administrada de mayor precedencia](/es/server-managed-settings#settings-precedence) la define, esa lista se aplica tal cual y las entradas de usuario, proyecto y local no pueden extenderla. Entre ámbitos no administrados las matrices se fusionan como de costumbre. Consulte [Comportamiento de fusión](/es/model-config#merge-behavior).
Verificar configuraciones activas
Ejecute `/status` dentro de Fuxi Code para ver qué fuentes de configuración están activas. Dentro del menú, la pestaña **Status** incluye una línea `Setting sources` que enumera cada capa que Fuxi Code cargó para la sesión actual, como `User settings` o `Project local settings`. Cuando [configuraciones administradas](/es/admin-setup#decide-how-settings-reach-devices) están en efecto, la entrada muestra el canal de entrega entre paréntesis, por ejemplo `Enterprise managed settings (remote)`, `(plist)`, `(HKLM)`, `(HKCU)`, o `(file)`. El canal `remote` cubre tanto configuraciones administradas por servidor de fuxi.ai como políticas entregadas por [puerta de aplicaciones Fuxi](/es/fuxi-apps-gateway). Una capa aparece en la lista solo cuando esa fuente se carga con al menos una clave, por lo que una lista vacía significa que no se encontraron fuentes de configuración.
La línea `Setting sources` confirma qué fuentes se están leyendo. No muestra qué capa suministró cada clave individual. La pestaña **Config** en el mismo diálogo es un editor para un conjunto fijo de toggles como tema y salida detallada, no una vista de sus contenidos de `settings.json`.
Si un archivo de configuración contiene errores, como JSON inválido o un valor que falla la validación, `/status` enumera los archivos afectados. Ejecute `/doctor` para ver los detalles de cada error.
Puntos clave sobre el sistema de configuración
* **Archivos de memoria (`FUXI.md`)**: Contienen instrucciones y contexto que Fuxi carga al inicio
* **Archivos de configuración (JSON)**: Configurar permisos, variables de entorno y comportamiento de herramientas
* **Skills**: Indicaciones personalizadas que se pueden invocar con `/skill-name` o cargar automáticamente por Fuxi
* **MCP servers**: Extender Fuxi Code con herramientas e integraciones adicionales
* **Precedencia**: Las configuraciones de nivel superior (Managed) anulan las de nivel inferior (User/Project)
* **Herencia**: Las configuraciones se fusionan entre ámbitos; los valores escalares de ámbitos de mayor prioridad anulan, y las matrices se concatenan, con dos excepciones descritas en la [Nota de fusión de matriz](#settings-precedence)
Indicador del sistema
El indicador del sistema interno de Fuxi Code no se publica. Para agregar instrucciones personalizadas, use archivos `FUXI.md` o la bandera `--append-system-prompt`.
Excluyendo archivos sensibles
Para evitar que Fuxi Code acceda a archivos que contienen información sensible como claves API, secretos y archivos de entorno, use la configuración `permissions.deny` en su archivo `.fuxi/settings.json`:
```json theme={null}
{
"permissions": {
"deny": [
"Read(./.env)",
"Read(./.env.*)",
"Read(./secrets/**)",
"Read(./config/credentials.json)",
"Read(./build)"
]
}
}
```
Esto reemplaza la configuración `ignorePatterns` obsoleta. Los archivos que coinciden con estos patrones se excluyen del descubrimiento de archivos y resultados de búsqueda, y las operaciones de lectura en estos archivos se deniegan.
Configuración de subagents
Fuxi Code admite subagents de IA personalizados que se pueden configurar en niveles de usuario y proyecto. Estos subagents se almacenan como archivos Markdown con frontmatter YAML:
* **Subagents de usuario**: `~/.fuxi/agents/`, disponibles en todos sus proyectos
* **Subagents de proyecto**: `.fuxi/agents/`, específicos de su proyecto y compartibles con su equipo
Los archivos de subagent definen asistentes de IA especializados con indicaciones personalizadas y permisos de herramientas. Obtenga más información sobre cómo crear y usar subagents en la [documentación de subagents](/es/sub-agents).
Configuración de plugins
Fuxi Code admite un sistema de plugins que le permite extender la funcionalidad con skills, agentes, hooks y servidores MCP. Los plugins se distribuyen a través de marketplaces y se pueden configurar en niveles de usuario y repositorio.
Ajustes de plugins
Configuraciones relacionadas con plugins en `settings.json`:
```json theme={null}
{
"enabledPlugins": {
"formatter@acme-tools": true,
"deployer@acme-tools": true,
"analyzer@security-plugins": false
},
"extraKnownMarketplaces": {
"acme-tools": {
"source": {
"source": "github",
"repo": "acme-corp/fuxi-plugins"
}
}
}
}
```
`enabledPlugins`
Controla qué plugins están habilitados. Formato: `"plugin-name@marketplace-name": true/false`. Un plugin sin entrada en ningún ámbito vuelve a su valor [`defaultEnabled`](/es/plugins-reference#default-enablement).
**Ámbitos**:
* **Configuraciones de usuario** (`~/.fuxi/settings.json`): Preferencias personales de plugins
* **Configuraciones de proyecto** (`.fuxi/settings.json`): Plugins específicos del proyecto compartidos con el equipo
* **Configuraciones locales** (`.fuxi/settings.local.json`): Anulaciones por máquina, ignoradas por git cuando Fuxi Code las crea
* **Configuraciones administradas** (`managed-settings.json`): Anulaciones de política a nivel de organización que bloquean la instalación en todos los ámbitos y ocultan el plugin del marketplace
Las configuraciones de proyecto tienen precedencia sobre las configuraciones de usuario, por lo que establecer un plugin en `false` en `~/.fuxi/settings.json` no deshabilita un plugin que la `.fuxi/settings.json` del proyecto habilita. Para optar por no participar en un plugin habilitado por el proyecto en su máquina, establézcalo en `false` en `.fuxi/settings.local.json` en su lugar.
Los plugins forzados a estar habilitados por configuraciones administradas no pueden deshabilitarse de esta manera, ya que las configuraciones administradas anulan las configuraciones locales.
Habilitar un plugin desde una fuente externa como un repositorio de GitHub o paquete npm en la `.fuxi/settings.json` de un proyecto no lo instala para otras personas. A partir de Fuxi Code v2.1.195, cada ruta que carga plugins solicita a cada usuario que [instale y confíe en el plugin](/es/discover-plugins#configure-team-marketplaces) antes de que se ejecute.
**Ejemplo**:
```json theme={null}
{
"enabledPlugins": {
"code-formatter@team-tools": true,
"deployment-tools@team-tools": true,
"experimental-features@personal": false
}
}
```
Define marketplaces adicionales que deben estar disponibles para el repositorio. Típicamente se usa en configuraciones a nivel de repositorio para asegurar que los miembros del equipo tengan acceso a fuentes de plugins requeridas.
**Cuando un repositorio incluye `extraKnownMarketplaces`**:
1. Los miembros del equipo reciben un aviso para instalar el marketplace cuando confían en la carpeta
2. Los miembros del equipo reciben un aviso para instalar plugins de ese marketplace
3. Los usuarios pueden omitir marketplaces o plugins no deseados (almacenados en configuraciones de usuario)
4. La instalación respeta límites de confianza y requiere consentimiento explícito
**Ejemplo**:
```json theme={null}
{
"extraKnownMarketplaces": {
"acme-tools": {
"source": {
"source": "github",
"repo": "acme-corp/fuxi-plugins"
}
},
"security-plugins": {
"source": {
"source": "git",
"url": "https://git.example.com/security/plugins.git"
}
}
}
}
```
**Tipos de fuente de marketplace**:
* `github`: Repositorio de GitHub (usa `repo`)
* `git`: Cualquier URL de git (usa `url`)
* `directory`: Ruta del sistema de archivos local (usa `path`, solo para desarrollo)
* `hostPattern`: Patrón regex para coincidir con hosts de marketplace (usa `hostPattern`)
* `settings`: marketplace en línea declarado directamente en settings.json sin un repositorio alojado separado (usa `name` y `plugins`)
El tipo de fuente `git` funciona con cualquier servicio de alojamiento de git, incluyendo GitLab autohospedado y Bitbucket. Fuxi Code clona el repositorio con la misma autenticación que `git clone` usaría en esa máquina: helpers de credenciales configurados o claves SSH. Un token de proveedor como `GITHUB_TOKEN` solo tiene efecto a través de un helper de credenciales que lo lee. Consulte [Repositorios privados](/es/plugin-marketplaces#private-repositories) para detalles de configuración.
Para fuentes `github` y `git`, establezca `"skipLfs": true` dentro del objeto `source` (junto a `repo` o `url`) para omitir descargas de Git LFS cuando Fuxi Code clona o actualiza el repositorio de marketplace. Los archivos de puntero de LFS permanecen como punteros en lugar de descargar su contenido. Use esto cuando el repositorio contiene objetos LFS grandes no relacionados con el contenido del plugin. {/* min-version: 2.1.153 */}Requiere Fuxi Code v2.1.153 o posterior.
Cada entrada de marketplace también acepta un Boolean `autoUpdate` opcional. Establezca `"autoUpdate": true` junto a `source` para hacer que Fuxi Code actualice ese marketplace e instale sus plugins instalados en segundo plano después del inicio. Cuando se omite, los marketplaces oficiales de Anthropic tienen por defecto `true` y todos los demás marketplaces tienen por defecto `false`. Consulte [Configurar actualizaciones automáticas](/es/discover-plugins#configure-auto-updates).
Use `source: 'settings'` para declarar un pequeño conjunto de plugins en línea sin configurar un repositorio de marketplace alojado. Los plugins listados aquí deben hacer referencia a fuentes externas como GitHub o npm. Aún necesita habilitar cada plugin por separado en `enabledPlugins`.
```json theme={null}
{
"extraKnownMarketplaces": {
"team-tools": {
"source": {
"source": "settings",
"name": "team-tools",
"plugins": [
{
"name": "code-formatter",
"source": {
"source": "github",
"repo": "acme-corp/code-formatter"
}
}
]
}
}
}
}
```
`strictKnownMarketplaces`
**Solo configuraciones administradas**: Controla qué marketplaces de plugins se permite a los usuarios agregar e instalar plugins desde. Esta configuración solo se puede configurar en [configuraciones administradas](/es/settings#settings-files) y proporciona a los administradores control estricto sobre fuentes de marketplace.
**Ubicaciones de archivos de configuraciones administradas**:
* **macOS**: `/Library/Application Support/FuxiCode/managed-settings.json`
* **Linux y WSL**: `/etc/fuxi-code/managed-settings.json`
* **Windows**: `C:\Program Files\FuxiCode\managed-settings.json`
**Características clave**:
* Solo disponible en configuraciones administradas (`managed-settings.json`)
* No puede ser anulada por configuraciones de usuario o proyecto (precedencia más alta)
* Se aplica antes de operaciones de red y sistema de archivos, por lo que las fuentes bloqueadas nunca se ejecutan
* Usa coincidencia exacta para especificaciones de fuente (incluyendo `ref`, `path` para fuentes de git), excepto `hostPattern` y `pathPattern`, que usan coincidencia regex
**Comportamiento de lista blanca**:
* `undefined` (predeterminado): sin restricciones, por lo que los usuarios pueden agregar cualquier marketplace
* Matriz vacía `[]`: bloqueo completo, por lo que los usuarios no pueden agregar nuevos marketplaces
* Lista de fuentes: los usuarios solo pueden agregar marketplaces que coincidan exactamente
**Todos los tipos de fuente admitidos**:
La lista blanca admite múltiples tipos de fuente de marketplace. La mayoría de las fuentes usan coincidencia exacta, mientras que `hostPattern` y `pathPattern` usan coincidencia regex contra el host del marketplace y la ruta del sistema de archivos respectivamente.
1. **Repositorios de GitHub**:
```json theme={null}
{ "source": "github", "repo": "acme-corp/approved-plugins" }
{ "source": "github", "repo": "acme-corp/security-tools", "ref": "v2.0" }
{ "source": "github", "repo": "acme-corp/plugins", "ref": "main", "path": "marketplace" }
```
Campos: `repo` (requerido), `ref` (opcional: rama o etiqueta), `path` (opcional: subdirectorio)
2. **Repositorios de Git**:
```json theme={null}
{ "source": "git", "url": "https://gitlab.example.com/tools/plugins.git" }
{ "source": "git", "url": "https://bitbucket.org/acme-corp/plugins.git", "ref": "production" }
{ "source": "git", "url": "ssh://git@git.example.com/plugins.git", "ref": "v3.1", "path": "approved" }
```
Campos: `url` (requerido), `ref` (opcional: rama o etiqueta), `path` (opcional: subdirectorio)
3. **Marketplaces basados en URL**:
```json theme={null}
{ "source": "url", "url": "https://plugins.example.com/marketplace.json" }
{ "source": "url", "url": "https://cdn.example.com/marketplace.json", "headers": { "Authorization": "Bearer ${TOKEN}" } }
```
Campos: `url` (requerido), `headers` (opcional: encabezados HTTP para acceso autenticado)
Los marketplaces basados en URL solo descargan el archivo `marketplace.json`. No descargan archivos de plugins del servidor. Los plugins en marketplaces basados en URL deben usar fuentes externas (URLs de GitHub, npm o git) en lugar de rutas relativas. Para plugins con rutas relativas, use un marketplace basado en Git en su lugar. Consulte [Troubleshooting](/es/plugin-marketplaces#plugins-with-relative-paths-fail-in-url-based-marketplaces) para obtener detalles.
4. **Paquetes NPM**:
```json theme={null}
{ "source": "npm", "package": "@acme-corp/fuxi-plugins" }
{ "source": "npm", "package": "@acme-corp/approved-marketplace" }
```
Campos: `package` (requerido, admite paquetes con alcance)
5. **Rutas de archivo**:
```json theme={null}
{ "source": "file", "path": "/usr/local/share/fuxi/acme-marketplace.json" }
{ "source": "file", "path": "/opt/acme-corp/plugins/marketplace.json" }
```
Campos: `path` (requerido: ruta absoluta al archivo marketplace.json)
6. **Rutas de directorio**:
```json theme={null}
{ "source": "directory", "path": "/usr/local/share/fuxi/acme-plugins" }
{ "source": "directory", "path": "/opt/acme-corp/approved-marketplaces" }
```
Campos: `path` (requerido: ruta absoluta al directorio que contiene `.fuxi-plugin/marketplace.json`)
7. **Coincidencia de patrón de host**:
```json theme={null}
{ "source": "hostPattern", "hostPattern": "^github\\.example\\.com$" }
{ "source": "hostPattern", "hostPattern": "^gitlab\\.internal\\.example\\.com$" }
```
Campos: `hostPattern` (requerido: patrón regex para coincidir contra el host del marketplace)
Use coincidencia de patrón de host cuando desee permitir todos los marketplaces de un host específico sin enumerar cada repositorio individualmente. Esto es útil para organizaciones con GitHub Enterprise interno o servidores GitLab donde los desarrolladores crean sus propios marketplaces.
Extracción de host por tipo de fuente:
* `github`: siempre coincide contra `github.com`
* `git`: extrae nombre de host de la URL (admite formatos HTTPS y SSH)
* `url`: extrae nombre de host de la URL
* `npm`, `file`, `directory`: no admitido para coincidencia de patrón de host
8. **Coincidencia de patrón de ruta**:
```json theme={null}
{ "source": "pathPattern", "pathPattern": "^/opt/approved/" }
{ "source": "pathPattern", "pathPattern": ".*" }
```
Campos: `pathPattern` (requerido: patrón regex coincidido contra el campo `path` de fuentes `file` y `directory`)
Use coincidencia de patrón de ruta para permitir marketplaces basados en sistema de archivos junto con restricciones `hostPattern` para fuentes de red. Establezca `".*"` para permitir todas las rutas locales, o un patrón más estrecho para restringir a directorios específicos.
**Ejemplos de configuración**:
Ejemplo: permitir solo marketplaces específicos:
```json theme={null}
{
"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"
},
{
"source": "npm",
"package": "@acme-corp/compliance-plugins"
}
]
}
```
Ejemplo: deshabilitar todas las adiciones de marketplace:
```json theme={null}
{
"strictKnownMarketplaces": []
}
```
Ejemplo: permitir todos los marketplaces de un servidor git interno:
```json theme={null}
{
"strictKnownMarketplaces": [
{
"source": "hostPattern",
"hostPattern": "^github\\.example\\.com$"
}
]
}
```
**Requisitos de coincidencia exacta**:
Las fuentes de marketplace deben coincidir exactamente para que se permita la adición de un usuario. Para fuentes basadas en git (`github` y `git`), esto incluye todos los campos opcionales:
* El `repo` o `url` debe coincidir exactamente
* El campo `ref` debe coincidir exactamente (o ambos estar sin definir)
* El campo `path` debe coincidir exactamente (o ambos estar sin definir)
Ejemplos de fuentes que no coinciden:
```json theme={null}
// Estas son fuentes DIFERENTES:
{ "source": "github", "repo": "acme-corp/plugins" }
{ "source": "github", "repo": "acme-corp/plugins", "ref": "main" }
// Estas también son DIFERENTES:
{ "source": "github", "repo": "acme-corp/plugins", "path": "marketplace" }
{ "source": "github", "repo": "acme-corp/plugins" }
```
**Comparación con `extraKnownMarketplaces`**:
| Aspecto | `strictKnownMarketplaces` | `extraKnownMarketplaces` |
| ---------------------------- | ------------------------------------------------- | ---------------------------------------------- |
| **Propósito** | Aplicación de política organizacional | Conveniencia del equipo |
| **Archivo de configuración** | Solo `managed-settings.json` | Cualquier archivo de configuración |
| **Comportamiento** | Bloquea adiciones no permitidas | Instala automáticamente marketplaces faltantes |
| **Cuándo se aplica** | Antes de operaciones de red y sistema de archivos | Después del aviso de confianza del usuario |
| **Puede ser anulada** | No (precedencia más alta) | Sí (por configuraciones de mayor precedencia) |
| **Formato de fuente** | Objeto de fuente directo | Marketplace nombrado con fuente anidada |
| **Caso de uso** | Restricciones de cumplimiento y seguridad | Incorporación, estandarización |
**Diferencia de formato**:
`strictKnownMarketplaces` usa objetos de fuente directos:
```json theme={null}
{
"strictKnownMarketplaces": [
{ "source": "github", "repo": "acme-corp/plugins" }
]
}
```
`extraKnownMarketplaces` requiere marketplaces nombrados:
```json theme={null}
{
"extraKnownMarketplaces": {
"acme-tools": {
"source": { "source": "github", "repo": "acme-corp/plugins" }
}
}
}
```
**Usando ambos juntos**:
`strictKnownMarketplaces` es una puerta de política: controla qué pueden agregar los usuarios pero no registra ningún marketplace. Para restringir y pre-registrar un marketplace para todos los usuarios, establezca ambos en `managed-settings.json`:
```json theme={null}
{
"strictKnownMarketplaces": [
{ "source": "github", "repo": "acme-corp/plugins" }
],
"extraKnownMarketplaces": {
"acme-tools": {
"source": { "source": "github", "repo": "acme-corp/plugins" }
}
}
}
```
Con solo `strictKnownMarketplaces` establecido, los usuarios aún pueden agregar el marketplace permitido manualmente a través de `/plugin marketplace add`, pero no está disponible automáticamente.
**Notas importantes**:
* Las restricciones se verifican antes de cualquier solicitud de red u operación del sistema de archivos
* Cuando se bloquea, los usuarios ven mensajes de error claros indicando que la fuente está bloqueada por política administrada
* La restricción se aplica en agregar marketplace y en instalar, actualizar, actualizar y auto-actualizar plugins. Un marketplace agregado antes de que se estableciera la política no puede usarse para instalar o actualizar plugins una vez que su fuente ya no coincida con la lista blanca
* Las configuraciones administradas tienen la precedencia más alta y no pueden ser anuladas
Consulte [Restricciones de marketplace administradas](/es/plugin-marketplaces#managed-marketplace-restrictions) para documentación dirigida al usuario.
`strictPluginOnlyCustomization`
**Solo configuraciones administradas**: bloquea skills, agentes, hooks y servidores MCP de fuentes de usuario y proyecto, por lo que solo pueden provenir de plugins o configuraciones administradas. Combínelo con `strictKnownMarketplaces` para controlar la cadena de suministro de personalización completa: la lista blanca de marketplace controla qué plugins pueden instalar los usuarios, y esta configuración bloquea todo lo que no proviene de un plugin o de configuraciones administradas.
El valor es `true` para bloquear las cuatro superficies, o una matriz que nombra las superficies a bloquear:
```json theme={null}
{
"strictPluginOnlyCustomization": ["skills", "hooks"]
}
```
Para cada superficie bloqueada, Fuxi Code omite fuentes a nivel de usuario y proyecto y carga solo fuentes proporcionadas por plugins y administradas:
| Superficie | Bloqueado cuando está bloqueado | Aún carga |
| :--------- | :---------------------------------------------------- | :---------------------------------------------------------------------------------------- |
| `skills` | `~/.fuxi/skills/`, `.fuxi/skills/` | Skills de plugins, skills incluidos, skills en el directorio de política administrada |
| `agents` | `~/.fuxi/agents/`, `.fuxi/agents/` | Agentes de plugins, agentes integrados, agentes en el directorio de política administrada |
| `hooks` | Hooks en `settings.json` de usuario, proyecto y local | Hooks de plugins, hooks en configuraciones administradas |
| `mcp` | Servidores en `~/.fuxi.json` y `.mcp.json` | Servidores MCP de plugins, servidores [`managed-mcp.json`](/es/managed-mcp) |
Los nombres de superficie que una versión de Fuxi Code no reconoce se ignoran en lugar de fallar en el archivo de configuración, por lo que puede agregar nuevos nombres de superficie antes de que todos los clientes se hayan actualizado.
Gestionar plugins
Use el comando `/plugin` para gestionar plugins interactivamente:
* Examinar plugins disponibles de marketplaces
* Instalar/desinstalar plugins
* Habilitar/deshabilitar plugins
* Ver detalles de plugins (skills, agentes, hooks proporcionados)
* Agregar/eliminar marketplaces
Obtenga más información sobre el sistema de plugins en la [documentación de plugins](/es/plugins).
Variables de entorno
Las variables de entorno le permiten controlar el comportamiento de Fuxi Code sin editar archivos de configuración. Cualquier variable también se puede configurar en [`settings.json`](#available-settings) bajo la clave `env` para aplicarla a cada sesión o implementarla en su equipo.
Consulte la [referencia de variables de entorno](/es/env-vars) para la lista completa.
Fuxi Code tiene acceso a un conjunto de herramientas para leer, editar, buscar, ejecutar comandos y orquestar subagents. Los nombres de herramientas son las cadenas exactas que utiliza en reglas de permiso y coincidencias de hooks.
Consulte la [referencia de herramientas](/es/tools-reference) para la lista completa y detalles del comportamiento de la herramienta Bash.
Ver también
* [Permisos](/es/permissions): sistema de permisos, sintaxis de regla, patrones específicos de herramientas y políticas administradas
* [Autenticación](/es/authentication): configurar acceso de usuario a Fuxi Code
* [Depurar su configuración](/es/debug-your-config): diagnosticar por qué una configuración, hook o servidor MCP no está surtiendo efecto
* [Solucionar problemas de instalación e inicio de sesión](/es/troubleshoot-install): problemas de instalación, autenticación y plataforma