@introspection-ai/recipes 0.18.0 → 0.19.0

package/dist/mcp-chunks/chunk-H7F5RZXS.js

@@ -0,0 +1,26 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/definition-fields.js
+var SHARED_DEFINITION_FIELDS = [
+  "auth",
+  "tokenCacheDir",
+  "clientName",
+  "protocolVersion",
+  "oauthClientId",
+  "oauthClientSecretEnv",
+  "oauthTokenEndpointAuthMethod",
+  "oauthRedirectUrl",
+  "oauthClientMetadataUrl",
+  "oauthScope",
+  "refresh",
+  "httpFetch",
+  "allowedTools",
+  "blockedTools"
+];
+function pickSharedDefinitionFields(definition) {
+  return Object.fromEntries(SHARED_DEFINITION_FIELDS.map((field) => [field, definition[field]]));
+}
+
+export {
+  pickSharedDefinitionFields
+};

package/dist/mcp-chunks/{chunk-ECIVB7P4.js → chunk-HAO6PL7Z.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/env.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/env.js
 import os from "node:os";
 import path from "node:path";
 var ENV_DEFAULT_PATTERN = /^\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-|:|-)?([^}]*)\}$/;
@@ -96,44 +96,9 @@ async function withEnvOverrides(envOverrides, fn) {
   }
 }
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/paths.js
-import os2 from "node:os";
-import path2 from "node:path";
-var XDG_HOME_ENV = {
-  config: "XDG_CONFIG_HOME",
-  data: "XDG_DATA_HOME",
-  state: "XDG_STATE_HOME",
-  cache: "XDG_CACHE_HOME"
-};
-function legacyMcporterDir() {
-  return path2.join(os2.homedir(), ".mcporter");
-}
-function mcporterDir(kind) {
-  const raw = process.env[XDG_HOME_ENV[kind]];
-  if (raw && raw.trim().length > 0) {
-    const resolved = expandHome(raw.trim());
-    if (path2.isAbsolute(resolved)) {
-      return path2.join(resolved, "mcporter");
-    }
-  }
-  return legacyMcporterDir();
-}
-function mcporterConfigCandidates() {
-  const base = mcporterDir("config");
-  const candidates = [path2.join(base, "mcporter.json"), path2.join(base, "mcporter.jsonc")];
-  if (base !== legacyMcporterDir()) {
-    const legacy = legacyMcporterDir();
-    candidates.push(path2.join(legacy, "mcporter.json"), path2.join(legacy, "mcporter.jsonc"));
-  }
-  return candidates;
-}
-
 export {
   expandHome,
   resolveEnvValue,
   resolveEnvPlaceholders,
-  withEnvOverrides,
-  legacyMcporterDir,
-  mcporterDir,
-  mcporterConfigCandidates
+  withEnvOverrides
 };

package/dist/mcp-chunks/{chunk-WQJZMCJN.js → chunk-HTZ2URXW.js}

@@ -1,10 +1,12 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
-  expandHome,
   mcporterConfigCandidates
-} from "./chunk-ECIVB7P4.js";
+} from "./chunk-FWP4RACK.js";
+import {
+  expandHome
+} from "./chunk-HAO6PL7Z.js";
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/config/path-discovery.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/config/path-discovery.js
 import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";

package/dist/mcp-chunks/{chunk-BWHIA4PC.js → chunk-JAKI24KR.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/identifier-helpers.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/cli/identifier-helpers.js
 var AUTO_THRESHOLD_RATIO = 0.3;
 var AUTO_THRESHOLD_MIN = 2;
 function chooseClosestIdentifier(input, candidates) {

package/dist/mcp-chunks/{chunk-PWYFKGKG.js → chunk-KSGYBW3F.js}

@@ -1,48 +1,156 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
-  withFileLock
-} from "./chunk-2XL7MG7R.js";
+  DAEMON_PROTOCOL_VERSION,
+  DaemonFrameDecoder,
+  isDaemonProgressFrame,
+  resolveProgressInterval
+} from "./chunk-ZBFZ5UFE.js";
 import {
   listConfigLayerPaths
-} from "./chunk-WQJZMCJN.js";
+} from "./chunk-L4VKBFYI.js";
+import {
+  isProcessRunning,
+  withFileLock
+} from "./chunk-7A63PAGP.js";
 import {
-  expandHome,
   mcporterDir
-} from "./chunk-ECIVB7P4.js";
+} from "./chunk-FWP4RACK.js";
+import {
+  expandHome
+} from "./chunk-HAO6PL7Z.js";
+import {
+  keepAliveIdleTimeout
+} from "./chunk-6D6KPSXN.js";
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/daemon/client.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/daemon/client.js
 import crypto, { randomUUID } from "node:crypto";
-import fs from "node:fs/promises";
+import fs2 from "node:fs/promises";
 import net from "node:net";
