@introspection-ai/recipes 0.13.0 → 0.14.0

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

@@ -0,0 +1,385 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  withFileLock
+} from "./chunk-2XL7MG7R.js";
+import {
+  listConfigLayerPaths
+} from "./chunk-WQJZMCJN.js";
+import {
+  expandHome,
+  mcporterDir
+} from "./chunk-ECIVB7P4.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/daemon/client.js
+import crypto, { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import net from "node:net";
+import path2 from "node:path";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/daemon/paths.js
+import path 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 mcporterDir("state");
+}
+function ensureRunDir() {
+  return path.join(resolveBaseDir(), "daemon");
+}
+function getDaemonMetadataPath(configKey) {
+  return path.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`);
+}
+function getDaemonLogPath(configKey) {
+  return path.join(ensureRunDir(), `daemon-${configKey}.log`);
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/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);
+  }
+  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() {
+    return await this.readVerifiedStatus();
+  }
+  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-YKRXHXJI.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() {
+    const deadline = Date.now() + 1e4;
+    while (Date.now() < deadline) {
+      if (await this.isResponsive()) {
+        return;
+      }
+      await delay(100);
+    }
+    throw new Error("Timeout while waiting for MCPorter daemon to start.");
+  }
+  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 = normalizeLayers(await collectConfigLayers(this.options));
+    const metadataLayers = normalizeLayers(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";
+      }
+    }
+    return "fresh";
+  }
+  async sendRequest(method, params, timeoutOverrideMs) {
+    const request = {
+      id: randomUUID(),
+      method,
+      params
+    };
+    const payload = JSON.stringify(request);
+    const timeoutMs = resolveDaemonTimeout(timeoutOverrideMs);
+    const response = await new Promise((resolve, reject) => {
+      const socket = net.createConnection(this.socketPath);
+      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(timeoutMs, () => {
+        socket.destroy(Object.assign(new Error("Daemon request timed out."), {
+          code: "ETIMEDOUT"
+        }));
+      });
+      let buffer = "";
+      socket.on("connect", () => {
+        socket.write(payload, (error) => {
+          if (error) {
+            finishReject(error);
+          }
+        });
+      });
+      socket.on("data", (chunk) => {
+        buffer += chunk.toString();
+      });
+      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;
+    }
+    if (!parsed.ok) {
+      const error = new Error(parsed.error?.message ?? "Daemon error");
+      error.code = parsed.error?.code;
+      throw error;
+    }
+    return parsed.result;
+  }
+};
+function deriveConfigKey(configPath) {
+  const absolute = path2.resolve(configPath);
+  return crypto.createHash("sha1").update(absolute).digest("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 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;
+  }
+  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 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");
+    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 {
+  getDaemonLogPath,
+  resolveDaemonPaths,
+  DaemonClient
+};

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

@@ -0,0 +1,45 @@
+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
+function buildConnectionIssueEnvelope(params) {
+  return {
+    server: params.server,
+    tool: params.tool,
+    error: formatErrorMessage(params.error),
+    issue: serializeConnectionIssue(params.issue)
+  };
+}
+function serializeConnectionIssue(issue) {
+  if (!issue) {
+    return void 0;
+  }
+  return {
+    kind: issue.kind,
+    statusCode: issue.statusCode,
+    stdioExitCode: issue.stdioExitCode,
+    stdioSignal: issue.stdioSignal,
+    rawMessage: issue.rawMessage
+  };
+}
+function formatErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message ?? "Unknown error";
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error === void 0 || error === null) {
+    return "Unknown error";
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return "Unknown error";
+  }
+}
+
+export {
+  buildConnectionIssueEnvelope,
+  serializeConnectionIssue,
+  formatErrorMessage
+};

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

@@ -0,0 +1,194 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  readJsonFile,
+  withFileLock,
+  writeJsonFile
+} from "./chunk-2XL7MG7R.js";
+import {
+  mcporterDir
+} from "./chunk-ECIVB7P4.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/oauth-vault.js
+import crypto from "node:crypto";
+import path from "node:path";
+function getOAuthVaultPath() {
+  return path.join(mcporterDir("data"), "credentials.json");
+}
+async function readVaultState() {
+  try {
+    const existing = await readJsonFile(getOAuthVaultPath());
+    if (existing && existing.version === 1 && existing.entries && typeof existing.entries === "object") {
+      return { vault: existing, needsRepair: false };
+    }
+    if (existing !== void 0) {
+      return { vault: emptyVault(), needsRepair: true };
+    }
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) {
+      throw error;
+    }
+    return { vault: emptyVault(), needsRepair: true };
+  }
+  return { vault: emptyVault(), needsRepair: false };
+}
+async function readVault() {
+  return (await readVaultState()).vault;
+}
+function emptyVault() {
+  return { version: 1, entries: {} };
+}
+async function writeVault(contents) {
+  await writeJsonFile(getOAuthVaultPath(), contents);
+}
+function vaultKeyForDefinition(definition) {
+  const descriptor = {
+    name: definition.name,
+    url: definition.command.kind === "http" ? definition.command.url.toString() : null,
+    command: definition.command.kind === "stdio" ? { command: definition.command.command, args: definition.command.args ?? [] } : null
+  };
+  const hash = crypto.createHash("sha256").update(JSON.stringify(descriptor)).digest("hex").slice(0, 16);
+  return `${definition.name}|${hash}`;
+}
+async function loadVaultEntry(definition) {
+  const vault = await readVault();
+  const key = vaultKeyForDefinition(definition);
+  const exact = isVaultEntry(vault.entries[key]) ? vault.entries[key] : void 0;
+  const fallback = findSameUrlCredentials(vault, definition, key, exact);
+  if (!fallback.tokens && !fallback.clientInfo) {
+    return exact;
+  }
+  if (!exact) {
+    return {
+      serverName: definition.name,
+      serverUrl: definition.command.kind === "http" ? definition.command.url.toString() : void 0,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tokens: fallback.tokens,
+      clientInfo: fallback.clientInfo
+    };
+  }
+  return {
+    ...exact,
+    tokens: exact.tokens ?? fallback.tokens,
+    clientInfo: exact.clientInfo ?? (exact.tokens ? void 0 : fallback.clientInfo)
+  };
+}
+function findSameUrlCredentials(vault, definition, exactKey, exact) {
+  if (definition.command.kind !== "http") {
+    return { sourceKeys: [] };
+  }
+  const serverUrl = definition.command.url.toString();
+  const candidates = Object.entries(vault.entries).filter(([key, entry]) => key !== exactKey && isVaultEntry(entry) && entry.serverUrl === serverUrl && isLegacyOAuthRenameCandidate(definition, entry) && (entry.tokens || entry.clientInfo)).map(([key, entry]) => ({ key, entry })).toSorted((a, b) => Date.parse(b.entry.updatedAt) - Date.parse(a.entry.updatedAt));
+  const requiredClientId = definition.oauthClientId ?? clientIdFromEntry(exact);
+  if (requiredClientId) {
+    const tokenSource = candidates.find(({ entry }) => (entry.tokens || entry.clientInfo) && clientIdFromEntry(entry) === requiredClientId);
+    return {
+      tokens: tokenSource?.entry.tokens,
+      clientInfo: exact?.clientInfo ? void 0 : tokenSource?.entry.clientInfo,
+      sourceKeys: tokenSource ? [tokenSource.key] : []
+    };
+  }
+  const source = candidates.find(({ entry }) => entry.clientInfo && clientIdFromEntry(entry));
+  return {
+    tokens: source?.entry.tokens,
+    clientInfo: source?.entry.clientInfo,
+    sourceKeys: source ? [source.key] : []
+  };
+}
+function isLegacyOAuthRenameCandidate(definition, entry) {
+  return entry.serverName === `${definition.name}-oauth`;
+}
+function legacyOAuthRenameKeys(vault, definition, exactKey) {
+  if (definition.command.kind !== "http") {
+    return [];
+  }
+  const serverUrl = definition.command.url.toString();
+  return Object.entries(vault.entries).filter(([key, entry]) => key !== exactKey && isVaultEntry(entry) && entry.serverUrl === serverUrl && isLegacyOAuthRenameCandidate(definition, entry)).map(([key]) => key);
+}
+function isVaultEntry(entry) {
+  return Boolean(entry && typeof entry === "object" && typeof entry.serverName === "string" && typeof entry.updatedAt === "string");
+}
+function clientIdFromEntry(entry) {
+  const clientId = entry?.clientInfo?.client_id;
+  return typeof clientId === "string" && clientId.length > 0 ? clientId : void 0;
+}
+async function saveVaultEntry(definition, patch) {
+  await withFileLock(getOAuthVaultPath(), async () => {
+    const vault = await readVault();
+    const key = vaultKeyForDefinition(definition);
+    const existing = isVaultEntry(vault.entries[key]) ? vault.entries[key] : void 0;
+    const fallback = findSameUrlCredentials(vault, definition, key, existing);
+    const current = existing ?? {
+      serverName: definition.name,
+      serverUrl: definition.command.kind === "http" ? definition.command.url.toString() : void 0,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    vault.entries[key] = {
+      ...current,
+      ...patch,
+      clientInfo: patch.clientInfo ?? current.clientInfo ?? (patch.tokens && !current.tokens ? fallback.clientInfo : void 0),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeVault(vault);
+  });
+}
+async function clearVaultEntry(definition, scope) {
+  const key = vaultKeyForDefinition(definition);
+  await withFileLock(getOAuthVaultPath(), async () => {
+    const { vault, needsRepair } = await readVaultState();
+    const existing = isVaultEntry(vault.entries[key]) ? vault.entries[key] : void 0;
+    const fallback = findSameUrlCredentials(vault, definition, key, existing);
+    const inheritedKeys = scope === "all" ? legacyOAuthRenameKeys(vault, definition, key) : fallback.sourceKeys;
+    if (!existing && inheritedKeys.length === 0) {
+      if (needsRepair) {
+        await writeVault(vault);
+      }
+      return;
+    }
+    if (scope === "all") {
+      delete vault.entries[key];
+    } else if (existing) {
+      const updated = { ...existing };
+      if (scope === "tokens") {
+        delete updated.tokens;
+      }
+      if (scope === "client") {
+        delete updated.clientInfo;
+      }
+      if (scope === "verifier") {
+        delete updated.codeVerifier;
+      }
+      if (scope === "state") {
+        delete updated.state;
+      }
+      updated.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      vault.entries[key] = updated;
+    }
+    for (const fallbackKey of inheritedKeys) {
+      const inherited = vault.entries[fallbackKey];
+      if (!inherited) {
+        continue;
+      }
+      if (scope === "all") {
+        delete vault.entries[fallbackKey];
+        continue;
+      }
+      const updated = { ...inherited };
+      if (scope === "tokens") {
+        delete updated.tokens;
+      }
+      if (scope === "client") {
+        delete updated.clientInfo;
+      }
+      updated.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      vault.entries[fallbackKey] = updated;
+    }
+    await writeVault(vault);
+  });
+}
+
+export {
+  getOAuthVaultPath,
+  loadVaultEntry,
+  saveVaultEntry,
+  clearVaultEntry
+};

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

@@ -0,0 +1,29 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  normalizeHttpUrl
+} from "./chunk-M3TPODXI.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/server-lookup.js
+function findServerByHttpUrl(definitions, urlString) {
+  const normalizedTarget = normalizeHttpUrl(urlString);
+  if (!normalizedTarget) {
+    return void 0;
+  }
+  for (const definition of definitions) {
+    if (definition.command.kind !== "http") {
+      continue;
+    }
+    const normalizedDefinitionUrl = normalizeHttpUrl(definition.command.url);
+    if (!normalizedDefinitionUrl) {
+      continue;
+    }
+    if (normalizedDefinitionUrl === normalizedTarget) {
+      return definition.name;
+    }
+  }
+  return void 0;
+}
+
+export {
+  findServerByHttpUrl
+};