Claude Command Runner

Servidor MCP para Warp Terminal. Envía comandos de Claude a tu pestaña activa de Warp mediante warp:// deeplinks y eventos OSC 777. Funciona desde Claude Desktop o el panel de agente nativo de Warp. macOS, Swift.

GitHub

Prueba este MCPPatrocinado

Documentación

Warp Command Runner

Dale a cualquier IA de chat una terminal real. Preguntas en Warp, Claude Desktop, ChatGPT desktop o cualquier otro host MCP. El modelo escribe el comando en tu pestaña de Warp, captura la salida y te dice qué pasó. Cuarenta herramientas: ejecución de comandos, configuraciones de proyectos, monitoreo de archivos, SSH, portapapeles, inteligencia de entorno. macOS, Swift, código abierto.

Esto es para personas que no viven en Cursor o Claude Code. Si ya chateas con Grok, ChatGPT, Claude o Gemini desde una aplicación de escritorio (especialmente el panel de agente de Warp), agrega este MCP y ese chat puede leer tus archivos y ejecutar comandos en tu máquina.

Construido para Warp Terminal. Las cinco herramientas más potentes enrutan comandos visiblemente hacia tu pestaña activa de Warp. Registra el mismo binario con tantos hosts MCP como quieras — el servidor habla MCP estándar sobre stdio y no le importa qué modelo lo esté llamando.

¿Puede cualquier IA en la nube usar esto? Cualquier host MCP local puede, a través de stdio. Las aplicaciones de teléfono y los sitios web necesitan MCP remoto: ejecutas --http y publicas HTTPS con un túnel tuyo. Guía: docs/REMOTE.md. Matriz: docs/COMPATIBILITY.md.

Novedades en v8.0.0 — MCP remoto

Streamable HTTP opcional para que Grok, ChatGPT y Claude puedan llamar a esta Mac desde un teléfono o un sitio web. Tú creas la URL HTTPS pública (tu túnel de Cloudflare, tu Tailscale Funnel o tu proxy inverso). Este proyecto no aloja un relay.

warp-command-runner --http escucha en 127.0.0.1 solamente (puerto predeterminado 8741)
OAuth 2.1 con PKCE y Dynamic Client Registration
Las herramientas de enrutamiento de Warp (teclas) permanecen desactivadas para llamadores remotos; usa execute_pipeline
--remote-doctor y --install-agent para un LaunchAgent de inicio de sesión

El stdio local no cambia. Detalles: docs/REMOTE.md.

Novedades en v7.0.0 — cambio de marca

Anteriormente Claude Command Runner. Mismo motor, nombre agnóstico al host:

Producto, binario, bundle ID y directorio de configuración renombrados a Warp Command Runner (warp-command-runner, ~/.warp-command-runner)
Los datos existentes de ~/.claude-command-runner se copian en el primer lanzamiento (la carpeta anterior se deja en su lugar)
El nombre de serverInfo MCP es Warp Command Runner para que cada host lo liste de esa manera
Fragmentos de configuración para Warp, Claude Desktop, ChatGPT desktop, Cursor, VS Code y un host stdio genérico
Documentación de compatibilidad honesta: stdio MCP funciona en todos lados donde exista un host local. MCP remoto es opcional en v8 (docs/REMOTE.md).

El historial de v6.x (deeplinks de Warp, OSC 777, Warp Agent de doble consumidor, 40 herramientas) no cambia — consulta CHANGELOG.md.

Descripción general

Warp Command Runner es un servidor MCP. Un binario, cualquier cliente MCP:

Ejecuta comandos de terminal desde una conversación
Encadena comandos con pipelines y modos de fallo
Transmite salida para builds largos
Guarda y reutiliza plantillas de comandos con variables
Captura automática de salida con temporización inteligente
Rastrea el historial de comandos
Lee/escribe el portapapeles de macOS
Sondea el contexto del entorno (git, venv, Docker, Node)
Analiza la salida de comandos en JSON estructurado
Gestiona perfiles de espacio de trabajo (opcionalmente como configuraciones de lanzamiento de Warp)
Abre pestañas de Warp mediante deeplinks warp:// y envía comandos a la pestaña activa
Observa archivos y dispara comandos ante cambios
Ejecuta comandos en hosts remotos vía SSH
Expone el estado en Warp como eventos OSC 777 warp://cli-agent
Shim de shell opcional: eventos preexec / command-finished a través de un socket Unix

🧭 ¿Con qué aplicación debería registrarlo?

El protocolo es MCP. El valor depende de si el host es local y si Warp es tu terminal. Detalles en docs/COMPATIBILITY.md.

Host	Configuración	¿Recomendado?
Warp Agent (Grok, Claude, GPT, Gemini — lo que Warp tenga configurado)	`~/.warp/.mcp.json`	Sí — el mejor ajuste. Consulta docs/WARP_AGENT.md
Claude Desktop	`~/Library/Application Support/Claude/claude_desktop_config.json`	Sí
ChatGPT desktop (Connectors / Developer Mode)	configuración MCP del host; fragmento en `config/chatgpt-mcp.json`	Sí, si tu plan expone MCP local
VS Code / Continue / Cline / Windsurf	su configuración MCP; consulta `config/`	Opcional
Cursor	`~/.cursor/mcp.json`	Opcional — Cursor ya tiene terminal
Claude Code	`~/.claude.json`	De nicho — ya tiene Bash
Chats de navegador / teléfono (chatgpt.com, grok.com, claude.ai)	URL de conector personalizada	Opcional — necesita v8 `--http` más tu túnel HTTPS. `docs/REMOTE.md`

Árbol de decisión rápido

