@introspection-ai/recipes 0.13.0 → 0.14.1

package/dist/mcp-chunks/chunk-6XCZGU3G.js

@@ -0,0 +1,1004 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  createRuntime
+} from "./chunk-NNOEGEUZ.js";
+import {
+  listConfigLayerPaths,
+  loadDaemonConfig
+} from "./chunk-2U4BSDC4.js";
+import {
+  launchDaemonDetached
+} from "./chunk-NRAJX5E4.js";
+import {
+  DaemonClient,
+  getDaemonLogPath,
+  resolveDaemonPaths
+} from "./chunk-PWYFKGKG.js";
+import {
+  readJsonFile,
+  withFileLock,
+  writeJsonFile
+} from "./chunk-2XL7MG7R.js";
+import {
+  expandHome
+} from "./chunk-ECIVB7P4.js";
+import {
+  isKeepAliveServer,
+  keepAliveIdleTimeout
+} from "./chunk-LS7PMWSR.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/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
+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;
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/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
+import fsSync from "node:fs";
+import path2 from "node:path";
+function createLogContext(options) {
+  const derivedEnabled = options.enabled || options.logAllServers || options.servers.size > 0;
+  const context = {
+    enabled: derivedEnabled,
+    logAllServers: options.logAllServers,
+    servers: options.servers
+  };
+  if (derivedEnabled && options.logPath) {
+    try {
+      fsSync.mkdirSync(path2.dirname(options.logPath), { recursive: true });
+      context.writer = fsSync.createWriteStream(options.logPath, {
+        flags: "a"
+      });
+    } catch (error) {
+      console.warn(`[daemon] Failed to open log file ${options.logPath}: ${error.message}`);
+    }
+  }
+  return context;
+}
+function logEvent(context, message) {
+  if (!context.enabled) {
+    return;
+  }
+  const line = `[daemon] ${(/* @__PURE__ */ new Date()).toISOString()} ${message}`;
+  console.log(line);
+  try {
+    context.writer?.write(`${line}
+`);
+  } catch {
+  }
+}
+async function disposeLogContext(context) {
+  const writer = context.writer;
+  if (!writer) {
+    return;
+  }
+  await new Promise((resolve) => {
+    writer.end(() => resolve());
+    writer.on("error", () => resolve());
+  });
+}
+function shouldLogServer(context, server) {
+  if (!context.enabled) {
+    return false;
+  }
+  if (context.logAllServers) {
+    return true;
+  }
+  return context.servers.has(server);
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return 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
+async function runDaemonHost(options) {
+  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({
+    configPath: options.configExplicit ? options.configPath : void 0,
+    rootDir: options.rootDir
+  });
+  const keepAliveDefinitions = runtime.getDefinitions().filter(isKeepAliveServer);
+  const definitionHash = hashDaemonDefinitions(keepAliveDefinitions);
+  if (keepAliveDefinitions.length === 0) {
+    throw new Error("No MCP servers require keep-alive; daemon will not start.");
+  }
+  const managedServers = /* @__PURE__ */ new Map();
+  for (const definition of keepAliveDefinitions) {
+    managedServers.set(definition.name, definition);
+  }
+  const serverLoggingOverrides = /* @__PURE__ */ new Set();
+  for (const definition of keepAliveDefinitions) {
+    if (definition.logging?.daemon?.enabled) {
+      serverLoggingOverrides.add(definition.name);
+    }
+  }
+  const combinedServerLogs = /* @__PURE__ */ new Set([
+    ...serverLoggingOverrides,
+    ...options.logServers ? Array.from(options.logServers) : []
+  ]);
+  const logContext = createLogContext({
+    enabled: Boolean(options.logPath),
+    logAllServers: options.logAllServers ?? false,
+    servers: combinedServerLogs,
+    logPath: options.logPath
+  });
+  await fs2.mkdir(path3.dirname(options.metadataPath), { recursive: true });
+  const configMtimeMs = await statConfigMtime(options.configPath);
+  const activity = /* @__PURE__ */ new Map();
+  for (const definition of keepAliveDefinitions) {
+    activity.set(definition.name, { connected: false });
+  }
+  let shuttingDown = false;
+  let idleWatcher;
+  const shutdown = async () => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    logEvent(logContext, "Shutting down daemon host.");
+    if (idleWatcher) {
+      clearInterval(idleWatcher);
+    }
+    server.close();
+    await runtime.close().catch(() => {
+    });
+    await disposeLogContext(logContext).catch(() => {
+    });
+    await cleanupArtifacts(options);
+    process.exit(0);
+  };
+  let lastDaemonActivityAt = Date.now();
+  let activeDaemonRequests = 0;
+  idleWatcher = setInterval(() => {
+    void (async () => {
+      await evictIdleServers(runtime, managedServers, activity);
+      if (shouldShutdownDaemonForIdle(lastDaemonActivityAt, Date.now(), daemonConfig.idleTimeoutMs, activeDaemonRequests)) {
+        logEvent(logContext, "Daemon idle timeout reached.");
+        await shutdown();
+      }
+    })();
+  }, daemonIdleWatcherInterval(daemonConfig.idleTimeoutMs));
+  idleWatcher.unref();
+  logEvent(logContext, "Daemon host started.");
+  const startedAt = Date.now();
+  const server = net.createServer({ allowHalfOpen: true }, (socket) => {
+    socket.setEncoding("utf8");
+    let buffer = "";
+    let handled = false;
+    const tryHandle = () => {
+      if (handled) {
+        return;
+      }
+      const trimmed = buffer.trim();
+      if (trimmed.length === 0) {
+        return;
+      }
+      let parsedRequest;
+      try {
+        parsedRequest = JSON.parse(trimmed);
+      } catch {
+        return;
+      }
+      handled = true;
+      lastDaemonActivityAt = Date.now();
+      activeDaemonRequests += 1;
+      void handleSocketRequest(trimmed, socket, runtime, managedServers, activity, {
+        configPath: options.configPath,
+        configLayers,
+        socketPath: options.socketPath,
+        startedAt,
+        logPath: options.logPath ?? null,
+        configMtimeMs,
+        definitionHash
+      }, logContext, shutdown, parsedRequest).finally(() => {
+        activeDaemonRequests -= 1;
+        lastDaemonActivityAt = Date.now();
+      });
+    };
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      tryHandle();
+    });
+    socket.on("end", () => {
+      if (!handled) {
+        tryHandle();
+      }
+    });
+    socket.on("error", () => {
+      socket.destroy();
+    });
+  });
+  let claimed = false;
+  await withFileLock(`${options.metadataPath}.bind`, async () => {
+    const live = await probeLiveDaemon(options.socketPath);
+    if (live) {
+      if (daemonConfigMatches(live, configLayers, options.configPath, configMtimeMs, definitionHash)) {
+        if (!await metadataMatches(options.metadataPath, live)) {
+          await writeJsonFile(options.metadataPath, metadataFromStatus(live, configLayers));
+        }
+        return;
+      }
+      await stopLiveDaemon(options.socketPath, live.pid);
+    }
+    await prepareSocket(options.socketPath);
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(options.socketPath, () => {
+        server.off("error", reject);
+        resolve();
+      });
+    });
+    await writeJsonFile(options.metadataPath, {
+      pid: process.pid,
+      socketPath: options.socketPath,
+      configPath: options.configPath,
+      configLayers,
+      startedAt: Date.now(),
+      logPath: options.logPath ?? null,
+      configMtimeMs,
+      definitionHash
+    });
+    claimed = true;
+  });
+  if (!claimed) {
+    logEvent(logContext, "Daemon already running for this config; exiting without rebinding.");
+    server.close();
+    await runtime.close().catch(() => {
+    });
+    await disposeLogContext(logContext).catch(() => {
+    });
+    process.exit(0);
+  }
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+  process.once("SIGQUIT", shutdown);
+}
+var DAEMON_PROBE_TIMEOUT_MS = 2e3;
+async function probeLiveDaemon(socketPath) {
+  const status = await probeDaemonStatus(socketPath);
+  if (!status || status.socketPath !== socketPath || !isProcessAlive(status.pid)) {
+    return null;
+  }
+  return status;
+}
+async function metadataMatches(metadataPath, live) {
+  try {
+    const existing = await readJsonFile(metadataPath);
+    return existing?.pid === live.pid && existing?.socketPath === live.socketPath;
+  } catch {
+    return false;
+  }
+}
+function metadataFromStatus(status, fallbackConfigLayers) {
+  return {
+    pid: status.pid,
+    socketPath: status.socketPath,
+    configPath: status.configPath,
+    configLayers: status.configLayers && status.configLayers.length > 0 ? status.configLayers : fallbackConfigLayers,
+    startedAt: status.startedAt,
+    logPath: status.logPath ?? null,
+    configMtimeMs: status.configMtimeMs ?? null,
+    definitionHash: status.definitionHash
+  };
+}
+function daemonConfigMatches(live, currentLayers, currentConfigPath, currentConfigMtimeMs, currentDefinitionHash) {
+  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 }]);
+  if (liveLayers.length !== expectedLayers.length) {
+    return false;
+  }
+  return liveLayers.every((entry, index) => {
+    const expected = expectedLayers[index];
+    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) {
+    throw new Error("Live daemon did not accept stop before rebinding.");
+  }
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(livePid)) {
+      return;
+    }
+    await delay(100);
+  }
+  throw new Error("Live daemon did not stop before rebinding.");
+}
+async function sendDaemonStop(socketPath) {
+  return await new Promise((resolve) => {
+    const request = {
+      id: randomUUID(),
+      method: "stop",
+      params: {}
+    };
+    const socket = net.createConnection(socketPath);
+    let buffer = "";
+    let settled = false;
+    const finish = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve(result);
+    };
+    socket.setTimeout(DAEMON_PROBE_TIMEOUT_MS, () => finish(false));
+    socket.once("connect", () => {
+      socket.write(JSON.stringify(request));
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString();
+    });
+    socket.once("end", () => {
+      try {
+        const response = JSON.parse(buffer.trim());
+        finish(response.ok);
+      } catch {
+        finish(false);
+      }
+    });
+    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);
+    let buffer = "";
+    let settled = false;
+    const finish = (status) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      probe.removeAllListeners();
+      probe.destroy();
+      resolve(status);
+    };
+    const parse = () => {
+      try {
+        const response = JSON.parse(buffer.trim());
+        return response.ok && response.result ? response.result : null;
+      } catch {
+        return null;
+      }
+    };
+    probe.setTimeout(DAEMON_PROBE_TIMEOUT_MS, () => finish(null));
+    probe.once("connect", () => {
+      probe.write(JSON.stringify({ id: randomUUID(), method: "status", params: {} }));
+    });
+    probe.on("data", (chunk) => {
+      buffer += chunk.toString();
+      const status = parse();
+      if (status) {
+        finish(status);
+      }
+    });
+    probe.once("end", () => finish(parse()));
+    probe.once("error", () => finish(null));
+  });
+}
+async function prepareSocket(socketPath) {
+  if (process.platform === "win32") {
+    return;
+  }
+  try {
+    await fs2.unlink(socketPath);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  await fs2.mkdir(path3.dirname(socketPath), { recursive: true });
+}
+async function cleanupArtifacts(options) {
+  await cleanupDaemonArtifactsIfOwned(options, process.pid);
+}
+async function cleanupDaemonArtifactsIfOwned(paths, ownerPid) {
+  const metadata = await readJsonFile(paths.metadataPath).catch(() => void 0);
+  if (metadata?.pid !== ownerPid || metadata.socketPath !== paths.socketPath) {
+    return;
+  }
+  if (process.platform !== "win32") {
+    await fs2.unlink(paths.socketPath).catch(() => {
+    });
+  }
+  await fs2.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), () => {
+    socket.end(() => {
+      if (shouldShutdown) {
+        void shutdown();
+      }
+    });
+  });
+}
+function normalizeDaemonDisableOAuth(value) {
+  return value === true;
+}
+async function processRequest(rawPayload, runtime, managedServers, activity, metadata, logContext, preParsedRequest) {
+  const trimmed = rawPayload.trim();
+  if (!trimmed && !preParsedRequest) {
+    return {
+      response: buildErrorResponse("unknown", "empty_request"),
+      shouldShutdown: false
+    };
+  }
+  let request;
+  if (preParsedRequest) {
+    request = preParsedRequest;
+  } else {
+    try {
+      request = JSON.parse(trimmed);
+    } catch (error) {
+      return {
+        response: buildErrorResponse("unknown", "invalid_json", error),
+        shouldShutdown: false
+      };
+    }
+  }
+  const id = request.id ?? "unknown";
+  try {
+    switch (request.method) {
+      case "callTool": {
+        const params = request.params;
+        ensureManaged(params.server, managedServers);
+        const loggable = shouldLogServer(logContext, params.server);
+        if (loggable) {
+          logEvent(logContext, `callTool start server=${params.server} tool=${params.tool}`);
+        }
+        try {
+          const result = await runtime.callTool(params.server, params.tool, {
+            args: params.args ?? {},
+            timeoutMs: params.timeoutMs,
+            disableOAuth: normalizeDaemonDisableOAuth(params.disableOAuth)
+          });
+          markActivity(params.server, activity);
+          if (loggable) {
+            logEvent(logContext, `callTool success server=${params.server} tool=${params.tool}`);
+          }
+          return { response: { id, ok: true, result }, shouldShutdown: false };
+        } catch (error) {
+          if (loggable) {
+            const detail = formatError(error);
+            logEvent(logContext, `callTool error server=${params.server} tool=${params.tool} err=${detail}`);
+          }
+          throw error;
+        }
+      }
+      case "listTools": {
+        const params = request.params;
+        ensureManaged(params.server, managedServers);
+        const definition = managedServers.get(params.server);
+        const loggable = shouldLogServer(logContext, params.server);
+        if (loggable) {
+          logEvent(logContext, `listTools start server=${params.server}`);
+        }
+        try {
+          const result = await runtime.listTools(params.server, {
+            includeSchema: params.includeSchema,
+            autoAuthorize: resolveDaemonListToolsAutoAuthorize(params, definition),
+            allowCachedAuth: params.allowCachedAuth ?? true,
+            disableOAuth: normalizeDaemonDisableOAuth(params.disableOAuth)
+          });
+          markActivity(params.server, activity);
+          if (loggable) {
+            logEvent(logContext, `listTools success server=${params.server}`);
+          }
+          return { response: { id, ok: true, result }, shouldShutdown: false };
+        } catch (error) {
+          if (loggable) {
+            const detail = formatError(error);
+            logEvent(logContext, `listTools error server=${params.server} err=${detail}`);
+          }
+          throw error;
+        }
+      }
+      case "listResources": {
+        const params = request.params;
+        ensureManaged(params.server, managedServers);
+        const loggable = shouldLogServer(logContext, params.server);
+        if (loggable) {
+          logEvent(logContext, `listResources start server=${params.server}`);
+        }
+        try {
+          const result = await runtime.listResources(params.server, {
+            ...params.params,
+            allowCachedAuth: params.allowCachedAuth,
+            disableOAuth: normalizeDaemonDisableOAuth(params.disableOAuth)
+          });
+          markActivity(params.server, activity);
+          if (loggable) {
+            logEvent(logContext, `listResources success server=${params.server}`);
+          }
+          return { response: { id, ok: true, result }, shouldShutdown: false };
+        } catch (error) {
+          if (loggable) {
+            const detail = formatError(error);
+            logEvent(logContext, `listResources error server=${params.server} err=${detail}`);
+          }
+          throw error;
+        }
+      }
+      case "readResource": {
+        const params = request.params;
+        ensureManaged(params.server, managedServers);
+        const loggable = shouldLogServer(logContext, params.server);
+        if (loggable) {
+          logEvent(logContext, `readResource start server=${params.server} uri=${params.uri}`);
+        }
+        try {
+          const result = await runtime.readResource(params.server, params.uri, {
+            allowCachedAuth: params.allowCachedAuth,
+            disableOAuth: normalizeDaemonDisableOAuth(params.disableOAuth)
+          });
+          markActivity(params.server, activity);
+          if (loggable) {
+            logEvent(logContext, `readResource success server=${params.server}`);
+          }
+          return { response: { id, ok: true, result }, shouldShutdown: false };
+        } catch (error) {
+          if (loggable) {
+            const detail = formatError(error);
+            logEvent(logContext, `readResource error server=${params.server} err=${detail}`);
+          }
+          throw error;
+        }
+      }
+      case "closeServer": {
+        const params = request.params;
+        ensureManaged(params.server, managedServers);
+        const loggable = shouldLogServer(logContext, params.server);
+        if (loggable) {
+          logEvent(logContext, `closeServer start server=${params.server}`);
+        }
+        try {
+          await runtime.close(params.server);
+          activity.set(params.server, { connected: false });
+          if (loggable) {
+            logEvent(logContext, `closeServer success server=${params.server}`);
+          }
+          return {
+            response: { id, ok: true, result: true },
+            shouldShutdown: false
+          };
+        } catch (error) {
+          if (loggable) {
+            const detail = formatError(error);
+            logEvent(logContext, `closeServer error server=${params.server} err=${detail}`);
+          }
+          throw error;
+        }
+      }
+      case "status": {
+        const result = {
+          pid: process.pid,
+          startedAt: metadata.startedAt,
+          configPath: metadata.configPath,
+          configLayers: metadata.configLayers,
+          configMtimeMs: metadata.configMtimeMs,
+          definitionHash: metadata.definitionHash,
+          socketPath: metadata.socketPath,
+          logPath: metadata.logPath ?? void 0,
+          servers: Array.from(managedServers.values()).map((def) => {
+            const entry = activity.get(def.name);
+            return {
+              name: def.name,
+              connected: Boolean(entry?.connected),
+              lastUsedAt: entry?.lastUsedAt
+            };
+          })
+        };
+        return { response: { id, ok: true, result }, shouldShutdown: false };
+      }
+      case "stop": {
+        logEvent(logContext, "Received stop request.");
+        return {
+          response: { id, ok: true, result: true },
+          shouldShutdown: true
+        };
+      }
+      default:
+        return {
+          response: buildErrorResponse(id, "unknown_method"),
+          shouldShutdown: false
+        };
+    }
+  } catch (error) {
+    return {
+      response: buildErrorResponse(id, "runtime_error", error),
+      shouldShutdown: false
+    };
+  }
+}
+function resolveDaemonListToolsAutoAuthorize(params, definition) {
+  if (params.autoAuthorize === false && definition.command.kind === "stdio") {
+    return void 0;
+  }
+  return params.autoAuthorize;
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/daemon-command.js
+async function handleDaemonCli(args, options) {
+  const subcommand = args.shift();
+  if (!subcommand || subcommand === "help" || subcommand === "--help") {
+    printDaemonHelp();
+    return;
+  }
+  const client = new DaemonClient({
+    configPath: options.configPath,
+    configExplicit: options.configExplicit,
+    rootDir: options.rootDir
+  });
+  if (subcommand === "start") {
+    await handleDaemonStart(args, options, client);
+    return;
+  }
+  if (subcommand === "status") {
+    await handleDaemonStatus(client);
+    return;
+  }
+  if (subcommand === "stop") {
+    await client.stop();
+    console.log("Daemon stopped (if it was running).");
+    return;
+  }
+  if (subcommand === "restart") {
+    await handleDaemonRestart(args, options, client);
+    return;
+  }
+  throw new Error(`Unknown daemon subcommand '${subcommand}'.`);
+}
+function printDaemonHelp() {
+  console.log(`Usage: mcporter daemon <start|status|stop|restart>
+
+Commands:
+  start    Start the keep-alive daemon (auto-detects keep-alive servers).
+  status   Show whether the daemon is running and which servers are active.
+  stop     Shut down the daemon and all managed servers.
+  restart  Stop the daemon (if running) and start a fresh instance.
+
+Flags:
+  --foreground        Run the daemon in the current process (debug only).
+  --log               Enable daemon logging (defaults to ~/.mcporter/daemon/daemon-<hash>.log,
+                      or $XDG_STATE_HOME/mcporter/daemon/... when set).
+  --log-file <path>   Write daemon stdout/stderr to a specific log file.
+  --log-servers <csv> Only log call activity for the listed servers (implies --log).`);
+}
+async function handleDaemonStart(args, options, client) {
+  const foregroundFlag = consumeFlag(args, "--foreground");
+  const isChildLaunch = process.env.MCPORTER_DAEMON_CHILD === "1";
+  const foreground = foregroundFlag || isChildLaunch;
+  const paths = resolveDaemonPaths(options.configPath);
+  const socketPath = process.env.MCPORTER_DAEMON_SOCKET ?? paths.socketPath;
+  const metadataPath = process.env.MCPORTER_DAEMON_METADATA ?? paths.metadataPath;
+  const logging = await resolveDaemonLoggingOptions(args, paths.key);
+  const runtime = await createRuntime({
+    configPath: options.configExplicit ? options.configPath : void 0,
+    rootDir: options.rootDir
+  });
+  const keepAlive = runtime.getDefinitions().filter(isKeepAliveServer);
+  await runtime.close().catch(() => {
+  });
+  if (keepAlive.length === 0) {
+    console.log("No MCP servers are configured for keep-alive; daemon not started.");
+    return;
+  }
+  if (foreground) {
+    await runDaemonHost({
+      socketPath,
+      metadataPath,
+      configPath: options.configPath,
+      configExplicit: options.configExplicit,
+      rootDir: options.rootDir,
+      logPath: logging.enabled ? logging.logPath : void 0,
+      logServers: logging.serverFilter,
+      logAllServers: logging.logAllServers
+    });
+    return;
+  }
+  const existing = await client.status();
+  if (existing) {
+    console.log(`Daemon already running (pid ${existing.pid}).`);
+    return;
+  }
+  const forwardedArgs = [];
+  if (logging.enabled && logging.logPath) {
+    forwardedArgs.push("--log-file", logging.logPath);
+  }
+  if (logging.serverFilter.size > 0) {
+    forwardedArgs.push("--log-servers", Array.from(logging.serverFilter).join(","));
+  }
+  launchDaemonDetached({
+    configPath: options.configPath,
+    configExplicit: options.configExplicit,
+    rootDir: options.rootDir,
+    metadataPath,
+    socketPath,
+    extraArgs: forwardedArgs
+  });
+  const ready = await waitFor(() => client.status(), 1e4, 100);
+  if (!ready) {
+    throw new Error("Failed to start daemon before timeout expired.");
+  }
+  console.log(`Daemon started for ${keepAlive.length} server(s).`);
+}
+async function handleDaemonRestart(args, options, client) {
+  await client.stop();
+  console.log("Daemon stopped (if it was running).");
+  const stopped = await waitFor(async () => {
+    const status = await client.status();
+    return status ? null : true;
+  }, 5e3, 100);
+  if (!stopped) {
+    throw new Error("Daemon did not stop before restart could begin.");
+  }
+  await handleDaemonStart(args, options, client);
+}
+async function handleDaemonStatus(client) {
+  const status = await client.status();
+  if (!status) {
+    console.log("Daemon is not running.");
+    return;
+  }
+  console.log(`Daemon pid ${status.pid} \u2014 socket: ${status.socketPath}`);
+  if (status.logPath) {
+    console.log(`Log file: ${status.logPath}`);
+  }
+  if (status.servers.length === 0) {
+    console.log("No keep-alive servers registered.");
+    return;
+  }
+  status.servers.forEach((server) => {
+    const state = server.connected ? "connected" : "idle";
+    const lastUsed = server.lastUsedAt ? ` (last used ${new Date(server.lastUsedAt).toISOString()})` : "";
+    console.log(`- ${server.name}: ${state}${lastUsed}`);
+  });
+}
+function consumeFlag(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) {
+    return false;
+  }
+  args.splice(index, 1);
+  return true;
+}
+function consumeValueFlag(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) {
+    return void 0;
+  }
+  if (index + 1 >= args.length) {
+    throw new Error(`Flag '${flag}' requires a value.`);
+  }
+  const value = args[index + 1];
+  args.splice(index, 2);
+  return value;
+}
+async function waitFor(probe, timeoutMs, intervalMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const result = await probe();
+    if (result) {
+      return result;
+    }
+    await delay2(intervalMs);
+  }
+  return null;
+}
+function delay2(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+async function resolveDaemonLoggingOptions(args, configKey) {
+  const logFlag = consumeFlag(args, "--log");
+  const logFileValue = consumeValueFlag(args, "--log-file");
+  const logServersValue = consumeValueFlag(args, "--log-servers");
+  const envLogEnabled = process.env.MCPORTER_DAEMON_LOG === "1";
+  const envLogPath = process.env.MCPORTER_DAEMON_LOG_PATH;
+  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 enabled = logFlag || Boolean(resolvedFileFlag) || envLogEnabled || Boolean(resolvedEnvFile) || explicitServerLogging;
+  if (!enabled) {
+    return {
+      enabled: false,
+      logPath: void 0,
+      logAllServers: false,
+      serverFilter
+    };
+  }
+  const logPath = resolvedFileFlag ?? resolvedEnvFile ?? getDaemonLogPath(configKey);
+  await fsPromises.mkdir(path4.dirname(logPath), { recursive: true });
+  return {
+    enabled: true,
+    logPath,
+    logAllServers: serverFilter.size === 0,
+    serverFilter
+  };
+}
+function parseServerList(value) {
+  if (!value) {
+    return /* @__PURE__ */ new Set();
+  }
+  const entries = value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  return new Set(entries);
+}
+
+export {
+  handleDaemonCli
+};