Cómo aislar un servidor MCP con codex sandbox

Codex no aísla mediante sandbox los servidores MCP de stdio, así que los servidores npx se ejecutan con todos tus permisos. Crea un perfil de permisos, envuelve el servidor en codex sandbox y pruébalo.

INEZA Felin-Michel

INEZA Felin-Michel

20 November 2026

Cómo aislar un servidor MCP con codex sandbox

Apidog para empresas

Despliegue local

SSO & RBAC

Conforme con SOC 2

Explorar Apidog Enterprise

Para ejecutar un servidor MCP de Codex con sandbox, define un perfil de permisos en ~/.codex/config.toml y luego apunta el command del servidor a codex sandbox --permission-profile <name> --, seguido del comando original. Codex no aplica sandbox a los servidores MCP de stdio por defecto, así que sin ese wrapper un servidor npx se ejecuta con todos tus permisos de usuario.

El artículo de ingeniería de OpenAI Inside the Codex sandbox, publicado el 18 de noviembre de 2026, lo deja claro: Codex no puede adivinar de forma fiable qué archivos o servicios de red necesita un servidor, así que deja intacto el comando de lanzamiento. Cada servidor MCP que añadas con npx -y puede leer tu carpeta personal, escribir donde tú puedas escribir y llamar a cualquier host de internet.

A continuación crearás un perfil para el Servidor MCP de Apidog, lo vincularás a un archivo OpenAPI local con la red desactivada, demostrarás que el perfil funciona con codex sandbox y luego delegarás el trabajo rutinario a tu agente de programación con el CLI de Apidog.

Por qué Codex deja los servidores MCP de stdio sin sandbox

Un servidor MCP de stdio es un programa local que Codex inicia y con el que se comunica mediante entrada y salida estándar. Codex aplica sandbox a los comandos de shell que ejecuta su modelo, pero no al comando que lanza un servidor MCP, porque no puede saber qué archivos u hosts necesita ese servidor. El servidor hereda todos tus permisos de usuario.

Los comandos que ejecuta el modelo obtienen el perfil integrado :workspace: escrituras solo dentro del espacio de trabajo, .git y .codex en modo lectura, lecturas amplias, sin red. Un servidor MCP en [mcp_servers] no recibe nada de eso.

Esa diferencia importa porque los servidores MCP son código de terceros que descargas al lanzar. Así es una configuración típica:

[mcp_servers.memory]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-memory@1.0.0"]

npx -y descarga el paquete y lo ejecuta sin pedir confirmación. Si ese paquete está comprometido, puede leer tus archivos .env y tus claves SSH y enviarlos a cualquier parte. Nuestra guía sobre políticas de seguridad de MCP cubre el modelo de amenazas más amplio; esta publicación cierra el único agujero de tu configuración de Codex.

Cómo funciona un perfil de permisos de Codex

Un perfil de permisos es un conjunto con nombre de reglas de sistema de archivos y red bajo [permissions] en config.toml. El artículo de OpenAI y la documentación de permisos de Codex describen tres niveles de sistema de archivos:

Valor Efecto
read Acceso de solo lectura
write Acceso de lectura y escritura
deny Sin acceso en absoluto

Tres claves hacen la mayor parte del trabajo:

  1. ":root" = "read" otorga lecturas amplias, que Node.js y npm necesitan para cargar sus propios archivos.
  2. Una ruta como "~/.npm" = "write" otorga escrituras solo a esa carpeta.
  3. Una tabla ":workspace_roots" aplica reglas relativas a cada raíz de espacio de trabajo. "**/*.env" = "deny" bloquea todos los archivos .env que haya debajo.

La red tiene tres modos: desactivada, enrutada a través del proxy de Codex con una lista de dominios permitidos, o acceso completo.

Tres modos de red para un perfil de permisos de Codex: network.enabled = false para sin red, un proxy con una lista de dominios permitidos como api.apidog.com, y acceso completo a la red que los servidores MCP deben evitar

El CLI de Codex de código abierto aplica estas reglas con el sistema operativo: Seatbelt en macOS, bubblewrap más seccomp en Linux y, en dispositivos Windows compatibles, MXC de Microsoft. Los procesos hijos heredan los límites, así que cualquier cosa que genere el servidor permanece dentro de la misma caja.

Paso 1: elige el modo más seguro para el Servidor MCP de Apidog

El Servidor MCP de Apidog (apidog-mcp-server en npm, versión 0.0.18 hoy) se ejecuta en dos modos:

El modo OAS con un archivo local no necesita red en absoluto. Ese es el perfil más robusto que puedes escribir, así que es el ejemplo principal aquí. El CLI de Apidog mantiene la especificación actualizada desde fuera del sandbox (Paso 5).

