ssmcp

Opere espaços de trabalho ssmcp conectados via SSH através de list e code_mode. Use para comandos em paralelo e em segundo plano, esperas limitadas, recarregamento de cliente, harnesses de codificação descobertos automaticamente, acesso e auditoria de arquivos com escopo, descoberta de navegadores Chrome e nativos existentes, pesquisa concisa de ferramentas, descoberta de skills e instruções, transferências rsync Linux e encaminhamento TCP loopback.

O que é ssmcp?

A skill ssmcp unifica o gerenciamento de múltiplos espaços de trabalho remotos conectados por SSH, fornecendo uma ponte entre ferramentas de desenvolvimento e ambientes de execução. Ela permite listar clientes disponíveis, inspecionar suas capacidades (como sistemas de arquivos, ferramentas e skills), e executar comandos de forma independente ou interativa em terminais separados. A skill suporta execução paralela de até 32 jobs com controle de concorrência, descoberta automática de harnesses de codificação e transferências de arquivos via rsync, além de encaminhamento TCP loopback. É particularmente útil para agentes de IA como o Claude Code, Cursor e Codex, pois oferece um ambiente de trabalho rico com ferramentas de auditoria e acesso escopo a arquivos, sem necessitar de instalações adicionais no lado do servidor. O ssmcp também integra-se com navegadores Chrome existentes do operador para automação web e fornece uma interface para gerenciamento de skills e instruções de agente.

Funciona com✓Claude Code✓Codex CLI✓Cursor✓OpenCode
npx skills add https://github.com/LIghtJUNction/ssmcp/tree/HEAD/skills/ssmcp

Installed? Explore more Programação e Desenvolvimento skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

ssmcp ponte de espaço de trabalho unificada

Descubra as máquinas e suas capacidades

Chame list primeiro. Use o title opcional de cada cliente para entender sua tarefa, depois verifique seu name e cwd. Selecione clientes pelo id retornado; títulos, nomes e hostnames são rótulos e podem se repetir. Use tools.search(clientId,{query,limit:20}) dentro de code_mode para localizar resumos concisos de ferramentas; solicite include_schemas:true para o descritor nativo completo antes de chamar. Em brokers mais antigos, use list({client_id}) ou tools(clientId,cursor) para paginação. Respeite a política de permissões e aprovação de cada backend nativo.

Mantenha cada travessia do catálogo de ferramentas em seu cursor retornado. Suas páginas compartilham um snapshot mesmo se um diretório de ferramentas nativo mudar; inicie uma nova solicitação sem cursor para descobrir atualizações. Um cliente retém no máximo quatro snapshots e 64 MiB de JSON serializado no total. Cada leitura de página bem-sucedida renova o tempo limite de inatividade de 120 segundos, mas um snapshot expira no máximo 900 segundos após a criação. Cursores inválidos não o renovam, e reutilizar um catálogo inalterado não redefine seu tempo de criação; limites de LRU e capacidade podem removê-lo antes. Reinicie a descoberta se o servidor relatar que um snapshot expirou ou foi removido.

Os clientes atuais se conectam como type:"shell" e fornecem um terminal interativo principal, terminais independentes adicionais, jobs de comando independentes, arquivos e ferramentas de contexto sem exigir um Harness. A descoberta em segundo plano verifica provedores instalados e registra apenas interfaces cuja versão, política de inicialização, handshake e catálogo real são utilizáveis. ssmcp.harnesses.list relata status e diagnósticos; um provedor indisponível não remove Shell ou outras ferramentas. Remova argumentos obsoletos -t, --type, --backend e argumentos de backend no final dos comandos de inicialização.

A descoberta não deve instalar runtimes, dependências ou Harnesses, enviar solicitações de modelo ou relaxar permissões nativas. Não trate caches de pacotes offline como prova de que nada será instalado. Provedores sem uma inicialização segura verificada permanecem indisponíveis. A descoberta Pi conecta-se apenas a uma sessão RPC JSONL nativa explicitamente configurada e já inicializada através de SSMCP_PI_RPC_SOCKET. O socket Unix absoluto e seu pai direto devem pertencer ao UID atual, não ter permissões de grupo/outros e não ser links simbólicos; o UID do peer conectado, binário instalado e versão são verificados antes de um handshake get_state de cinco segundos. A descoberta OpenCode anexa-se apenas a um serviço existente em http://127.0.0.1:PORT/ (SSMCP_OPENCODE_URL, OPENCODE_PASSWORD). A porta explícita e o caminho raiz são obrigatórios; proxies, redirecionamentos, outros hosts, userinfo, query e fragment são rejeitados. A descoberta nativa lê apenas info e OpenAPI; a assinatura de eventos é preguiçosa. Endpoints ausentes significam indisponível. Nenhum adaptador inicia um serviço externo ou desabilita extensões de usuário para fabricar um catálogo completo.

