symfony-command-ui: tus comandos Symfony son tu MCP server

☄ Teleport al Blog

Pascualhybrid

✨ mcp/sse

14 de abril de 2026

El problema que todos tenemos

Si trabajas con Symfony, tienes comandos de consola. Muchos. app:users:sync, app:payments:process, app:cache:warmup… Son la columna vertebral de tu aplicacion: encapsulan logica de negocio, se ejecutan en cron, los usas para debuggear, para migraciones, para todo.

Y sin embargo, ejecutarlos es un rollo:

SSH al servidor (o al pod de Kubernetes)
Recordar la sintaxis exacta (--limit=100 o --limit 100?)
Copiar el output a mano si quieres compartirlo
Si estas en un pod de K8s, ni siquiera tienes terminal a veces

Y ahora, en la era agentica, hay un segundo problema: como le dices a un agente de IA que ejecute tus comandos? Los LLMs son buenos entendiendo JSON, haciendo HTTP, procesando streams. Pero no pueden hacer SSH a tu pod.

La solucion: un bundle que los expone a todos

symfony-command-ui es un bundle de Symfony que he publicado hoy. Hace una cosa simple:

Convierte tus comandos de consola en una UI web con terminal streaming Y en una API JSON que cualquier agente de IA puede usar.

composer require pascualmg/symfony-command-ui

Tres lineas de YAML y tienes un dashboard con todos tus comandos, auto-descubiertos, con formularios generados automaticamente desde tu InputDefinition.

Como funciona

La arquitectura es simple:

El bundle ejecuta php bin/console list --format=json para descubrir los comandos disponibles
Filtra por una whitelist que tu configuras (seguridad)
Traduce cada InputOption y InputArgument a un formulario web (checkboxes, dropdowns, text inputs)
Cuando pulsas Run, ejecuta el comando via Symfony\Component\Process y te streama el output en tiempo real como NDJSON

Cada comando se renderiza como una card independiente con su propio formulario y su propia terminal. Los outputs persisten: puedes ejecutar Stats mientras Generate JWT mantiene su resultado.

La parte interesante: interfaz dual

Aqui es donde se pone bueno. El bundle expone dos interfaces con los mismos endpoints:

Para humanos: el dashboard web

Un Web Component (<symfony-command>) con Shadow DOM, zero dependencias, que descubre los comandos al montar y renderiza todo automaticamente. No hay npm, no hay webpack, no hay build step. Un unico fichero JS que el bundle sirve como asset.

CSS customizable via custom properties. Dark theme por defecto. Theming completo si quieres.

Para agentes: la API JSON

Dos endpoints:

GET /commands: devuelve un JSON estructurado con todos los comandos disponibles, sus opciones, defaults y tipos
POST /execute: recibe {command, options} y streama el output como NDJSON

Cualquier agente que hable HTTP puede:

Descubrir que operaciones existen en tu app
Entender sus parametros (sin documentacion extra – salen del InputDefinition de Symfony)
Ejecutarlas y observar el resultado en tiempo real

Es un MCP server gratis. Sin instalar nada especial. Sin protocolo custom. Solo HTTP + JSON.

Un ejemplo real: Claude operando una app

Imagina que tienes un e-commerce con estos comandos:

allowed_commands:
    - app:orders:pending
    - app:orders:process
    - app:inventory:check
    - app:reports:daily

Un agente de IA (Claude, GPT, tu propio agente) puede hacer:

Tu: "Hay pedidos pendientes de mas de 500 euros?"

Agente: /llama GET commands, encuentra app:orders:pending /llama POST execute con {"command":"app:orders:pending","options":{"–min-amount":500,"–json":true}}

"Si, hay 3 pedidos pendientes por encima de 500 euros: #4521 (720 euros), #4523 (1100 euros), #4529 (550 euros). Quieres que los procese?"

Tu: "Primero con dry-run"

Agente: /llama POST execute con {"command":"app:orders:process","options":{"–ids":"4521,4523,4529","–dry-run":true}}

"Dry run completado. Los 3 se procesarian correctamente. Total: 2370 euros. Ejecuto en real?"

Todo esto funciona porque tus comandos de Symfony ya encapsulan la logica. El bundle solo la expone.

El patron: logica en comandos, interfaz como adaptador

