mcp-compress-router 1.6.3 → 1.6.4

package/build/services/discovery.js

@@ -1,22 +1,35 @@
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import { getDownstreamTimeoutMs } from '../utils/index.js';
+import { getDownstreamTimeoutMs, killProcessTree } from '../utils/index.js';
 import { createDedicatedFetch, createConnectTimeoutFetch } from './dedicated-fetch.js';
 /** JSON-RPC error code for "Method not found". */
 const METHOD_NOT_FOUND = -32601;
 /**
  * A {@link StdioClientTransport} whose `start()` (the child-process spawn
- * wait inside `client.connect()`) is bounded by a timeout. The SDK's own
- * transport resolves `start()` only on the process `'spawn'` event, so a
- * spawn that never completes — e.g. an executable on a stalled filesystem —
- * would stall the connect phase forever with no timeout of any kind.
+ * wait inside `client.connect()`) is bounded by a timeout, and whose
+ * `close()` terminates the spawned process tree.
  *
- * On timeout the child is force-closed (graduated kill) and the attempt
- * is rejected, so the router degrades or fails fast instead of hanging.
+ * The SDK's own transport resolves `start()` only on the process `'spawn'`
+ * event, so a spawn that never completes — e.g. an executable on a stalled
+ * filesystem — would stall the connect phase forever with no timeout of
+ * any kind. On timeout the child is force-closed and the attempt is
+ * rejected, so the router degrades or fails fast instead of hanging.
+ *
+ * The SDK also only signals the direct child on close. When the configured
+ * command is a wrapper (`npx`, `npm exec`), the actual MCP server is a
+ * grandchild that the SDK cannot reach — and if the wrapper exits while
+ * that grandchild still holds the inherited stdio pipes, the SDK skips its
+ * own SIGTERM/SIGKILL escalation and the server is orphaned. This
+ * transport therefore kills the whole descendant tree as well, and caches
+ * its close promise: `Client.connect()` may start the close
+ * fire-and-forget when the handshake fails, so a later `client.close()`
+ * must await the same full cleanup instead of returning immediately.
  */
 class TimeoutStdioClientTransport extends StdioClientTransport {
     spawnTimeoutMs;
+    childPid;
+    closeInFlight;
     constructor(params, spawnTimeoutMs) {
         super(params);
         this.spawnTimeoutMs = spawnTimeoutMs;
@@ -30,7 +43,12 @@ class TimeoutStdioClientTransport extends StdioClientTransport {
             timer.unref?.();
         });
         try {
-            await Promise.race([super.start(), spawnTimeout]);
+            const startPromise = super.start();
+            // `StdioClientTransport.start()` assigns the child process
+            // synchronously, so capture the pid before a failed handshake can
+            // clear the reference and leave the tree unkillable.
+            this.childPid = this.pid ?? undefined;
+            await Promise.race([startPromise, spawnTimeout]);
         }
         catch (err) {
             await this.close().catch(() => { });
@@ -42,6 +60,19 @@ class TimeoutStdioClientTransport extends StdioClientTransport {
             }
         }
     }
