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

package/dist/src/gui-worker.js

@@ -0,0 +1,212 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { Hono } from "hono";
+import { GUI_LISTEN_HOST, ProxyClient, createLogger, honoGuiGuard, setupLogging } from "@imenam/mcp-gui-interface";
+import { APP_VERSION } from "./version.js";
+import { findProjectRoot, loadConfig } from "./core/config.js";
+import { GateError } from "./core/errors.js";
+import { Executor } from "./core/executor.js";
+import { HEARTBEAT_INTERVAL_MS, writeHeartbeat } from "./core/heartbeat.js";
+import { RequestStore } from "./core/request-store.js";
+import { ServerStore } from "./core/server-store.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = findProjectRoot(__dirname);
+const staticRoot = path.resolve(rootDir, "gui/dist");
+const configuredAppPath = process.env.APP_PATH || "/ssh-gate";
+let effectiveAppPath = configuredAppPath;
+const config = loadConfig();
+setupLogging({ processLabel: "mcp-ssh-gate:GUI", logDir: config.logDir });
+const logger = createLogger("mcp-ssh-gate:GUI");
+process.on("uncaughtException", (err) => {
+    logger.error(`Uncaught exception: ${err.message}`);
+    logger.error(err.stack || "No stack trace");
+    process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+    logger.error(`Unhandled rejection: ${reason}`);
+    process.exit(1);
+});
+const servers = new ServerStore(config.dataDir, config.vaultKey);
+const requests = new RequestStore(config.dataDir);
+const executor = new Executor(servers, requests, (message) => logger.info(message));
+// Le worker s'arrête avec le processus MCP qui l'a lancé : canal IPC fermé, ou PID parent disparu.
+const parentPid = process.ppid;
+const parentCheck = setInterval(() => {
+    let parentAlive = process.connected;
+    if (parentAlive) {
+        try {
+            process.kill(parentPid, 0);
+        }
+        catch {
+            parentAlive = false;
+        }
+    }
+    if (!parentAlive) {
+        logger.info("MCP master is gone. Exiting.");
+        clearInterval(parentCheck);
+        process.exit(0);
+    }
+}, 2000);
+function safeSend(message) {
+    if (!process.send || !process.connected)
+        return;
+    try {
+        process.send({ ...message, timestamp: new Date().toISOString() });
+    }
+    catch (err) {
+        logger.error(`[IPC] Failed to send message: ${err.message}`);
+    }
+}
+process.on("message", (msg) => {
+    if (msg?.type === "GET_HEALTH") {
+        safeSend({ type: "HEALTH_RESPONSE", correlationId: msg.correlationId, data: { status: "ok", uptime: process.uptime() } });
+    }
+});
+process.on("disconnect", () => {
+    logger.warn("IPC disconnected from MCP master. Exiting.");
+    process.exit(0);
+});
+// --- API -----------------------------------------------------------------------
+const app = new Hono();
+app.use("*", honoGuiGuard());
+async function readBody(c) {
+    try {
+        return await c.req.json();
+    }
+    catch {
+        throw new GateError("Corps de requête JSON invalide.");
+    }
+}
+function handle(fn) {
+    return async (c) => {
+        try {
+            return c.json((await fn(c)));
+        }
+        catch (err) {
+            if (err instanceof GateError)
+                return c.json({ error: err.message }, 400);
+            logger.error(`${c.req.method} ${c.req.path}: ${err?.stack ?? err}`);
+            return c.json({ error: err?.message ?? String(err) }, 500);
+        }
+    };
+}
+function serverInput(body) {
+    return { name: body?.name, host: body?.host, port: Number(body?.port), username: body?.username };
+}
+function commandIndex(c) {
+    const index = Number(c.req.param("index"));
+    if (!Number.isInteger(index) || index < 0)
+        throw new GateError("Index de commande invalide.");
+    return index;
+}
+app.get("/api/state", handle(() => ({ version: APP_VERSION, servers: executor.views() })));
+app.get("/api/servers/:id/requests", handle((c) => {
+    const server = servers.get(c.req.param("id"));
+    const limit = Math.min(Math.max(Number(c.req.query("limit") ?? 50) || 50, 1), 200);
+    return { requests: requests.listForServer(server.id, limit) };
+}));
+app.post("/api/servers", handle(async (c) => executor.addServer(serverInput(await readBody(c)))));
+app.put("/api/servers/:id", handle(async (c) => executor.updateServer(c.req.param("id"), serverInput(await readBody(c)))));
+app.delete("/api/servers/:id", handle((c) => {
+    executor.deleteServer(c.req.param("id"));
+    return { deleted: true };
+}));
+app.post("/api/servers/:id/test", handle((c) => executor.testConnection(c.req.param("id"))));
+app.post("/api/servers/:id/disconnect", handle((c) => {
+    const server = servers.get(c.req.param("id"));
+    executor.disconnect(server.id);
+    return executor.view(servers.get(server.id));
+}));
+app.put("/api/servers/:id/notes", handle(async (c) => {
+    const body = await readBody(c);
+    const server = servers.get(c.req.param("id"));
+    const expected = body?.expectedUpdatedAt === undefined ? null : body.expectedUpdatedAt;
+    return executor.view(servers.setNotes(server.id, body?.notes, "user", expected));
+}));
+app.post("/api/servers/:id/manual", handle(async (c) => executor.runManual(c.req.param("id"), (await readBody(c))?.command)));
+app.put("/api/requests/:id/commands/:index", handle(async (c) => executor.editCommand(c.req.param("id"), commandIndex(c), (await readBody(c))?.command)));
+app.delete("/api/requests/:id/commands/:index", handle((c) => executor.removeCommand(c.req.param("id"), commandIndex(c))));
+app.post("/api/requests/:id/approve", handle(async (c) => executor.approve(c.req.param("id"), (await readBody(c))?.note)));
+app.post("/api/requests/:id/refuse", handle(async (c) => executor.refuse(c.req.param("id"), (await readBody(c))?.note)));
+app.post("/api/requests/:id/interrupt", handle(async (c) => {
+    await executor.interrupt(c.req.param("id"));
+    return { interrupted: true };
+}));
+app.use("/assets/*", serveStatic({ root: path.relative(process.cwd(), staticRoot) }));
+function baseHref(appPath) {
+    const normalized = appPath.startsWith("/") ? appPath : `/${appPath}`;
+    return normalized.endsWith("/") ? normalized : `${normalized}/`;
+}
+let standalone = false;
+app.get("/*", (c, next) => {
+    if (c.req.path.startsWith("/api") || c.req.path.startsWith("/assets"))
+        return next();
+    const indexPath = path.join(staticRoot, "index.html");
+    if (!fs.existsSync(indexPath))
+        return c.text(`GUI build not found at ${staticRoot}`, 404);
+    const href = standalone || c.req.query("__direct") === "1" ? "/" : baseHref(effectiveAppPath);
+    return c.html(fs.readFileSync(indexPath, "utf8").replace("<head>", `<head>\n    <base href="${href}" />`));
+});
+// --- Démarrage -----------------------------------------------------------------
+function listen(port, publicUrl) {
+    const instance = serve({ fetch: app.fetch, port, hostname: GUI_LISTEN_HOST }, (info) => {
+        logger.info(`GUI listening on port ${info.port}`);
+        executor.recoverAbandoned();
+        writeHeartbeat(config.dataDir, publicUrl);
+        setInterval(() => writeHeartbeat(config.dataDir, publicUrl), HEARTBEAT_INTERVAL_MS);
+        safeSend({ type: "READY", data: { port: info.port, url: publicUrl } });
+    });
+    instance.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+            logger.info(`Port ${port} already in use — another GUI worker is running.`);
+            safeSend({ type: "ALREADY_RUNNING", data: { url: publicUrl } });
+            process.exit(0);
+        }
+        logger.error(`Server error: ${err.message}`);
+        process.exit(1);
+    });
+}
+async function start() {
+    const proxyUrl = process.env.PROXY_URL?.trim();
+    if (!proxyUrl) {
+        const port = Number(process.env.APP_PORT?.trim());
+        if (!Number.isInteger(port) || port < 1 || port > 65535) {
+            logger.error(`APP_PORT is invalid (${process.env.APP_PORT}): expected an integer between 1 and 65535.`);
+            process.exit(1);
+        }
+        standalone = true;
+        listen(port, `http://localhost:${port}`);
+        return;
+    }
+    const proxyClient = new ProxyClient(proxyUrl);
+    const result = await proxyClient.register({
+        path: configuredAppPath,
+        name: process.env.APP_NAME || "SSH Gate",
+        group: process.env.APP_GROUP,
+    });
+    if (result.error === "HTTP 409") {
+        logger.info("Another GUI worker is already registered with the proxy.");
+        safeSend({ type: "ALREADY_RUNNING", data: { url: `${proxyUrl}${configuredAppPath}` } });
+        process.exit(0);
+    }
+    if (!result.success) {
+        logger.error(`Proxy registration failed: ${result.error}`);
+        process.exit(1);
+    }
+    effectiveAppPath = result.path ?? configuredAppPath;
+    const publicUrl = result.url || `${proxyUrl}${effectiveAppPath}`;
+    const cleanup = async () => {
+        await proxyClient.unregister();
+        process.exit(0);
+    };
+    process.on("SIGTERM", cleanup);
+    process.on("SIGINT", cleanup);
+    listen(result.port, publicUrl);
+}
+start().catch((err) => {
+    logger.error(`Failed to start the GUI worker: ${err.message}`);
+    process.exit(1);
+});

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/index.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+import dotenv from "dotenv";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { GuiLauncher, createLogger, setupLogging } from "@imenam/mcp-gui-interface";
+import { APP_VERSION } from "./version.js";
+import { assertGuiConfigured, findProjectRoot, loadConfig } from "./core/config.js";
+import { liveGuiUrl } from "./core/heartbeat.js";
+import { RequestStore } from "./core/request-store.js";
+import { ServerStore } from "./core/server-store.js";
+import { generateVaultKey } from "./core/vault.js";
+import { TOOL_DEFINITIONS, callTool } from "./tools/tools.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const argv = process.argv.slice(2);
+if (argv.includes("--generate-vault-key")) {
+    console.log(generateVaultKey());
+    process.exit(0);
+}
+if (argv.includes("--claude-setup-mcp")) {
+    const { runSetupMcp, parseGuiExposure } = await import("./cli/setup-mcp.js");
+    const parsed = parseGuiExposure(argv);
+    if ("error" in parsed) {
+        console.error(`Erreur : ${parsed.error}`);
+        process.exit(1);
+    }
+    process.exit(runSetupMcp({ cwd: process.cwd(), force: argv.includes("--force"), exposure: parsed.exposure }));
+}
+const rootDir = findProjectRoot(__dirname);
+const packageEnvPath = path.join(rootDir, ".env");
+if (fs.existsSync(packageEnvPath))
+    dotenv.config({ path: packageEnvPath, override: true, quiet: true });
+let config;
+try {
+    config = loadConfig();
+    assertGuiConfigured();
+}
+catch (err) {
+    process.stderr.write(`[mcp-ssh-gate] ${err.message}\n`);
+    process.exit(1);
+}
+setupLogging({ processLabel: "mcp-ssh-gate", logDir: config.logDir });
+const logger = createLogger("mcp-ssh-gate");
+const servers = new ServerStore(config.dataDir, config.vaultKey);
+const requests = new RequestStore(config.dataDir);
+try {
+    servers.verifyVault();
+}
+catch (err) {
+    logger.error(err.message);
+    process.stderr.write(`[mcp-ssh-gate] ${err.message}\n`);
+    process.exit(1);
+}
+let guiStatus = "stopped";
+let ownGuiUrl = null;
+let guiStartWaiter = null;
+function handleIpcMessage(msg) {
+    if (!msg || typeof msg.type !== "string")
+        return;
+    switch (msg.type) {
+        case "READY":
+            guiStatus = "ready";
+            ownGuiUrl = msg.data?.url ?? ownGuiUrl;
+            logger.info(`GUI ready at ${ownGuiUrl}`);
+            guiStartWaiter?.();
+            return;
+        case "ALREADY_RUNNING":
+            guiStatus = "already_running";
+            guiStartWaiter?.();
+            return;
+        default:
+            logger.debug(`Unhandled IPC message type: ${msg.type}`);
+    }
+}
+const guiLauncher = new GuiLauncher({
+    guiPath: path.join(__dirname, "gui-worker.js"),
+    env: { ...process.env },
+    maxRestarts: 0,
+    onMessage: handleIpcMessage,
+});
+function startGuiWorker() {
+    guiStatus = "starting";
+    const child = guiLauncher.start();
+    child.on("exit", () => {
+        if (guiLauncher.getProcess() === child && guiStatus !== "already_running")
+            guiStatus = "stopped";
+    });
+}
+/**
+ * Un seul worker sert l'interface et exécute les commandes pour toutes les
+ * sessions d'agent. Il en démarre un quand aucun n'a donné signe de vie.
+ */
+function ensureGui() {
+    if (guiStatus === "starting")
+        return;
+    if (guiStatus === "ready" && guiLauncher.getProcess()?.connected)
+        return;
+    if (liveGuiUrl(config.dataDir))
+        return;
+    logger.info("No live GUI worker — starting one.");
+    startGuiWorker();
+}
+function guiUrl() {
+    return liveGuiUrl(config.dataDir) ?? ownGuiUrl;
+}
+async function reconnectGui() {
+    ensureGui();
+    if (guiStatus === "starting") {
+        await new Promise((resolve) => {
+            const timer = setTimeout(resolve, 10_000);
+            guiStartWaiter = () => {
+                clearTimeout(timer);
+                resolve();
+            };
+        });
+        guiStartWaiter = null;
+    }
+    const url = guiUrl();
+    if (!url) {
+        return { content: [{ type: "text", text: "Error: the GUI did not start. Check the logs in " + config.logDir }], isError: true };
+    }
+    return { content: [{ type: "text", text: `GUI running at ${url}` }] };
+}
+// --- Serveur MCP ---------------------------------------------------------------
+const toolContext = { servers, requests, ensureGui, guiUrl, reconnectGui };
+const server = new Server({ name: "mcp-ssh-gate", version: APP_VERSION }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOL_DEFINITIONS }));
+server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+    return callTool(toolContext, request.params.name, request.params.arguments, extra.signal);
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    logger.info(`MCP server running on stdio (data dir: ${config.dataDir})`);
+    ensureGui();
+}
+main().catch((err) => {
+    logger.error(`Fatal error: ${err.message}`);
+    process.exit(1);
+});
+process.on("uncaughtException", (err) => {
+    logger.error(`Uncaught exception: ${err.message}`);
+    logger.error(err.stack || "No stack trace");
+    guiLauncher.getProcess()?.kill("SIGTERM");
+    process.exit(1);
+});