list e tools usam um registro, preservando Schema e descritores nativos com namespaces de roteamento. Namespaces incluem codex.*, claude.*, pi.*, opencode.* e playwright.* quando sua descoberta MCP nativa é bem-sucedida; nomes exatos vêm do catálogo atual. As ferramentas MCP do Codex são enumeradas através de mcpServerStatus/list nativo e encaminhadas através de mcpServer/tool/call; selecione nomes codex.mcp.* descobertos sem codificar um servidor. Pi expõe apenas as operações de ponte pi.rpc, ssmcp.pi.events, ssmcp.pi.requests e ssmcp.pi.respond quando disponível. Uma instalação CLI ou lista de comandos de controle conhecida não é uma enumeração de seu modelo, plugin ou Schema de ferramenta MCP interno.

Leia ssmcp://guide, ssmcp://limits e ssmcp://clients através de recursos MCP ou resources.read(uri) dentro de code_mode. Use resources.templates() para recursos específicos do cliente. Verifique os catálogos atuais quando um cliente conectado tiver uma versão mais antiga.

code_mode é executado no servidor MCP. Seu sistema de arquivos e rede loopback não são o espaço de trabalho do chamador. Para incluir um sandbox ou outro computador em uma transferência, execute um cliente ssmcp separado nesse ambiente e selecione seu ID retornado. Inicie-o a partir do diretório a ser compartilhado:

cd /caminho/para/workspace
ssmcp --name workspace --title "Descreva a tarefa desta sessão" --allow SEU_LOGIN_GITHUB@github [email protected]

Use o destino SSH configurado e a identidade autorizada do operador. Não copie chaves SSH privadas, desabilite verificações de chave de host ou contorne uma política de rede. Se o ambiente do chamador não puder se conectar, relate essa limitação exata e continue o trabalho em peers alcançáveis.

Inspecione skills e arquivos de instrução disponíveis

Use context.roots(id) para ver o espaço de trabalho e quaisquer raízes de contexto somente leitura explícitas. Comece com skills.view(id) para um índice Markdown compacto ou skills.list(id,options) para metadados. Siga next_cursor usando as mesmas opções de varredura. Nomes podem se repetir; escolha pela raiz e caminho, depois chame skills.read(id,{path}) para o SKILL.md completo.

agents.resolve(id,{path:"src/lib.rs"}) retorna origens de instrução e conteúdo exato na ordem raiz-para-alvo. agents.list retorna apenas origens, e agents.read lê um arquivo selecionado. Em cada diretório, o ssmcp seleciona o primeiro AGENTS.override.md, AGENTS.md ou agents.md não vazio. Revise a proveniência e diagnósticos antes de aplicar instruções relevantes.

A raiz padrão é o espaço de trabalho de inicialização do cliente. Um operador pode adicionar até oito raízes somente leitura com --context-root PATH repetido; selecione seus IDs retornados explicitamente com a opção root. Uma raiz que contém diretamente pastas de skill pode ser varrida com paths:["."]. Essas raízes de contexto não estendem o acesso de escrita de arquivos comum. Esta é uma visão atual do disco, não um inventário do prompt carregado de um modelo backend. A análise de metadados usa o subconjunto YAML documentado; leia diagnósticos e não infira descrições ausentes do corpo do texto.

Execute e gerencie comandos

Use exec para comandos independentes com status de saída e stdout/stderr separados. Passe arrays argv, um cwd opcional existente dentro do espaço de trabalho autorizado e substituições env opcionais. Cada início cria um processo e pipes independentes; ele não enfileira entrada através do PTY interativo. Para pipelines ou expansão de shell, invoque o shell da plataforma explicitamente. Um comando não herda cd ou alterações de ambiente posteriores dentro do terminal interativo.