¿Usas Warp y chateas con Grok / ChatGPT / Claude / Gemini dentro de Warp? → Regístralo en ~/.warp/.mcp.json. Ese es todo el producto.
¿Usas Claude Desktop (o ChatGPT desktop) y quieres comandos visibles en Warp? → Regístralo también allí. Mismo binario.
¿Usas Cursor o Claude Code y quieres todo en un solo panel? → Probablemente no lo necesitas.
¿Solo usas un chatbot de sitio web o teléfono? → Stdio no puede alcanzar esa pestaña. Habilita MCP remoto (docs/REMOTE.md) o usa un host MCP de escritorio.

Cinco de las 40 herramientas (execute_command, execute_with_auto_retrieve, execute_with_streaming, run_template, send_to_session) son las de enrutamiento de Warp. El resto son utilidades ordinarias del lado del servidor (portapapeles, SSH, instantáneas, …) que funcionan desde cualquier host.

🎯 Características clave

Pipelines de comandos

Encadena múltiples comandos con manejo inteligente de fallos:

{
  "steps": [
    {"name": "Build", "command": "swift build", "on_fail": "stop"},
    {"name": "Test", "command": "swift test", "on_fail": "continue"},
    {"name": "Package", "command": "swift build -c release", "on_fail": "stop"}
  ]
}

Modos de fallo:

stop – Detener el pipeline ante un fallo
continue – Registrar el error y continuar al siguiente paso
warn – Mostrar advertencia y continuar

Transmisión de salida

Salida en tiempo real para comandos de larga duración:

{
  "command": "swift build -c release",
  "update_interval": 3,
  "max_duration": 180
}

Perfecto para:

Procesos de compilación largos
Suites de pruebas
Cualquier comando que antes "se colgaba" esperando salida

Plantillas de comandos

Guarda patrones reutilizables con sustitución de variables:

// Save a template
{
  "name": "swift-release",
  "template": "cd {{project}} && swift build -c release",
  "category": "Swift Development",
  "description": "Build Swift project in release mode"
}

// Run with variables
{
  "name": "swift-release",
  "variables": {"project": "~/GitHub/MyApp"}
}

Las plantillas se almacenan en ~/.warp-command-runner/templates.json y persisten entre sesiones.

Auto-recuperación inteligente

El comando execute_with_auto_retrieve detecta inteligentemente los tipos de comando y ajusta los tiempos de espera:

Comandos rápidos (echo, pwd): 2-6 segundos
Comandos moderados (git, npm): hasta 20 segundos
Comandos de build (swift build, make): hasta 77 segundos
Comandos de prueba: hasta 40 segundos

📊 ¿Por qué Warp Terminal?

Warp Terminal es el objetivo de integración principal. Otros terminales funcionan para lo básico — Warp desbloquea de manera única deeplinks, OSC 777, el panel de agente nativo y configuraciones de lanzamiento:

Característica	Warp	Terminal.app	iTerm2
Deeplinks `warp://` para pestaña/ventana	✅	❌	❌
Panel de agente MCP nativo — chatea con Grok, ChatGPT, Claude, Gemini en la terminal	✅ (`~/.warp/.mcp.json`)	❌	❌
Canal de eventos OSC 777 cli-agent para mostrar estado	✅	❌	❌
Perfil de espacio de trabajo → configuración de lanzamiento reconocida	✅ (`~/.warp/launch_configurations/`)	❌	❌
Nueva pestaña impulsada por AppleScript + envío de teclas	✅	✅	✅
UI/UX moderna	✅	⚠️	⚠️

La captura de salida (sondeo /tmp/<id>.json) y las herramientas que no tocan la terminal (portapapeles, SSH, monitoreo de archivos, instantáneas de entorno, etc.) funcionan de manera idéntica en todos los terminales.

Descarga Warp desde warp.dev. Es gratuito, y las superficies específicas de Warp mencionadas arriba lo requieren.

Instalación

Requisitos previos

macOS 13.0 o posterior
Swift 6.0+ (Xcode 16+)
Al menos un host MCP local (Warp Agent, Claude Desktop, ChatGPT desktop, VS Code, …) — no una pestaña de chat de navegador
Un terminal compatible (Warp muy recomendado)

Instalación rápida

Clona y compila:

git clone https://github.com/M-Pineapple/warp-command-runner.git
cd warp-command-runner

# For the 5 keystroke-routing tools (execute_command, etc.) to work, the build
# must be SIGNED with your code-signing identity. build.sh auto-detects a single
# Apple Development / Developer ID identity; to be explicit (or if you have
# several), export it first — find yours with:
#   security find-identity -v -p codesigning
export WCR_CODESIGN_IDENTITY="<your-cert-sha1>"   # optional if auto-detect finds one; persist in ~/.zshrc
./build.sh

¿Solo necesitas las 34 herramientas sin teclas (incl. execute_pipeline)? Una compilación sin firmar es suficiente — omite el export.

Elige tu(s) host(s) MCP — puedes registrar el mismo binario en varios. Apunta al binario dentro del bundle .app (macOS Sequoia+ necesita el Info.plist para los avisos de TCC en las 5 herramientas de enrutamiento de teclas):

A — Warp Agent (~/.warp/.mcp.json) — Grok, ChatGPT, Claude, Gemini, lo que Warp tenga configurado:
```
{
  "mcpServers": {
    "warp-command-runner": {
      "command": "/Applications/Warp Command Runner.app/Contents/MacOS/warp-command-runner",
      "args": []
    }
  }
}
```
Consulta docs/WARP_AGENT.md.

B — Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json) — misma forma JSON. ChatGPT desktop, Cursor, VS Code, Continue: copia un fragmento de config/ o docs/COMPATIBILITY.md.

