mcp-compress-router 1.6.2 → 1.6.4

package/build/cli/config-io.js

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { parseJsonc } from '../utils/index.js';
+import { atomicWriteFile, parseJsonc } from '../utils/index.js';
 /**
  * Type guard for Node.js system errors that carry a `code` property.
  *
@@ -32,7 +32,7 @@ export async function ensureConfigDir(configPath) {
         await fs.access(configPath);
     }
     catch {
-        await fs.writeFile(configPath, JSON.stringify({ mcpServers: {} }, null, 2) + '\n');
+        await atomicWriteFile(configPath, JSON.stringify({ mcpServers: {} }, null, 2) + '\n');
     }
 }
 /**
@@ -86,7 +86,7 @@ export async function writeConfigFile(configPath, mcpServers) {
     // credentials.json separation
     delete existing.credentials;
     existing.mcpServers = mcpServers;
-    await fs.writeFile(configPath, JSON.stringify(existing, null, 2) + '\n');
+    await atomicWriteFile(configPath, JSON.stringify(existing, null, 2) + '\n');
 }
 /**
  * Reads the credentials object from credentials.json.
@@ -136,7 +136,7 @@ export async function writeCredentials(configPath, name, credentials, logger) {
     // Write atomically (unique temporary sibling + rename): a crash or
     // forced exit can never leave credentials.json truncated, and
     // readCredentials treats invalid JSON as a hard startup error.
-    await writeCredentialsFileAtomic(credPath, JSON.stringify(store, null, 2) + '\n', mode);
+    await atomicWriteFile(credPath, JSON.stringify(store, null, 2) + '\n', mode);
     // On first creation, set restrictive permissions (owner read/write only)
     if (isNewFile) {
         await restrictNewCredentialsFile(credPath, logger);
@@ -183,26 +183,6 @@ async function resolveCredentialsMode(credPath) {
         return { isNewFile: true, mode: 0o600 };
     }
 }
-/**
- * Writes `data` atomically: the content goes to a unique temporary
- * sibling file first, then is renamed over the target, so a crash or a
- * forced exit can never leave a truncated credentials file behind.
- *
- * @param credPath - Target credentials file path.
- * @param data - Full file content to write.
- * @param mode - Permissions to create the replacement file with.
- */
-async function writeCredentialsFileAtomic(credPath, data, mode) {
-    const tempPath = `${credPath}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-    try {
-        await fs.writeFile(tempPath, data, { mode });
-        await fs.rename(tempPath, credPath);
-    }
-    catch (err) {
-        await fs.unlink(tempPath).catch(() => { });
-        throw err;
-    }
-}
 /**
  * Restricts a freshly created credentials file to owner read/write and
  * warns when the platform cannot enforce it.
@@ -248,6 +228,6 @@ export async function removeCredentials(configPath, name) {
     }
     else {
         const { mode } = await resolveCredentialsMode(credPath);
-        await writeCredentialsFileAtomic(credPath, JSON.stringify(store, null, 2) + '\n', mode);
+        await atomicWriteFile(credPath, JSON.stringify(store, null, 2) + '\n', mode);
     }
 }

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/services/tool-cache.js

@@ -1,5 +1,6 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { atomicWriteFile } from '../utils/index.js';
 /**
  * Per-cache-file write queues. Each value is the promise of the most
  * recently queued write for that file. New writes chain onto it so all
@@ -102,28 +103,6 @@ async function readCacheStore(configPath) {
         return {};
     }
 }
-/**
- * Writes `data` to `cachePath` atomically: the content is first written
- * to a unique temporary sibling file and then renamed over the target.
- * Renaming within the same directory is atomic on POSIX, so a reader
- * (or a crash mid-write) can never observe a truncated or half-written
- * cache file — it sees either the previous complete file or the new
- * complete file.
- *
- * @param cachePath - Target cache file path.
- * @param data - Full file content to write.
- */
-async function writeCacheFileAtomic(cachePath, data) {
-    const tempPath = `${cachePath}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-    try {
-        await fs.writeFile(tempPath, data);
-        await fs.rename(tempPath, cachePath);
-    }
-    catch (err) {
-        await fs.unlink(tempPath).catch(() => { });
-        throw err;
-    }
-}
 /**
  * Saves discovered tools to the on-disk tool cache for a single server.
  * Preserves other servers' cached entries. Overwrites the entry for the
@@ -143,7 +122,7 @@ export async function saveToolCache(configPath, serverName, tools) {
             tools,
             cachedAt: new Date().toISOString(),
         };
-        await writeCacheFileAtomic(cachePath, JSON.stringify(store, null, 2) + '\n');
+        await atomicWriteFile(cachePath, JSON.stringify(store, null, 2) + '\n');
     });
 }
 /**
@@ -188,7 +167,7 @@ export async function clearToolCache(configPath, serverName) {
             await fs.unlink(cachePath).catch(() => { });
         }
         else {
-            await writeCacheFileAtomic(cachePath, JSON.stringify(store, null, 2) + '\n');
+            await atomicWriteFile(cachePath, JSON.stringify(store, null, 2) + '\n');
         }
     });
 }

package/build/utils/atomic-write.js

@@ -0,0 +1,31 @@
+import * as fs from 'node:fs/promises';
+/**
+ * Writes a file atomically: the content is first written to a unique
+ * temporary sibling file, then renamed over the target. Renaming within
+ * the same directory is atomic on POSIX, so a reader or a concurrent
+ * writer can only ever observe the old complete file or the new complete
+ * file — never a torn or empty one. The temporary file is removed when
+ * the write or the rename fails.
+ *
+ * The optional `mode` is applied to the temporary file (the rename
+ * preserves it), so callers can keep a sensitive file's permissions —
+ * e.g. `credentials.json` must stay owner-only across rewrites.
+ *
+ * @param filePath - Absolute path to the destination file.
+ * @param content - The full content to write.
+ * @param mode - Optional file mode (e.g. `0o600`); omitted to use the
+ *   default umask-based mode.
+ * @throws If writing the temporary file or renaming it over the target
+ *   fails. The temporary file is removed before the error propagates.
+ */
+export async function atomicWriteFile(filePath, content, mode) {
+    const tempPath = `${filePath}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+    try {
+        await fs.writeFile(tempPath, content, mode !== undefined ? { mode } : undefined);
+        await fs.rename(tempPath, filePath);
+    }
+    catch (err) {
+        await fs.unlink(tempPath).catch(() => { });
+        throw err;
+    }
+}

package/build/utils/index.js

@@ -5,5 +5,7 @@ export { validateGlobPattern } from './validate-glob.js';
 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.2",
+  "version": "1.6.4",
   "description": "Compress all connected MCP servers into a single router MCP to save tokens",
   "license": "MIT",
   "type": "module",