ssmcp

Exploitez les espaces de travail ssmcp connectés via SSH avec list et code_mode pour des commandes parallèles et en arrière-plan, des délais d'attente limités, la découverte automatique de harnais de développement, l'accès et l'audit de fichiers restreints, la découverte de navigateurs Chrome et natifs, la recherche concise d'outils, la découverte de compétences et d'instructions, les transferts rsync Linux et le forwarding TCP en boucle.

Qu'est-ce que ssmcp ?

Ce skill implémente un pont d'espace de travail unifié pour ssmcp, permettant d'exploiter des machines distantes connectées via SSH. Il offre des fonctionnalités avancées telles que l'exécution de commandes parallèles et en arrière-plan, la découverte automatique de harnais de développement (coding harnesses), l'accès restreint aux fichiers avec audit, et la découverte de navigateurs Chrome et natifs. Il prend en charge une recherche concise d'outils, la découverte de compétences et d'instructions, les transferts rsync Linux et le forwarding TCP en boucle. Ce skill est conçu pour être utilisé avec des agents d'IA comme Claude Code, Cursor, ou Codex, et nécessite de respecter les politiques d'autorisation et d'approbation de chaque backend natif. Il fonctionne en se connectant à des clients ssmcp existants, en listant leurs capacités et en exécutant des outils via l'interface MCP.

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

Installed? Explore more Développement et programmation skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Pont unifié de l'espace de travail ssmcp

Découvrir les machines et leurs capacités

Appelez list d'abord. Utilisez le title facultatif de chaque client pour comprendre sa tâche, puis vérifiez son name et son cwd. Sélectionnez les clients par leur id renvoyé ; les titres, les noms et les noms d'hôte sont des étiquettes et peuvent se répéter. Utilisez tools.search(clientId,{query,limit:20}) dans code_mode pour localiser des résumés d'outils concis ; demandez include_schemas:true pour le descripteur natif complet avant d'appeler. Sur les anciens brokers, utilisez list({client_id}) ou la pagination tools(clientId,cursor). Respectez la politique d'autorisation et d'approbation de chaque backend natif.

Gardez chaque parcours de catalogue d'outils sur son curseur renvoyé. Ses pages partagent un instantané même si un répertoire d'outils natif change ; démarrez une nouvelle requête sans curseur pour découvrir les mises à jour. Un client conserve au maximum quatre instantanés et 64 Mio de JSON sérialisé au total. Chaque lecture de page réussie renouvelle le délai d'inactivité de 120 secondes, mais un instantané expire au maximum 900 secondes après sa création. Les curseurs invalides ne le renouvellent pas, et la réutilisation d'un catalogue inchangé ne réinitialise pas son heure de création ; les limites LRU et de capacité peuvent l'évincer plus tôt. Redémarrez la découverte si le serveur signale qu'un instantané a expiré ou a été évincé.

Les clients actuels se connectent en tant que type:"shell" et fournissent un terminal interactif principal, des terminaux supplémentaires indépendants, des tâches de commande indépendantes, des fichiers et des outils de contexte sans nécessiter de harnais. La découverte en arrière-plan vérifie les fournisseurs installés et n'enregistre que les interfaces dont la version, la politique de démarrage, la poignée de main et le catalogue réel sont utilisables. ssmcp.harnesses.list signale l'état et les diagnostics ; un fournisseur indisponible ne supprime pas Shell ou d'autres outils. Supprimez les arguments -t, --type, --backend obsolètes et les arguments de backend de fin des commandes de démarrage.

La découverte ne doit pas installer d'exécutions, de dépendances ou de harnais, soumettre des requêtes de modèle ou assouplir les autorisations natives. Ne traitez pas les caches de paquets hors ligne comme une preuve que rien ne sera installé. Les fournisseurs sans démarrage sécurisé vérifié restent indisponibles. La découverte Pi se connecte uniquement à une session native JSONL RPC déjà initialisée et explicitement configurée via SSMCP_PI_RPC_SOCKET. Le socket Unix absolu et son parent direct doivent appartenir à l'UID actuel, ne pas avoir d'autorisations de groupe/autres et ne pas être des liens symboliques ; le pair connecté, l'UID, le binaire installé et la version sont vérifiés avant une poignée de main get_state de cinq secondes. La découverte OpenCode s'attache uniquement à un service existant à http://127.0.0.1:PORT/ (SSMCP_OPENCODE_URL, OPENCODE_PASSWORD). Le port explicite et le chemin racine sont requis ; les proxys, redirections, autres hôtes, userinfo, requête et fragment sont rejetés. La découverte native lit uniquement les informations et OpenAPI ; l'abonnement aux événements est paresseux. Les points de terminaison manquants signifient indisponible. Aucun adaptateur ne démarre un service externe ou ne désactive les extensions utilisateur pour fabriquer un catalogue complet.