Leímos el paquete 0.0.18 para averiguar qué escribe el servidor: almacena datos en caché en ~/.apidog-mcp-server (o en la carpeta indicada por APIDOG_DATA_LOCATION), y en modo de proyecto llama a https://api.apidog.com a menos que pases --apidog-api-base-url.

Paso 2: define el perfil de permisos

Añade esto a ~/.codex/config.toml:

[permissions.apidog-mcp.filesystem]
# Broad reads so Node.js and npm can load their own files.
":root" = "read"
"~/.npm" = "write"
"~/.apidog-mcp-server" = "write"

[permissions.apidog-mcp.filesystem.":workspace_roots"]
"**/*.env" = "deny"

[permissions.apidog-mcp.network]
enabled = false

El servidor puede leer la especificación y escribir en dos carpetas de caché. No puede abrir ningún archivo .env del espacio de trabajo y no tiene red.

Paso 3: envuelve el comando del servidor con codex sandbox

Ahora reemplaza el lanzamiento simple con npx por codex sandbox. El flag -C establece el directorio de trabajo, que también es la raíz del espacio de trabajo a la que se aplica la regla de .env:

[mcp_servers.pets-api-docs]
command = "codex"
args = [
  "sandbox",
  "--permission-profile", "apidog-mcp",
  "-C", "/Users/you/code/pets-api",
  "--",
  "npx", "--offline",
  "apidog-mcp-server@0.0.18",
  "--oas=/Users/you/code/pets-api/openapi.json"
]

Tres detalles importan:

El README de Apidog sugiere nombrar el servidor según la API que documenta, como «Pets API Documentation», para que el modelo sepa cuándo usarlo.

Diagrama: Codex lanza codex sandbox con el perfil apidog-mcp, que ejecuta npx --offline apidog-mcp-server con un archivo OpenAPI; dentro del sandbox puede leer openapi.json y escribir en ~/.npm y ~/.apidog-mcp-server, mientras que los archivos .env, internet y otras carpetas están bloqueados

Paso 4: precarga el paquete en caché y demuestra que el perfil funciona

El sandbox puede escribir en la carpeta de caché pero no puede crearla, y no puede descargar nada. Ejecuta esto una vez, fuera del sandbox:

mkdir -p ~/.apidog-mcp-server
npx -y --package=apidog-mcp-server@0.0.18 -c true

Luego prueba el perfil antes de confiar en él. codex sandbox ejecuta cualquier comando bajo un perfil, lo que lo convierte en un banco de pruebas rápido:

cd /Users/you/code/pets-api

# 1. A .env file in the workspace is unreadable
codex sandbox --permission-profile apidog-mcp -- cat .env
# cat: .env: Operation not permitted

# 2. Writes outside the allowed folders fail
codex sandbox --permission-profile apidog-mcp -- bash -c 'echo x > /tmp/probe.txt'
# bash: /tmp/probe.txt: Operation not permitted

# 3. The allowed cache folder is writable
codex sandbox --permission-profile apidog-mcp -- touch ~/.apidog-mcp-server/probe
# (no output, exit 0)

# 4. No network
codex sandbox --permission-profile apidog-mcp -- curl -sS https://api.apidog.com/
# curl: (6) Could not resolve host: api.apidog.com

Esos son los resultados que obtuvimos en macOS. Luego comprueba que el servidor sigue funcionando enviándole un handshake MCP:

printf '%s\n' \
 '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"t","version":"1"}}}' \
 '{"jsonrpc":"2.0","method":"notifications/initialized"}' \
 '{"jsonrpc":"2.0","id":2,"method":"tools/list"}' \
| codex sandbox --permission-profile apidog-mcp -- \
  npx --offline apidog-mcp-server@0.0.18 --oas=$PWD/openapi.json

Con la red desactivada, el servidor respondió con tres herramientas: una que lee la especificación OpenAPI, otra que lee los archivos referenciados por $ref y otra que actualiza la especificación. Eso es todo lo que Codex necesita para escribir código contra tu API.

En macOS, añade --log-denials a cualquier llamada de codex sandbox para imprimir las denegaciones de Seatbelt cuando el comando finalice. Es la forma más rápida de encontrar una carpeta que el servidor necesite legítimamente.

Paso 5: deja que Codex mantenga la especificación actualizada con el CLI de Apidog

Un servidor sin conexión lee un archivo, así que algo tiene que actualizarlo. Delega esa tarea a tu agente de programación con el CLI de Apidog. Se ejecuta fuera del sandbox MCP, bajo las reglas normales de comandos de Codex, y el servidor MCP nunca necesita un token.

Configuración (una vez):

npm install -g apidog-cli
apidog auth login --with-token <your-access-token>

Si aún no has integrado el CLI en Codex, sigue Cómo usar el CLI de Apidog en Codex.

Prompt para tu agente:

