@zswarm/mcp 0.1.7 → 0.1.8

package/README.md

@@ -41,7 +41,9 @@ the Zellij environment. Give the interpreter an absolute path and set
 `ZSWARM_SESSION`. Forward `ZELLIJ_PANE_ID` (or set `ZSWARM_FROM`) so send
 labels `[zswarm from=…]` with the sending pane instead of `swarm`.
 `ZSWARM_SSH` or `ZSWARM_SERVE` routes the same tool at a remote crew.
-Details: the [zswarm README](../../README.md).
+`ZSWARM_SERVE` may be `host:port` or `ssh://user@host?servePort=9419` (MCP reuses
+a healthy owned tunnel until stdin EOF, then cancels in-flight work and reaps
+the SSH child). Details: the [zswarm README](../../README.md).
 
 ## License
 

package/dist/mcp-server.js

@@ -3,9 +3,58 @@ import { createRequire } from "node:module";
 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 { dispatchZswarm, mcpInputSchema, MCP_TOOL_DESCRIPTION, } from "@zswarm/core";
+import { createServeTunnelManager, dispatchZswarm, mcpInputSchema, MCP_TOOL_DESCRIPTION, } from "@zswarm/core";
 const { version } = createRequire(import.meta.url)("../package.json");
+const SHUTDOWN_BOUND_MS = 5_000;
+const serveTunnels = createServeTunnelManager({ persistIdle: true });
+const requestAborts = new Set();
+let inflight = 0;
+let shuttingDown = false;
+let shutdownPromise;
 const server = new Server({ name: "zswarm", version }, { capabilities: { tools: {} } });
+const transport = new StdioServerTransport();
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function shutdown() {
+    if (shutdownPromise)
+        return shutdownPromise;
+    shuttingDown = true;
+    shutdownPromise = (async () => {
+        for (const ac of requestAborts)
+            ac.abort();
+        const bound = Date.now() + SHUTDOWN_BOUND_MS;
+        while (inflight > 0 && Date.now() < bound) {
+            await sleep(15);
+        }
+        await Promise.race([
+            serveTunnels.closeAll(),
+            sleep(2_000),
+        ]);
+        await Promise.race([
+            server.close().catch(() => undefined),
+            sleep(500),
+        ]);
+        try {
+            await Promise.race([transport.close(), sleep(500)]);
+        }
+        catch {
+            /* already closed */
+        }
+    })();
+    await shutdownPromise;
+}
+function requestShutdown(exitAfter) {
+    const force = setTimeout(() => {
+        if (exitAfter)
+            process.exit(0);
+    }, SHUTDOWN_BOUND_MS);
+    void shutdown().finally(() => {
+        clearTimeout(force);
+        if (exitAfter)
+            process.exit(0);
+    });
+}
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
         {
@@ -32,13 +81,59 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
             isError: true,
         };
     }
-    const result = await dispatchZswarm(args, undefined, { signal: extra.signal });
-    return {
-        content: [
-            { type: "text", text: JSON.stringify(result, null, 2) },
-        ],
-        isError: !result.ok,
-    };
+    if (shuttingDown) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        ok: false,
+                        error: { code: "cancelled", message: "serve tunnel manager is closed" },
+                    }),
+                },
+            ],
+            isError: true,
+        };
+    }
+    const ac = new AbortController();
+    const onExtraAbort = () => ac.abort();
+    extra.signal?.addEventListener("abort", onExtraAbort, { once: true });
+    requestAborts.add(ac);
+    inflight += 1;
+    try {
+        const result = await dispatchZswarm(args, undefined, {
+            signal: ac.signal,
+            serveTunnels,
+        });
+        return {
+            content: [
+                { type: "text", text: JSON.stringify(result, null, 2) },
+            ],
+            isError: !result.ok,
+        };
+    }
+    finally {
+        extra.signal?.removeEventListener("abort", onExtraAbort);
+        requestAborts.delete(ac);
+        inflight -= 1;
+    }
+});
+transport.onclose = () => {
+    requestShutdown(true);
+};
+transport.onerror = () => {
+    requestShutdown(true);
+};
+process.stdin.on("end", () => {
+    requestShutdown(true);
+});
+process.stdin.on("close", () => {
+    requestShutdown(true);
+});
+process.once("SIGINT", () => {
+    requestShutdown(true);
+});
+process.once("SIGTERM", () => {
+    requestShutdown(true);
 });
-const transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zswarm/mcp",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "type": "module",
   "description": "zSwarm MCP server — Zellij pane coordination",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",
-    "@zswarm/core": "0.1.7"
+    "@zswarm/core": "0.1.8"
   },
   "devDependencies": {
     "@types/node": "22.14.1",