list et tools utilisent un registre, préservant les schémas natifs et les descripteurs avec des espaces de noms de routage. Les espaces de noms incluent codex.*, claude.*, pi.*, opencode.*, et playwright.* lorsque sa découverte MCP native réussit ; les noms exacts proviennent du catalogue actuel. Les outils MCP Codex sont énumérés via mcpServerStatus/list natif et transférés via mcpServer/tool/call ; sélectionnez les noms codex.mcp.* découverts sans coder en dur un serveur. Pi expose uniquement les opérations de pont pi.rpc, ssmcp.pi.events, ssmcp.pi.requests, et ssmcp.pi.respond lorsqu'elles sont disponibles. Une installation CLI ou une liste de commandes de contrôle connue n'est pas une énumération de son modèle, de son plugin ou de son schéma d'outil MCP interne.

Lisez ssmcp://guide, ssmcp://limits, et ssmcp://clients via les ressources MCP ou resources.read(uri) dans code_mode. Utilisez resources.templates() pour les ressources spécifiques au client. Vérifiez les catalogues actuels lorsqu'un client connecté a une version plus ancienne.

code_mode s'exécute sur le serveur MCP. Son système de fichiers et son réseau en boucle ne sont pas l'espace de travail de l'appelant. Pour inclure un bac à sable ou un autre ordinateur dans un transfert, exécutez un client ssmcp séparé dans cet environnement et sélectionnez son ID renvoyé. Démarrez-le depuis le répertoire à partager :

cd /chemin/vers/espace_de_travail
ssmcp --name espace_de_travail --title "Décrivez la tâche de cette session" --allow VOTRE_LOGIN_GITHUB@github [email protected]

Utilisez la destination SSH configurée de l'opérateur et l'identité autorisée. Ne copiez pas les clés SSH privées, ne désactivez pas la vérification des clés d'hôte et ne contournez pas une politique réseau. Si l'environnement de l'appelant ne peut pas se connecter, signalez cette limitation exacte et continuez le travail sur les pairs accessibles.

Inspecter les compétences et les fichiers d'instructions disponibles

Utilisez context.roots(id) pour voir l'espace de travail et toutes les racines de contexte en lecture seule explicites. Commencez par skills.view(id) pour un index Markdown compact ou skills.list(id,options) pour les métadonnées. Suivez next_cursor en utilisant les mêmes options d'analyse. Les noms peuvent se répéter ; choisissez par racine et chemin, puis appelez skills.read(id,{path}) pour le SKILL.md complet.

agents.resolve(id,{path:"src/lib.rs"}) renvoie les origines des instructions et le contenu exact dans l'ordre racine-cible. agents.list renvoie uniquement les origines, et agents.read lit un fichier sélectionné. Dans chaque répertoire, ssmcp sélectionne le premier fichier non vide AGENTS.override.md, AGENTS.md ou agents.md. Examinez la provenance et les diagnostics avant d'appliquer les instructions pertinentes.

La racine par défaut est l'espace de travail de démarrage du client. Un opérateur peut ajouter jusqu'à huit racines en lecture seule avec des --context-root CHEMIN répétés ; sélectionnez leurs ID renvoyés explicitement avec l'option root. Une racine qui contient directement des dossiers de compétences peut être analysée avec paths:["."]. Ces racines de contexte n'étendent pas l'accès en écriture de fichier ordinaire. Il s'agit d'une vue disque actuelle, pas d'un inventaire de l'invite chargée du modèle backend. L'analyse des métadonnées utilise le sous-ensemble YAML documenté ; lisez les diagnostics et n'inférez pas les descriptions manquantes à partir du texte du corps.

Exécuter et gérer les commandes

Utilisez exec pour des commandes indépendantes avec statut de sortie et stdout/stderr séparés. Passez des tableaux d'arguments, un cwd existant facultatif dans l'espace de travail autorisé et des remplacements env facultatifs. Chaque démarrage crée un processus indépendant et des tubes ; il ne met pas en file d'attente l'entrée via le PTY interactif. Pour les pipelines ou l'expansion du shell, invoquez le shell de la plateforme explicitement. Une commande n'hérite pas des modifications ultérieures de cd ou d'environnement dans le terminal interactif.