Si haces DDD o hexagonal, tus comandos de Symfony son adaptadores CLI que llaman a use cases del dominio. Este bundle anade un segundo adaptador (HTTP) al mismo use case, sin tocar una linea de tu logica de negocio.

                    ┌──────────────┐
      bin/console──►│              │
                    │  Use Case    │
symfony-command-ui──►│  (dominio)   │
      (HTTP+NDJSON) │              │
                    └──────────────┘

No importa si llegas por CLI o por HTTP: el mismo codigo se ejecuta. El bundle solo se encarga del transporte.

Detalles tecnicos

PHP >= 7.4, Symfony 5.4 / 6.x / 7.x
NDJSON sobre HTTP (no WebSocket, no SSE). fetch() + ReadableStream + TextDecoder
Web Component con Shadow DOM. Un unico fichero JS, zero deps
Auto-discovery via bin/console list --format=json + Process
Whitelist configurable. Solo los comandos que tu permitas se exponen
Overrides para convertir text inputs en dropdowns (ej: --gateway: [stripe, paypal, braintree])
No incluye autenticacion. Tu pones tu access_control, firewall, VPN o lo que uses

Instalacion en 4 pasos

# 1. Instalar
composer require pascualmg/symfony-command-ui

# 2. El bundle se auto-registra en bundles.php

# 3. Importar rutas
# config/routes/symfony_command_ui.yaml
# symfony_command_ui:
#     resource: '@SymfonyCommandUIBundle/Resources/config/routes.php'
#     prefix: /symfony-console

# 4. Configurar whitelist
# config/packages/symfony_command_ui.yaml
# symfony_command_ui:
#     allowed_commands:
#         - app:mi:comando
#         - app:otro:comando

Abrir https://tu-app.com/symfony-console y listo.

El origen

Esto surgio de un problema real: teniamos un microservicio de identity con 6 comandos de consola para gestionar colectivos (una feature B2B para un partner). Necesitabamos una UI para que el equipo pudiera ejecutarlos sin SSH, y al mismo tiempo queriamos que los agentes de IA pudieran operar el flujo programaticamente.

En vez de hacer un dashboard ad-hoc, extraje la logica generica en un bundle reutilizable. El prototipo funciono en una tarde. La lib se publico al dia siguiente. Hoy esta en Packagist.

Links

Repositorio: https://github.com/pascualmg/symfony-command-ui
Packagist: https://packagist.org/packages/pascualmg/symfony-command-ui
Licencia: MIT

Es tu post

Titulo Contenido (HTML)