Después de ./build.sh también puedes apuntar a $(pwd)/.build/release/warp-command-runner.app/Contents/MacOS/warp-command-runner antes de copiar el bundle a /Applications/.

¿Actualizando desde v6.0.0–6.0.2? Edita tu archivo de configuración existente y agrega .app/Contents/MacOS/warp-command-runner a la ruta. La ruta heredada del binario directo aún funciona para las 34 herramientas sin teclas, pero execute_command / execute_with_auto_retrieve / execute_with_streaming / run_template / send_to_session fallarán silenciosamente sin la ruta del bundle.
Otorga permiso de Accesibilidad (solo requerido para la inyección de teclas send_to_session en v6.0; abrir pestañas/ventanas usa deeplinks y no lo requiere):
- Abre Configuración del Sistema → Privacidad y Seguridad → Accesibilidad
- Haz clic en + y navega a warp-command-runner/.build/release/
- Presiona Cmd+Shift+. para revelar la carpeta oculta .build
- Selecciona el binario warp-command-runner y actívalo

Importante: macOS rastrea los permisos por identidad del binario. Después de cada recompilación (./build.sh), debes eliminar la entrada anterior y volver a agregar el nuevo binario en la configuración de Accesibilidad.

Reinicia tu(s) host(s) MCP (Warp, Claude Desktop, ChatGPT desktop, …).
(Opcional) Instala el shim de shell para una captura de límites de bloque más limpia:
```
helper/install-shim.sh
```
Consulta helper/shell-shim.zsh / helper/shell-shim.bash para la implementación. Desinstala con helper/uninstall-shim.sh.

Actualización desde una versión anterior

Si ya tienes una instalación firmada funcionando (permisos TCC otorgados), actualizar es:

cd warp-command-runner
git pull

# Rebuild with the SAME signing identity you used originally. Without it, build.sh
# falls back to an ad-hoc-signed bundle, macOS sees a new identity, and your
# keystroke (TCC) grants stop applying → error 1002 on execute_command.
# (build.sh auto-detects a single identity; export to be explicit.)
export WCR_CODESIGN_IDENTITY="<your-cert-sha1>"   # persist in ~/.zshrc so you don't forget
./build.sh

# Confirm it signed with your cert (NOT adhoc) BEFORE replacing your good bundle:
codesign -dvv .build/release/warp-command-runner.app 2>&1 | grep -E "Authority=Apple|Signature=adhoc"

# Replace the deployed bundle (rm first — cp -R onto an existing .app nests it):
rm -rf "/Applications/Warp Command Runner.app"
cp -R .build/release/warp-command-runner.app "/Applications/Warp Command Runner.app"

Luego reinicia tu host MCP. Si actualizaste desde v6 y mantuviste el mismo certificado de firma, las concesiones TCC existentes en com.m-pineapple.claude-command-runner no se transfieren a com.m-pineapple.warp-command-runner — vuelve a otorgar Accesibilidad / Monitoreo de Entrada / Acceso Total al Disco / Automatización para el nuevo bundle una vez. Después de eso, las recompilaciones con el mismo certificado mantienen las concesiones.

🛡️ Receta completa de configuración para macOS Sequoia (los 7 pasos ordenados)

Si execute_command / execute_with_auto_retrieve / execute_with_streaming / run_template / send_to_session fallan con osascript is not allowed to send keystrokes (1002) aunque hayas activado todos los paneles en Configuración del Sistema, sigue esto en orden — omitir cualquier paso deja una denegación silenciosa en algún punto de la cadena. Las otras 34 herramientas funcionan sin nada de esto; execute_pipeline es un sustituto totalmente funcional si quieres omitir toda la saga de TCC.

Esta es la receta verificada empíricamente de una sesión real de depuración de 6 horas. v6.0.3+ incluye la infraestructura de bundle que hace esto posible; v6.0.4 es esta pasada de documentación.

El patrón de denegación. El TCC y el sandbox de macOS Sequoia tienen requisitos no obvios y en capas para binarios CLI que manejan osascript → System Events → keystroke. El mensaje de error es engañoso — el bloqueo real generalmente no es el permiso de teclas; es una verificación previa anterior que aborta silenciosamente la cadena. Las cinco puertas, en el orden en que macOS las evalúa:

Puerta	Servicio TCC	Qué la otorga
1. Capacidad de aviso del bundle	(n/a — política)	Bundle en `/Applications/`, no `.build/release/`
2. Identidad del bundle estable	(n/a — codesign)	Firmado con un certificado estable (el cdhash no varía entre recompilaciones)
3. Verificación previa de FDA del sandbox	`kTCCServiceSystemPolicyAllFiles`	Concesión de Acceso Total al Disco en el bundle
4. AppleEvents	`kTCCServiceAppleEvents`	Automatización → System Events ☑
5. Síntesis de teclas	`kTCCServiceListenEvent` / `kTCCServicePostEvent`	Monitoreo de Entrada + Accesibilidad

Paso 1 — Ten un certificado de desarrollo de Apple (o un certificado de Code Signing autofirmado)

Si tienes una cuenta de desarrollador de Apple de pago, ya tienes uno (verifica con security find-identity -v -p codesigning). Si no, crea uno autofirmado:

Acceso a Llaveros → menú Asistente de Certificados → Crear un Certificado…
Nombre: warp-command-runner, Tipo de Identidad: Certificado raíz autofirmado, Tipo de Certificado: Firma de Código
Haga clic en Crear → Continuar a través de las advertencias → Listo

Exporte el identificador del certificado para que build.sh lo encuentre:

# Get the SHA-1 hash (more reliable than the cert name)
security find-identity -v -p codesigning
# Then in your shell rc (~/.zshrc, ~/.config/fish/config.fish, etc.):
export WCR_CODESIGN_IDENTITY="<the-sha1-hash-from-above>"

