puente de espacio de trabajo unificado ssmcp
Descubre las máquinas y sus capacidades
Primero llama a list. Usa el title opcional de cada cliente para entender su tarea, luego verifica su name y cwd. Selecciona clientes por su id devuelto; los títulos, nombres y hostnames son etiquetas y pueden repetirse. Usa tools.search(clientId,{query,limit:20}) dentro de code_mode para localizar resúmenes concisos de herramientas; solicita include_schemas:true para obtener el descriptor nativo completo antes de llamar. En brokers antiguos, usa list({client_id}) o la paginación tools(clientId,cursor). Respeta la política de permisos y aprobación de cada backend nativo.
Mantén cada recorrido del catálogo de herramientas en su cursor devuelto. Sus páginas comparten una instantánea incluso si un directorio de herramientas nativo cambia; inicia una nueva solicitud sin cursor para descubrir actualizaciones. Un cliente retiene como máximo cuatro instantáneas y 64 MiB de JSON serializado en total. Cada lectura de página exitosa renueva el tiempo de espera de 120 segundos, pero una instantánea expira como máximo 900 segundos después de su creación. Los cursores inválidos no lo renuevan, y reutilizar un catálogo sin cambios no restablece su tiempo de creación; los límites LRU y de capacidad pueden desalojarlo antes. Reinicia el descubrimiento si el servidor informa que una instantánea expiró o fue desalojada.
Los clientes actuales se conectan como type:"shell" y proporcionan una terminal interactiva principal, terminales adicionales independientes, trabajos de comando independientes, herramientas de archivos y contexto sin necesidad de un Harness. La verificación en segundo plano descubre los proveedores instalados y registra solo las interfaces cuya versión, política de inicio, protocolo de enlace y catálogo real son utilizables. ssmcp.harnesses.list informa el estado y los diagnósticos; un proveedor no disponible no elimina Shell u otras herramientas. Elimina los argumentos obsoletos -t, --type, --backend y los argumentos finales de backend de los comandos de inicio.
El descubrimiento no debe instalar tiempos de ejecución, dependencias o Harnesses, enviar solicitudes de modelo, ni relajar los permisos nativos. No trates los cachés de paquetes sin conexión como prueba de que no se instalará nada. Los proveedores sin un inicio seguro verificado permanecen no disponibles. El descubrimiento de Pi se conecta solo a una sesión RPC JSONL nativa explícitamente configurada e inicializada a través de SSMCP_PI_RPC_SOCKET. El socket Unix absoluto y su directorio padre directo deben pertenecer al UID actual, no tener permisos de grupo/otros y no ser enlaces simbólicos; el UID del par conectado, el binario instalado y la versión se verifican antes de un protocolo de enlace get_state de cinco segundos. El descubrimiento de OpenCode se adjunta solo a un servicio existente en http://127.0.0.1:PORT/ (SSMCP_OPENCODE_URL, OPENCODE_PASSWORD). Se requieren el puerto explícito y la ruta raíz; se rechazan proxies, redirecciones, otros hosts, userinfo, consulta y fragmento. El descubrimiento nativo lee solo info y OpenAPI; la suscripción a eventos es diferida. Los endpoints faltantes significan no disponibles. Ningún adaptador inicia un servicio externo o deshabilita las extensiones del usuario para fabricar un catálogo completo.
list y tools usan un solo registro, preservando el Schema nativo y los descriptores con espacios de nombres de enrutamiento. Los espacios de nombres incluyen codex.*, claude.*, pi.*, opencode.* y playwright.* cuando su descubrimiento MCP nativo tiene éxito; los nombres exactos provienen del catálogo actual. Las herramientas MCP de Codex se enumeran a través de mcpServerStatus/list nativo y se reenvían a través de mcpServer/tool/call; selecciona los nombres codex.mcp.* descubiertos sin codificar un servidor. Pi expone solo las operaciones de puente pi.rpc, ssmcp.pi.events, ssmcp.pi.requests y ssmcp.pi.respond cuando están disponibles. Una instalación CLI o una lista de comandos de control conocidos no es una enumeración de su modelo, complemento o Schema de herramienta MCP interna.
Lee ssmcp://guide, ssmcp://limits y ssmcp://clients a través de recursos MCP o resources.read(uri) dentro de code_mode. Usa resources.templates() para recursos específicos del cliente. Verifica los catálogos actuales cuando un cliente conectado tiene una versión anterior.
code_mode se ejecuta en el servidor MCP. Su sistema de archivos y red de bucle invertido no son el espacio de trabajo de la persona que llama. Para incluir un sandbox u otra computadora en una transferencia, ejecuta un cliente ssmcp separado en ese entorno y selecciona su ID devuelto. Inícialo desde el directorio a compartir:
cd /path/to/workspace
ssmcp --name workspace --title "Describe la tarea de esta sesión" --allow TU_USUARIO_DE_GITHUB@github [email protected]
Usa el destino SSH configurado por el operador y la identidad autorizada. No copies claves SSH privadas, deshabilites las comprobaciones de clave de host ni eludas una política de red. Si el entorno de la persona que llama no puede conectarse, informa esa limitación exacta y continúa el trabajo en pares accesibles.
Inspecciona las habilidades y archivos de instrucción disponibles
Usa context.roots(id) para ver el espacio de trabajo y las raíces de contexto de solo lectura explícitas. Comienza con skills.view(id) para un índice Markdown compacto o skills.list(id,options) para metadatos. Sigue next_cursor usando las mismas opciones de escaneo. Los nombres pueden repetirse; elige por raíz y ruta, luego llama a skills.read(id,{path}) para el SKILL.md completo.
agents.resolve(id,{path:"src/lib.rs"}) devuelve los orígenes de las instrucciones y el contenido exacto en orden de raíz a destino. agents.list devuelve solo los orígenes, y agents.read lee un archivo seleccionado. En cada directorio, ssmcp selecciona el primer archivo no vacío entre AGENTS.override.md, AGENTS.md o agents.md. Revisa la procedencia y los diagnósticos antes de aplicar las instrucciones relevantes.
La raíz predeterminada es el espacio de trabajo de inicio del cliente. Un operador puede agregar hasta ocho raíces de solo lectura con --context-root PATH repetido; selecciona sus ID devueltos explícitamente con la opción root. Una raíz que contenga directamente carpetas de habilidades se puede escanear con paths:["."]. Estas raíces de contexto no extienden el acceso de escritura de archivos ordinario. Esta es una vista de disco actual, no un inventario del mensaje cargado del modelo backend. El análisis de metadatos utiliza el subconjunto YAML documentado; lee los diagnósticos y no infieras descripciones faltantes del texto del cuerpo.
Ejecuta y gestiona comandos
Usa exec para comandos independientes con estado de salida y stdout/stderr separados. Pasa arrays argv, un cwd opcional existente dentro del espacio de trabajo autorizado y anulaciones env opcionales. Cada inicio crea un proceso y tuberías independientes; no pone en cola la entrada a través del PTY interactivo. Para tuberías o expansión de shell, invoca el shell de la plataforma explícitamente. Un comando no hereda cambios posteriores de cd o entorno dentro de la terminal interactiva.
const client = clients.find(c => c.id === "CLIENT_ID_FROM_LIST");
if (!client) throw new Error("Selecciona un cliente en línea de list");
return await exec.run(client.id, {
command: ["git", "status", "--short"],
cwd: client.cwd,
wait_ms: 5000,
max_bytes: 16384
});
Lee job_id, running, state, exit_code, stdout, stderr, los dos cursores de salida y snapshot. Un inicio exitoso confirma solo el lanzamiento. Si los metadatos del proceso incluyen pid_role, consérvalo al informar el PID; un PID de supervisor no es el PID del comando. Solo evalúa la salida final cuando running:false; los códigos de salida distintos de cero son fallos de comando incluso si el ayudante se resolvió correctamente. snapshot contiene el último estado atómico y los metadatos de salida. wait_timed_out registra el paso de espera; la lectura posterior puede mostrar ya la finalización.
Mantén la espera separada de la vida útil del comando. wait_ms predeterminado es 5000 y acepta 0..60000; la expiración deja el comando en ejecución. El timeout_ms de un comando predeterminado es 0, lo que significa que no hay plazo de ejecución; un valor positivo de hasta 900000 termina su árbol de procesos al expirar. Establece el code_mode.timeout_ms externo lo suficientemente largo para toda la secuencia. Una fecha límite de JavaScript no deshace los comandos que ya se iniciaron.
Para trabajos largos, comienza con exec.start(clientId,{command,cwd}) y devuelve su job_id rápidamente. Continúa en solicitudes posteriores:
| Ayudante | Propósito |
|---|---|
exec.list(clientId) | Encuentra trabajos en ejecución y completados retenidos |
exec.status(clientId,jobId) | Inspecciona el estado actual, la duración, el código de salida y los metadatos del artefacto |
exec.wait(clientId,jobId,{wait_ms:5000}) | Espera la finalización dentro de un intervalo acotado |
exec.read(clientId,jobId,{stdout_cursor,stderr_cursor,max_bytes,wait_ms}) | Lee la salida incremental y una snapshot atómica |
exec.cancel(clientId,jobId) | Termina el árbol de procesos propiedad y revisa el estado devuelto |
exec.forget(clientId,jobId) | Libera el registro retenido de un trabajo completado |
exec.events(clientId,{cursor,max_events,wait_ms}) | Lee eventos de comando acotados |
Lleva stdout_cursor y stderr_cursor por separado entre lecturas. Cada flujo devuelve como máximo 32768 bytes por lectura; *_base64 preserva los bytes exactos y *_eof identifica su final. Si *_truncated es verdadero, lee bytes más antiguos del snapshot.stdout.artifact o snapshot.stderr.artifact correspondiente. Si la observación falla después del inicio, inspecciona el job_id del error con status/read antes de reintentar; no inicies trabajo duplicado.
Usa exec.parallel(clientId,[{command:[...]},...],{concurrency:4}) para hasta 32 comandos con 1..8 trabajadores. Cada trabajador espera hasta que su comando realmente termine antes de iniciar el siguiente; un wait_ms:0 inicial nunca libera una ranura en ejecución. Los resultados mantienen el orden de entrada y contienen fulfilled/value o rejected/reason. Los fallos de observación retienen job_id cuando está disponible y detienen ese trabajador; las entradas en cola que nunca se lanzaron se marcan not_started:true. Inspecciona cada código de salida y recupera trabajos inciertos antes de reintentar. Las esperas acotadas internas cuentan para el presupuesto de 128 llamadas de code_mode y el tiempo de espera externo. Usa exec.start para servidores persistentes. La salida paralela predeterminada es de 2048 bytes por flujo.
Espera como máximo 32 trabajos en ejecución y 128 registros retenidos por cliente. Al alcanzar el límite de registros, los nuevos inicios desalojan el trabajo completado más antiguo; los trabajos en ejecución permanecen registrados. Los trabajos sobreviven a la finalización de code_mode pero se detienen en la desconexión o recarga del cliente. forget no elimina inmediatamente los artefactos de salida. Usa exec.* para comandos; jobs.* gestiona trabajos de transferencia rsync. Usa terminal.* cuando sea necesario un shell interactivo compartido, y no infieras la finalización de un comando a partir de una lectura de terminal.
Escribe entrada en segundo plano y selecciona terminales
Inicia un comando con stdin:"pipe" antes de usar exec.write(clientId,jobId,{data,close_stdin:true}). Usa data_base64 para entrada binaria; nunca proporciones ambas formas. Cada escritura está limitada a 32 KiB. Inspecciona written, remaining_bytes, timed_out y closed; reintenta solo el sufijo no escrito. Cerrar la entrada envía EOF después de que todos los bytes hayan sido aceptados. Los cuerpos de entrada no se copian en los registros de auditoría.
Usa terminal.open(clientId,{name,cwd,select}) para un shell interactivo independiente, luego terminal.write/read/status/resize con su terminal_id. Mantén los cursores de salida separados. terminal.list informa la vista local seleccionada; terminal.select cambia la vista y el objetivo del teclado humano mientras otras sesiones siguen ejecutándose. F7 cicla las sesiones, F6 selecciona los registros de auditoría. Omitir terminal_id siempre apunta a la principal, independientemente de la vista seleccionada. terminal.close finaliza una sesión adicional; la principal finaliza con la conexión. Se pueden abrir hasta 16 terminales.
Pasa controller:{name,model} con la solicitud code_mode externa cuando se conoce la persona que llama/modelo actual. El cliente muestra esta declaración como reportada por la persona que llama, no como una identidad de proveedor verificada. Nunca adivines un modelo a partir de un nombre de aplicación. MCP clientInfo puede identificar la aplicación; los modelos desconocidos permanecen desconocidos. Verifica el controller_metadata de list antes de confiar en clientes antiguos para mostrar declaraciones.
Usa cua.status y los métodos nativos cua screenshot/input/window para uso de computadora; cua.browser comparte los métodos del navegador. Emite capturas de pantalla con image(await cua.screenshot(clientId,args)) y devuelve los metadatos de coordenadas por separado. Llama a un CUA MCP conectado a Codex a través del nombre exacto codex.mcp.* descubierto en su catálogo de herramientas actual. Preserva los errores nativos, el contenido de la imagen y los estados de aprobación; no invoques otro modelo para proxy de estas operaciones.
Ejecuta otras herramientas nativas
const client = clients.find(c => c.id === "CLIENT_ID_FROM_LIST");
if (!client) throw new Error("Selecciona un cliente en línea de list");
return await tools.search(client.id, {query:"browser", limit:10, include_schemas:true});
La búsqueda coincide con subcadenas de nombre/descripción sin distinción de mayúsculas y minúsculas. Por defecto devuelve nombres, espacios de nombres de enrutamiento observados y descripciones acortadas a 240 caracteres Unicode; include_schemas preserva el descriptor nativo completo. Mantén las mismas opciones de cliente/consulta/límite/schema al continuar con nextCursor. Search reduce la salida del catálogo visible para el modelo y la paginación manual, no el primer escaneo de página subyacente. Cada página aún está autorizada y cuenta para el presupuesto de llamadas; usa max_pages para trabajo acotado. Una página cambiada o vencida requiere reiniciar el descubrimiento. Los esquemas demasiado grandes fallan explícitamente en lugar de truncarse. Consulta ssmcp://limits para presupuestos; el ayudante requiere un broker actualizado.
Llama a una operación descubierta con await call(clientId, toolName, arguments). Verifica isError y lee structuredContent cuando esté presente. Los resultados cortos permanecen en línea; los resultados backend de gran tamaño devuelven metadatos de artefactos en lugar del cuerpo completo. Espera cada llamada. Devuelve solo la salida necesaria para la tarea. Nunca inicies un agente o modelo a través de un backend nativo a menos que el usuario haya autorizado esa delegación.
Los primitivos de comando nativos son ssmcp.exec.start/list/status/wait/read/write/cancel/events, más ssmcp.exec.forget para registros completados. Cuando un servidor antiguo carece de ayudantes exec, llama a estas herramientas descubiertas con call(clientId, toolName, arguments) e inspecciona el resultado MCP completo. Los esquemas siguen siendo autoritarios. Usa Promise.all para llamadas nativas independientes; cada llamada está autorizada por separado. Los comandos Cargo concurrentes aún pueden competir por su bloqueo de compilación compartido.
Reutiliza el Chrome existente del operador
Cuando el usuario nombra una sesión de Chrome existente, comienza con call(id,"ssmcp.browser.discover",{}) y ssmcp.harnesses.list. El descubrimiento lee metadatos; los archivos de extensión instalados no establecen una conexión emparejada y autorizada. No inicies un prof...