mcp-compress-router 1.5.6 → 1.6.1

package/build/services/dedicated-fetch.js

@@ -0,0 +1,49 @@
+import { Agent, fetch as undiciFetch } from 'undici';
+/**
+ * Max concurrent connections per origin for the dedicated agent behind a
+ * Streamable HTTP transport. MUST be greater than one: the MCP streamable
+ * HTTP spec keeps a long-lived GET SSE stream open while POSTing
+ * messages, and a single-connection pool would deadlock — the SSE holds
+ * the only socket and every message POST queues behind it forever.
+ * Four connections cover the SSE stream plus concurrent message POSTs and
+ * the occasional session DELETE without sharing a pool with other
+ * servers.
+ */
+const DEDICATED_FETCH_CONNECTIONS = 4;
+/**
+ * Idle timeout (ms) for sockets owned by a dedicated agent. Kept short so
+ * sockets from a closed transport drain within a second instead of
+ * holding the process alive at undici's default 4 s keep-alive.
+ */
+const DEDICATED_FETCH_KEEP_ALIVE_MS = 1_000;
+/**
+ * Builds a fetch implementation backed by a dedicated undici `Agent`.
+ *
+ * Every `StreamableHTTPClientTransport` gets its own agent, so all of a
+ * downstream server's traffic — the SSE stream and the message POSTs —
+ * runs on connections drawn from a private pool for that transport
+ * instead of the shared default fetch pool. This isolates one server's
+ * connections from the OAuth metadata probes and from every other
+ * server: a probe or another server can never reuse a socket that
+ * belongs to this transport (and a connection-sensitive downstream or
+ * proxy never sees unrelated requests on the same TCP connection).
+ *
+ * The agent is intentionally left open-ended: it keeps per-origin
+ * keep-alive sockets that drain after {@link DEDICATED_FETCH_KEEP_ALIVE_MS}
+ * (the router force-exits on shutdown, so no explicit close is needed).
+ *
+ * @returns A fetch-compatible function for the caller's transport.
+ */
+export function createDedicatedFetch() {
+    const agent = new Agent({
+        connections: DEDICATED_FETCH_CONNECTIONS,
+        keepAliveTimeout: DEDICATED_FETCH_KEEP_ALIVE_MS,
+    });
+    return (url, init) => undiciFetch(url, {
+        // undici v8's `RequestInit`/`Response` and the global fetch types come
+        // from different type generations (TS 7 ArrayBuffer variance), so the
+        // bridge casts below are required; the runtime objects are identical.
+        ...init,
+        dispatcher: agent,
+    });
+}

package/build/services/discovery.js

@@ -2,6 +2,7 @@ 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 { createDedicatedFetch } from './dedicated-fetch.js';
 /** JSON-RPC error code for "Method not found". */
 const METHOD_NOT_FOUND = -32601;
 /**
@@ -131,5 +132,8 @@ export function createTransport(server, getAuthProvider) {
     return new StreamableHTTPClientTransport(new URL(server.url), {
         requestInit: Object.keys(requestInit).length > 0 ? requestInit : undefined,
         authProvider,
+        // Route all of this server's traffic through its own undici agent so
+        // it uses a private connection pool instead of the shared default one.
+        fetch: createDedicatedFetch(),
     });
 }

package/build/services/tool-cache.js

@@ -47,13 +47,39 @@ function serializeCacheWrite(cachePath, task) {
 function isNodeError(err) {
     return err instanceof Error && typeof err.code === 'string';
 }
+/**
+ * Sanitizes a parsed cache store: keeps only entries that are plain
+ * objects carrying a `tools` array, and drops everything else. A cache
+ * file that is damaged in parts therefore degrades to the subset of
+ * still-valid entries instead of being rejected wholesale; a root that
+ * is not a plain object degrades to an empty store.
+ *
+ * @param parsed - The raw JSON.parse() result of the cache file.
+ * @returns A validated store containing only well-formed entries.
+ */
+function sanitizeStore(parsed) {
+    const store = {};
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        return store;
+    }
+    for (const [serverName, entry] of Object.entries(parsed)) {
+        const candidate = entry;
+        if (candidate !== null && typeof candidate === 'object' && Array.isArray(candidate.tools)) {
+            store[serverName] = candidate;
+        }
+    }
+    return store;
+}
 /**
  * Reads the full tool cache store from disk. Returns an empty object
- * when the file does not exist.
+ * when the file does not exist. A corrupted cache file (invalid JSON,
+ * a non-object root, or entries without a `tools` array) never throws:
+ * it is treated as empty or partially empty so a damaged cache can
+ * never break the router. The next write simply rebuilds the file.
  *
  * @param configPath - Absolute path to the mcp.json file.
- * @returns The tool cache store, or empty object if file is absent.
- * @throws If the file exists but contains invalid JSON.
+ * @returns The tool cache store (possibly empty or partial).
+ * @throws Only on unexpected I/O errors (e.g. permission denied).
  */
 async function readCacheStore(configPath) {
     const cachePath = getCachePath(configPath);
@@ -67,17 +93,36 @@ async function readCacheStore(configPath) {
         }
         throw new Error(`Failed to read tool cache file: ${cachePath}`, { cause: err });
     }
-    let parsed;
     try {
-        parsed = JSON.parse(raw);
+        return sanitizeStore(JSON.parse(raw));
     }
-    catch (err) {
-        throw new Error(`Tool cache file contains invalid JSON: ${cachePath}`, { cause: err });
+    catch {
+        // Invalid JSON: treat the whole cache as empty rather than throwing.
+        // loadToolCache reports "no cache" and saveToolCache rebuilds it.
+        return {};
     }
-    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-        throw new Error(`Tool cache file must contain a JSON object: ${cachePath}`);
+}
+/**
+ * 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;
     }
-    return parsed;
 }
 /**
  * Saves discovered tools to the on-disk tool cache for a single server.
@@ -98,7 +143,7 @@ export async function saveToolCache(configPath, serverName, tools) {
             tools,
             cachedAt: new Date().toISOString(),
         };
-        await fs.writeFile(cachePath, JSON.stringify(store, null, 2) + '\n');
+        await writeCacheFileAtomic(cachePath, JSON.stringify(store, null, 2) + '\n');
     });
 }
 /**
@@ -108,8 +153,8 @@ export async function saveToolCache(configPath, serverName, tools) {
  *
  * @param configPath - Absolute path to the mcp.json file.
  * @param serverName - The server whose cached tools to load.
- * @returns The cached tool descriptors, or `undefined` when not cached.
- * @throws If the cache file exists but contains invalid JSON.
+ * @returns The cached tool descriptors, or `undefined` when not cached
+ *   (including when the cache file is missing or corrupted).
  */
 export async function loadToolCache(configPath, serverName) {
     const store = await readCacheStore(configPath);
@@ -143,7 +188,7 @@ export async function clearToolCache(configPath, serverName) {
             await fs.unlink(cachePath).catch(() => { });
         }
         else {
-            await fs.writeFile(cachePath, JSON.stringify(store, null, 2) + '\n');
+            await writeCacheFileAtomic(cachePath, JSON.stringify(store, null, 2) + '\n');
         }
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-compress-router",
-  "version": "1.5.6",
+  "version": "1.6.1",
   "description": "Compress all connected MCP servers into a single router MCP to save tokens",
   "license": "MIT",
   "type": "module",
@@ -68,6 +68,7 @@
     "dotenv": "17.4.2",
     "jsonc-parser": "3.3.1",
     "picomatch": "4.0.5",
+    "undici": "8.10.0",
     "zod": "4.4.3"
   }
 }