Paso 2 — Compilar (crea el paquete `.app` firmado)

./build.sh

build.sh invoca a scripts/make-app-bundle.sh, que envuelve la CLI en .build/release/warp-command-runner.app/ con un Info.plist adecuado (CFBundleIdentifier com.m-pineapple.warp-command-runner, las tres cadenas NSXxxUsageDescription requeridas, LSUIElement=true). Si WCR_CODESIGN_IDENTITY está configurado, el paquete se firma con ese certificado como una unidad — cdhash estable entre reconstrucciones.

Verificar:

codesign --display --verbose=4 .build/release/warp-command-runner.app | grep -E 'Identifier|TeamIdentifier|CDHash'
codesign --verify --deep --strict .build/release/warp-command-runner.app  # should succeed silently

Paso 3 — Instalar el paquete en `/Applications/` (CRÍTICO)

macOS se niega a solicitar permisos TCC para paquetes en .build/release/ u otros directorios de desarrollo. El paquete debe residir en /Applications/. Cópielo:

cp -R .build/release/warp-command-runner.app "/Applications/Warp Command Runner.app"

Verifique que la firma sobrevivió a la copia:

codesign --verify --deep --strict "/Applications/Warp Command Runner.app"

Paso 4 — Apunte su configuración MCP a la ruta `/Applications/`

Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "warp-command-runner": {
      "command": "/Applications/Warp Command Runner.app/Contents/MacOS/warp-command-runner",
      "args": []
    }
  }
}

Refleje en ~/.warp/.mcp.json si usa la ruta del Agente Warp.

Paso 5 — Restablecer entradas TCC obsoletas para el ID del paquete

Si ha estado lidiando con denegaciones TCC anteriormente, su TCC.db probablemente tenga entradas Denied obsoletas de reconstrucciones anteriores con diferentes cdhashes. Límpielas para el paquete:

for svc in AppleEvents ListenEvent PostEvent Accessibility; do
    tccutil reset "$svc" com.m-pineapple.warp-command-runner
done

Cada línea debería imprimir "Successfully reset". Si ve "no entries", también está bien — significa que TCC no tenía nada registrado aún.

Paso 6 — Otorgar los tres permisos TCC (Acceso Total al Disco es el sorprendente)

En Configuración del Sistema → Privacidad y Seguridad, agregue /Applications/Warp Command Runner.app a cada uno de:

Acceso Total al Disco — inesperado pero obligatorio. La sandbox de macOS realiza una verificación previa de kTCCServiceSystemPolicyAllFiles antes de permitir que osascript se ejecute para cadenas de pulsaciones de teclas. Sin FDA en el paquete, la sandbox deniega antes de que la verificación de AppleEvents de TCC siquiera se active, y obtiene el engañoso error de "enviar pulsaciones de teclas".
Monitoreo de Entrada — para kTCCServiceListenEvent / kTCCServicePostEvent (generación sintética de pulsaciones de teclas).
Accesibilidad — para la acción AppleEvent keystroke en sí.

Cada concesión requiere Touch ID / contraseña de administrador para confirmar. El nombre del paquete aparece como "Warp Command Runner" en los paneles.

Paso 7 — Reinicie Claude Desktop, active una vez, otorgue el aviso de Automatización

⌘Q Claude Desktop, vuelva a abrirlo. En su primer execute_command, macOS puede mostrar un aviso más — Automatización → "Warp Command Runner quiere controlar System Events" — haga clic en Permitir. Después de eso, es permanente. Las reconstrucciones futuras no restablecen nada (el certificado mantiene el cdhash estable; el paquete mantiene la identidad estable).

Diagnóstico: ¿qué ve TCC ahora mismo?

Si algo no funciona después de la receta, la única forma confiable de averiguar qué puerta está fallando es el registro TCC:

log show --predicate 'process == "tccd"' --last 30s --info --debug \
    | grep -E 'AUTHREQ_CTX|AUTHREQ_RESULT|m-pineapple|promptPolicy|Service Policy'

Active un execute_command primero, luego ejecute inmediatamente lo anterior. Léalo para:

service="kTCCServiceXxx" — qué categoría de permiso se está verificando
promptPolicy = 0 → macOS se niega incluso a solicitar; generalmente un problema de ubicación (paquete no en /Applications/)
promptPolicy = 2 + Denied (Service Policy) → le falta el permiso para el servicio nombrado
AttributionChain: responsible={identifier=com.m-pineapple.warp-command-runner, ...} → bien, TCC nos está identificando correctamente

Si realmente no puede hacerlo funcionar

execute_pipeline es un sustituto totalmente funcional para execute_command:

// instead of execute_command: {"command": "git status"}
// use:
{"steps": [{"command": "git status"}]}

Subproceso puro, sin AppleScript, sin capa TCC, captura la salida limpiamente, funciona en cualquier versión de macOS independientemente de los permisos. El efecto secundario visible (el comando que aparece en su pestaña de Warp) es lo único que pierde — para la mayoría de los flujos de trabajo de agentes, eso no es lo que realmente necesita de todos modos.

Uso

Herramientas Disponibles (40)

En sesiones --http, las cinco herramientas de enrutamiento Warp se rechazan a menos que remote.allowKeystrokeTools sea verdadero. Use execute_pipeline. Consulte docs/REMOTE.md.

Ejecución Principal