const client = clients.find(c => c.id === "CLIENT_ID_FROM_LIST");
if (!client) throw new Error("Selecione um cliente online da lista");
return await exec.run(client.id, {
  command: ["git", "status", "--short"],
  cwd: client.cwd,
  wait_ms: 5000,
  max_bytes: 16384
});

Leia job_id, running, state, exit_code, stdout, stderr, os dois cursores de saída e snapshot. Um início bem-sucedido confirma apenas o lançamento. Se os metadados do processo incluírem pid_role, retenha-o ao relatar o PID; um PID de supervisor não é o PID do comando. Avalie a saída final apenas quando running:false; códigos de saída diferentes de zero são falhas de comando mesmo quando o helper resolveu com sucesso. snapshot contém o estado atômico mais recente e metadados de saída. wait_timed_out registra a etapa de espera; a leitura subsequente pode já mostrar conclusão.

Mantenha a espera separada do tempo de vida do comando. wait_ms padrão é 5000 e aceita 0..60000; a expiração deixa o comando em execução. O timeout_ms de um comando padrão é 0, significando nenhum prazo de execução; um valor positivo até 900000 termina sua árvore de processos na expiração. Defina o code_mode.timeout_ms externo longo o suficiente para toda a sequência. Um prazo JavaScript não desfaz comandos que já foram iniciados.

Para trabalho longo, inicie com exec.start(clientId,{command,cwd}) e retorne seu job_id prontamente. Continue em solicitações posteriores:

HelperPropósito
exec.list(clientId)Encontre jobs em execução e concluídos retidos
exec.status(clientId,jobId)Inspecione estado atual, duração, código de saída e metadados de artefato
exec.wait(clientId,jobId,{wait_ms:5000})Aguarde a conclusão dentro de um intervalo limitado
exec.read(clientId,jobId,{stdout_cursor,stderr_cursor,max_bytes,wait_ms})Leia saída incremental e um snapshot atômico
exec.cancel(clientId,jobId)Termine a árvore de processos proprietária e inspecione o estado retornado
exec.forget(clientId,jobId)Libere o registro retido de um job concluído
exec.events(clientId,{cursor,max_events,wait_ms})Leia eventos de comando limitados

Carregue stdout_cursor e stderr_cursor separadamente entre leituras. Cada fluxo retorna no máximo 32768 bytes por leitura; *_base64 preserva bytes exatos e *_eof identifica seu fim. Se *_truncated for verdadeiro, leia bytes mais antigos do snapshot.stdout.artifact ou snapshot.stderr.artifact correspondente. Se a observação falhar após o início, inspecione o job_id do erro com status/leitura antes de tentar novamente; não lance trabalho duplicado.

Use exec.parallel(clientId,[{command:[...]},...],{concurrency:4}) para até 32 comandos com 1..8 workers. Cada worker espera até que seu comando realmente termine antes de iniciar o próximo; um wait_ms:0 inicial nunca libera um slot de execução. Os resultados mantêm a ordem de entrada e contêm fulfilled/value ou rejected/reason. Falhas de observação retêm job_id quando disponível e param aquele worker; entradas enfileiradas nunca lançadas são marcadas not_started:true. Inspecione cada código de saída e recupere jobs incertos antes de tentar novamente. Esperas internas limitadas contam para o orçamento de 128 chamadas do code_mode e o timeout externo. Use exec.start para servidores persistentes. A saída paralela padrão é 2048 bytes por fluxo.

Espere no máximo 32 jobs em execução e 128 registros retidos por cliente. Ao atingir o limite de registros, novos inícios removem o job concluído mais antigo; jobs em execução permanecem registrados. Jobs sobrevivem à conclusão do code_mode, mas param na desconexão ou recarregamento do cliente. forget não exclui artefatos de saída imediatamente. Use exec.* para comandos; jobs.* gerencia jobs de transferência rsync. Use terminal.* quando um shell interativo compartilhado for necessário, e não infira conclusão de comando de uma única leitura de terminal.

Escreva entrada em segundo plano e selecione terminais