Export the OpenAPI 3.1 spec for Apidog project 1234567 to ./openapi.json,
then run test scenario 637132 in environment 358171 against it and give me
a CLI summary. Don't touch any .env file.

Comandos que ejecuta el agente (flags de apidog export --help y apidog run --help, CLI 2.2.12):

apidog export --project 1234567 --format openapi --oas-version 3.1 --output ./openapi.json
apidog run -t 637132 -e 358171 -r cli,junit --out-dir ./apidog-reports

export sobrescribe el archivo que lee el servidor con sandbox, así que la siguiente llamada MCP verá endpoints nuevos. run ejecuta tu escenario de prueba y escribe un informe JUnit para CI. Añade --upload-report si quieres revisar la ejecución en la app de Apidog. El plan Free de Apidog cubre hasta 4 usuarios.

Cuando el servidor necesita red: la lista de dominios permitidos

El modo de proyecto necesita acceder a api.apidog.com. La respuesta de Codex es el proxy de red: establece enabled = true, enumera los dominios permitidos y activa la función network_proxy. Esta es la forma documentada en el artículo de OpenAI, adaptada a Apidog:

[permissions.apidog-mcp-live.filesystem]
":root" = "read"
"~/.npm" = "write"
"~/.apidog-mcp-server" = "write"

[permissions.apidog-mcp-live.filesystem.":workspace_roots"]
"**/*.env" = "deny"

[permissions.apidog-mcp-live.network]
enabled = true

[permissions.apidog-mcp-live.network.domains]
"api.apidog.com" = "allow"

[features]
network_proxy = true

Un deny explícito prevalece sobre allow, y el proxy resuelve un nombre de host solo después de que una regla lo permita, ya que incluso una consulta DNS puede filtrar datos. OpenAI advierte que los comodines amplios aún pueden permitir exfiltración mediante DNS, así que enumera los hosts exactos.

Una advertencia de nuestra propia prueba. En nuestro Mac, el proxy se inició e inyectó HTTP_PROXY y similares en el sandbox, pero respondió 403 con x-proxy-error: blocked-by-allowlist para cada host, incluso los permitidos. Nuestra máquina enruta el DNS a través de una app de proxy local, y puede que esa sea la razón. Ejecuta codex sandbox --permission-profile apidog-mcp-live -- curl -sS https://api.apidog.com/ en tu propia máquina antes de depender de este perfil. Si el host permitido falla, recurre al modo OAS del Paso 1.

¿Qué perfil deberías usar?

Tipo de servidor Red Escrituras en el sistema de archivos Ejemplo
Solo lee archivos locales enabled = false caché de npm + carpeta de datos propia Servidor MCP de Apidog con --oas
Llama a una API conocida Proxy + dominios exactos caché de npm + carpeta de datos propia Servidor MCP de Apidog con --project-id
Necesita internet abierto Evitar, o aislar en una VM Lo más restringido posible Servidores de navegación web

Si ejecutas Codex en equipo, los administradores pueden usar allowed_permission_profiles en requirements.toml para limitar qué perfiles pueden elegir los usuarios. Y si te tienta desactivar el sandbox, lee por qué saltarse el sandbox de Codex sacrifica exactamente esta protección.

Preguntas frecuentes

¿Codex aplica sandbox a los servidores MCP por defecto? No. OpenAI afirma que Codex no aplica sandbox al comando que inicia un servidor MCP de stdio configurado en config.toml. Tú mismo añades el sandbox lanzando el servidor mediante codex sandbox --permission-profile <name> --.

¿Por qué usar npx --offline en lugar de npx -y? Con network.enabled = false, npx no puede descargar nada. --offline le indica que use la copia que guardaste en caché con npx -y --package=<pkg>@<version> -c true, y fijar la versión impide que una nueva versión reemplace el código.

¿Protege el sandbox mis claves de API? Bloquea lo que tú deniegues. El perfil :workspace permite lecturas amplias, así que añade reglas deny para archivos .env y carpetas de secretos. Con la red desactivada, el servidor tampoco puede enviar nada de lo que lea.

¿Funciona esto en Linux y Windows? Sí. El mismo perfil se aplica en todas partes; Codex lo impone con bubblewrap y seccomp en Linux y con un sandbox basado en MXC en dispositivos Windows compatibles. Prueba cada máquina con codex sandbox, ya que las rutas y las configuraciones de DNS difieren.

¿Puedo aplicar sandbox a otros servidores MCP de la misma forma? Sí. Funciona con cualquier servidor de stdio: encuentra las carpetas en las que escribe y los hosts a los que llama, dale un perfil, envuelve el comando, precarga el paquete en caché y pruébalo. El propio ejemplo de OpenAI aplica sandbox a @modelcontextprotocol/server-memory con escrituras limitadas a ~/.npm y ~/mcp-data.

Practica el diseño de API en Apidog

Descubre una forma más fácil de construir y usar APIs