Herramienta	Descripción	Caso de Uso
`execute_command`	Ejecutar con recuperación manual de salida	Comandos simples
`execute_with_auto_retrieve`	Ejecutar con recuperación automática inteligente	Uso más común ⭐
`execute_pipeline`	Encadenar comandos con lógica condicional	Flujos de trabajo de compilación, CI/CD
`execute_with_streaming`	Transmisión de salida en tiempo real	Compilaciones largas, suites de pruebas
`save_template`	Guardar patrón de comando reutilizable	Crear atajos
`run_template`	Ejecutar plantilla guardada con variables	Ejecutar patrones guardados
`list_templates`	Ver todas las plantillas guardadas	Gestionar plantillas
`delete_template`	Eliminar una plantilla guardada por nombre	Gestionar plantillas
`get_command_output`	Recuperar manualmente la salida del comando	Depuración
`preview_command`	Vista previa sin ejecutar	Verificación de seguridad
`suggest_command`	Sugerir comandos (pase `working_directory` para ideas conscientes de git/Swift/Node)	Descubrimiento
`list_recent_commands`	Ver historial de comandos	Analítica
`self_check`	Diagnósticos de salud del sistema	Solución de problemas

Portapapeles (v5.0)

Herramienta	Descripción	Caso de Uso
`copy_to_clipboard`	Escribir texto al portapapeles de macOS	Compartir salida
`read_from_clipboard`	Leer contenido actual del portapapeles	Pegar contexto

Notificaciones (v5.0)

Herramienta	Descripción	Caso de Uso
`set_notification_preference`	Alternar notificaciones de macOS	Personalización

Inteligencia de Entorno (v5.0)

Herramienta	Descripción	Caso de Uso
`get_environment_context`	Sondear estado de git, venv, Node, Docker	Conciencia de contexto
`execute_and_parse`	Ejecutar y analizar salida a JSON estructurado	Salida inteligente
`capture_environment`	Capturar instantánea de su entorno de shell real (carga su perfil de inicio de sesión)	Comparación antes/después
`diff_environment`	Comparar dos instantáneas de entorno	Detección de cambios

Perfiles de Espacio de Trabajo (v5.0)

Herramienta	Descripción	Caso de Uso
`save_workspace_profile`	Guardar contexto de proyecto como perfil nombrado	Cambio de proyecto
`load_workspace_profile`	Restaurar un contexto de proyecto guardado	Reanudar trabajo
`list_workspace_profiles`	Ver todos los perfiles guardados	Organización
`delete_workspace_profile`	Eliminar un perfil de espacio de trabajo	Limpieza

Sesiones Multi-Terminal (v5.0)

Herramienta	Descripción	Caso de Uso
`open_terminal_tab`	Abrir una nueva pestaña de terminal nombrada (Warp: vía enlace profundo `warp://action/new_tab` en v6.0)	Procesos de larga duración
`send_to_session`	Enviar comando a una pestaña específica (pulsación de teclas AppleScript; direccionamiento de pestañas limitado en Warp)	Ejecución dirigida
`list_sessions`	Ver sesiones de terminal activas	Resumen de sesiones
`close_session`	Cerrar una sesión nombrada	Limpieza
`cleanup_sessions`	Eliminar en masa sesiones obsoletas; opcionalmente cerrar sus pestañas	Higiene

Detección de Comandos Interactivos (v5.0)

Herramienta	Descripción	Caso de Uso
`check_interactive`	Clasificar un comando para requisitos TTY/stdin antes de ejecutarlo	Evitar bloqueos de `vim`, `ssh`, `psql`, REPLs

Vigilancia de Archivos (v5.0)

Herramienta	Descripción	Caso de Uso
`add_file_watch`	Vigilar directorio y activar comando en cambios	Auto-recompilación, auto-prueba
`remove_file_watch`	Dejar de vigilar un directorio	Limpieza
`list_file_watches`	Ver vigilantes activos	Resumen

Ejecución Remota SSH (v5.0)

Herramienta	Descripción	Caso de Uso
`ssh_execute`	Ejecutar comando en host remoto vía SSH	Operaciones remotas
`save_ssh_profile`	Guardar perfil de conexión SSH	Conexión rápida
`list_ssh_profiles`	Ver perfiles SSH guardados	Resumen
`delete_ssh_profile`	Eliminar un perfil SSH	Limpieza

Warp v6.0 — enlaces profundos, OSC 777, shim de shell

Herramienta	Descripción	Caso de Uso
`focus_warp_session`	Enviar `warp://session/<uuid>` para enfocar un panel de Warp (el UUID debe ser uno que Warp reconozca — típicamente de los eventos del shim de shell opcional)	Reanudar trabajo en un panel específico
`emit_warp_event`	Construir una invocación `printf` que emite un evento JSON OSC 777 `warp://cli-agent` en la interfaz de Warp. Esquema: `session_start` / `prompt_submit` / `tool_complete` / `stop` / `permission_request` / `idle_prompt`. El `printf` devuelto debe ejecutarse dentro de un panel de Warp (p. ej., vía `execute_command`) para que surta efecto	Notificaciones de estado
`shell_shim_status`	Informar estado del socket del shim de shell opcional y eventos recientes	Verificar que el shim esté conectado

Flujos de Trabajo de Ejemplo

Comando Simple:

You: "Check my Swift version"
Assistant: [execute_with_auto_retrieve: swift --version]
Assistant: "You're running Swift 6.0.2"

Canalización de Compilación:

You: "Build, test, and package my app"
Assistant: [execute_pipeline with build → test → package steps]
Assistant: "Pipeline complete! Build: ✅ Test: ✅ Package: ✅"

Compilación Larga en Transmisión:

You: "Build this large project"
Assistant: [execute_with_streaming: swift build -c release]
Assistant: "Building... [live updates every 3 seconds]"
Assistant: "Build completed in 45 seconds!"

Uso de Plantillas:

You: "Save a template for deploying to staging"
Assistant: [save_template: name="deploy-staging", template="cd {{project}} && ./deploy.sh staging"]