package/dist/src/tools/format.d.ts

@@ -0,0 +1,4 @@
+import type { GateRequest } from "../../shared/model.js";
+import type { StoredServer } from "../core/server-store.js";
+/** Demande lisible par l'agent : statut, note de l'utilisateur, commandes avec leur sortie. */
+export declare function formatRequest(request: GateRequest, server: StoredServer | null, maxOutput: number): string;

package/dist/src/tools/format.js

@@ -0,0 +1,66 @@
+const STATUS_TEXT = {
+    pending: "waiting for the user's approval",
+    running: "running",
+    completed: "completed",
+    failed: "failed",
+    interrupted: "interrupted by the user",
+    refused: "refused by the user",
+    cancelled: "cancelled by you",
+};
+/** Garde la fin d'une sortie : les erreurs sont en général dans les dernières lignes. */
+function tail(text, max) {
+    if (text.length <= max)
+        return { text, omitted: 0 };
+    return { text: text.slice(-max), omitted: text.length - max };
+}
+function duration(command) {
+    if (!command.startedAt || !command.endedAt)
+        return "";
+    const seconds = (Date.parse(command.endedAt) - Date.parse(command.startedAt)) / 1000;
+    return ` · ${seconds.toFixed(1)} s`;
+}
+function formatCommand(command, index, maxOutput) {
+    const lines = [`${index + 1}. $ ${command.command}`];
+    if (command.original !== null)
+        lines.push(`   Edited by the user. You proposed: $ ${command.original}`);
+    switch (command.status) {
+        case "skipped":
+            lines.push("   Not run.");
+            return lines.join("\n");
+        case "pending":
+            lines.push("   Waiting.");
+            return lines.join("\n");
+        case "running":
+            lines.push("   Running…");
+            break;
+        case "interrupted":
+            lines.push(`   Interrupted by the user (Ctrl+C)${command.exitCode === null ? "" : `, exit code ${command.exitCode}`}${duration(command)}`);
+            break;
+        default:
+            lines.push(`   ${command.exitCode === null ? "No exit code" : `Exit code ${command.exitCode}`}${duration(command)}`);
+    }
+    const output = tail(command.output, maxOutput);
+    if (output.omitted > 0 || command.outputTruncated)
+        lines.push(`   [The beginning of the output was omitted; the full stored output is in the GUI.]`);
+    lines.push(output.text.trim() ? "```\n" + output.text.replace(/\s+$/, "") + "\n```" : "   (no output)");
+    return lines.join("\n");
+}
+/** Demande lisible par l'agent : statut, note de l'utilisateur, commandes avec leur sortie. */
+export function formatRequest(request, server, maxOutput) {
+    const target = server ? `${server.id} (${server.username}@${server.host})` : request.serverId;
+    const author = request.source === "user" ? " — typed by the user" : "";
+    const lines = [`Request ${request.id} on ${target}${author}: ${STATUS_TEXT[request.status]}.`];
+    if (request.explanation)
+        lines.push(`Your explanation: ${request.explanation}`);
+    if (request.note)
+        lines.push(`${request.status === "refused" ? "Reason given by the user" : "Note from the user"}: ${request.note}`);
+    else if (request.status === "refused")
+        lines.push("The user gave no reason.");
+    if (request.error)
+        lines.push(`Execution stopped: ${request.error}`);
+    lines.push("");
+    request.commands.forEach((command, index) => lines.push(formatCommand(command, index, maxOutput)));
+    if (request.cwd)
+        lines.push("", `Shell working directory afterwards: ${request.cwd}`);
+    return lines.join("\n");
+}

package/dist/src/tools/tools.d.ts

@@ -0,0 +1,14 @@
+import type { CallToolResult, Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { RequestStore } from "../core/request-store.js";
+import type { ServerStore } from "../core/server-store.js";
+export interface ToolContext {
+    servers: ServerStore;
+    requests: RequestStore;
+    /** Démarre le worker de l'interface si aucun n'est vivant. */
+    ensureGui: () => void;
+    /** URL de l'interface servie par le worker vivant. */
+    guiUrl: () => string | null;
+    reconnectGui: () => Promise<CallToolResult>;
+}
+export declare const TOOL_DEFINITIONS: Tool[];
+export declare function callTool(ctx: ToolContext, name: string, args: unknown, signal?: AbortSignal): Promise<CallToolResult>;