@introspection-ai/recipes 0.18.1 → 0.19.0

package/dist/mcp-chunks/{chunk-6XCZGU3G.js → chunk-WXBPMFSN.js}

@@ -1,105 +1,89 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  configureAutoSelectFamilyAttemptTimeout
+} from "./chunk-64EP2BVO.js";
+import {
+  stableJsonStringify
+} from "./chunk-UHOKCTZT.js";
 import {
   createRuntime
-} from "./chunk-NNOEGEUZ.js";
+} from "./chunk-2FSDGCHW.js";
+import {
+  NON_INTERACTIVE_ELICITATION_HINT,
+  createNonInteractiveElicitationResponder
+} from "./chunk-CA5WFJZA.js";
 import {
-  listConfigLayerPaths,
-  loadDaemonConfig
-} from "./chunk-2U4BSDC4.js";
+  OAuthTimeoutError,
+  resolveOAuthTimeoutFromEnv
+} from "./chunk-SRZZQ6TL.js";
+import {
+  raceWithTimeout
+} from "./chunk-ETWN4IIA.js";
+import {
+  DEFAULT_REQUEST_TIMEOUT_MSEC,
+  SdkErrorCode
+} from "./chunk-YPJ5EHXR.js";
 import {
   launchDaemonDetached
-} from "./chunk-NRAJX5E4.js";
+} from "./chunk-YSPT6F7K.js";
 import {
   DaemonClient,
+  buildErrorResponse,
+  collectConfigLayers,
+  daemonIdleWatcherInterval,
+  delay,
+  ensureManaged,
+  evictIdleServers,
   getDaemonLogPath,
-  resolveDaemonPaths
-} from "./chunk-PWYFKGKG.js";
+  markActivity,
+  normalizeConfigLayers,
+  resolveDaemonPaths,
+  shouldShutdownDaemonForIdle,
+  statConfigMtime
+} from "./chunk-KSGYBW3F.js";
+import {
+  DAEMON_OPERATION_TIMEOUT_CODE,
+  DAEMON_PROGRESS_INTERVAL_MS,
+  DAEMON_PROTOCOL_VERSION,
+  encodeDaemonFrame
+} from "./chunk-ZBFZ5UFE.js";
 import {
+  loadConfigSnapshot
+} from "./chunk-L4VKBFYI.js";
+import {
+  isProcessRunning,
   readJsonFile,
   withFileLock,
   writeJsonFile
-} from "./chunk-2XL7MG7R.js";
+} from "./chunk-7A63PAGP.js";
 import {
   expandHome
-} from "./chunk-ECIVB7P4.js";
+} from "./chunk-HAO6PL7Z.js";
 import {
-  isKeepAliveServer,
-  keepAliveIdleTimeout
-} from "./chunk-LS7PMWSR.js";
+  isKeepAliveServer
+} from "./chunk-6D6KPSXN.js";
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/daemon-command.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/cli/daemon-command.js
 import fsPromises from "node:fs/promises";
-import path4 from "node:path";
-
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/daemon/host.js
-import { randomUUID } from "node:crypto";
-import fs2 from "node:fs/promises";
-import net from "node:net";
 import path3 from "node:path";
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/daemon/config-layers.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/daemon/host.js
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
-import path from "node:path";
-async function statConfigMtime(configPath) {
-  try {
-    const stats = await fs.stat(configPath);
-    return stats.mtimeMs;
-  } catch {
-    return null;
-  }
-}
-async function collectConfigLayers(options) {
-  const layerPaths = await listConfigLayerPaths(options, options.rootDir ?? process.cwd());
-  const entries = [];
-  for (const layerPath of layerPaths) {
-    entries.push({ path: layerPath, mtimeMs: await statConfigMtime(layerPath) });
-  }
-  if (entries.length === 0 && options.configPath) {
-    entries.push({ path: path.resolve(options.configPath), mtimeMs: await statConfigMtime(options.configPath) });
-  }
-  return entries;
-}
+import net from "node:net";
+import path2 from "node:path";
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/daemon/definition-hash.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/daemon/definition-hash.js
 import { createHash } from "node:crypto";
 function hashDaemonDefinitions(definitions) {
   const sorted = definitions.toSorted((a, b) => a.name.localeCompare(b.name));
   return createHash("sha256").update(stableJsonStringify(sorted)).digest("hex").slice(0, 16);
 }