+    close() {
+        this.closeInFlight ??= this.performClose();
+        return this.closeInFlight;
+    }
+    async performClose() {
+        this.childPid ??= this.pid ?? undefined;
+        const treeTermination = this.childPid === undefined ? undefined : killProcessTree(this.childPid);
+        // The tree kill runs concurrently with the SDK's graduated close: the
+        // descendant snapshot is only valid while the direct child is alive,
+        // and killing the grandchildren lets the SDK's own close resolve fast.
+        await super.close();
+        await treeTermination;
+    }
 }
 /**
  * Returns true when an error is a JSON-RPC "Method not found" response,

package/build/services/server-connection.js

@@ -197,6 +197,11 @@ export class ServerConnection {
             };
         }
         catch (err) {
+            // Tear down any half-initialized client. The connect may have
+            // succeeded while `tools/list` failed, in which case a live
+            // transport (and its spawned child process) would otherwise linger
+            // until the next reconnect attempt or shutdown.
+            await this.closeClient();
             // Record the failure on the connection so the cooldown engages
             // (status != 'ok') and subsequent callers see the real reason
             // rather than re-running the full connect→fail cycle with no

package/build/utils/index.js

@@ -6,5 +6,6 @@ export { expandEnvField } from './expand-env.js';
 export { Logger } from './logger.js';
 export { parseJsonc } from './parse-jsonc.js';
 export { atomicWriteFile } from './atomic-write.js';
+export { killProcessTree } from './process-tree.js';
 export { VALID_COMPRESSION_LEVELS, isCompressionLevel } from './compression-level.js';
 export { getDownstreamTimeoutMs, getAuthDiscoveryTimeoutMs, createTimeoutFetch, } from './timeout.js';

package/build/utils/process-tree.js

@@ -0,0 +1,161 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+/** How long to wait for a tree to exit after SIGTERM before SIGKILL. */
+const DEFAULT_GRACE_MS = 1_000;
+/** Poll interval used while waiting for processes to disappear. */
+const POLL_INTERVAL_MS = 25;
+/** Process-table size bound for `ps`; fits even large host tables. */
+const PS_MAX_BUFFER = 16 * 1024 * 1024;
+/**
+ * Terminates a process and every descendant it has spawned.
+ *
+ * This is required for stdio downstream servers launched through a
+ * wrapper — `npx`, `npm exec`, a shell script — where the actual MCP
+ * server is a grandchild of the router. The MCP SDK's transport only
+ * signals the direct child, so a wrapper that exits (or is killed)
+ * while the real server still holds the inherited stdio pipes leaves
+ * that server orphaned with a dead peer.
+ *
+ * On POSIX the descendant list is resolved from one `ps` snapshot
+ * taken while the tree is still intact, then the whole tree gets
+ * `SIGTERM` followed by `SIGKILL` for survivors after a short grace
+ * period. On Windows a `taskkill /T /F` is used.
+ *
+ * Best-effort and never rejects: missing processes, a failed
+ * `ps`/`taskkill` invocation, and permission errors are ignored.
+ *
+ * @param rootPid - Pid of the direct child (the wrapper, when one is
+ *   used).
+ */
+export async function killProcessTree(rootPid) {
+    if (process.platform === 'win32') {
+        await taskkillTree(rootPid);
+        return;
+    }
+    const pids = await collectTreePids(rootPid);
+    signalProcesses(pids, 'SIGTERM');
+    await waitForExit(pids, DEFAULT_GRACE_MS);
+    signalProcesses(pids.filter(isAlive), 'SIGKILL');
+}
+/**
+ * Collects `rootPid` plus all of its descendants from a single `ps`
+ * snapshot. Falls back to just the root when the process table cannot
+ * be read.
+ *
+ * @param rootPid - Pid of the tree root.
+ * @returns Root pid followed by its descendants.
+ */
+async function collectTreePids(rootPid) {
+    const table = await readProcessTable();
+    const childrenByParent = new Map();
+    for (const entry of table) {
+        const children = childrenByParent.get(entry.ppid);
+        if (children === undefined) {
+            childrenByParent.set(entry.ppid, [entry.pid]);
+        }
+        else {
+            children.push(entry.pid);
+        }
+    }
+    const pids = [rootPid];
+    for (let index = 0; index < pids.length; index += 1) {
+        const children = childrenByParent.get(pids[index]);
+        if (children !== undefined) {
+            pids.push(...children);
+        }
+    }
+    return pids;
+}
+/**
+ * Reads the POSIX process table via `ps`. Returns an empty list when
+ * `ps` is unavailable or fails.
+ *
+ * @returns Parsed pid/parent-pid rows.
+ */
+async function readProcessTable() {
+    try {
+        const { stdout } = await execFileAsync('ps', ['-A', '-o', 'pid=,ppid='], {
+            maxBuffer: PS_MAX_BUFFER,
+        });
+        const entries = [];
+        for (const line of stdout.split('\n')) {
+            const match = /^\s*(\d+)\s+(\d+)\s*$/.exec(line);
+            if (match !== null) {
+                entries.push({ pid: Number(match[1]), ppid: Number(match[2]) });
+            }
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Sends `signal` to every pid, ignoring pids that are already gone or
+ * cannot be signalled.
+ *
+ * @param pids - Target process ids.
+ * @param signal - Signal to deliver.
+ */
+function signalProcesses(pids, signal) {
+    for (const pid of pids) {
+        try {
+            process.kill(pid, signal);
+        }
+        catch {
+            // Already exited or not signalable; nothing to do.
+        }
+    }
+}
+/**
+ * Returns whether a pid still exists.
+ *
+ * @param pid - Process id to probe.
+ */
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Waits until every pid is gone or the grace period expires.
+ *
+ * @param pids - Process ids to await.
+ * @param timeoutMs - Maximum time to wait.
+ */
+async function waitForExit(pids, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline && pids.some(isAlive)) {
+        await delay(POLL_INTERVAL_MS);
+    }
+}
+/**
+ * Force-kills a Windows process tree rooted at `pid` and falls back to
+ * a direct kill if `taskkill` is unavailable.
+ *
+ * @param pid - Root process id.
+ */
+async function taskkillTree(pid) {
+    try {
+        await execFileAsync('taskkill', ['/PID', String(pid), '/T', '/F']);
+    }
+    catch {
+        // taskkill is unavailable or the process is already gone.
+    }
+    signalProcesses([pid], 'SIGKILL');
+}
+/**
+ * Promise that resolves after `ms` milliseconds.
+ *
+ * @param ms - Delay in milliseconds.
+ */
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-compress-router",
-  "version": "1.6.3",
+  "version": "1.6.4",
   "description": "Compress all connected MCP servers into a single router MCP to save tokens",
   "license": "MIT",
   "type": "module",