mcp-compress-router 1.6.2 → 1.6.3

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/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,6 @@ 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 { VALID_COMPRESSION_LEVELS, isCompressionLevel } from './compression-level.js';
 export { getDownstreamTimeoutMs, getAuthDiscoveryTimeoutMs, createTimeoutFetch, } from './timeout.js';

package/package.json

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