@imenam/mcp-ssh-gate 0.0.0-stage → 1.0.1

package/README.md

@@ -1,3 +1,129 @@
-# Temporary Holding Version
+# @imenam/mcp-ssh-gate
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Un agent propose des commandes à exécuter sur un serveur de production ; tu les lis, les modifies ou les refuses dans une interface web, et seules celles que tu valides partent sur le serveur, en SSH. Le résultat revient à l'agent sans copier-coller.
+
+L'agent ne détient aucun accès au serveur. La paire de clés SSH est générée par le MCP à l'ajout d'un serveur ; tu poses la clé publique sur le serveur, la clé privée reste chiffrée dans le MCP et n'est jamais affichée.
+
+```
+Agent ──submit_commands──▶  file d'attente  ──▶  Interface : tu valides, modifies ou refuses
+  ▲                                                        │
+  └──── wait_for_result ◀── sortie, code de retour ◀── SSH ─┘  (shell bash persistant)
+```
+
+---
+
+## Installation
+
+```bash
+npm install -g @imenam/mcp-ssh-gate
+```
+
+Ou directement via `npx`, sans installation.
+
+### Déclaration dans un projet
+
+```bash
+npx -y @imenam/mcp-ssh-gate --claude-setup-mcp
+```
+
+Crée ou complète le `.mcp.json` du dossier courant avec une entrée `ssh-gate` et une `VAULT_KEY` générée. Relancé avec `--force`, il remplace l'entrée en **conservant** la `VAULT_KEY` existante.
+
+```bash
+# Interface derrière le proxy central
+npx -y @imenam/mcp-ssh-gate --claude-setup-mcp --proxy_url=http://localhost:3000
+
+# Interface en accès direct, sans proxy : http://localhost:4600
+npx -y @imenam/mcp-ssh-gate --claude-setup-mcp --app_port=4600
+```
+
+### Derrière le gateway manager
+
+Déclare le MCP comme les autres, et ajoute `VAULT_KEY` en cochant **secret** : le manager la stocke chiffrée avec sa clé maître et la réinjecte au lancement. Une clé se génère avec :
+
+```bash
+npx -y @imenam/mcp-ssh-gate --generate-vault-key
+```
+
+### Variables d'environnement
+
+| Variable | Défaut | Rôle |
+|---|---|---|
+| `DATA_DIR` | — | **Requis.** Serveurs, clés chiffrées et historique des commandes. Créé s'il n'existe pas. |
+| `VAULT_KEY` | — | **Requis.** 32 octets en base64. Chiffre les clés privées SSH (AES-256-GCM). La perdre ou la changer rend les clés existantes illisibles : le MCP refuse alors de démarrer. |
+| `PROXY_URL` | — | URL du proxy qui expose l'interface. |
+| `APP_PORT` | — | Port local de l'interface quand il n'y a pas de proxy. `PROXY_URL` ou `APP_PORT` est **requis** : sans interface, rien ne peut être validé. `PROXY_URL` prime si les deux sont renseignés. |
+| `APP_GROUP` | — | Groupe d'affichage dans le dashboard du proxy. |
+| `APP_NAME` | `SSH Gate` | Nom affiché dans le dashboard du proxy. |
+| `APP_PATH` | `/ssh-gate` | Chemin de montage derrière le proxy. |
+| `MCP_LOG_DIR` | `<DATA_DIR>/logs` | Répertoire des logs. |
+
+Un réglage requis absent ou invalide arrête le lancement avec un message qui dit quoi corriger.
+
+---
+
+## Ajouter un serveur
+
+1. **Ajouter un serveur** dans l'interface : nom, hôte, port, utilisateur.
+2. Le MCP génère une paire `ed25519`. La clé privée est chiffrée avec `VAULT_KEY` dans `DATA_DIR/servers.json`.
+3. Copie la clé publique affichée dans `~/.ssh/authorized_keys` de l'utilisateur, sur le serveur (une commande prête à coller est proposée).
+4. **Tester la connexion** : l'empreinte de la clé d'hôte est enregistrée. Si elle change plus tard, la connexion est refusée. Changer l'hôte ou le port du serveur efface l'empreinte : il faut tester à nouveau.
+
+Tant que la connexion n'a pas été testée, l'agent ne peut pas soumettre de commandes à ce serveur.
+
+## Les outils
+
+| Outil | Rôle |
+|---|---|
+| `list_servers` | Serveurs configurés, si leur connexion a été testée, et leurs notes. |
+| `update_server_notes` | Complète (`append`, par défaut) ou réécrit (`replace`) les notes d'un serveur. |
+| `submit_commands` | Soumet 1 à 20 commandes avec une explication. Rien ne s'exécute avant ta validation. Renvoie un `request_id`. |
+| `wait_for_result` | Attend ta décision et la fin de l'exécution, puis renvoie le refus et son motif, ou chaque commande avec son code de retour et sa sortie, et ta note. Rend la main au bout de `timeout_seconds` (300 par défaut, 1800 au plus) : il suffit de le rappeler. |
+| `cancel_request` | Retire une demande pas encore validée. |
+| `get_history` | Dernières demandes d'un serveur, y compris les commandes que tu as tapées toi-même. |
+| `reconnect_gui` | Relance l'interface si elle ne tourne plus, et donne son URL. |
+
+## Notes du serveur
+
+Chaque serveur porte des notes en texte libre : dossier des sites, gestion des applis (PM2, systemd…), emplacement des configurations, règles à respecter. L'agent les reçoit avec `list_servers` avant d'intervenir et les complète avec `update_server_notes` quand il découvre quelque chose d'utile ; tu les lis et les modifies dans l'onglet **Notes** du serveur.
+
+Les notes sont limitées à 20 000 caractères. Une modification faite dans l'interface est refusée si l'agent a changé les notes pendant la saisie, pour ne pas écraser sa mise à jour.
+
+## Exécution
+
+- Les commandes validées s'exécutent **dans l'ordre**, dans un shell `bash -l` **persistant** par serveur : un `cd` ou un `export` reste actif pour les commandes et les demandes suivantes.
+- **Pas de terminal** : l'entrée standard est `/dev/null` (une commande qui attend une saisie reçoit une fin de fichier), stderr est fusionné dans stdout. `sudo` doit être configuré sans mot de passe pour l'utilisateur SSH.
+- Chaque commande est d'abord vérifiée avec `bash -n` : une erreur de syntaxe l'arrête sans rien exécuter.
+- Le lot **s'arrête à la première commande** dont le code de retour n'est pas 0 ; les suivantes sont marquées « non exécutée ».
+- **Interrompre (Ctrl+C)** envoie `SIGINT` aux processus lancés par le shell (`pkill -INT -P`, à installer sur le serveur s'il manque). Une boucle exécutée par le shell lui-même n'a pas de processus à interrompre : il faut fermer le shell.
+- Chaque commande garde au plus 512 Ko de sortie (la fin) ; l'agent en reçoit les 20 000 derniers caractères.
+
+## L'interface
+
+- **Barre latérale** : les serveurs, l'état de leur shell, une pastille par demande en attente.
+- **Journal** : chaque commande exécutée, son auteur (Agent ou Toi), son heure, son code de retour ; un clic déplie sa sortie.
+- **Demande en attente** : l'explication de l'agent, les commandes numérotées. Au survol d'une ligne, le crayon la modifie (Entrée pour valider, Échap pour annuler) et la croix la retire. La note pour l'agent est jointe au résultat, ou sert de motif au refus.
+- **Exécution en cours** : l'avancement commande par commande et la sortie en direct.
+- **Onglets Session / Notes** dans l'en-tête du serveur ; la pastille de demande en attente reste visible sur « Session ».
+- **Saisie manuelle** en bas d'écran : une commande tapée là s'exécute aussitôt dans le même shell, et l'agent la voit dans l'historique.
+
+L'interface se met à jour par rafraîchissement périodique.
+
+## Architecture
+
+- Chaque session d'agent lance son processus MCP ; **un seul worker** sert l'interface et exécute les commandes pour toutes. Il écrit un battement dans `DATA_DIR/gui.json` ; un processus MCP qui ne le voit plus en démarre un autre.
+- Les demandes sont des fichiers JSON dans `DATA_DIR/requests/<serveur>/`, écrits par renommage atomique et modifiés sous verrou de fichier.
+- Les sessions SSH vivent dans le worker. S'il s'arrête pendant une exécution, la demande est marquée en échec au démarrage suivant : le résultat des commandes en cours est inconnu.
+
+## Développement
+
+```bash
+npm install
+npm run build   # serveur et interface
+npm test        # dont un test de bout en bout contre un faux serveur SSH qui exécute bash
+```
+
+## Publication
+
+Chaque push sur `master`, merge de pull request compris, publie une nouvelle version sur npm (`.github/workflows/publish.yml`) : `npm ci`, build, tests, puis `npm version patch`, `npm publish`, et enfin le push sur `master` du commit et du tag de version. La publication passe par le trusted publishing de npm (OIDC, sans token), avec attestation de provenance. Un échec du build ou des tests arrête le workflow avant la montée de version ; un échec de `npm publish` l'arrête avant le push, si bien que relancer le run reprend la même version.
+
+Sur npmjs.com, le paquet déclare ce workflow comme publieur de confiance (Settings → Trusted publishing → GitHub Actions : `Matthieu-Pesnot-Pin`, `mcp-ssh-gate`, `publish.yml`, avec `npm publish` dans les actions autorisées). Le commit de version est poussé avec `GITHUB_TOKEN` : si `master` est protégée, la règle doit autoriser GitHub Actions à y pousser.

package/dist/shared/model.d.ts

@@ -0,0 +1,76 @@
+/** Auteur d'une demande : l'agent via les outils MCP, ou l'utilisateur via la saisie manuelle. */
+export type RequestSource = "agent" | "user";
+export type RequestStatus = "pending" | "running" | "completed" | "failed" | "interrupted" | "refused" | "cancelled";
+export type CommandStatus = "pending" | "running" | "succeeded" | "failed" | "interrupted" | "skipped";
+/** Statuts après lesquels une demande ne change plus. */
+export declare const FINAL_STATUSES: readonly RequestStatus[];
+export declare function isFinalStatus(status: RequestStatus): boolean;
+export interface CommandRun {
+    /** Commande exécutée, ou à exécuter. */
+    command: string;
+    /** Commande proposée par l'agent quand l'utilisateur l'a modifiée, sinon null. */
+    original: string | null;
+    status: CommandStatus;
+    exitCode: number | null;
+    /** Sortie standard et d'erreur, fusionnées. */
+    output: string;
+    /** Vrai quand le début de la sortie a été écarté pour rester sous la limite de stockage. */
+    outputTruncated: boolean;
+    startedAt: string | null;
+    endedAt: string | null;
+}
+export interface GateRequest {
+    id: string;
+    serverId: string;
+    source: RequestSource;
+    /** Explication de l'agent ; vide pour une commande saisie à la main. */
+    explanation: string;
+    createdAt: string;
+    status: RequestStatus;
+    /** Note de l'utilisateur : jointe au résultat, ou motif du refus. */
+    note: string | null;
+    decidedAt: string | null;
+    finishedAt: string | null;
+    /** Erreur qui a arrêté l'exécution hors du code de retour d'une commande (connexion perdue…). */
+    error: string | null;
+    /** Répertoire courant du shell à la fin de l'exécution. */
+    cwd: string | null;
+    commands: CommandRun[];
+}
+export interface ServerPublic {
+    id: string;
+    name: string;
+    host: string;
+    port: number;
+    username: string;
+    publicKey: string;
+    /** Empreinte SHA256 de la clé d'hôte, enregistrée au premier test de connexion. */
+    hostKeyFingerprint: string | null;
+    createdAt: string;
+    /** Contexte du serveur en texte libre, lu par l'agent avant d'intervenir. */
+    notes: string;
+    notesUpdatedAt: string | null;
+    notesUpdatedBy: NotesAuthor | null;
+}
+export type NotesAuthor = "agent" | "user";
+export declare const MAX_NOTES_LENGTH = 20000;
+export type SessionState = "connected" | "closed";
+export interface ServerView extends ServerPublic {
+    session: SessionState;
+    cwd: string | null;
+    pendingCount: number;
+    busy: boolean;
+}
+export interface StateResponse {
+    version: string;
+    servers: ServerView[];
+}
+export interface RequestsResponse {
+    requests: GateRequest[];
+}
+export interface TestConnectionResponse {
+    server: ServerView;
+    fingerprint: string;
+    cwd: string;
+}
+export declare const MAX_COMMANDS_PER_REQUEST = 20;

package/dist/shared/model.js

@@ -0,0 +1,7 @@
+/** Statuts après lesquels une demande ne change plus. */
+export const FINAL_STATUSES = ["completed", "failed", "interrupted", "refused", "cancelled"];
+export function isFinalStatus(status) {
+    return FINAL_STATUSES.includes(status);
+}
+export const MAX_NOTES_LENGTH = 20_000;
+export const MAX_COMMANDS_PER_REQUEST = 20;

package/dist/src/cli/setup-mcp.d.ts

@@ -0,0 +1,21 @@
+export interface GuiExposure {
+    proxyUrl?: string;
+    appPort?: number;
+}
+/** Traduit `--proxy_url=` / `--app_port=` en mode d'exposition de l'interface ; les deux ensemble sont refusés. */
+export declare function parseGuiExposure(argv: string[]): {
+    exposure: GuiExposure;
+} | {
+    error: string;
+};
+export interface SetupMcpOptions {
+    cwd: string;
+    force: boolean;
+    exposure?: GuiExposure;
+}
+/**
+ * Écrit l'entrée du serveur dans le .mcp.json du dossier courant. Une
+ * VAULT_KEY déjà présente est conservée : la remplacer rendrait illisibles les
+ * clés des serveurs enregistrés.
+ */
+export declare function runSetupMcp({ cwd, force, exposure }: SetupMcpOptions): number;

package/dist/src/cli/setup-mcp.js

@@ -0,0 +1,137 @@
+import fs from "node:fs";
+import path from "node:path";
+import { generateVaultKey } from "../core/vault.js";
+const SERVER_NAME = "ssh-gate";
+const PACKAGE_NAME = "@imenam/mcp-ssh-gate";
+/** Slashes POSIX : pas de backslashes échappés dans le JSON, et Node les accepte sous Windows. */
+function toPosixPath(dir) {
+    return dir.replace(/\\/g, "/");
+}
+function capitalize(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function buildServerEntry(codeRoot, exposure, vaultKey) {
+    const folder = path.basename(codeRoot) || "ssh-gate";
+    const proxyUrl = exposure.appPort !== undefined ? "" : exposure.proxyUrl ?? "http://localhost:";
+    return {
+        command: "npx",
+        args: ["-y", PACKAGE_NAME],
+        env: {
+            PROXY_URL: proxyUrl,
+            APP_PORT: exposure.appPort !== undefined ? String(exposure.appPort) : "",
+            APP_GROUP: capitalize(folder),
+            APP_NAME: "SSH Gate",
+            APP_PATH: "/ssh-gate",
+            DATA_DIR: toPosixPath(path.join(codeRoot, ".ssh-gate-data")),
+            VAULT_KEY: vaultKey,
+            MCP_LOG_DIR: "",
+        },
+    };
+}
+const GENERATED_VARS = [
+    ["PROXY_URL", "URL du proxy pour exposer l'interface (compléter le port)"],
+    ["APP_PORT", "port local si aucun proxy — l'interface est servie sur http://localhost:<port>"],
+    ["APP_GROUP", "groupe d'affichage dans le dashboard du proxy"],
+    ["APP_NAME", "nom affiché de l'interface dans le dashboard du proxy"],
+    ["APP_PATH", "chemin de montage de l'interface derrière le proxy"],
+    ["DATA_DIR", "serveurs, clés chiffrées et historique des commandes (pré-rempli)"],
+    ["VAULT_KEY", "clé de chiffrement des clés SSH (générée) — à conserver, la perdre rend les clés illisibles"],
+    ["MCP_LOG_DIR", "répertoire des logs (défaut : <DATA_DIR>/logs)"],
+];
+function readFlag(argv, name) {
+    const prefixes = [`--${name}=`, `--${name.replace(/_/g, "-")}=`];
+    for (const arg of argv) {
+        const prefix = prefixes.find((p) => arg.startsWith(p));
+        if (prefix)
+            return arg.slice(prefix.length).trim();
+    }
+    return undefined;
+}
+/** Traduit `--proxy_url=` / `--app_port=` en mode d'exposition de l'interface ; les deux ensemble sont refusés. */
+export function parseGuiExposure(argv) {
+    const rawProxyUrl = readFlag(argv, "proxy_url");
+    const rawAppPort = readFlag(argv, "app_port");
+    if (rawProxyUrl !== undefined && rawAppPort !== undefined) {
+        return { error: "--proxy_url et --app_port sont exclusifs : l'interface passe par le proxy, ou écoute sur un port local." };
+    }
+    if (rawProxyUrl !== undefined) {
+        if (rawProxyUrl === "")
+            return { error: "--proxy_url attend une URL, ex : --proxy_url=http://localhost:3000" };
+        let parsed;
+        try {
+            parsed = new URL(rawProxyUrl);
+        }
+        catch {
+            return { error: `--proxy_url invalide : "${rawProxyUrl}" n'est pas une URL absolue (ex : http://localhost:3000).` };
+        }
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+            return { error: `--proxy_url invalide : protocole "${parsed.protocol}" non supporté (http ou https attendu).` };
+        }
+        return { exposure: { proxyUrl: rawProxyUrl.replace(/\/+$/, "") } };
+    }
+    if (rawAppPort !== undefined) {
+        const port = Number(rawAppPort);
+        if (!Number.isInteger(port) || port < 1 || port > 65535) {
+            return { error: `--app_port invalide : "${rawAppPort}" n'est pas un entier entre 1 et 65535.` };
+        }
+        return { exposure: { appPort: port } };
+    }
+    return { exposure: {} };
+}
+/**
+ * Écrit l'entrée du serveur dans le .mcp.json du dossier courant. Une
+ * VAULT_KEY déjà présente est conservée : la remplacer rendrait illisibles les
+ * clés des serveurs enregistrés.
+ */
+export function runSetupMcp({ cwd, force, exposure = {} }) {
+    const target = path.join(cwd, ".mcp.json");
+    let config = {};
+    const exists = fs.existsSync(target);
+    if (exists) {
+        const raw = fs.readFileSync(target, "utf-8").trim();
+        if (raw !== "") {
+            try {
+                config = JSON.parse(raw);
+            }
+            catch (err) {
+                console.error(`Erreur : ${target} contient du JSON invalide (${err.message}).`);
+                console.error("Corrigez le fichier ou supprimez-le, puis relancez la commande.");
+                return 1;
+            }
+        }
+        if (typeof config !== "object" || config === null || Array.isArray(config)) {
+            console.error(`Erreur : ${target} ne contient pas un objet JSON.`);
+            return 1;
+        }
+    }
+    if (typeof config.mcpServers !== "object" || config.mcpServers === null || Array.isArray(config.mcpServers)) {
+        config.mcpServers = {};
+    }
+    const previous = config.mcpServers[SERVER_NAME];
+    if (previous && !force) {
+        console.error(`Le serveur "${SERVER_NAME}" est déjà configuré dans ${target}.`);
+        console.error("Relancez avec --force pour écraser cette entrée (les autres serveurs et la VAULT_KEY sont préservés).");
+        return 1;
+    }
+    const previousKey = typeof previous?.env?.VAULT_KEY === "string" && previous.env.VAULT_KEY.trim() ? previous.env.VAULT_KEY.trim() : null;
+    config.mcpServers[SERVER_NAME] = buildServerEntry(cwd, exposure, previousKey ?? generateVaultKey());
+    fs.writeFileSync(target, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    const action = previous ? "remplacée" : exists ? "ajoutée" : "créée";
+    console.log(`Configuration ${SERVER_NAME} ${action} dans ${target}`);
+    console.log(previousKey ? "VAULT_KEY existante conservée." : "Nouvelle VAULT_KEY générée.");
+    console.log("");
+    if (exposure.appPort !== undefined) {
+        console.log(`Interface en accès direct : http://localhost:${exposure.appPort} (sans proxy).`);
+    }
+    else if (exposure.proxyUrl !== undefined) {
+        console.log(`Interface exposée via le proxy ${exposure.proxyUrl}.`);
+    }
+    console.log('Variables du champ "env" :');
+    for (const [name, description] of GENERATED_VARS) {
+        console.log(`  ${name.padEnd(14)} ${description}`);
+    }
+    console.log("");
+    console.log("PROXY_URL ou APP_PORT doit être renseigné : sans interface, aucune commande ne peut être validée.");
+    console.log("PROXY_URL et APP_PORT s'excluent : PROXY_URL prime si les deux sont renseignés.");
+    return 0;
+}

package/dist/src/core/config.d.ts

@@ -0,0 +1,14 @@
+export interface GateConfig {
+    dataDir: string;
+    vaultKey: Buffer;
+    logDir: string;
+}
+/** Racine du paquet : premier dossier contenant un package.json en remontant depuis `startDir`. */
+export declare function findProjectRoot(startDir: string): string;
+/**
+ * Lit la configuration dans l'environnement. DATA_DIR et VAULT_KEY sont
+ * obligatoires ; un DATA_DIR qui n'existe pas encore est créé.
+ */
+export declare function loadConfig(env?: NodeJS.ProcessEnv): GateConfig;
+/** L'interface est indispensable : sans elle, aucune commande ne peut être validée. */
+export declare function assertGuiConfigured(env?: NodeJS.ProcessEnv): void;

package/dist/src/core/config.js

@@ -0,0 +1,36 @@
+import fs from "node:fs";
+import path from "node:path";
+import { GateError } from "./errors.js";
+import { parseVaultKey } from "./vault.js";
+/** Racine du paquet : premier dossier contenant un package.json en remontant depuis `startDir`. */
+export function findProjectRoot(startDir) {
+    let current = startDir;
+    while (current !== path.dirname(current)) {
+        if (fs.existsSync(path.join(current, "package.json")))
+            return current;
+        current = path.dirname(current);
+    }
+    return startDir;
+}
+/**
+ * Lit la configuration dans l'environnement. DATA_DIR et VAULT_KEY sont
+ * obligatoires ; un DATA_DIR qui n'existe pas encore est créé.
+ */
+export function loadConfig(env = process.env) {
+    const rawDataDir = env.DATA_DIR?.trim();
+    if (!rawDataDir) {
+        throw new GateError("DATA_DIR is not set. It is the folder where the servers and the command history are stored.");
+    }
+    const dataDir = path.resolve(rawDataDir);
+    fs.mkdirSync(dataDir, { recursive: true });
+    const vaultKey = parseVaultKey(env.VAULT_KEY);
+    const configuredLogDir = env.MCP_LOG_DIR?.trim();
+    const logDir = configuredLogDir ? path.resolve(configuredLogDir) : path.join(dataDir, "logs");
+    return { dataDir, vaultKey, logDir };
+}
+/** L'interface est indispensable : sans elle, aucune commande ne peut être validée. */
+export function assertGuiConfigured(env = process.env) {
+    if (env.PROXY_URL?.trim() || env.APP_PORT?.trim())
+        return;
+    throw new GateError("Neither PROXY_URL nor APP_PORT is set. The web GUI is where commands are approved: set PROXY_URL to expose it through the proxy, or APP_PORT to serve it on http://localhost:<port>.");
+}

package/dist/src/core/errors.d.ts

@@ -0,0 +1,4 @@
+/** Erreur attendue, dont le message est destiné tel quel à l'agent ou à l'interface. */
+export declare class GateError extends Error {
+    name: string;
+}

package/dist/src/core/errors.js

@@ -0,0 +1,4 @@
+/** Erreur attendue, dont le message est destiné tel quel à l'agent ou à l'interface. */
+export class GateError extends Error {
+    name = "GateError";
+}

package/dist/src/core/executor.d.ts

@@ -0,0 +1,46 @@
+import type { GateRequest, ServerView } from "../../shared/model.js";
+import type { RequestStore } from "./request-store.js";
+import { type ServerInput, type ServerStore, type StoredServer } from "./server-store.js";
+/** Sortie conservée par commande ; au-delà, le début est écarté. */
+export declare const MAX_STORED_OUTPUT: number;
+/**
+ * Exécution des demandes validées. Une session SSH par serveur, ouverte à la
+ * première exécution, et une seule demande en cours par serveur.
+ */
+export declare class Executor {
+    private readonly servers;
+    private readonly requests;
+    private readonly log;
+    private readonly sessions;
+    private readonly running;
+    constructor(servers: ServerStore, requests: RequestStore, log: (message: string) => void);
+    /** Marque en échec les demandes restées « en cours » après l'arrêt du worker. */
+    recoverAbandoned(): void;
+    views(): ServerView[];
+    view(server: StoredServer, open?: GateRequest[]): ServerView;
+    addServer(input: ServerInput): ServerView;
+    updateServer(id: string, input: ServerInput): ServerView;
+    deleteServer(id: string): void;
+    /** Ouvre une nouvelle session ; enregistre l'empreinte de l'hôte au premier test. */
+    testConnection(id: string): Promise<{
+        server: ServerView;
+        fingerprint: string;
+        cwd: string;
+    }>;
+    disconnect(serverId: string): void;
+    approve(requestId: string, note: unknown): GateRequest;
+    refuse(requestId: string, note: unknown): GateRequest;
+    editCommand(requestId: string, index: number, command: unknown): GateRequest;
+    removeCommand(requestId: string, index: number): GateRequest;
+    /** Commande saisie par l'utilisateur : exécutée aussitôt, sans validation. */
+    runManual(serverId: string, command: unknown): GateRequest;
+    interrupt(requestId: string): Promise<void>;
+    private assertIdle;
+    private openSession;
+    private sessionFor;
+    private start;
+    private finish;
+    private execute;
+    /** Exécute une commande ; renvoie de quoi clore la demande si l'exécution doit s'arrêter là. */
+    private runOne;
+}