-function stableJsonStringify(value) {
-  const json = JSON.stringify(sortJsonValue(value));
-  if (json === void 0) {
-    throw new TypeError("Cannot serialize unsupported JSON root value.");
-  }
-  return json;
-}
-function sortJsonValue(value) {
-  if (Array.isArray(value)) {
-    return value.map((entry) => sortJsonValue(entry));
-  }
-  if (!isPlainObject(value)) {
-    return value;
-  }
-  const result = {};
-  for (const key of Object.keys(value).toSorted()) {
-    const entry = value[key];
-    if (entry !== void 0) {
-      result[key] = sortJsonValue(entry);
-    }
-  }
-  return result;
-}
-function isPlainObject(value) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/daemon/log-context.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/daemon/log-context.js
 import fsSync from "node:fs";
-import path2 from "node:path";
+import path from "node:path";
 function createLogContext(options) {
   const derivedEnabled = options.enabled || options.logAllServers || options.servers.size > 0;
   const context = {
@@ -109,7 +93,7 @@ function createLogContext(options) {
   };
   if (derivedEnabled && options.logPath) {
     try {
-      fsSync.mkdirSync(path2.dirname(options.logPath), { recursive: true });
+      fsSync.mkdirSync(path.dirname(options.logPath), { recursive: true });
       context.writer = fsSync.createWriteStream(options.logPath, {
         flags: "a"
       });
@@ -160,80 +144,19 @@ function formatError(error) {
   return "unknown";
 }
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/daemon/request-utils.js
-function ensureManaged(server, managedServers) {
-  if (!managedServers.has(server)) {
-    throw new Error(`Server '${server}' is not managed by the daemon.`);
-  }
-}
-function markActivity(server, activity) {
-  const entry = activity.get(server);
-  if (entry) {
-    entry.connected = true;
-    entry.lastUsedAt = Date.now();
-  } else {
-    activity.set(server, { connected: true, lastUsedAt: Date.now() });
-  }
-}
-async function evictIdleServers(runtime, managedServers, activity) {
-  const now = Date.now();
-  await Promise.all(Array.from(managedServers.entries()).map(async ([name, definition]) => {
-    const timeout = keepAliveIdleTimeout(definition);
-    if (!timeout) {
-      return;
-    }
-    const entry = activity.get(name);
-    if (!entry?.lastUsedAt) {
-      return;
-    }
-    if (now - entry.lastUsedAt < timeout) {
-      return;
-    }
-    await runtime.close(name).catch(() => {
-    });
-    activity.set(name, { connected: false });
-  }));
-}
-function shouldShutdownDaemonForIdle(lastActivityAt, now, idleTimeoutMs, activeRequests = 0) {
-  return activeRequests <= 0 && typeof idleTimeoutMs === "number" && idleTimeoutMs > 0 && now - lastActivityAt >= idleTimeoutMs;
-}
-function daemonIdleWatcherInterval(idleTimeoutMs) {
-  if (!idleTimeoutMs) {
-    return 3e4;
-  }
-  return Math.min(3e4, Math.max(100, Math.floor(idleTimeoutMs / 2)));
-}
-function buildErrorResponse(id, code, error) {
-  let message = code;
-  if (error instanceof Error) {
-    message = error.message;
-  } else if (typeof error === "string") {
-    message = error;
-  }
-  return {
-    id,
-    ok: false,
-    error: {
-      code,
-      message
-    }
-  };
-}
-
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/daemon/host.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/daemon/host.js
+var daemonRequestNotices = new AsyncLocalStorage();
 async function runDaemonHost(options) {
+  configureAutoSelectFamilyAttemptTimeout();
   const configLayers = await collectConfigLayers({
     configPath: options.configExplicit ? options.configPath : void 0,
     rootDir: options.rootDir
   });
-  const daemonConfig = await loadDaemonConfig({
-    configPath: options.configExplicit ? options.configPath : void 0,
-    rootDir: options.rootDir
-  });
-  const runtime = await createRuntime({
+  const startup = await loadDaemonRuntimeState({
     configPath: options.configExplicit ? options.configPath : void 0,
     rootDir: options.rootDir
   });
+  const { daemonConfig, runtime } = startup;
   const keepAliveDefinitions = runtime.getDefinitions().filter(isKeepAliveServer);
   const definitionHash = hashDaemonDefinitions(keepAliveDefinitions);
   if (keepAliveDefinitions.length === 0) {
@@ -259,7 +182,7 @@ async function runDaemonHost(options) {
     servers: combinedServerLogs,
     logPath: options.logPath
   });
-  await fs2.mkdir(path3.dirname(options.metadataPath), { recursive: true });
+  await fs.mkdir(path2.dirname(options.metadataPath), { recursive: true });
   const configMtimeMs = await statConfigMtime(options.configPath);
   const activity = /* @__PURE__ */ new Map();
   for (const definition of keepAliveDefinitions) {
@@ -323,6 +246,7 @@ async function runDaemonHost(options) {
         configPath: options.configPath,
         configLayers,
         socketPath: options.socketPath,
+        protocolVersion: DAEMON_PROTOCOL_VERSION,
         startedAt,
         logPath: options.logPath ?? null,
         configMtimeMs,
@@ -367,6 +291,7 @@ async function runDaemonHost(options) {
     });
     await writeJsonFile(options.metadataPath, {
       pid: process.pid,
+      protocolVersion: DAEMON_PROTOCOL_VERSION,
       socketPath: options.socketPath,
       configPath: options.configPath,
       configLayers,
@@ -390,10 +315,20 @@ async function runDaemonHost(options) {
   process.once("SIGTERM", shutdown);
   process.once("SIGQUIT", shutdown);
 }
+async function loadDaemonRuntimeState(options) {
+  const snapshot = await loadConfigSnapshot(options);
+  const elicitation = createNonInteractiveElicitationResponder({
+    onDecline: () => daemonRequestNotices.getStore()?.add(NON_INTERACTIVE_ELICITATION_HINT)
+  });
+  return {
+    daemonConfig: snapshot.daemon,
+    runtime: await createRuntime({ servers: snapshot.servers, elicitationHandler: elicitation.handler })
+  };
+}
 var DAEMON_PROBE_TIMEOUT_MS = 2e3;
 async function probeLiveDaemon(socketPath) {
   const status = await probeDaemonStatus(socketPath);
-  if (!status || status.socketPath !== socketPath || !isProcessAlive(status.pid)) {
+  if (!status || status.socketPath !== socketPath || !isProcessRunning(status.pid)) {
     return null;
   }
   return status;
@@ -409,6 +344,7 @@ async function metadataMatches(metadataPath, live) {
 function metadataFromStatus(status, fallbackConfigLayers) {
   return {
     pid: status.pid,
+    protocolVersion: status.protocolVersion,
     socketPath: status.socketPath,
     configPath: status.configPath,
     configLayers: status.configLayers && status.configLayers.length > 0 ? status.configLayers : fallbackConfigLayers,
@@ -422,8 +358,8 @@ function daemonConfigMatches(live, currentLayers, currentConfigPath, currentConf
   if (live.definitionHash !== currentDefinitionHash) {
     return false;
   }
-  const liveLayers = normalizeLayers(live.configLayers && live.configLayers.length > 0 ? live.configLayers : [{ path: live.configPath, mtimeMs: live.configMtimeMs ?? null }]);
-  const expectedLayers = normalizeLayers(currentLayers.length > 0 ? currentLayers : [{ path: currentConfigPath, mtimeMs: currentConfigMtimeMs }]);
+  const liveLayers = normalizeConfigLayers(live.configLayers && live.configLayers.length > 0 ? live.configLayers : [{ path: live.configPath, mtimeMs: live.configMtimeMs ?? null }]);
+  const expectedLayers = normalizeConfigLayers(currentLayers.length > 0 ? currentLayers : [{ path: currentConfigPath, mtimeMs: currentConfigMtimeMs }]);
   if (liveLayers.length !== expectedLayers.length) {
     return false;
   }
@@ -432,16 +368,6 @@ function daemonConfigMatches(live, currentLayers, currentConfigPath, currentConf
     return Boolean(expected && entry.path === expected.path && entry.mtimeMs === expected.mtimeMs);
   });
 }
-function normalizeLayers(layers) {
-  const normalized = layers.map((entry) => ({
-    path: path3.isAbsolute(entry.path) ? entry.path : path3.resolve(entry.path),
-    mtimeMs: entry.mtimeMs ?? null
-  }));
-  if (normalized.length < 2) {
-    return normalized;
-  }
-  return normalized.toSorted((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
-}
 async function stopLiveDaemon(socketPath, livePid) {
   const stopped = await sendDaemonStop(socketPath);
   if (!stopped) {
@@ -449,7 +375,7 @@ async function stopLiveDaemon(socketPath, livePid) {
   }
   const deadline = Date.now() + 5e3;
   while (Date.now() < deadline) {
-    if (!isProcessAlive(livePid)) {
+    if (!isProcessRunning(livePid)) {
       return;
     }
     await delay(100);
@@ -493,22 +419,6 @@ async function sendDaemonStop(socketPath) {
     socket.once("error", () => finish(false));
   });
 }
-function delay(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-function isProcessAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) {
-    return false;
-  }
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-}
 async function probeDaemonStatus(socketPath) {
   return await new Promise((resolve) => {
     const probe = net.createConnection(socketPath);
@@ -551,13 +461,13 @@ async function prepareSocket(socketPath) {
     return;
   }
   try {
-    await fs2.unlink(socketPath);
+    await fs.unlink(socketPath);
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;
     }
   }
-  await fs2.mkdir(path3.dirname(socketPath), { recursive: true });
+  await fs.mkdir(path2.dirname(socketPath), { recursive: true });
 }
 async function cleanupArtifacts(options) {
   await cleanupDaemonArtifactsIfOwned(options, process.pid);
@@ -568,15 +478,22 @@ async function cleanupDaemonArtifactsIfOwned(paths, ownerPid) {
     return;
   }
   if (process.platform !== "win32") {
-    await fs2.unlink(paths.socketPath).catch(() => {
+    await fs.unlink(paths.socketPath).catch(() => {
     });
   }
-  await fs2.unlink(paths.metadataPath).catch(() => {
+  await fs.unlink(paths.metadataPath).catch(() => {
   });
 }
 async function handleSocketRequest(rawPayload, socket, runtime, managedServers, activity, metadata, logContext, shutdown, preParsedRequest) {
-  const { response, shouldShutdown } = await processRequest(rawPayload, runtime, managedServers, activity, metadata, logContext, preParsedRequest);
-  socket.write(JSON.stringify(response), () => {
+  const stopProgress = startProgressFrames(socket, preParsedRequest);
+  let response;
+  let shouldShutdown;
+  try {
+    ({ response, shouldShutdown } = await processRequestWithNotices(rawPayload, runtime, managedServers, activity, metadata, logContext, preParsedRequest));
+  } finally {
+    stopProgress();
+  }
+  socket.write(encodeDaemonFrame(response), () => {
     socket.end(() => {
       if (shouldShutdown) {
         void shutdown();
@@ -584,9 +501,47 @@ async function handleSocketRequest(rawPayload, socket, runtime, managedServers,
     });
   });
 }
+function startProgressFrames(socket, request) {
+  if (request?.protocolVersion !== DAEMON_PROTOCOL_VERSION || typeof request.progressIntervalMs !== "number" || !Number.isFinite(request.progressIntervalMs) || request.progressIntervalMs <= 0) {
+    return () => {
+    };
+  }
+  const intervalMs = Math.min(request.progressIntervalMs, DAEMON_PROGRESS_INTERVAL_MS);
+  const emit = () => {
+    if (!socket.destroyed && !socket.writableEnded) {
+      socket.write(encodeDaemonFrame({ type: "progress", id: request.id }));
+    }
+  };
+  emit();
+  const timer = setInterval(emit, intervalMs);
+  timer.unref();
+  return () => clearInterval(timer);
+}
 function normalizeDaemonDisableOAuth(value) {
   return value === true;
 }
+function operationCeilingMs(requestTimeoutMs) {
+  const requestPhase = typeof requestTimeoutMs === "number" && Number.isFinite(requestTimeoutMs) && requestTimeoutMs > 0 ? requestTimeoutMs : DEFAULT_REQUEST_TIMEOUT_MSEC;
+  return resolveOAuthTimeoutFromEnv() + requestPhase;
+}
+function daemonRuntimeErrorCode(error) {
+  const errorCode = error && typeof error === "object" ? error.code : void 0;
+  if (error instanceof OAuthTimeoutError || errorCode === SdkErrorCode.RequestTimeout || error instanceof Error && error.message === "Timeout") {
+    return DAEMON_OPERATION_TIMEOUT_CODE;
+  }
+  return "runtime_error";
+}
+async function processRequestWithNotices(...args) {
+  const notices = /* @__PURE__ */ new Set();
+  const processed = await daemonRequestNotices.run(notices, () => processRequest(...args));
+  if (notices.size === 0) {
+    return processed;
+  }
+  return {
+    ...processed,
+    response: { ...processed.response, notices: [...notices] }
+  };
+}
 async function processRequest(rawPayload, runtime, managedServers, activity, metadata, logContext, preParsedRequest) {
   const trimmed = rawPayload.trim();
   if (!trimmed && !preParsedRequest) {
@@ -619,11 +574,11 @@ async function processRequest(rawPayload, runtime, managedServers, activity, met
           logEvent(logContext, `callTool start server=${params.server} tool=${params.tool}`);
         }
         try {
-          const result = await runtime.callTool(params.server, params.tool, {
+          const result = await raceWithTimeout(runtime.callTool(params.server, params.tool, {
             args: params.args ?? {},
             timeoutMs: params.timeoutMs,
             disableOAuth: normalizeDaemonDisableOAuth(params.disableOAuth)
-          });
+          }), operationCeilingMs(params.timeoutMs));
           markActivity(params.server, activity);
           if (loggable) {
             logEvent(logContext, `callTool success server=${params.server} tool=${params.tool}`);
@@ -646,12 +601,13 @@ async function processRequest(rawPayload, runtime, managedServers, activity, met
           logEvent(logContext, `listTools start server=${params.server}`);
         }
         try {
-          const result = await runtime.listTools(params.server, {
+          const result = await raceWithTimeout(runtime.listTools(params.server, {
             includeSchema: params.includeSchema,
             autoAuthorize: resolveDaemonListToolsAutoAuthorize(params, definition),
             allowCachedAuth: params.allowCachedAuth ?? true,
-            disableOAuth: normalizeDaemonDisableOAuth(params.disableOAuth)
-          });
+            disableOAuth: normalizeDaemonDisableOAuth(params.disableOAuth),
+            timeoutMs: params.timeoutMs
+          }), operationCeilingMs(params.timeoutMs));
           markActivity(params.server, activity);
           if (loggable) {
             logEvent(logContext, `listTools success server=${params.server}`);
@@ -673,11 +629,11 @@ async function processRequest(rawPayload, runtime, managedServers, activity, met
           logEvent(logContext, `listResources start server=${params.server}`);
         }
         try {
-          const result = await runtime.listResources(params.server, {
+          const result = await raceWithTimeout(runtime.listResources(params.server, {
             ...params.params,
             allowCachedAuth: params.allowCachedAuth,
             disableOAuth: normalizeDaemonDisableOAuth(params.disableOAuth)
-          });
+          }), operationCeilingMs());
           markActivity(params.server, activity);
           if (loggable) {
             logEvent(logContext, `listResources success server=${params.server}`);
@@ -699,10 +655,10 @@ async function processRequest(rawPayload, runtime, managedServers, activity, met
           logEvent(logContext, `readResource start server=${params.server} uri=${params.uri}`);
         }
         try {
-          const result = await runtime.readResource(params.server, params.uri, {
+          const result = await raceWithTimeout(runtime.readResource(params.server, params.uri, {
             allowCachedAuth: params.allowCachedAuth,
             disableOAuth: normalizeDaemonDisableOAuth(params.disableOAuth)
-          });
+          }), operationCeilingMs());
           markActivity(params.server, activity);
           if (loggable) {
             logEvent(logContext, `readResource success server=${params.server}`);
@@ -724,7 +680,7 @@ async function processRequest(rawPayload, runtime, managedServers, activity, met
           logEvent(logContext, `closeServer start server=${params.server}`);
         }
         try {
-          await runtime.close(params.server);
+          await raceWithTimeout(runtime.close(params.server), operationCeilingMs());
           activity.set(params.server, { connected: false });
           if (loggable) {
             logEvent(logContext, `closeServer success server=${params.server}`);
@@ -744,6 +700,7 @@ async function processRequest(rawPayload, runtime, managedServers, activity, met
       case "status": {
         const result = {
           pid: process.pid,
+          protocolVersion: metadata.protocolVersion ?? DAEMON_PROTOCOL_VERSION,
           startedAt: metadata.startedAt,
           configPath: metadata.configPath,
           configLayers: metadata.configLayers,
@@ -777,7 +734,7 @@ async function processRequest(rawPayload, runtime, managedServers, activity, met
     }
   } catch (error) {
     return {
-      response: buildErrorResponse(id, "runtime_error", error),
+      response: buildErrorResponse(id, daemonRuntimeErrorCode(error), error),
       shouldShutdown: false
     };
   }
@@ -789,7 +746,7 @@ function resolveDaemonListToolsAutoAuthorize(params, definition) {
   return params.autoAuthorize;
 }
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/daemon-command.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/cli/daemon-command.js
 async function handleDaemonCli(args, options) {
   const subcommand = args.shift();
   if (!subcommand || subcommand === "help" || subcommand === "--help") {
@@ -971,8 +928,8 @@ async function resolveDaemonLoggingOptions(args, configKey) {
   const envLogServers = process.env.MCPORTER_DAEMON_LOG_SERVERS;
   const serverFilter = parseServerList(logServersValue ?? envLogServers);
   const explicitServerLogging = serverFilter.size > 0;
-  const resolvedFileFlag = logFileValue ? path4.resolve(expandHome(logFileValue)) : void 0;
-  const resolvedEnvFile = envLogPath ? path4.resolve(expandHome(envLogPath)) : void 0;
+  const resolvedFileFlag = logFileValue ? path3.resolve(expandHome(logFileValue)) : void 0;
+  const resolvedEnvFile = envLogPath ? path3.resolve(expandHome(envLogPath)) : void 0;
   const enabled = logFlag || Boolean(resolvedFileFlag) || envLogEnabled || Boolean(resolvedEnvFile) || explicitServerLogging;
   if (!enabled) {
     return {
@@ -983,7 +940,7 @@ async function resolveDaemonLoggingOptions(args, configKey) {
     };
   }
   const logPath = resolvedFileFlag ?? resolvedEnvFile ?? getDaemonLogPath(configKey);
-  await fsPromises.mkdir(path4.dirname(logPath), { recursive: true });
+  await fsPromises.mkdir(path3.dirname(logPath), { recursive: true });
   return {
     enabled: true,
     logPath,

package/dist/mcp-chunks/{chunk-XQK2JSW4.js → chunk-XRGLP3Z2.js}

@@ -1,6 +1,6 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/flag-utils.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/cli/flag-utils.js
 function extractFlags(args, keys) {
   const flags = {};
   let index = 0;
@@ -28,8 +28,20 @@ function expectValue(flag, value) {
   }
   return value;
 }
+function consumeMatchingTokens(args, predicate) {
+  let found = false;
+  for (let index = args.length - 1; index >= 0; index -= 1) {
+    const token = args[index];
+    if (token && predicate(token)) {
+      args.splice(index, 1);
+      found = true;
+    }
+  }
+  return found;
+}
 
 export {
   extractFlags,
-  expectValue
+  expectValue,
+  consumeMatchingTokens
 };

package/dist/mcp-chunks/{chunk-L7NTQVYN.js → chunk-XTL4MHFH.js}

@@ -1,13 +1,18 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
-  isKeepAliveServer
-} from "./chunk-LS7PMWSR.js";
+  isUnauthorizedError
+} from "./chunk-7DH57OKF.js";
+import {
+  ProtocolErrorCode
+} from "./chunk-YPJ5EHXR.js";
+import {
+  DAEMON_OPERATION_TIMEOUT_CODE
+} from "./chunk-ZBFZ5UFE.js";
 import {
-  ErrorCode,
-  McpError
-} from "./chunk-D3MRAZ6H.js";
+  isKeepAliveServer
+} from "./chunk-6D6KPSXN.js";
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/daemon/runtime-wrapper.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/daemon/runtime-wrapper.js
 function createKeepAliveRuntime(base, options) {
   if (!options.daemonClient || options.keepAliveServers.size === 0) {
     return base;
@@ -54,7 +59,8 @@ var KeepAliveRuntime = class {
         includeSchema: options?.includeSchema,
         autoAuthorize: options?.autoAuthorize,
         allowCachedAuth: options?.allowCachedAuth ?? true,
-        disableOAuth: options?.disableOAuth
+        disableOAuth: options?.disableOAuth,
+        timeoutMs: options?.timeoutMs
       }));
     }
     return this.base.listTools(server, options);
@@ -141,16 +147,28 @@ var KeepAliveRuntime = class {
     }
   }
 };
-var NON_FATAL_CODES = /* @__PURE__ */ new Set([ErrorCode.InvalidRequest, ErrorCode.MethodNotFound, ErrorCode.InvalidParams]);
+var NON_FATAL_CODES = /* @__PURE__ */ new Set([ProtocolErrorCode.InvalidRequest, ProtocolErrorCode.MethodNotFound, ProtocolErrorCode.InvalidParams]);
 function shouldRestartDaemonServer(error) {
   if (!error) {
     return false;
   }
-  if (error instanceof McpError) {
-    return !NON_FATAL_CODES.has(error.code);
+  if (typeof error === "object" && error.code === DAEMON_OPERATION_TIMEOUT_CODE) {
+    return false;
+  }
+  if (isUnauthorizedError(error)) {
+    return false;
+  }
+  const code = protocolErrorCode(error);
+  if (code !== void 0) {
+    return !NON_FATAL_CODES.has(code);
   }
   return true;
 }
+function protocolErrorCode(error) {
+  if (!error || typeof error !== "object" || !("code" in error))
+    return void 0;
+  return typeof error.code === "number" ? error.code : void 0;
+}
 function logDaemonRetry(server, operation, error) {
   const reason = error instanceof Error ? error.message : String(error);
   console.error(`[mcporter] Restarting '${server}' before retrying ${operation}: ${reason}`);

package/dist/mcp-chunks/{chunk-N46NEFAF.js → chunk-XUF6KARU.js}

@@ -1,6 +1,6 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/terminal.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/cli/terminal.js
 var forceColorRaw = process.env.FORCE_COLOR?.toLowerCase();
 var forceDisableColor = forceColorRaw === "0" || forceColorRaw === "false";
 var forceEnableColor = forceColorRaw === "1" || forceColorRaw === "true" || forceColorRaw === "2" || forceColorRaw === "3";