@introspection-ai/recipes 0.25.1 → 0.27.1

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

@@ -1,92 +0,0 @@
-import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
-import {
-  resolveEnvPlaceholders
-} from "./chunk-WTMJMM3B.js";
-
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/runtime/utils.js
-var ENV_PLACEHOLDER_PATTERN = /\$\{(?:env:[^}]*|[A-Za-z_][A-Za-z0-9_]*(?::-[^}]*)?)\}/;
-var MAX_TIMER_DELAY_MS = 2147483647;
-function resolveCommandArgument(value, env = process.env) {
-  if (!value) {
-    return value;
-  }
-  if (!value.includes("$")) {
-    return value;
-  }
-  const needsInterpolation = value.startsWith("$env:") || ENV_PLACEHOLDER_PATTERN.test(value);
-  if (!needsInterpolation) {
-    return value;
-  }
-  return resolveEnvPlaceholders(value, env);
-}
-function resolveCommandArguments(args, env = process.env) {
-  if (args.length === 0) {
-    return [];
-  }
-  return args.map((arg) => resolveCommandArgument(arg, env));
-}
-function normalizeTimeout(raw) {
-  if (raw == null) {
-    return void 0;
-  }
-  if (!Number.isFinite(raw)) {
-    return void 0;
-  }
-  const coerced = Math.trunc(raw);
-  return coerced > 0 ? Math.min(coerced, MAX_TIMER_DELAY_MS) : void 0;
-}
-function raceWithTimeout(promise, timeoutMs) {
-  return new Promise((resolve, reject) => {
-    const delayMs = Number.isFinite(timeoutMs) ? Math.min(Math.max(Math.trunc(timeoutMs), 1), MAX_TIMER_DELAY_MS) : MAX_TIMER_DELAY_MS;
-    const cancelTimeout = scheduleDeadline(() => {
-      reject(new Error("Timeout"));
-    }, delayMs);
-    promise.then((value) => {
-      cancelTimeout();
-      resolve(value);
-    }, (error) => {
-      cancelTimeout();
-      reject(error);
-    });
-  });
-}
-function scheduleDeadline(callback, delayMs) {
-  const deadline = performance.now() + delayMs;
-  let timer;
-  let cancelled = false;
-  const scheduleNext = () => {
-    if (cancelled)
-      return;
-    const remainingMs = deadline - performance.now();
-    if (remainingMs <= 0) {
-      callback();
-    } else if (remainingMs > 864e5) {
-      timer = setTimeout(scheduleNext, 864e5);
-    } else if (remainingMs > 36e5) {
-      timer = setTimeout(scheduleNext, 36e5);
-    } else if (remainingMs > 6e4) {
-      timer = setTimeout(scheduleNext, 6e4);
-    } else if (remainingMs > 1e3) {
-      timer = setTimeout(scheduleNext, 1e3);
-    } else if (remainingMs > 100) {
-      timer = setTimeout(scheduleNext, 100);
-    } else if (remainingMs > 10) {
-      timer = setTimeout(scheduleNext, 10);
-    } else {
-      timer = setTimeout(scheduleNext, 1);
-    }
-  };
-  scheduleNext();
-  return () => {
-    cancelled = true;
-    if (timer)
-      clearTimeout(timer);
-  };
-}
-
-export {
-  resolveCommandArgument,
-  resolveCommandArguments,
-  normalizeTimeout,
-  raceWithTimeout
-};

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

@@ -1,28 +0,0 @@
-import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
-import {
-  analyzeConnectionError
-} from "./chunk-QZUC2T72.js";
-
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/runtime-oauth-support.js
-function maybeEnableOAuth(definition, logger) {
-  if (definition.auth === "oauth" || definition.auth === "refreshable_bearer") {
-    return void 0;
-  }
-  if (definition.command.kind !== "http") {
-    return void 0;
-  }
-  logger.info(`Detected OAuth requirement for '${definition.name}'. Launching browser flow...`);
-  return {
-    ...definition,
-    auth: "oauth"
-  };
-}
-function isUnauthorizedError(error) {
-  const issue = analyzeConnectionError(error);
-  return issue.kind === "auth";
-}
-
-export {
-  maybeEnableOAuth,
-  isUnauthorizedError
-};

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