<h1 id="el-problema-que-todos-tenemos">El problema que todos
tenemos</h1>
Si trabajas con Symfony, tienes comandos de consola. Muchos.
<code>app:users:sync</code>, <code>app:payments:process</code>,
<code>app:cache:warmup</code>… Son la columna vertebral de tu
aplicacion: encapsulan logica de negocio, se ejecutan en cron, los usas
para debuggear, para migraciones, para todo.
Y sin embargo, ejecutarlos es un rollo:
<ul>
<li>SSH al servidor (o al pod de Kubernetes)</li>
<li>Recordar la sintaxis exacta (<code>--limit=100</code> o
<code>--limit 100</code>?)</li>
<li>Copiar el output a mano si quieres compartirlo</li>
<li>Si estas en un pod de K8s, ni siquiera tienes terminal a veces</li>
</ul>
Y ahora, en la era agentica, hay un segundo problema: como le
dices a un agente de IA que ejecute tus comandos? Los LLMs son
buenos entendiendo JSON, haciendo HTTP, procesando streams. Pero no
pueden hacer SSH a tu pod.
<h1 id="la-solucion-un-bundle-que-los-expone-a-todos">La solucion: un
bundle que los expone a todos</h1>
<code>symfony-command-ui</code> es un bundle de Symfony que he
publicado hoy. Hace una cosa simple:
Convierte tus comandos de consola en una UI web con terminal
streaming Y en una API JSON que cualquier agente de IA puede
usar.
<div class="sourceCode" id="cb1"><pre
class="sourceCode bash"><code class="sourceCode bash"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a>composer require pascualmg/symfony-command-ui</code></pre></div>
Tres lineas de YAML y tienes un dashboard con todos tus comandos,
auto-descubiertos, con formularios generados automaticamente desde tu
<code>InputDefinition</code>.
<h1 id="como-funciona">Como funciona</h1>
La arquitectura es simple:
<ol>
<li>El bundle ejecuta <code>php bin/console list --format=json</code>
para descubrir los comandos disponibles</li>
<li>Filtra por una whitelist que tu configuras (seguridad)</li>
<li>Traduce cada <code>InputOption</code> y <code>InputArgument</code> a
un formulario web (checkboxes, dropdowns, text inputs)</li>
<li>Cuando pulsas Run, ejecuta el comando via
<code>Symfony\Component\Process</code> y te streama el output en tiempo
real como NDJSON</li>
</ol>
Cada comando se renderiza como una card
independiente con su propio formulario y su propia terminal.
Los outputs persisten: puedes ejecutar Stats mientras Generate JWT
mantiene su resultado.
<h1 id="la-parte-interesante-interfaz-dual">La parte interesante:
interfaz dual</h1>
Aqui es donde se pone bueno. El bundle expone dos interfaces
con los mismos endpoints:
<h2 id="para-humanos-el-dashboard-web">Para humanos: el dashboard
web</h2>
Un Web Component (<code>&lt;symfony-command&gt;</code>) con Shadow
DOM, zero dependencias, que descubre los comandos al montar y renderiza
todo automaticamente. No hay npm, no hay webpack, no hay build step. Un
unico fichero JS que el bundle sirve como asset.
CSS customizable via custom properties. Dark theme por defecto.
Theming completo si quieres.
<h2 id="para-agentes-la-api-json">Para agentes: la API JSON</h2>
Dos endpoints:
<ul>
<li><code>GET /commands</code>: devuelve un JSON estructurado con todos
los comandos disponibles, sus opciones, defaults y tipos</li>
<li><code>POST /execute</code>: recibe <code>{command, options}</code> y
streama el output como NDJSON</li>
</ul>
Cualquier agente que hable HTTP puede:
<ol>
<li>Descubrir que operaciones existen en tu app</li>
<li>Entender sus parametros (sin documentacion extra – salen del
<code>InputDefinition</code> de Symfony)</li>
<li>Ejecutarlas y observar el resultado en tiempo real</li>
</ol>
Es un MCP server gratis. Sin instalar nada especial.
Sin protocolo custom. Solo HTTP + JSON.
<h1 id="un-ejemplo-real-claude-operando-una-app">Un ejemplo real: Claude
operando una app</h1>
Imagina que tienes un e-commerce con estos comandos:
<div class="sourceCode" id="cb2"><pre
class="sourceCode yaml"><code class="sourceCode yaml"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a>allowed_commands:
<a href="#cb2-2" aria-hidden="true" tabindex="-1"></a> - app:orders:pending
<a href="#cb2-3" aria-hidden="true" tabindex="-1"></a> - app:orders:process
<a href="#cb2-4" aria-hidden="true" tabindex="-1"></a> - app:inventory:check
<a href="#cb2-5" aria-hidden="true" tabindex="-1"></a> - app:reports:daily</code></pre></div>
Un agente de IA (Claude, GPT, tu propio agente) puede hacer:
<blockquote>
Tu: "Hay pedidos pendientes de mas de 500
euros?"
Agente: /llama GET commands, encuentra
app:orders:pending /llama POST execute con
{"command":"app:orders:pending","options":{"–min-amount":500,"–json":true}}
"Si, hay 3 pedidos pendientes por encima de 500 euros: #4521 (720
euros), #4523 (1100 euros), #4529 (550 euros). Quieres que los
procese?"
Tu: "Primero con dry-run"
Agente: /llama POST execute con
{"command":"app:orders:process","options":{"–ids":"4521,4523,4529","–dry-run":true}}
"Dry run completado. Los 3 se procesarian correctamente. Total: 2370
euros. Ejecuto en real?"
</blockquote>
Todo esto funciona porque tus comandos de Symfony ya
encapsulan la logica. El bundle solo la expone.
<h1 id="el-patron-logica-en-comandos-interfaz-como-adaptador">El patron:
logica en comandos, interfaz como adaptador</h1>
Si haces DDD o hexagonal, tus comandos de Symfony son
adaptadores CLI que llaman a use cases del dominio.
Este bundle anade un segundo adaptador (HTTP) al mismo use case, sin
tocar una linea de tu logica de negocio.
<pre><code> ┌──────────────┐
 bin/console──►│ │
 │ Use Case │