const client = clients.find(c => c.id === "ID_CLIENT_DE_LISTE");
if (!client) throw new Error("Sélectionnez un client en ligne à partir de la liste");
return await exec.run(client.id, {
  command: ["git", "status", "--short"],
  cwd: client.cwd,
  wait_ms: 5000,
  max_bytes: 16384
});

Lisez job_id, running, state, exit_code, stdout, stderr, les deux curseurs de sortie et snapshot. Un démarrage réussi confirme uniquement le lancement. Si les métadonnées du processus incluent pid_role, conservez-le lors du signalement du PID ; un PID superviseur n'est pas le PID de la commande. N'évaluez la sortie finale que lorsque running:false ; les codes de sortie non nuls sont des échecs de commande même si l'assistant s'est résolu avec succès. snapshot contient l'état atomique le plus récent et les métadonnées de sortie. wait_timed_out enregistre l'étape d'attente ; la lecture suivante peut déjà montrer l'achèvement.

Gardez l'attente séparée de la durée de vie de la commande. wait_ms par défaut à 5 000 et accepte 0..60000 ; l'expiration laisse la commande en cours d'exécution. timeout_ms d'une commande par défaut à 0, ce qui signifie qu'il n'y a pas de délai d'exécution ; une valeur positive jusqu'à 900 000 termine son arborescence de processus à l'expiration. Définissez code_mode.timeout_ms externe suffisamment long pour toute la séquence. Un délai JavaScript n'annule pas les commandes qui ont déjà été démarrées.

Pour les travaux longs, démarrez avec exec.start(clientId,{command,cwd}) et renvoyez son job_id rapidement. Continuez dans les requêtes ultérieures :

AssistantObjectif
exec.list(clientId)Trouver les travaux en cours d'exécution et les travaux terminés conservés
exec.status(clientId,jobId)Inspecter l'état actuel, la durée, le code de sortie et les métadonnées de l'artefact
exec.wait(clientId,jobId,{wait_ms:5000})Attendre la fin dans un intervalle limité
exec.read(clientId,jobId,{stdout_cursor,stderr_cursor,max_bytes,wait_ms})Lire la sortie incrémentielle et un snapshot atomique
exec.cancel(clientId,jobId)Terminer l'arborescence de processus propriétaire et inspecter l'état renvoyé
exec.forget(clientId,jobId)Libérer l'enregistrement conservé d'un travail terminé
exec.events(clientId,{cursor,max_events,wait_ms})Lire les événements de commande limités

Transportez stdout_cursor et stderr_cursor séparément entre les lectures. Chaque flux renvoie au maximum 32 768 octets par lecture ; *_base64 préserve les octets exacts et *_eof identifie sa fin. Si *_truncated est vrai, lisez les octets plus anciens à partir du snapshot.stdout.artifact ou snapshot.stderr.artifact correspondant. Si l'observation échoue après le démarrage, inspectez le job_id de l'erreur avec status/read avant de réessayer ; ne lancez pas de travail en double.

Utilisez exec.parallel(clientId,[{command:[...]},...],{concurrency:4}) pour un maximum de 32 commandes avec 1 à 8 workers. Chaque worker attend que sa commande se termine réellement avant d'en démarrer une autre ; un wait_ms:0 initial ne libère jamais un slot en cours. Les résultats conservent l'ordre d'entrée et contiennent fulfilled/value ou rejected/reason. Les échecs d'observation conservent job_id lorsqu'ils sont disponibles et arrêtent ce worker ; les entrées mises en file d'attente jamais lancées sont marquées not_started:true. Inspectez chaque code de sortie et récupérez les travaux incertains avant de réessayer. Les attentes internes limitées comptent dans le budget de 128 appels de code_mode et le délai d'attente externe. Utilisez exec.start pour les serveurs persistants. La sortie parallèle par défaut est de 2 048 octets par flux.

Attendez-vous à un maximum de 32 travaux en cours et 128 enregistrements conservés par client. En atteignant la limite d'enregistrement, les nouveaux démarrages évincents le travail terminé le plus ancien ; les travaux en cours restent enregistrés. Les travaux survivent à l'achèvement de code_mode mais s'arrêtent à la déconnexion ou au rechargement du client. forget ne supprime pas immédiatement les artefacts de sortie. Utilisez exec.* pour les commandes ; jobs.* gère les travaux de transfert rsync. Utilisez terminal.* lorsqu'un shell interactif partagé est nécessaire, et n'inférez pas l'achèvement de la commande à partir d'une seule lecture du terminal.

Écrire une entrée en arrière-plan et sélectionner des terminaux