Inicie um comando com stdin:"pipe" antes de usar exec.write(clientId,jobId,{data,close_stdin:true}). Use data_base64 para entrada binária; nunca forneça ambas as formas. Cada escrita é limitada a 32 KiB. Inspecione written, remaining_bytes, timed_out e closed; tente novamente apenas o sufixo não escrito. Fechar a entrada envia EOF depois que todos os bytes foram aceitos. Corpos de entrada não são copiados para logs de auditoria.

Use terminal.open(clientId,{name,cwd,select}) para um shell interativo independente, depois terminal.write/read/status/resize com seu terminal_id. Mantenha cursores de saída separados. terminal.list relata a visão local selecionada; terminal.select muda a visão e o alvo do teclado humano enquanto outras sessões continuam em execução. F7 alterna sessões, F6 seleciona logs de auditoria. Omitir terminal_id sempre tem como alvo o terminal principal, independentemente da visão selecionada. terminal.close encerra uma sessão extra; a principal termina com a conexão. No máximo 16 terminais podem estar abertos.

Passe controller:{name,model} com a solicitação code_mode externa quando o chamador/modelo atual for conhecido. O cliente mostra esta declaração como relatada pelo chamador, não uma identidade de provedor verificada. Nunca adivinhe um modelo a partir de um nome de aplicativo. MCP clientInfo pode identificar o aplicativo; modelos desconhecidos permanecem desconhecidos. Verifique o controller_metadata da lista antes de confiar em clientes antigos para exibir declarações.

Use cua.status e métodos nativos de screenshot/input/window do cua para uso de computador; cua.browser compartilha os métodos do navegador. Emita screenshots com image(await cua.screenshot(clientId,args)) e retorne metadados de coordenadas separadamente. Chame um CUA MCP conectado ao Codex através do nome exato codex.mcp.* descoberto em seu catálogo de ferramentas atual. Preserve erros nativos, conteúdo de imagem e estados de aprovação; não invoque outro modelo para fazer proxy dessas operações.

Execute outras ferramentas nativas

const client = clients.find(c => c.id === "CLIENT_ID_FROM_LIST");
if (!client) throw new Error("Selecione um cliente online da lista");
return await tools.search(client.id, {query:"browser", limit:10, include_schemas:true});

A pesquisa corresponde a substrings de nome/descrição insensíveis a maiúsculas/minúsculas. Por padrão, retorna nomes, namespaces de roteamento observados e descrições encurtadas para 240 caracteres Unicode; include_schemas preserva o descritor nativo completo. Mantenha as mesmas opções de cliente/query/limit/schema ao continuar com nextCursor. A pesquisa reduz a saída do catálogo visível ao modelo e a paginação manual, não a primeira varredura de página subjacente. Cada página ainda é autorizada e conta para o orçamento de chamadas; use max_pages para trabalho limitado. Uma página alterada ou expirada requer reiniciar a descoberta. Schemas muito grandes falham explicitamente em vez de serem truncados. Veja ssmcp://limits para orçamentos; o helper requer um broker atualizado.

Chame uma operação descoberta com await call(clientId, toolName, arguments). Verifique isError e leia structuredContent quando presente. Resultados curtos permanecem inline; resultados grandes do backend retornam metadados de artefato em vez do corpo completo. Aguarde cada chamada. Retorne apenas a saída necessária para a tarefa. Nunca inicie um agente ou modelo através de um backend nativo, a menos que o usuário tenha autorizado essa delegação.

Os primitivos de comando nativos são ssmcp.exec.start/list/status/wait/read/write/cancel/events, mais ssmcp.exec.forget para registros concluídos. Quando um servidor mais antigo não tiver helpers exec, chame essas ferramentas descobertas com call(clientId, toolName, arguments) e inspecione o resultado MCP completo. Os schemas permanecem autoritativos. Use Promise.all para chamadas nativas independentes; cada chamada é autorizada separadamente. Comandos Cargo concorrentes ainda podem competir por seu bloqueio de construção compartilhado.

Reutilize o Chrome existente do operador

Quando o usuário nomear uma sessão Chrome existente, comece com call(id,"ssmcp.browser.discover",{}) e ssmcp.harnesses.list. A descoberta lê metadados; arquivos de extensão instalados não estabelecem uma conexão pareada e autorizada. Não lance um perfil isolado...

Habilidades Relacionadas