symfony-command-ui──►│ (dominio) │
 (HTTP+NDJSON) │ │
 └──────────────┘
</code></pre>
No importa si llegas por CLI o por HTTP: el mismo codigo se ejecuta.
El bundle solo se encarga del transporte.
<h1 id="detalles-tecnicos">Detalles tecnicos</h1>
<ul>
<li>PHP &gt;= 7.4, Symfony 5.4 / 6.x / 7.x</li>
<li>NDJSON sobre HTTP (no WebSocket, no SSE).
<code>fetch()</code> + <code>ReadableStream</code> +
<code>TextDecoder</code></li>
<li>Web Component con Shadow DOM. Un unico fichero JS,
zero deps</li>
<li>Auto-discovery via
<code>bin/console list --format=json</code> + <code>Process</code></li>
<li>Whitelist configurable. Solo los comandos que tu
permitas se exponen</li>
<li>Overrides para convertir text inputs en dropdowns
(ej: <code>--gateway: [stripe, paypal, braintree]</code>)</li>
<li>No incluye autenticacion. Tu pones tu
<code>access_control</code>, firewall, VPN o lo que uses</li>
</ul>
<h1 id="instalacion-en-4-pasos">Instalacion en 4 pasos</h1>
<div class="sourceCode" id="cb4"><pre
class="sourceCode bash"><code class="sourceCode bash"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a># 1. Instalar
<a href="#cb4-2" aria-hidden="true" tabindex="-1"></a>composer require pascualmg/symfony-command-ui
<a href="#cb4-3" aria-hidden="true" tabindex="-1"></a>
<a href="#cb4-4" aria-hidden="true" tabindex="-1"></a># 2. El bundle se auto-registra en bundles.php
<a href="#cb4-5" aria-hidden="true" tabindex="-1"></a>
<a href="#cb4-6" aria-hidden="true" tabindex="-1"></a># 3. Importar rutas
<a href="#cb4-7" aria-hidden="true" tabindex="-1"></a># config/routes/symfony_command_ui.yaml
<a href="#cb4-8" aria-hidden="true" tabindex="-1"></a># symfony_command_ui:
<a href="#cb4-9" aria-hidden="true" tabindex="-1"></a># resource: &#39;@SymfonyCommandUIBundle/Resources/config/routes.php&#39;
<a href="#cb4-10" aria-hidden="true" tabindex="-1"></a># prefix: /symfony-console
<a href="#cb4-11" aria-hidden="true" tabindex="-1"></a>
<a href="#cb4-12" aria-hidden="true" tabindex="-1"></a># 4. Configurar whitelist
<a href="#cb4-13" aria-hidden="true" tabindex="-1"></a># config/packages/symfony_command_ui.yaml
<a href="#cb4-14" aria-hidden="true" tabindex="-1"></a># symfony_command_ui:
<a href="#cb4-15" aria-hidden="true" tabindex="-1"></a># allowed_commands:
<a href="#cb4-16" aria-hidden="true" tabindex="-1"></a># - app:mi:comando
<a href="#cb4-17" aria-hidden="true" tabindex="-1"></a># - app:otro:comando</code></pre></div>
Abrir <code>https://tu-app.com/symfony-console</code> y listo.
<h1 id="el-origen">El origen</h1>
Esto surgio de un problema real: teniamos un microservicio de
identity con 6 comandos de consola para gestionar colectivos (una
feature B2B para un partner). Necesitabamos una UI para que el equipo
pudiera ejecutarlos sin SSH, y al mismo tiempo queriamos que los agentes
de IA pudieran operar el flujo programaticamente.
En vez de hacer un dashboard ad-hoc, extraje la logica generica en un
bundle reutilizable. El prototipo funciono en una tarde. La lib se
publico al dia siguiente. Hoy esta en Packagist.
<h1 id="links">Links</h1>
<ul>
<li>Repositorio: <a
href="https://github.com/pascualmg/symfony-command-ui">https://github.com/pascualmg/symfony-command-ui</a></li>
<li>Packagist: <a
href="https://packagist.org/packages/pascualmg/symfony-command-ui">https://packagist.org/packages/pascualmg/symfony-command-ui</a></li>
<li>Licencia: MIT</li>
</ul>

Estas seguro? Esto no se puede deshacer.

Comentarios (0)

Sin comentarios todavia. Se el primero!