You: "Deploy MyApp to staging"
Assistant: [run_template: name="deploy-staging", variables={project: "MyApp"}]

Contexto de Entorno (v5.0):

You: "What's my current dev environment?"
Assistant: [get_environment_context]
Assistant: "You're on branch feature/auth, Python venv active, Node 20.11, 3 Docker containers running."

Perfiles de Espacio de Trabajo (v5.0):

You: "Save this as my API project profile"
Assistant: [save_workspace_profile: name="api-project", directory="~/Projects/api", ...]

You: "Switch to the API project"
Assistant: [load_workspace_profile: name="api-project"]

Vigilancia de Archivos (v5.0):

You: "Rebuild whenever a Swift file changes"
Assistant: [add_file_watch: path="./Sources", pattern="*.swift", command="swift build"]
Assistant: "Watching ./Sources for *.swift changes. Will run swift build on each change."

Ejecución Remota SSH (v5.0):

You: "Check disk space on the staging server"
Assistant: [ssh_execute: host="staging.example.com", username="deploy", command="df -h"]
Assistant: "Here's the disk usage on staging..."

Configuración

El archivo de configuración se encuentra en ~/.warp-command-runner/config.json:

{
  "terminal": {
    "preferred": "auto",
    "fallbackOrder": ["Warp", "WarpPreview", "iTerm", "Terminal"]
  },
  "security": {
    "blockedCommands": ["rm -rf /", "format"],
    "maxCommandLength": 1000
  },
  "history": {
    "enabled": true,
    "maxEntries": 10000
  },
  "notifications": {
    "enabled": true,
    "soundEnabled": true,
    "showOnSuccess": false,
    "showOnFailure": true,
    "minimumDuration": 10
  },
  "fileWatching": {
    "maxWatchers": 5,
    "defaultDebounce": 2.0,
    "autoExpireMinutes": 60
  },
  "ssh": {
    "defaultTimeout": 30,
    "allowPasswordAuth": false
  },
  "interactiveDetection": {
    "enabled": true,
    "customPatterns": []
  }
}

Las plantillas se almacenan por separado en ~/.warp-command-runner/templates.json. Los perfiles de espacio de trabajo se almacenan en ~/.warp-command-runner/profiles.json. Los perfiles SSH se almacenan en ~/.warp-command-runner/ssh_profiles.json.

🤔 Preguntas Frecuentes

P: ¿Pueden Grok, ChatGPT o Gemini usar esto — no solo Claude?

R: Sí, si chatea dentro de un host MCP local. El panel de agente de Warp es la ruta habitual: configure el modelo de Warp a Grok (o GPT, Claude, Gemini) y registre este servidor en ~/.warp/.mcp.json. El escritorio de ChatGPT y Claude Desktop funcionan de la misma manera. Las pestañas del navegador en grok.com / chatgpt.com / claude.ai no pueden lanzar un proceso local. Matriz completa: docs/COMPATIBILITY.md.

P: ¿Qué hay de nuevo en v8.0.0?

R: MCP remoto opcional. warp-command-runner --http sirve Streamable HTTP en loopback con OAuth 2.1. Usted publica HTTPS con su propio túnel. Los conectores de teléfono y sitio web pueden entonces llamar a esta Mac. Las herramientas de pulsaciones de teclas permanecen desactivadas de forma remota. Consulte docs/REMOTE.md.

P: ¿Qué hay de nuevo en v7.0.0?

R: Renombre de Claude Command Runner a Warp Command Runner. Mismas 40 herramientas y protocolo MCP stdio; nombres, ID de paquete y rutas ~/.warp-command-runner actualizados. La configuración v6 se copia en el primer lanzamiento.

P: Cursor dice `spawn /Applications/Warp ENOENT`?

R: Cursor divide command en espacios. La ruta oficial /Applications/Warp Command Runner.app/... es correcta para Warp y Claude Desktop — no renombre el .app. Para Cursor, ejecute helper/install-cursor-wrapper.sh y apunte ~/.cursor/mcp.json a ~/.local/bin/warp-command-runner. Consulte config/cursor-mcp.json.

P: ¿Qué hay de nuevo en v6.0.0?

R: Re-pivote hacia Warp después de que Warp se volviera de código abierto. Arquitectura de doble consumidor (registre el mismo binario en ~/.warp/.mcp.json para usarlo desde el panel de agente nativo de Warp, además de Claude Desktop). Los enlaces profundos warp:// reemplazan los clics de menú AppleScript para operaciones de pestañas/ventanas. Nuevo emisor OSC 777 (emit_warp_event) que muestra eventos estructurados en la interfaz de Warp. Nuevo shim de shell opcional que emite eventos limpios de preejecución/fin de comando al MCP. Los perfiles de espacio de trabajo ahora también pueden emitir configuraciones de lanzamiento nativas de Warp. ~460 LOC de código muerto eliminados. El recuento de herramientas pasa de un subestimado 36 (el README v5 afirmaba 30) a 39. Consulte CHANGELOG.md y docs/WARP_AGENT.md para la historia completa.

P: ¿Qué fue nuevo en v5.0.0?

R: Diez nuevas categorías de funciones que llevan el recuento de herramientas de 12 a 36 (el README v5 subestimó como 30; la tabla de despacho realmente registró 36). Destacados: integración de portapapeles, notificaciones de macOS, inteligencia de entorno, análisis de salida estructurada, perfiles de espacio de trabajo, sesiones multi-terminal, vigilantes de archivos, ejecución remota SSH.

P: ¿Cuándo debo usar pipelines en lugar de comandos regulares?

R: Usa pipelines cuando necesites:

Múltiples comandos secuenciales
Lógica condicional (detener en fallo de compilación, continuar en fallo de pruebas)
Un resumen de todos los pasos con tiempos
Flujos de trabajo estilo CI/CD

P: ¿Por qué mi comando se "cuelga" con execute_with_auto_retrieve?

R: Para comandos muy largos, usa execute_with_streaming en su lugar. Proporciona actualizaciones de salida en tiempo real y maneja comandos que se ejecutan durante minutos. Esta fue la principal motivación para agregar streaming en v4.0.

P: ¿Cómo uso plantillas con múltiples variables?

R: Define variables en tu plantilla con la sintaxis {{variable_name}}:

{
  "template": "cd {{project}} && git checkout {{branch}} && swift build -c {{config}}"
}

Luego proporciona todas las variables al ejecutar:

{
  "variables": {"project": "~/MyApp", "branch": "main", "config": "release"}
}

P: ¿Dónde se almacenan mis plantillas?

R: En ~/.warp-command-runner/templates.json. Persisten entre sesiones y reinicios del host MCP.

P: ¿Cuánto tiempo esperará auto-retrieve por mi comando?

R: Depende del tipo de comando:

Comandos simples: 6 segundos
Comandos Git/npm: 20 segundos
Comandos de compilación: 77 segundos
Comandos desconocidos: 30 segundos

Para comandos más largos, usa execute_with_streaming en su lugar.

P: ¿Puedo usar esto con Terminal.app o iTerm2?

R: Sí, la ejecución básica de comandos funciona con cualquier terminal. La captura automática de salida y las funciones específicas de Warp (deeplinks, OSC 777, panel de agente) requieren Warp. Descárgalo desde warp.dev.

P: ¿Es seguro permitir que una IA ejecute comandos?

R: Los comandos se envían directamente a tu terminal y se ejecutan automáticamente — no hay un paso manual de "presionar Enter". Configura comandos bloqueados en ~/.warp-command-runner/config.json. Solo conecta este MCP a un host en el que confíes. No lo expongas como un servidor HTTP público.

P: ¿Qué sucede si falla un paso del pipeline?

R: Depende de la configuración on_fail:

stop – El pipeline se detiene inmediatamente, los pasos restantes se omiten
continue – El error se registra, el pipeline continúa al siguiente paso
warn – Se muestra una advertencia, el pipeline continúa

P: ¿Puedo anidar pipelines o ejecutar plantillas dentro de pipelines?

R: No directamente. Puedes crear plantillas que contengan múltiples comandos separados por && o ;, o componer llamando a run_template y execute_pipeline desde la misma conversación.

P: ¿Dónde se almacena mi historial de comandos?

R: En una base de datos SQLite en ~/.warp-command-runner/warp_commands.db. Registra todos los comandos, salidas, códigos de salida y tiempos de ejecución.

🛠️ Solución de problemas

Error de permisos en macOS: "osascript is not allowed to send keystrokes" (Error 1002)

Este error afecta a las 5 herramientas enrutadas por keystrokes de AppleScript (execute_command, execute_with_auto_retrieve, execute_with_streaming, run_template, send_to_session). Las otras 34 herramientas — incluyendo execute_pipeline — no se ven afectadas.

No pierdas horas alternando paneles de Configuración del Sistema. Este es un problema en capas con la aplicación de TCC + sandbox de macOS Sequoia, y las correcciones parciales dejan denegaciones silenciosas en capas más profundas. La solución canónica es la 🛡️ receta de configuración completa de macOS Sequoia anterior (en la sección de Instalación) — siete pasos ordenados que incluyen: construir el paquete .app, instalar en /Applications/ (no en .build/), tccutil reset para el ID del paquete, y otorgar TRES permisos TCC incluyendo el sorprendente (Acceso completo al disco en el paquete — el sandbox lo verifica antes de permitir la cadena de keystrokes). Síguela de principio a fin; omitir cualquier paso deja una denegación oculta.

Triaje rápido — ¿estoy encontrando esto?

Ejecuta esto inmediatamente después de un execute_command fallido:

log show --predicate 'process == "tccd"' --last 20s --info --debug | grep -E 'm-pineapple|promptPolicy|Service Policy'

Verás uno de:

promptPolicy = 0 → el paquete no está en /Applications/ (o no hay paquete en absoluto). Solución: Pasos 2-3 de la receta.
promptPolicy = 2 + Denied (Service Policy) para kTCCServiceSystemPolicyAllFiles → falta Acceso completo al disco en el paquete. Solución: Paso 6 de la receta.
AttributionChain: responsible={identifier=warp-command-runner, ...} (sin m-pineapple) → no estás ejecutando desde el paquete, estás ejecutando el binario simple. Solución: vuelve a ejecutar ./build.sh y actualiza tu configuración MCP a la ruta .app (Pasos 2-4 de la receta).

Solución alternativa si no quieres molestarte con la receta:

// Use execute_pipeline instead of execute_command:
{"steps": [{"command": "git status"}]}

Subproceso puro, sin AppleScript, cero TCC. Funciona en cualquier macOS independientemente de los permisos. Las 34 herramientas sin keystrokes también funcionan.

Referencia de ID de paquete: com.m-pineapple.warp-command-runner (este proyecto), com.anthropic.claudefordesktop (Claude Desktop).

Problemas de permisos de Accesibilidad en macOS

El binario MCP requiere permiso de Accesibilidad solo para la ruta de keystrokes de AppleScript utilizada por send_to_session (escribir en una pestaña específica de Warp) y las rutas heredadas sin Warp en execute_command para iTerm/Terminal/Alacritty. La mayoría de las herramientas v6.0 funcionan sin Accesibilidad: ejecución basada en subprocesos, deeplinks warp:// para abrir pestañas, portapapeles, SSH, instantáneas de entorno, monitoreo de archivos, perfiles y las 24 herramientas del lado del servidor.

