@mrrlin-dev/mcp 0.4.87 → 0.4.88

package/dist/bin.cjs

@@ -56831,7 +56831,7 @@ Do NOT derail the current task - if the operator has an in-flight question, answ
 }
 
 // src/_generated/version.ts
-var PKG_VERSION = "0.4.87";
+var PKG_VERSION = "0.4.88";
 
 // src/api-base-url-migrate.ts
 var import_node_fs13 = __toESM(require("node:fs"), 1);
@@ -56856,28 +56856,45 @@ function resolveServiceCwd(opts) {
 }
 var BRIDGE_APP_NAME = "mrrlin-bridge";
 function renderEcosystemConfig(opts) {
-  const env = {
-    HOME: opts.home,
-    PATH: opts.pathEnv,
-    MRRLIN_DIRECTOR_BRIDGE_LOG: "1"
-  };
-  if (opts.user) {
-    env.USER = opts.user;
-    if (process.platform === "win32") {
-      env.USERNAME = opts.user;
+  let envLines;
+  if ("env" in opts && opts.env !== void 0) {
+    const safeEnv = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(opts.env)) {
+      const val = opts.env[key];
+      if (val !== void 0) {
+        safeEnv[key] = val;
+      }
+    }
+    const keys = Object.keys(safeEnv).sort();
+    envLines = keys.map((k) => {
+      const keyProp = k === "__proto__" ? '["__proto__"]' : k;
+      return `      ${keyProp}: ${JSON.stringify(safeEnv[k])},`;
+    }).join("\n");
+  } else {
+    const legacyOpts = opts;
+    const env = {
+      HOME: legacyOpts.home,
+      PATH: legacyOpts.pathEnv,
+      MRRLIN_DIRECTOR_BRIDGE_LOG: "1"
+    };
+    if (legacyOpts.user) {
+      env.USER = legacyOpts.user;
+      if (process.platform === "win32") {
+        env.USERNAME = legacyOpts.user;
+      }
     }
-  }
-  if (opts.codexHome) env.CODEX_HOME = opts.codexHome;
-  const claudeConfigDir = opts.claudeConfigDir?.trim();
-  if (claudeConfigDir) env.CLAUDE_CONFIG_DIR = claudeConfigDir;
-  const apiBaseUrl = opts.apiBaseUrl ? retargetRetiredApiBaseUrl(opts.apiBaseUrl).baseUrl : void 0;
-  if (apiBaseUrl && !isProductionApiBaseUrl(apiBaseUrl)) {
-    env.MRRLIN_API_BASE_URL = apiBaseUrl;
-    if (opts.apiAllowRemote && !isStagingApiBaseUrl(apiBaseUrl) && !isLoopbackUrl(apiBaseUrl)) {
-      env.MRRLIN_API_ALLOW_REMOTE = "1";
+    if (legacyOpts.codexHome) env.CODEX_HOME = legacyOpts.codexHome;
+    const claudeConfigDir = legacyOpts.claudeConfigDir?.trim();
+    if (claudeConfigDir) env.CLAUDE_CONFIG_DIR = claudeConfigDir;
+    const apiBaseUrl = legacyOpts.apiBaseUrl ? retargetRetiredApiBaseUrl(legacyOpts.apiBaseUrl).baseUrl : void 0;
+    if (apiBaseUrl && !isProductionApiBaseUrl(apiBaseUrl)) {
+      env.MRRLIN_API_BASE_URL = apiBaseUrl;
+      if (legacyOpts.apiAllowRemote && !isStagingApiBaseUrl(apiBaseUrl) && !isLoopbackUrl(apiBaseUrl)) {
+        env.MRRLIN_API_ALLOW_REMOTE = "1";
+      }
     }
+    envLines = Object.entries(env).map(([k, v]) => `      ${k}: ${JSON.stringify(v)},`).join("\n");
   }
-  const envLines = Object.entries(env).map(([k, v]) => `      ${k}: ${JSON.stringify(v)},`).join("\n");
   return `module.exports = {
   apps: [{
     name: ${JSON.stringify(BRIDGE_APP_NAME)},
@@ -71029,49 +71046,440 @@ function runSetCredential(args) {
 var import_node_os18 = __toESM(require("node:os"), 1);
 var import_node_fs24 = require("node:fs");
 var import_node_path38 = __toESM(require("node:path"), 1);
-function isOwnedEcosystemConfig(text) {
-  return /name:\s*"mrrlin-bridge"/.test(text) && /script:\s*"mrrlin-mcp"/.test(text) && /args:\s*"director-bridge"/.test(text);
-}
-function readEnvString(text, key) {
-  const match = new RegExp(`\\b${key}:\\s*("(?:[^"\\\\]|\\\\.)*")`).exec(text);
-  if (!match?.[1]) return void 0;
+function parseEnvLine(line, env) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed === "}" || trimmed === "},") return;
+  const match = /^\s*(?:([a-zA-Z_$][a-zA-Z0-9_$]*)|"((?:[^"\\]|\\.)*)"|(\["__proto__"\]))\s*:\s*("(?:[^"\\]|\\.)*")\s*,?\s*$/.exec(line);
+  if (!match) return;
+  const identKey = match[1];
+  const quotedKey = match[2];
+  const computedProto = match[3];
+  const rawValue = match[4];
+  if (!rawValue) return;
+  let key = null;
+  if (computedProto) {
+    key = "__proto__";
+  } else if (identKey) {
+    if (identKey === "__proto__") {
+      return;
+    }
+    key = identKey;
+  } else if (quotedKey !== void 0) {
+    try {
+      const parsedKey = JSON.parse(`"${quotedKey}"`);
+      if (typeof parsedKey !== "string" || parsedKey === "__proto__") {
+        return;
+      }
+      key = parsedKey;
+    } catch {
+      return;
+    }
+  }
+  if (key === null) return;
   try {
-    const value = JSON.parse(match[1]);
-    return typeof value === "string" && value.trim() ? value.trim() : void 0;
+    const parsedValue = JSON.parse(rawValue);
+    if (typeof parsedValue === "string") {
+      env[key] = parsedValue;
+    }
   } catch {
-    return void 0;
+    return;
   }
 }