Démarrez une commande avec stdin:"pipe" avant d'utiliser exec.write(clientId,jobId,{data,close_stdin:true}). Utilisez data_base64 pour l'entrée binaire ; ne fournissez jamais les deux formes. Chaque écriture est limitée à 32 Kio. Inspectez written, remaining_bytes, timed_out et closed ; ne recommencez que le suffixe non écrit. La fermeture de l'entrée envoie EOF après que tous les octets ont été acceptés. Les corps d'entrée ne sont pas copiés dans les journaux d'audit.

Utilisez terminal.open(clientId,{name,cwd,select}) pour un shell interactif indépendant, puis terminal.write/read/status/resize avec son terminal_id. Conservez les curseurs de sortie séparés. terminal.list signale la vue locale sélectionnée ; terminal.select change la vue et la cible du clavier humain tandis que les autres sessions continuent de s'exécuter. F7 alterne les sessions, F6 sélectionne les journaux d'audit. L'omission de terminal_id cible toujours le terminal principal, indépendamment de la vue sélectionnée. terminal.close termine une session supplémentaire ; le terminal principal se termine avec la connexion. Au maximum 16 terminaux peuvent être ouverts.

Passez controller:{name,model} avec la requête code_mode externe lorsque l'appelant/modèle actuel est connu. Le client affiche cette déclaration comme signalée par l'appelant, pas comme une identité de fournisseur vérifiée. Ne devinez jamais un modèle à partir d'un nom d'application. MCP clientInfo peut identifier l'application ; les modèles inconnus restent inconnus. Vérifiez controller_metadata de la liste avant de vous fier aux anciens clients pour afficher les déclarations.

Utilisez cua.status et les méthodes natives cua de capture d'écran/saisie/fenêtre pour une utilisation informatique ; cua.browser partage les méthodes du navigateur. Émettez des captures d'écran avec image(await cua.screenshot(clientId,args)) et renvoyez les métadonnées de coordonnées séparément. Appelez un MCP CUA connecté à Codex via le nom exact codex.mcp.* découvert dans son catalogue d'outils actuel. Préservez les erreurs natives, le contenu de l'image et les états d'approbation ; n'invoquez pas un autre modèle pour mandater ces opérations.

Exécuter d'autres outils natifs

const client = clients.find(c => c.id === "ID_CLIENT_DE_LISTE");
if (!client) throw new Error("Sélectionnez un client en ligne à partir de la liste");
return await tools.search(client.id, {query:"browser", limit:10, include_schemas:true});

La recherche correspond aux sous-chaînes insensibles à la casse du nom/description. Par défaut, elle renvoie les noms, les espaces de noms de routage observés et les descriptions raccourcies à 240 caractères Unicode ; include_schemas préserve le descripteur natif complet. Conservez les mêmes options client/query/limit/schema lors de la poursuite avec nextCursor. La recherche réduit la sortie du catalogue visible du modèle et la pagination manuelle, pas la première analyse de page sous-jacente. Chaque page est toujours autorisée et compte dans le budget d'appels ; utilisez max_pages pour un travail limité. Une page modifiée ou expirée nécessite de redémarrer la découverte. Les schémas surdimensionnés échouent explicitement plutôt que d'être tronqués. Voir ssmcp://limits pour les budgets ; l'assistant nécessite un broker mis à jour.

Appelez une opération découverte avec await call(clientId, toolName, arguments). Vérifiez isError et lisez structuredContent lorsqu'il est présent. Les résultats courts restent en ligne ; les résultats backend surdimensionnés renvoient des métadonnées d'artefact au lieu du corps complet. Attendez chaque appel. Ne renvoyez que la sortie nécessaire à la tâche. Ne démarrez jamais un agent ou un modèle via un backend natif à moins que l'utilisateur n'ait autorisé cette délégation.

Les primitives de commande natives sont ssmcp.exec.start/list/status/wait/read/write/cancel/events, plus ssmcp.exec.forget pour les enregistrements terminés. Lorsqu'un ancien serveur manque d'assistants exec, appelez ces outils découverts avec call(clientId, toolName, arguments) et inspectez le résultat MCP complet. Les schémas restent faisant autorité. Utilisez Promise.all pour les appels natifs indépendants ; chaque appel est autorisé séparément. Les commandes Cargo concurrentes peuvent toujours se disputer leur verrou de construction partagé.

Réutiliser le Chrome existant de l'opérateur

Lorsque l'utilisateur nomme une session Chrome existante, commencez par call(id,"ssmcp.browser.discover",{}) et ssmcp.harnesses.list. La découverte lit les métadonnées ; les fichiers d'extension installés n'établissent pas de connexion appairée et autorisée. Ne lancez pas de prof...

Skills associés