Síntomas (cuando importa):

Mensaje de error: osascript is not allowed assistive access. (-1719)
send_to_session falla; portapapeles, SSH, contexto de entorno, open_terminal_tab basado en deeplinks funcionan bien

Solución:

Abre Configuración del Sistema → Privacidad y Seguridad → Accesibilidad

Haz clic en el botón + y navega a tu binario warp-command-runner:

/path/to/warp-command-runner/.build/release/warp-command-runner

La carpeta .build está oculta por defecto — presiona Cmd+Shift+. en Finder para revelarla
Activa el permiso activado para el binario

Importante: macOS rastrea los permisos de Accesibilidad por identidad del binario. Después de cada swift build, el binario cambia y debes volver a agregarlo a la lista de Accesibilidad. Esto solo afecta las rutas de inyección de keystrokes — la mayoría de las herramientas no se ven afectadas.

MCP No Responde

Revisa los registros del cliente (Claude Desktop o Warp). El servidor predeterminado es un hijo del cliente sobre stdio. MCP remoto (--http) escucha solo en 127.0.0.1 — consulta docs/REMOTE.md.
Reinicia el cliente (Claude Desktop y/o Warp).
Reconstruye con ./build.sh. (Y vuelve a agregar el binario a Accesibilidad si send_to_session está fallando.)

Los Comandos No Aparecen en la Terminal

Asegúrate de que Warp/WarpPreview esté ejecutándose
Revisa los registros de Claude Desktop para ver errores
Verifica la ruta de tu configuración MCP

El Streaming No Se Actualiza

Verifica que el comando realmente se esté ejecutando (no esperando entrada)
Aumenta update_interval si las actualizaciones son demasiado frecuentes
Revisa /tmp/wcr_stream_*.log para archivos de salida

Pasos del Pipeline Omitidos Inesperadamente

Revisa la configuración on_fail – stop omitirá los pasos restantes
Verifica que cada comando funcione individualmente primero
Revisa los códigos de salida en el resumen del pipeline

Las Plantillas No Se Guardan

Asegúrate de que el directorio ~/.warp-command-runner/ exista
Revisa los permisos de escritura en templates.json
Verifica la sintaxis JSON en la definición de la plantilla

Auto-Retrieve No Funciona

Asegúrate de estar usando execute_with_auto_retrieve (no execute_command)
Verifica si existe el archivo de salida del comando: ls /tmp/wcr_output_*.json
Para comandos largos, usa execute_with_streaming en su lugar

Problemas de Base de Datos

Si los comandos se ejecutan pero no se guardan en la base de datos:

Verifica la integridad de la base de datos:

sqlite3 ~/.warp-command-runner/warp_commands.db "PRAGMA integrity_check;"

Si está corrupta, haz una copia de seguridad y elimínala:

mv ~/.warp-command-runner/warp_commands.db ~/.warp-command-runner/warp_commands.db.backup
# Restart the MCP host — a new database is created automatically

Arquitectura

  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐
  │ Warp Agent   │  │ Claude Desk. │  │ ChatGPT /    │
  │ (Grok, GPT,  │  │              │  │ Cursor / VS  │
  │  Claude, …)  │  │              │  │ Code / …     │
  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘
         │ stdio MCP       │ stdio MCP       │ stdio MCP
         └─────────────────┴─────────────────┘
                           ▼
         ┌─────────────────────────────────┐
         │  warp-command-runner v7.0       │
         │  Swift MCP server · 40 tools    │
         └─────────┬───────────┬───────────┘
                   │           │
                   ▼           ▼
         ┌──────────────┐  ┌─────────────────────┐
         │ Warp Terminal│  │ Optional shell shim │
         │ warp://      │  │ /tmp/wcr-shell-shim-│
         │ OSC 777      │  │   <uid>.sock        │
         └──────────────┘  └─────────────────────┘

Cualquier host MCP local, un servidor. Las operaciones de pestañas/ventanas usan el esquema de URL warp:// de Warp; los eventos de estado usan OSC 777; escribir en una pestaña aún usa keystrokes de AppleScript (Warp no tiene API para eso). Los chats de teléfono y sitio web necesitan --http más tu propio túnel HTTPS — consulta docs/REMOTE.md.

Contribuciones

¡Nos encantan las contribuciones! Así es como:

Haz un fork del repositorio
Crea una rama de características (git checkout -b feature/amazing-feature)
Haz commit de tus cambios (git commit -m 'Add amazing feature')
Haz push a la rama (git push origin feature/amazing-feature)
Abre una Pull Request

Configuración de Desarrollo

git clone https://github.com/M-Pineapple/warp-command-runner.git
cd warp-command-runner
swift package resolve
swift build

💖 Apoya Este Proyecto

Si Warp Command Runner ha mejorado tu flujo de trabajo de desarrollo o te ha ahorrado tiempo con la ejecución inteligente de comandos, considera apoyar su desarrollo:

Tu apoyo me ayuda a:

Mantener y mejorar Warp Command Runner con nuevas funciones
Mantener el proyecto de código abierto y gratuito para todos
Dedicar más tiempo a abordar solicitudes de usuarios y correcciones de errores
Explorar nuevas integraciones de terminal e inteligencia de comandos

¡Gracias por considerar apoyar mi trabajo! 🙏

Licencia

Licencia MIT – consulta el archivo LICENSE para más detalles

Construido con ❤️, originalmente por 🍍 como Claude Command Runner. v7 renombra el mismo MCP para cualquier host.

Si esto te ayuda, dale una estrella al repositorio y prueba Warp.