-function normalizeServiceApiTarget(apiBaseUrl, allowRemote) {
-  const normalized = retargetRetiredApiBaseUrl(apiBaseUrl).baseUrl;
-  if (isProductionApiBaseUrl(normalized)) return {};
-  const target = { apiBaseUrl: normalized };
-  if (allowRemote && !isStagingApiBaseUrl(normalized) && !isLoopbackUrl(normalized)) target.apiAllowRemote = true;
-  return target;
+function parseExistingEcosystemConfig(text) {
+  if (text === null || text === void 0) {
+    return { kind: "missing" };
+  }
+  let mode = "code";
+  const templateCurlyStack = [];
+  let curlyDepth = 0;
+  let squareDepth = 0;
+  let parenDepth = 0;
+  let moduleExportsOpened = false;
+  let moduleExportsClosed = false;
+  let appsArrayOpened = false;
+  let appsArrayClosed = false;
+  let appCandidateActive = false;
+  let candidateHasName = false;
+  let candidateHasScript = false;
+  let candidateHasArgs = false;
+  let candidateHasEnv = false;
+  let candidateEnvOpenedOnLine = false;
+  let candidateEnvClosed = false;
+  let candidateEnv = null;
+  let matchedAppEnv = null;
+  let matchedAppCount = 0;
+  let recentCode = "";
+  let lineCode = "";
+  const len = text.length;
+  let i = 0;
+  while (i < len) {
+    const ch = text[i] ?? "";
+    if (mode === "line_comment") {
+      if (ch === "\n") {
+        mode = "code";
+        lineCode = "";
+        candidateEnvOpenedOnLine = false;
+      }
+      i++;
+      continue;
+    }
+    if (mode === "block_comment") {
+      if (ch === "*" && i + 1 < len && text[i + 1] === "/") {
+        mode = "code";
+        i += 2;
+        continue;
+      }
+      if (ch === "\n") {
+        lineCode = "";
+        candidateEnvOpenedOnLine = false;
+      }
+      i++;
+      continue;
+    }
+    if (mode === "single_quote") {
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === "'") {
+        mode = "code";
+        i++;
+        continue;
+      }
+      if (ch === "\n" || ch === "\r") {
+        return { kind: "rejected", text };
+      }
+      i++;
+      continue;
+    }
+    if (mode === "double_quote") {
+      if (ch === "\\") {
+        lineCode += ch + (text[i + 1] ?? "");
+        i += 2;
+        continue;
+      }
+      lineCode += ch;
+      if (ch === '"') {
+        mode = "code";
+        if (appCandidateActive && curlyDepth === 2 && squareDepth === 1) {
+          if (/name\s*:\s*"mrrlin-bridge"/.test(lineCode)) candidateHasName = true;
+          if (/script\s*:\s*"mrrlin-mcp"/.test(lineCode)) candidateHasScript = true;
+          if (/args\s*:\s*"director-bridge"/.test(lineCode)) candidateHasArgs = true;
+        }
+        i++;
+        continue;
+      }
+      if (ch === "\n" || ch === "\r") {
+        return { kind: "rejected", text };
+      }
+      i++;
+      continue;
+    }
+    if (mode === "template") {
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === "`") {
+        mode = "code";
+        i++;
+        continue;
+      }
+      if (ch === "$" && i + 1 < len && text[i + 1] === "{") {
+        mode = "code";
+        templateCurlyStack.push(curlyDepth);
+        curlyDepth++;
+        i += 2;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "/" && i + 1 < len) {
+      if (text[i + 1] === "/") {
+        mode = "line_comment";
+        i += 2;
+        continue;
+      }
+      if (text[i + 1] === "*") {
+        mode = "block_comment";
+        i += 2;
+        continue;
+      }
+      return { kind: "rejected", text };
+    }
+    if (ch === "/") {
+      return { kind: "rejected", text };
+    }
+    if (ch === "'") {
+      mode = "single_quote";
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      mode = "double_quote";
+      lineCode += ch;
+      i++;
+      continue;
+    }
+    if (ch === "`") {
+      mode = "template";
+      i++;
+      continue;
+    }
+    if (ch === "\n") {
+      if (appCandidateActive && candidateHasEnv && !candidateEnvClosed && curlyDepth === 3 && candidateEnv) {
+        parseEnvLine(lineCode, candidateEnv);
+      }
+      lineCode = "";
+      candidateEnvOpenedOnLine = false;
+      recentCode += " ";
+      i++;
+      continue;
+    }
+    lineCode += ch;
+    recentCode += ch;
+    if (ch === "{") {
+      if (curlyDepth === 0 && squareDepth === 0) {
+        if (/module\.exports\s*=\s*\{$/.test(recentCode.trim())) {
+          if (moduleExportsOpened) return { kind: "rejected", text };
+          moduleExportsOpened = true;
+        }
+      } else if (moduleExportsOpened && !moduleExportsClosed && appsArrayOpened && !appsArrayClosed && squareDepth === 1 && curlyDepth === 1) {
+        appCandidateActive = true;
+        candidateHasName = false;
+        candidateHasScript = false;
+        candidateHasArgs = false;
+        candidateHasEnv = false;
+        candidateEnvOpenedOnLine = false;
+        candidateEnvClosed = false;
+        candidateEnv = /* @__PURE__ */ Object.create(null);
+      } else if (appCandidateActive && squareDepth === 1 && curlyDepth === 2) {
+        if (/\benv\s*:\s*\{$/.test(recentCode.trim())) {
+          candidateHasEnv = true;
+          candidateEnvOpenedOnLine = true;
+        }
+      }
+      curlyDepth++;
+      recentCode = "";
+      i++;
+      continue;
+    }
+    if (ch === "}") {
+      if (curlyDepth === 0) return { kind: "rejected", text };
+      if (templateCurlyStack.length > 0 && templateCurlyStack[templateCurlyStack.length - 1] === curlyDepth - 1) {
+        templateCurlyStack.pop();
+        mode = "template";
+        curlyDepth--;
+        recentCode = "";
+        i++;
+        continue;
+      }
+      if (appCandidateActive && candidateHasEnv && !candidateEnvClosed && curlyDepth === 3) {
+        if (candidateEnvOpenedOnLine) {
+          candidateHasEnv = false;
+        }
+        const beforeBrace = lineCode.slice(0, -1);
+        if (beforeBrace.trim() && candidateEnv) {
+          parseEnvLine(beforeBrace, candidateEnv);
+        }
+        candidateEnvClosed = true;
+      } else if (appCandidateActive && curlyDepth === 2 && squareDepth === 1) {
+        if (candidateHasName && candidateHasScript && candidateHasArgs && candidateHasEnv && candidateEnvClosed) {
+          matchedAppCount++;
+          if (matchedAppCount > 1) return { kind: "rejected", text };
+          matchedAppEnv = candidateEnv;
+        }
+        appCandidateActive = false;
+        candidateEnv = null;
+      } else if (moduleExportsOpened && !moduleExportsClosed && curlyDepth === 1 && squareDepth === 0) {
+        moduleExportsClosed = true;
+      }
+      curlyDepth--;
+      recentCode = "";
+      i++;
+      continue;
+    }
+    if (ch === "[") {
+      if (moduleExportsOpened && !moduleExportsClosed && curlyDepth === 1 && squareDepth === 0) {
+        if (/\bapps\s*:\s*\[$/.test(recentCode.trim())) {
+          if (appsArrayOpened) return { kind: "rejected", text };
+          appsArrayOpened = true;
+        }
+      }
+      squareDepth++;
+      recentCode = "";
+      i++;
+      continue;
+    }
+    if (ch === "]") {
+      if (squareDepth === 0) return { kind: "rejected", text };
+      if (moduleExportsOpened && !moduleExportsClosed && appsArrayOpened && squareDepth === 1 && curlyDepth === 1) {
+        appsArrayClosed = true;
+      }
+      squareDepth--;
+      recentCode = "";
+      i++;
+      continue;
+    }
+    if (ch === "(") {
+      parenDepth++;
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      if (parenDepth === 0) return { kind: "rejected", text };
+      parenDepth--;
+      i++;
+      continue;
+    }
+    i++;
+  }
+  if (mode !== "code") return { kind: "rejected", text };
+  if (curlyDepth !== 0 || squareDepth !== 0 || parenDepth !== 0) return { kind: "rejected", text };
+  if (!moduleExportsOpened || !moduleExportsClosed) return { kind: "rejected", text };
+  if (!appsArrayOpened || !appsArrayClosed) return { kind: "rejected", text };
+  if (matchedAppCount !== 1 || !matchedAppEnv) return { kind: "rejected", text };
+  return { kind: "accepted", env: matchedAppEnv, text };
+}
+var CURATED_KEYS = [
+  "CODEX_HOME",
+  "CLAUDE_CONFIG_DIR",
+  "MRRLIN_DIRECTOR_BRIDGE_LOG",
+  "MRRLIN_API_BASE_URL",
+  "MRRLIN_API_ALLOW_REMOTE",
+  "MRRLIN_STAGING"
+];
+function mergeConfigEnv(depsEnv, carriedEnv) {
+  const isWin = process.platform === "win32";
+  const DENIED_CARRIED_KEYS = new Set(isWin ? ["HOME", "PATH", "USER", "USERNAME"] : ["HOME", "PATH", "USER"]);
+  const mergedEnv = /* @__PURE__ */ Object.create(null);
+  const preservedNames = [];
+  const droppedNames = [];
+  const carriedKeys = Object.keys(carriedEnv);
+  for (const key of carriedKeys) {
+    if (DENIED_CARRIED_KEYS.has(key)) {
+      droppedNames.push(key);
+      continue;
+    }
+    const envVal = depsEnv[key];
+    if (Object.hasOwn(depsEnv, key) && envVal !== void 0) {
+      let installerVal = envVal;
+      if (key === "CODEX_HOME" || key === "CLAUDE_CONFIG_DIR" || key === "MRRLIN_API_BASE_URL") {
+        installerVal = installerVal.trim();
+      }
+      if (installerVal === "") {
+        droppedNames.push(key);
+      } else {
+        preservedNames.push(key);
+        mergedEnv[key] = installerVal;
+      }
+    } else {
+      const carriedVal = carriedEnv[key];
+      if (carriedVal !== void 0) {
+        preservedNames.push(key);
+        mergedEnv[key] = carriedVal;
+      }
+    }
+  }
+  for (const key of CURATED_KEYS) {
+    if (Object.hasOwn(carriedEnv, key)) continue;
+    const envVal = depsEnv[key];
+    if (Object.hasOwn(depsEnv, key) && envVal !== void 0) {
+      let val = envVal;
+      if (key === "CODEX_HOME" || key === "CLAUDE_CONFIG_DIR" || key === "MRRLIN_API_BASE_URL") {
+        val = val.trim();
+      }
+      if (val !== "") {
+        mergedEnv[key] = val;
+      }
+    } else {
+      if (key === "MRRLIN_DIRECTOR_BRIDGE_LOG") {
+        mergedEnv[key] = "1";
+      }
+    }
+  }
+  preservedNames.sort();
+  droppedNames.sort();
+  return { mergedEnv, preservedNames, droppedNames };
 }
-function readExistingServiceApiTarget(deps, ecoPath) {
-  try {
-    const existing = deps.readFile?.(ecoPath);
-    if (!existing || !isOwnedEcosystemConfig(existing)) return void 0;
-    const apiBaseUrl = readEnvString(existing, "MRRLIN_API_BASE_URL");
-    if (apiBaseUrl) {
-      return normalizeServiceApiTarget(apiBaseUrl, readEnvString(existing, "MRRLIN_API_ALLOW_REMOTE") === "1");
+function deriveMergedApiRouting(mergedEnv, invokingBridgeUrl) {
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const k of Object.keys(mergedEnv)) {
+    const v = mergedEnv[k];
+    if (v !== void 0) {
+      result[k] = v;
     }
-    if (readEnvString(existing, "MRRLIN_STAGING") === "1") {
-      return { apiBaseUrl: STAGING_API_BASE_URL };
+  }
+  if (Object.hasOwn(result, "MRRLIN_API_BASE_URL")) {
+    const rawApi = result["MRRLIN_API_BASE_URL"];
+    if (rawApi === "") {
+      result["MRRLIN_API_BASE_URL"] = "";
+    } else if (rawApi !== void 0) {
+      const retargeted = retargetRetiredApiBaseUrl(rawApi).baseUrl;
+      result["MRRLIN_API_BASE_URL"] = retargeted;
+    }
+  } else {
+    if (result["MRRLIN_STAGING"] === "1") {
+      result["MRRLIN_API_BASE_URL"] = STAGING_API_BASE_URL;
+    } else if (bridgeUrlImpliesStaging(invokingBridgeUrl)) {
+      result["MRRLIN_API_BASE_URL"] = STAGING_API_BASE_URL;
     }
-    return void 0;
-  } catch {
-    return void 0;
   }
+  return result;
+}
+function escapeRegex2(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function deriveServiceApiTarget(deps, ecoPath) {
-  const apiBaseUrl = deps.env.MRRLIN_API_BASE_URL?.trim();
-  if (apiBaseUrl) return normalizeServiceApiTarget(apiBaseUrl, deps.env.MRRLIN_API_ALLOW_REMOTE === "1");
-  if (deps.env.MRRLIN_STAGING === "1" || bridgeUrlImpliesStaging(deps.env.MRRLIN_BRIDGE_URL)) {
-    return { apiBaseUrl: STAGING_API_BASE_URL };
+function performConfigBackup(deps, ecoPath, existingText) {
+  try {
+    if (!deps.listDir || !deps.writeExclusiveFile) {
+      deps.log("Service config backup failed.");
+      return;
+    }
+    const dir = import_node_path38.default.dirname(ecoPath);
+    let files;
+    try {
+      files = deps.listDir(dir);
+    } catch {
+      deps.log("Service config backup failed.");
+      return;
+    }
+    if (!files || !Array.isArray(files)) {
+      deps.log("Service config backup failed.");
+      return;
+    }
+    const base = import_node_path38.default.basename(ecoPath);
+    const backupRegex = new RegExp(`^${escapeRegex2(base)}\\.bak-\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2}-\\d{2}-\\d{3}Z$`);
+    const existingBackups = files.filter((f) => backupRegex.test(f));
+    if (existingBackups.length >= 10) {
+      deps.log("Service config backup failed.");
+      return;
+    }
+    let now;
+    try {
+      now = deps.clock ? deps.clock() : /* @__PURE__ */ new Date();
+    } catch {
+      deps.log("Service config backup failed.");
+      return;
+    }
+    let iso;
+    try {
+      iso = now.toISOString();
+    } catch {
+      deps.log("Service config backup failed.");
+      return;
+    }
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(iso)) {
+      deps.log("Service config backup failed.");
+      return;
+    }
+    const ts = iso.replace(/:/g, "-").replace(/\./g, "-");
+    const backupPath = `${ecoPath}.bak-${ts}`;
+    deps.writeExclusiveFile(backupPath, existingText);
+  } catch {
+    deps.log("Service config backup failed.");
   }
-  return readExistingServiceApiTarget(deps, ecoPath) ?? {};
 }
 var SYSTEM_PATH_DIRS = ["/usr/bin", "/bin", "/usr/sbin", "/sbin"];
 function defaultHomeOwnerUid(home) {
@@ -71147,19 +71555,34 @@ function installService(deps) {
     /* @__PURE__ */ new Set([...resolvedBins.map((b) => import_node_path38.default.dirname(b)), ...systemDirs])
   ).join(import_node_path38.default.delimiter);
   const ecoPath = import_node_path38.default.join(home, ".mrrlin", "ecosystem.config.cjs");
-  const apiTarget = deriveServiceApiTarget(deps, ecoPath);
+  const existingText = deps.readFile ? deps.readFile(ecoPath) : null;
+  const parseResult = parseExistingEcosystemConfig(existingText);
+  if (parseResult.kind === "rejected") {
+    deps.log("Service config env carry skipped.");
+  }
+  if (existingText !== null && existingText !== void 0) {
+    performConfigBackup(deps, ecoPath, existingText);
+  }
+  const carriedEnv = parseResult.kind === "accepted" ? parseResult.env : /* @__PURE__ */ Object.create(null);
+  const { mergedEnv, preservedNames, droppedNames } = mergeConfigEnv(deps.env, carriedEnv);
+  const routedEnv = deriveMergedApiRouting(mergedEnv, deps.env.MRRLIN_BRIDGE_URL);
+  routedEnv.HOME = home;
+  routedEnv.PATH = pathEnv;
+  if (user !== void 0) {
+    routedEnv.USER = user;
+  }
+  if (preservedNames.length > 0) {
+    deps.log(`Service env preserved: ${preservedNames.join(", ")}.`);
+  }
+  if (droppedNames.length > 0) {
+    deps.log(`Service env dropped: ${droppedNames.join(", ")}.`);
+  }
   const text = renderEcosystemConfig({
     cwd: resolved.cwd,
-    home,
-    user,
-    codexHome: deps.env.CODEX_HOME?.trim() || void 0,
-    claudeConfigDir: deps.env.CLAUDE_CONFIG_DIR?.trim() || void 0,
-    pathEnv,
-    apiBaseUrl: apiTarget.apiBaseUrl,
-    apiAllowRemote: apiTarget.apiAllowRemote
+    env: routedEnv
   });
   deps.writeFile(ecoPath, text);
-  const start = deps.runPm2(["startOrReload", ecoPath, "--reset-env"]);
+  const start = deps.runPm2(["startOrReload", ecoPath, "--update-env"]);
   if (start.code !== 0) {
     deps.log(`pm2 startOrReload failed (exit ${start.code}).`);
     return { ok: false };
@@ -71782,6 +72205,15 @@ async function main() {
           (0, import_node_fs25.mkdirSync)(import_node_path42.default.dirname(p), { recursive: true, mode: 448 });
           (0, import_node_fs25.writeFileSync)(p, c, { mode: 384 });
         },
+        writeExclusiveFile: (p, c) => (0, import_node_fs25.writeFileSync)(p, c, { flag: "wx", mode: 384 }),
+        listDir: (p) => {
+          try {
+            return (0, import_node_fs25.readdirSync)(p);
+          } catch {
+            return null;
+          }
+        },
+        clock: () => /* @__PURE__ */ new Date(),
         // Swallows every error on purpose — the only caller uses this to recover settings from the
         // config it is about to overwrite, and a missing or unreadable file means "no previous
         // value", never a failed install. See readExistingTelemetryDefaultProject.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrlin-dev/mcp",
-  "version": "0.4.87",
+  "version": "0.4.88",
   "type": "module",
   "bin": {
     "mrrlin-mcp": "dist/bin.cjs"