@@ -1,526 +0,0 @@
-import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
-import {
-  DAEMON_PROTOCOL_VERSION,
-  DaemonFrameDecoder,
-  isDaemonProgressFrame,
-  resolveProgressTiming
-} from "./chunk-3Z7MFS6K.js";
-import {
-  CHROME_DEVTOOLS_RELAY_RUNTIME_IDENTITY_VERSION,
-  resolveChromeDevtoolsRelayRuntimeIdentity
-} from "./chunk-BWW4XRUC.js";
-import {
-  suppressBrowserLaunchFromEnv
-} from "./chunk-DTZHEVKC.js";
-import {
-  listConfigLayerPaths
-} from "./chunk-RD7NHCRK.js";
-import {
-  isProcessRunning,
-  withFileLock
-} from "./chunk-ITR7FQM3.js";
-import {
-  mcporterDir
-} from "./chunk-FS5JIKT6.js";
-import {
-  expandHome
-} from "./chunk-WTMJMM3B.js";
-import {
-  keepAliveIdleTimeout
-} from "./chunk-JG4TRUPF.js";
-
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/daemon/client.js
-import crypto, { 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.13.8/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.8/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 path2.resolve(expandHome(override.trim()));
-  }
-  return mcporterDir("state");
-}
-function ensureRunDir() {
-  return path2.join(resolveBaseDir(), "daemon");
-}
-function getDaemonMetadataPath(configKey) {
-  return path2.join(ensureRunDir(), `daemon-${configKey}.json`);
-}
-function getDaemonSocketPath(configKey) {
-  const runDir = ensureRunDir();
-  if (process.platform === "win32") {
-    return `\\\\.\\pipe\\mcporter-daemon-${configKey}`;
-  }
-  return path2.join(runDir, `daemon-${configKey}.sock`);
-}
-function getDaemonLogPath(configKey) {
-  return path2.join(ensureRunDir(), `daemon-${configKey}.log`);
-}
-
-// node_modules/.pnpm/mcporter@0.13.8/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.8/node_modules/mcporter/dist/daemon/startup-readiness.js
-var DAEMON_STARTUP_TIMEOUT_MS = 45e3;
-var DAEMON_STARTUP_SLOW_NOTICE_MS = 5e3;
-var DAEMON_STARTUP_POLL_INTERVAL_MS = 100;
-async function waitForDaemonReady(probe, timing = {}) {
-  const now = timing.now ?? Date.now;
-  const wait = timing.delay ?? delay2;
-  const reportSlowStart = timing.reportSlowStart ?? defaultSlowStartReporter;
-  const startedAt = now();
-  const deadline = startedAt + DAEMON_STARTUP_TIMEOUT_MS;
-  let reportedSlowStart = false;
-  while (true) {
-    const remainingBeforeProbe = deadline - now();
-    if (remainingBeforeProbe <= 0) {
-      throw daemonStartupTimeoutError();
-    }
-    const result = await probe(Math.min(DAEMON_STARTUP_POLL_INTERVAL_MS, remainingBeforeProbe));
-    if (result !== null) {
-      return result;
-    }
-    const currentTime = now();
-    if (currentTime >= deadline) {
-      throw daemonStartupTimeoutError();
-    }
-    if (!reportedSlowStart && currentTime - startedAt >= DAEMON_STARTUP_SLOW_NOTICE_MS) {
-      reportedSlowStart = true;
-      reportSlowStart();
-    }
-    await wait(Math.min(DAEMON_STARTUP_POLL_INTERVAL_MS, deadline - currentTime));
-  }
-}
-function defaultSlowStartReporter() {
-  console.error("[mcporter] Daemon startup is taking longer than usual; Chrome relay discovery can take up to 30 seconds.");
-}
-function daemonStartupTimeoutError() {
-  return new Error("MCPorter daemon did not become ready within 45 seconds. Run 'mcporter daemon start --foreground --log' to diagnose startup.");
-}
-function delay2(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/daemon/client.js
-var DEFAULT_DAEMON_TIMEOUT_MS = 3e4;
-var MIN_DAEMON_STATUS_TIMEOUT_MS = 1e3;
-function resolveDaemonPaths(configPath) {
-  const key = deriveConfigKey(configPath);
-  return {
-    key,
-    socketPath: getDaemonSocketPath(key),
-    metadataPath: getDaemonMetadataPath(key)
-  };
-}
-var DaemonClient = class {
-  options;
-  socketPath;
-  metadataPath;
-  startingPromise = null;
-  constructor(options) {
-    this.options = options;
-    const paths = resolveDaemonPaths(options.configPath);
-    this.socketPath = paths.socketPath;
-    this.metadataPath = paths.metadataPath;
-  }
-  async callTool(params) {
-    return this.invoke("callTool", params, params.timeoutMs);
-  }
-  async listTools(params) {
-    return this.invoke("listTools", params, params.timeoutMs);
-  }
-  async listResources(params) {
-    return this.invoke("listResources", params);
-  }
-  async readResource(params) {
-    return this.invoke("readResource", params);
-  }
-  async closeServer(params) {
-    await this.invoke("closeServer", params);
-  }
-  async status(timeoutMs) {
-    return await this.readVerifiedStatus(timeoutMs);
-  }
-  async stop() {
-    try {
-      await this.sendRequest("stop", {});
-    } catch (error) {
-      if (isTransportError(error)) {
-        return;
-      }
-      throw error;
-    }
-  }
-  async invoke(method, params, timeoutMs) {
-    await this.ensureDaemon(timeoutMs);
-    try {
-      return await this.sendRequest(method, params, timeoutMs);
-    } catch (error) {
-      if (isTransportError(error)) {
-        await this.restartDaemon();
-        return await this.sendRequest(method, params, timeoutMs);
-      }
-      throw error;
-    }
-  }
-  async ensureDaemon(timeoutMs) {
-    const statusTimeoutMs = resolveDaemonStatusTimeout(timeoutMs);
-    const metadata = await readDaemonMetadata(this.metadataPath);
-    const configState = await this.checkConfigState(metadata);
-    if (configState === "stale") {
-      await this.restartDaemon({ reason: "stale-config", expectedPid: metadata?.pid });
-      return;
-    }
-    if (configState === "fresh") {
-      if (await this.isResponsive(statusTimeoutMs)) {
-        return;
-      }
-    }
-    await this.startDaemon({ preflightTimeoutMs: statusTimeoutMs });
-  }
-  async restartDaemon(options = {}) {
-    await this.startingWithLock(async () => {
-      const currentStatus = await this.readVerifiedStatus();
-      if (currentStatus && options.expectedPid !== void 0 && currentStatus.pid !== options.expectedPid && await this.checkConfigState() === "fresh") {
-        return;
-      }
-      if (options.reason === "stale-config" && currentStatus && await this.checkConfigState() === "fresh") {
-        return;
-      }
-      await this.stop().catch(() => {
-      });
-      await this.waitForStopped();
-      await this.launchDaemonAndWait();
-    });
-  }
-  async startDaemon(options = {}) {
-    await this.startingWithLock(async () => {
-      if (await this.isResponsive(options.preflightTimeoutMs)) {
-        return;
-      }
-      await this.launchDaemonAndWait();
-    });
-  }
-  async startingWithLock(task) {
-    if (this.startingPromise) {
-      await this.startingPromise;
-      return;
-    }
-    this.startingPromise = withFileLock(this.metadataPath, async () => {
-      await task();
-    }).finally(() => {
-      this.startingPromise = null;
-    });
-    await this.startingPromise;
-  }
-  async launchDaemonAndWait() {
-    const { launchDaemonDetached } = await import("./launch-EIT73HX4.js");
-    launchDaemonDetached({
-      configPath: this.options.configPath,
-      configExplicit: this.options.configExplicit,
-      rootDir: this.options.rootDir,
-      metadataPath: this.metadataPath,
-      socketPath: this.socketPath
-    });
-    await this.waitForReady();
-  }
-  async waitForStopped() {
-    const deadline = Date.now() + 5e3;
-    while (Date.now() < deadline) {
-      if (!await this.isResponsive()) {
-        return;
-      }
-      await delay(100);
-    }
-    throw new Error("Daemon did not stop before restart could begin.");
-  }
-  async waitForReady() {
-    await waitForDaemonReady((timeoutMs) => this.readVerifiedStatus(timeoutMs));
-  }
-  async isResponsive(timeoutMs) {
-    return await this.readVerifiedStatus(timeoutMs) !== null;
-  }
-  async readVerifiedStatus(timeoutMs) {
-    const metadata = await readDaemonMetadata(this.metadataPath);
-    if (!metadata || metadata.socketPath !== this.socketPath || !isProcessRunning(metadata.pid)) {
-      return null;
-    }
-    try {
-      const status = await this.sendRequest("status", {}, timeoutMs);
-      if (status.pid !== metadata.pid || status.socketPath !== metadata.socketPath) {
-        return null;
-      }
-      return status;
-    } catch (error) {
-      if (isTransportError(error)) {
-        return null;
-      }
-      throw error;
-    }
-  }
-  async checkConfigState(metadata) {
-    metadata ??= await readDaemonMetadata(this.metadataPath);
-    if (!metadata) {
-      return "missing";
-    }
-    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";
-    }
-    for (let i = 0; i < currentLayers.length; i += 1) {
-      const current = currentLayers[i];
-      const previous = metadataLayers[i];
-      if (!current || !previous || current.path !== previous.path || current.mtimeMs !== previous.mtimeMs) {
-        return "stale";
-      }
-    }
-    if (metadata.relayRuntimeIdentityVersion !== CHROME_DEVTOOLS_RELAY_RUNTIME_IDENTITY_VERSION || !metadata.relayEnvironmentKeys || metadata.relayRuntimeIdentity !== await resolveChromeDevtoolsRelayRuntimeIdentity(metadata.relayEnvironmentKeys, process.env, this.options.chromeDevtoolsRelayIdentity)) {
-      return "stale";
-    }
-    if ((metadata.oauthNoBrowser ?? false) !== suppressBrowserLaunchFromEnv()) {
-      return "stale";
-    }
-    return "fresh";
-  }
-  async sendRequest(method, params, timeoutOverrideMs) {
-    const progressTiming = resolveProgressTiming(resolveDaemonTimeout(timeoutOverrideMs));
-    const request = {
-      id: randomUUID(),
-      method,
-      params,
-      protocolVersion: DAEMON_PROTOCOL_VERSION,
-      progressIntervalMs: progressTiming.progressIntervalMs
-    };
-    const payload = JSON.stringify(request);
-    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) {
-          return;
-        }
-        settled = true;
-        reject(error);
-      };
-      const finishResolve = (value) => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        resolve(value);
-      };
-      socket.setTimeout(progressTiming.idleTimeoutMs);
-      socket.on("timeout", () => {
-        socket.destroy(transportError("Daemon request timed out.", "ETIMEDOUT"));
-      });
-      const consume = (frames) => {
-        for (const frame of frames) {
-          if (isDaemonProgressFrame(frame)) {
-            if (frame.id === request.id) {
-              socket.setTimeout(progressTiming.idleTimeoutMs);
-            }
-            continue;
-          }
-          response = frame;
-          socket.setTimeout(0);
-        }
-      };
-      socket.on("connect", () => {
-        socket.write(payload, (error) => {
-          if (error) {
-            finishReject(error);
-          }
-        });
-      });
-      socket.on("data", (chunk) => {
-        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("error", (error) => {
-        finishReject(error);
-      });
-    });
-    for (const notice of parsed.notices ?? []) {
-      console.warn(`[mcporter] ${notice}`);
-    }
-    if (!parsed.ok) {
-      const error = new Error(parsed.error?.message ?? "Daemon error");
-      error.code = parsed.error?.code;
-      throw error;
-    }
-    return parsed.result;
-  }
-};
-function transportError(message, code) {
-  const error = new Error(message);
-  error.code = code;
-  return error;
-}
-function deriveConfigKey(configPath) {
-  const absolute = path3.resolve(configPath);
-  return crypto.hash("sha1", absolute, "hex").slice(0, 12);
-}
-function isTransportError(error) {
-  if (!error || typeof error !== "object") {
-    return false;
-  }
-  const code = error.code;
-  return code === "ECONNREFUSED" || code === "ENOENT" || code === "ETIMEDOUT" || code === "ECONNRESET";
-}
-function resolveDaemonTimeout(override) {
-  if (typeof override === "number" && Number.isFinite(override) && override > 0) {
-    return override;
-  }
-  const raw = process.env.MCPORTER_DAEMON_TIMEOUT_MS;
-  if (!raw) {
-    return DEFAULT_DAEMON_TIMEOUT_MS;
-  }
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    return DEFAULT_DAEMON_TIMEOUT_MS;
-  }
-  return parsed;
-}
-function resolveDaemonStatusTimeout(override) {
-  if (typeof override !== "number" || !Number.isFinite(override) || override <= 0) {
-    return void 0;
-  }
-  return Math.max(override, MIN_DAEMON_STATUS_TIMEOUT_MS);
-}
-async function readDaemonMetadata(metadataPath) {
-  try {
-    const raw = await fs2.readFile(metadataPath, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-
-export {
-  statConfigMtime,
-  collectConfigLayers,
-  normalizeConfigLayers,
-  getDaemonLogPath,
-  delay,
-  ensureManaged,
-  markActivity,
-  evictIdleServers,
-  shouldShutdownDaemonForIdle,
-  daemonIdleWatcherInterval,
-  buildErrorResponse,
-  waitForDaemonReady,
-  resolveDaemonPaths,
-  DaemonClient
-};

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

@@ -1,15 +0,0 @@
-import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
-
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/version.js
-import { createRequire } from "node:module";
-var MCPORTER_VERSION = (() => {
-  try {
-    return createRequire(import.meta.url)("../package.json").version;
-  } catch {
-    return process.env.MCPORTER_VERSION ?? "0.0.0-dev";
-  }
-})();
-
-export {
-  MCPORTER_VERSION
-};