mcp-compress-router 1.6.0 → 1.6.1

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.6.0",
+  "version": "1.6.1",
   "description": "Compress all connected MCP servers into a single router MCP to save tokens",
   "license": "MIT",
   "type": "module",