-import path2 from "node:path";
+import path3 from "node:path";
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/daemon/paths.js
+// node_modules/.pnpm/mcporter@0.13.0/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, fallbackConfigPath) {
+  const layerPaths = await listConfigLayerPaths(options, options.rootDir ?? process.cwd());
+  const entries = await Promise.all(layerPaths.map(async (layerPath) => ({ path: layerPath, mtimeMs: await statConfigMtime(layerPath) })));
+  const fallback = fallbackConfigPath ?? options.configPath;
+  if (entries.length === 0 && fallback) {
+    entries.push({ path: path.resolve(fallback), mtimeMs: await statConfigMtime(fallback) });
+  }
+  return entries;
+}
+function normalizeConfigLayers(layers) {
+  const normalized = layers.map((entry) => ({
+    path: path.isAbsolute(entry.path) ? entry.path : path.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);
+}
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/daemon/paths.js
+import path2 from "node:path";
 function resolveBaseDir() {
   const override = process.env.MCPORTER_DAEMON_DIR;
   if (override && override.trim().length > 0) {
-    return path.resolve(expandHome(override.trim()));
+    return path2.resolve(expandHome(override.trim()));
   }
   return mcporterDir("state");
 }
 function ensureRunDir() {
-  return path.join(resolveBaseDir(), "daemon");
+  return path2.join(resolveBaseDir(), "daemon");
 }
 function getDaemonMetadataPath(configKey) {
-  return path.join(ensureRunDir(), `daemon-${configKey}.json`);
+  return path2.join(ensureRunDir(), `daemon-${configKey}.json`);
 }
 function getDaemonSocketPath(configKey) {
   const runDir = ensureRunDir();
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\mcporter-daemon-${configKey}`;
   }
-  return path.join(runDir, `daemon-${configKey}.sock`);
+  return path2.join(runDir, `daemon-${configKey}.sock`);
 }
 function getDaemonLogPath(configKey) {
-  return path.join(ensureRunDir(), `daemon-${configKey}.log`);
+  return path2.join(ensureRunDir(), `daemon-${configKey}.log`);
 }
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/daemon/client.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/daemon/request-utils.js
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+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.13.0/node_modules/mcporter/dist/daemon/client.js
 var DEFAULT_DAEMON_TIMEOUT_MS = 3e4;
 var MIN_DAEMON_STATUS_TIMEOUT_MS = 1e3;
 function resolveDaemonPaths(configPath) {
@@ -68,7 +176,7 @@ var DaemonClient = class {
     return this.invoke("callTool", params, params.timeoutMs);
   }
   async listTools(params) {
-    return this.invoke("listTools", params);
+    return this.invoke("listTools", params, params.timeoutMs);
   }
   async listResources(params) {
     return this.invoke("listResources", params);
@@ -155,7 +263,7 @@ var DaemonClient = class {
     await this.startingPromise;
   }
   async launchDaemonAndWait() {
-    const { launchDaemonDetached } = await import("./launch-YKRXHXJI.js");
+    const { launchDaemonDetached } = await import("./launch-BWXPLPB7.js");
     launchDaemonDetached({
       configPath: this.options.configPath,
       configExplicit: this.options.configExplicit,
@@ -211,8 +319,11 @@ var DaemonClient = class {
     if (!metadata) {
       return "missing";
     }
-    const currentLayers = normalizeLayers(await collectConfigLayers(this.options));
-    const metadataLayers = normalizeLayers(metadata.configLayers ?? [{ path: metadata.configPath, mtimeMs: metadata.configMtimeMs ?? null }]);
+    const currentLayers = normalizeConfigLayers(await collectConfigLayers({
+      configPath: this.options.configExplicit ? this.options.configPath : void 0,
+      rootDir: this.options.rootDir
+    }, this.options.configPath));
+    const metadataLayers = normalizeConfigLayers(metadata.configLayers ?? [{ path: metadata.configPath, mtimeMs: metadata.configMtimeMs ?? null }]);
     if (currentLayers.length !== metadataLayers.length) {
       return "stale";
     }
@@ -226,15 +337,19 @@ var DaemonClient = class {
     return "fresh";
   }
   async sendRequest(method, params, timeoutOverrideMs) {
+    const idleTimeoutMs = resolveDaemonTimeout(timeoutOverrideMs);
     const request = {
       id: randomUUID(),
       method,
-      params
+      params,
+      protocolVersion: DAEMON_PROTOCOL_VERSION,
+      progressIntervalMs: resolveProgressInterval(idleTimeoutMs)
     };
     const payload = JSON.stringify(request);
-    const timeoutMs = resolveDaemonTimeout(timeoutOverrideMs);
-    const response = await new Promise((resolve, reject) => {
+    const parsed = await new Promise((resolve, reject) => {
       const socket = net.createConnection(this.socketPath);
+      const decoder = new DaemonFrameDecoder();
+      let response;
       let settled = false;
       const finishReject = (error) => {
         if (settled) {
@@ -250,12 +365,22 @@ var DaemonClient = class {
         settled = true;
         resolve(value);
       };
-      socket.setTimeout(timeoutMs, () => {
-        socket.destroy(Object.assign(new Error("Daemon request timed out."), {
-          code: "ETIMEDOUT"
-        }));
+      socket.setTimeout(idleTimeoutMs);
+      socket.on("timeout", () => {
+        socket.destroy(transportError("Daemon request timed out.", "ETIMEDOUT"));
       });
-      let buffer = "";
+      const consume = (frames) => {
+        for (const frame of frames) {
+          if (isDaemonProgressFrame(frame)) {
+            if (frame.id === request.id) {
+              socket.setTimeout(idleTimeoutMs);
+            }
+            continue;
+          }
+          response = frame;
+          socket.setTimeout(0);
+        }
+      };
       socket.on("connect", () => {
         socket.write(payload, (error) => {
           if (error) {
@@ -264,26 +389,22 @@ var DaemonClient = class {
         });
       });
       socket.on("data", (chunk) => {
-        buffer += chunk.toString();
+        consume(decoder.push(chunk.toString()));
+      });
+      socket.on("end", () => {
+        consume(decoder.flush());
+        if (response) {
+          finishResolve(response);
+          return;
+        }
+        finishReject(decoder.malformed ? transportError("Failed to parse daemon response.", "ECONNRESET") : transportError("Empty daemon response.", "ECONNRESET"));
       });
-      socket.on("end", () => finishResolve(buffer));
       socket.on("error", (error) => {
         finishReject(error);
       });
     });
-    const trimmed = response.trim();
-    if (!trimmed) {
-      const error = new Error("Empty daemon response.");
-      error.code = "ECONNRESET";
-      throw error;
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(trimmed);
-    } catch {
-      const parseError = new Error("Failed to parse daemon response.");
-      parseError.code = "ECONNRESET";
-      throw parseError;
+    for (const notice of parsed.notices ?? []) {
+      console.warn(`[mcporter] ${notice}`);
     }
     if (!parsed.ok) {
       const error = new Error(parsed.error?.message ?? "Daemon error");
@@ -293,8 +414,13 @@ var DaemonClient = class {
     return parsed.result;
   }
 };
+function transportError(message, code) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
 function deriveConfigKey(configPath) {
-  const absolute = path2.resolve(configPath);
+  const absolute = path3.resolve(configPath);
   return crypto.createHash("sha1").update(absolute).digest("hex").slice(0, 12);
 }
 function isTransportError(error) {
@@ -304,17 +430,6 @@ function isTransportError(error) {
   const code = error.code;
   return code === "ECONNREFUSED" || code === "ENOENT" || code === "ETIMEDOUT" || code === "ECONNRESET";
 }
-function isProcessRunning(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) {
-    return false;
-  }
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-}
 function resolveDaemonTimeout(override) {
   if (typeof override === "number" && Number.isFinite(override) && override > 0) {
     return override;
@@ -335,51 +450,27 @@ function resolveDaemonStatusTimeout(override) {
   }
   return Math.max(override, MIN_DAEMON_STATUS_TIMEOUT_MS);
 }
-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.configExplicit ? { configPath: options.configPath } : {}, options.rootDir ?? process.cwd());
-  const layers = [];
-  for (const layerPath of layerPaths) {
-    layers.push({ path: layerPath, mtimeMs: await statConfigMtime(layerPath) });
-  }
-  if (layers.length === 0) {
-    layers.push({ path: path2.resolve(options.configPath), mtimeMs: await statConfigMtime(options.configPath) });
-  }
-  return layers;
-}
 async function readDaemonMetadata(metadataPath) {
   try {
-    const raw = await fs.readFile(metadataPath, "utf8");
+    const raw = await fs2.readFile(metadataPath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
-function delay(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-function normalizeLayers(layers) {
-  const normalized = layers.map((entry) => ({
-    path: path2.isAbsolute(entry.path) ? entry.path : path2.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);
-}
 
 export {
+  statConfigMtime,
+  collectConfigLayers,
+  normalizeConfigLayers,
   getDaemonLogPath,
+  delay,
+  ensureManaged,
+  markActivity,
+  evictIdleServers,
+  shouldShutdownDaemonForIdle,
+  daemonIdleWatcherInterval,
+  buildErrorResponse,
   resolveDaemonPaths,
   DaemonClient
 };

package/dist/mcp-chunks/{chunk-SJCCBNZ4.js → chunk-KSMY7PXI.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/json-output.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/cli/json-output.js
 function buildConnectionIssueEnvelope(params) {
   return {
     server: params.server,