@introspection-ai/recipes 0.13.0 → 0.14.1

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

@@ -0,0 +1,44 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  buildToolMetadataList
+} from "./chunk-XANPGTLI.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/tool-cache.js
+var runtimeCache = /* @__PURE__ */ new WeakMap();
+function cacheKey(serverName, options) {
+  const includeSchema = options.includeSchema !== false;
+  const autoAuthorize = options.autoAuthorize !== false;
+  const allowCachedAuth = options.allowCachedAuth !== false;
+  const disableOAuth = options.disableOAuth === true;
+  return `${serverName}::schema:${includeSchema ? "1" : "0"}::auth:${autoAuthorize ? "1" : "0"}::cached-auth:${allowCachedAuth ? "1" : "0"}::disable-oauth:${disableOAuth ? "1" : "0"}`;
+}
+async function loadToolMetadata(runtime, serverName, options = {}) {
+  const key = cacheKey(serverName, options);
+  let cache = runtimeCache.get(runtime);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    runtimeCache.set(runtime, cache);
+  }
+  const existing = cache.get(key);
+  if (existing) {
+    return existing;
+  }
+  const includeSchema = options.includeSchema !== false;
+  const autoAuthorize = options.autoAuthorize !== false;
+  const listOptions = {
+    includeSchema,
+    autoAuthorize,
+    allowCachedAuth: options.allowCachedAuth ?? true,
+    disableOAuth: options.disableOAuth
+  };
+  const promise = runtime.listTools(serverName, listOptions).then((tools) => buildToolMetadataList(tools, { sort: false })).catch((error) => {
+    cache?.delete(key);
+    throw error;
+  });
+  cache.set(key, promise);
+  return promise;
+}
+
+export {
+  loadToolMetadata
+};

package/dist/mcp-chunks/chunk-J6LYIZXN.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/record-replay-env.js
+var KEEP_ALIVE_DISABLED_FOR_MODE = "*";
+function buildRecordCommandEnv(sessionName, server) {
+  return buildModeEnv({
+    MCPORTER_RECORD: sessionName,
+    MCPORTER_RECORD_SERVER: server,
+    MCPORTER_DISABLE_KEEPALIVE: KEEP_ALIVE_DISABLED_FOR_MODE
+  }, ["MCPORTER_REPLAY", "MCPORTER_REPLAY_SERVER"]);
+}
+function buildReplayCommandEnv(sessionName, server) {
+  return buildModeEnv({
+    MCPORTER_REPLAY: sessionName,
+    MCPORTER_REPLAY_SERVER: server,
+    MCPORTER_DISABLE_KEEPALIVE: KEEP_ALIVE_DISABLED_FOR_MODE
+  }, ["MCPORTER_RECORD", "MCPORTER_RECORD_SERVER"]);
+}
+function isRecordReplayModeActive(env = process.env) {
+  return Boolean(env.MCPORTER_RECORD || env.MCPORTER_REPLAY);
+}
+function isReplayModeActive(env = process.env) {
+  return Boolean(!env.MCPORTER_RECORD && env.MCPORTER_REPLAY);
+}
+function buildModeEnv(set, unset) {
+  const env = { ...process.env };
+  for (const key of unset) {
+    delete env[key];
+  }
+  for (const [key, value] of Object.entries(set)) {
+    if (value) {
+      env[key] = value;
+    } else {
+      delete env[key];
+    }
+  }
+  return env;
+}
+
+export {
+  buildRecordCommandEnv,
+  buildReplayCommandEnv,
+  isRecordReplayModeActive,
+  isReplayModeActive
+};

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

@@ -0,0 +1,161 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  isKeepAliveServer
+} from "./chunk-LS7PMWSR.js";
+import {
+  ErrorCode,
+  McpError
+} from "./chunk-D3MRAZ6H.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/daemon/runtime-wrapper.js
+function createKeepAliveRuntime(base, options) {
+  if (!options.daemonClient || options.keepAliveServers.size === 0) {
+    return base;
+  }
+  return new KeepAliveRuntime(base, options.daemonClient, options.keepAliveServers);
+}
+var KeepAliveRuntime = class {
+  base;
+  daemon;
+  keepAliveServers;
+  restartPromises = /* @__PURE__ */ new Map();
+  constructor(base, daemon, keepAliveServers) {
+    this.base = base;
+    this.daemon = daemon;
+    this.keepAliveServers = keepAliveServers;
+  }
+  listServers() {
+    return this.base.listServers();
+  }
+  getDefinitions() {
+    return this.base.getDefinitions();
+  }
+  getDefinition(server) {
+    return this.base.getDefinition(server);
+  }
+  registerDefinition(definition, options) {
+    this.base.registerDefinition(definition, options);
+    if (isKeepAliveServer(definition)) {
+      this.keepAliveServers.add(definition.name);
+    } else {
+      this.keepAliveServers.delete(definition.name);
+    }
+  }
+  async getInstructions(server) {
+    return this.base.getInstructions?.(server);
+  }
+  async listTools(server, options) {
+    if (options?.oauthSessionOptions) {
+      return this.base.listTools(server, options);
+    }
+    if (this.shouldUseDaemon(server)) {
+      return await this.invokeWithRestart(server, "listTools", () => this.daemon.listTools({
+        server,
+        includeSchema: options?.includeSchema,
+        autoAuthorize: options?.autoAuthorize,
+        allowCachedAuth: options?.allowCachedAuth ?? true,
+        disableOAuth: options?.disableOAuth
+      }));
+    }
+    return this.base.listTools(server, options);
+  }
+  async callTool(server, toolName, options) {
+    if (this.shouldUseDaemon(server)) {
+      return this.invokeWithRestart(server, "callTool", () => this.daemon.callTool({
+        server,
+        tool: toolName,
+        args: options?.args,
+        timeoutMs: options?.timeoutMs,
+        disableOAuth: options?.disableOAuth
+      }));
+    }
+    return this.base.callTool(server, toolName, options);
+  }
+  async listResources(server, options) {
+    if (options?.oauthSessionOptions) {
+      return this.base.listResources(server, options);
+    }
+    const { allowCachedAuth, disableOAuth, ...params } = options ?? {};
+    if (this.shouldUseDaemon(server)) {
+      return this.invokeWithRestart(server, "listResources", () => this.daemon.listResources({ server, params, allowCachedAuth, disableOAuth }));
+    }
+    return this.base.listResources(server, options);
+  }
+  async readResource(server, uri, options) {
+    if (options?.oauthSessionOptions) {
+      return this.base.readResource(server, uri, options);
+    }
+    if (this.shouldUseDaemon(server)) {
+      return this.invokeWithRestart(server, "readResource", () => this.daemon.readResource({
+        server,
+        uri,
+        allowCachedAuth: options?.allowCachedAuth,
+        disableOAuth: options?.disableOAuth
+      }));
+    }
+    return this.base.readResource(server, uri, options);
+  }
+  async connect(server, options) {
+    return this.base.connect(server, options);
+  }
+  async close(server) {
+    if (!server) {
+      await this.base.close();
+      return;
+    }
+    if (this.shouldUseDaemon(server)) {
+      await this.daemon.closeServer({ server }).catch(() => {
+      });
+      return;
+    }
+    await this.base.close(server);
+  }
+  shouldUseDaemon(server) {
+    return this.keepAliveServers.has(server);
+  }
+  async invokeWithRestart(server, operation, action) {
+    try {
+      return await action();
+    } catch (error) {
+      if (!shouldRestartDaemonServer(error)) {
+        throw error;
+      }
+      logDaemonRetry(server, operation, error);
+      await this.restartServer(server);
+      return action();
+    }
+  }
+  async restartServer(server) {
+    const existing = this.restartPromises.get(server);
+    if (existing) {
+      await existing;
+      return;
+    }
+    const restart = this.daemon.closeServer({ server }).catch(() => {
+    });
+    this.restartPromises.set(server, restart);
+    try {
+      await restart;
+    } finally {
+      this.restartPromises.delete(server);
+    }
+  }
+};
+var NON_FATAL_CODES = /* @__PURE__ */ new Set([ErrorCode.InvalidRequest, ErrorCode.MethodNotFound, ErrorCode.InvalidParams]);
+function shouldRestartDaemonServer(error) {
+  if (!error) {
+    return false;
+  }
+  if (error instanceof McpError) {
+    return !NON_FATAL_CODES.has(error.code);
+  }
+  return true;
+}
+function logDaemonRetry(server, operation, error) {
+  const reason = error instanceof Error ? error.message : String(error);
+  console.error(`[mcporter] Restarting '${server}' before retrying ${operation}: ${reason}`);
+}
+
+export {
+  createKeepAliveRuntime
+};

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

@@ -0,0 +1,141 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  consumeTimeoutFlag
+} from "./chunk-BNV3TPE4.js";
+import {
+  extractEphemeralServerFlags
+} from "./chunk-LQQEYD76.js";
+import {
+  consumeOutputFormat
+} from "./chunk-YVZKMV5H.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/list-flags.js
+function extractListFlags(args) {
+  let schema = false;
+  let timeoutMs;
+  let requiredOnly = true;
+  let verbose = false;
+  let includeSources = false;
+  let brief = false;
+  let quiet = false;
+  let exitCode = false;
+  let statusOnly = false;
+  let disableOAuth = false;
+  const format = consumeOutputFormat(args, {
+    defaultFormat: "text",
+    allowed: ["text", "json"],
+    enableRawShortcut: false,
+    jsonShortcutFlag: "--json"
+  });
+  const ephemeral = extractEphemeralServerFlags(args);
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (token === "--schema") {
+      schema = true;
+      args.splice(index, 1);
+      continue;
+    }
+    if (token === "--yes") {
+      args.splice(index, 1);
+      continue;
+    }
+    if (token === "--all-parameters") {
+      requiredOnly = false;
+      args.splice(index, 1);
+      continue;
+    }
+    if (token === "--verbose") {
+      verbose = true;
+      args.splice(index, 1);
+      continue;
+    }
+    if (token === "--sources") {
+      includeSources = true;
+      args.splice(index, 1);
+      continue;
+    }
+    if (token === "--brief" || token === "--signatures") {
+      brief = true;
+      args.splice(index, 1);
+      continue;
+    }
+    if (token === "--quiet") {
+      quiet = true;
+      exitCode = true;
+      args.splice(index, 1);
+      continue;
+    }
+    if (token === "--exit-code") {
+      exitCode = true;
+      args.splice(index, 1);
+      continue;
+    }
+    if (token === "--status") {
+      statusOnly = true;
+      args.splice(index, 1);
+      continue;
+    }
+    if (token === "--no-oauth") {
+      disableOAuth = true;
+      args.splice(index, 1);
+      continue;
+    }
+    if (token === "--timeout") {
+      timeoutMs = consumeTimeoutFlag(args, index, { flagName: "--timeout" });
+      continue;
+    }
+    index += 1;
+  }
+  if (brief) {
+    const conflicts = [];
+    if (format === "json") {
+      conflicts.push("--json");
+    }
+    if (schema) {
+      conflicts.push("--schema");
+    }
+    if (verbose) {
+      conflicts.push("--verbose");
+    }
+    if (!requiredOnly) {
+      conflicts.push("--all-parameters");
+    }
+    if (conflicts.length > 0) {
+      throw new Error(`--brief cannot be used with ${conflicts.join(", ")}`);
+    }
+  }
+  if (statusOnly) {
+    const conflicts = [];
+    if (brief) {
+      conflicts.push("--brief");
+    }
+    if (schema) {
+      conflicts.push("--schema");
+    }
+    if (!requiredOnly) {
+      conflicts.push("--all-parameters");
+    }
+    if (conflicts.length > 0) {
+      throw new Error(`--status cannot be used with ${conflicts.join(", ")}`);
+    }
+  }
+  return {
+    schema,
+    timeoutMs,
+    requiredOnly,
+    ephemeral,
+    format,
+    verbose,
+    includeSources,
+    brief,
+    quiet,
+    exitCode,
+    statusOnly,
+    disableOAuth
+  };
+}
+
+export {
+  extractListFlags
+};

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

@@ -0,0 +1,208 @@
+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-metadata.js
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+function metadataPathForArtifact(artifactPath) {
+  return `${artifactPath}.metadata.json`;
+}
+async function readCliMetadata(artifactPath) {
+  let embeddedError;
+  try {
+    return await readMetadataFromCli(artifactPath);
+  } catch (error) {
+    embeddedError = error;
+  }
+  const legacyPath = metadataPathForArtifact(artifactPath);
+  try {
+    const buffer = await fs.readFile(legacyPath, "utf8");
+    return JSON.parse(buffer);
+  } catch (error) {
+    if (isErrno(error, "ENOENT") && embeddedError) {
+      throw embeddedError;
+    }
+    if (!isErrno(error, "ENOENT")) {
+      throw error;
+    }
+  }
+  throw embeddedError;
+}
+async function readMetadataFromCli(artifactPath) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(artifactPath, ["__mcporter_inspect"], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (data) => {
+      stdout += String(data);
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (data) => {
+      stderr += String(data);
+    });
+    child.on("error", (error) => reject(error));
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`Failed to inspect CLI artifact at ${artifactPath}${stderr ? `: ${stderr.trim()}` : ""} (exit code ${code ?? -1})`));
+        return;
+      }
+      try {
+        const parsed = JSON.parse(stdout);
+        resolve(parsed);
+      } catch (error) {
+        reject(new Error(`Unable to parse embedded metadata from ${artifactPath}: ${error instanceof Error ? error.message : String(error)}`));
+      }
+    });
+  });
+}
+function isErrno(error, code) {
+  return Boolean(error && typeof error === "object" && error.code === code);
+}
+function serializeDefinition(definition) {
+  if (definition.command.kind === "http") {
+    return {
+      name: definition.name,
+      description: definition.description,
+      command: {
+        kind: "http",
+        url: definition.command.url.toString(),
+        headers: definition.command.headers
+      },
+      env: definition.env,
+      auth: definition.auth,
+      tokenCacheDir: definition.tokenCacheDir,
+      clientName: definition.clientName,
+      oauthClientId: definition.oauthClientId,
+      oauthClientSecretEnv: definition.oauthClientSecretEnv,
+      oauthTokenEndpointAuthMethod: definition.oauthTokenEndpointAuthMethod,
+      oauthRedirectUrl: definition.oauthRedirectUrl,
+      oauthScope: definition.oauthScope,
+      refresh: definition.refresh,
+      httpFetch: definition.httpFetch,
+      allowedTools: definition.allowedTools,
+      blockedTools: definition.blockedTools
+    };
+  }
+  return {
+    name: definition.name,
+    description: definition.description,
+    command: {
+      kind: "stdio",
+      command: definition.command.command,
+      args: [...definition.command.args],
+      cwd: definition.command.cwd
+    },
+    env: definition.env,
+    auth: definition.auth,
+    tokenCacheDir: definition.tokenCacheDir,
+    clientName: definition.clientName,
+    oauthClientId: definition.oauthClientId,
+    oauthClientSecretEnv: definition.oauthClientSecretEnv,
+    oauthTokenEndpointAuthMethod: definition.oauthTokenEndpointAuthMethod,
+    oauthRedirectUrl: definition.oauthRedirectUrl,
+    oauthScope: definition.oauthScope,
+    refresh: definition.refresh,
+    httpFetch: definition.httpFetch,
+    allowedTools: definition.allowedTools,
+    blockedTools: definition.blockedTools
+  };
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/template-data.js
+function buildGenerateCliCommand(invocation, definition, globalFlags = {}) {
+  const tokens = ["mcporter"];
+  const configPath = invocation.configPath ?? globalFlags["--config"];
+  const rootDir = invocation.rootDir ?? globalFlags["--root"];
+  if (configPath) {
+    tokens.push("--config", configPath);
+  }
+  if (rootDir) {
+    tokens.push("--root", rootDir);
+  }
+  tokens.push("generate-cli");
+  const serverRef = invocation.serverRef ?? definition.name ?? JSON.stringify(definition);
+  tokens.push("--server", serverRef);
+  if (invocation.outputPath) {
+    tokens.push("--output", invocation.outputPath);
+  }
+  if (invocation.bundler && invocation.bundler !== "rolldown") {
+    tokens.push("--bundler", invocation.bundler);
+  }
+  if (typeof invocation.bundle === "string") {
+    tokens.push("--bundle", invocation.bundle);
+  } else if (invocation.bundle) {
+    tokens.push("--bundle");
+  }
+  if (typeof invocation.compile === "string") {
+    tokens.push("--compile", invocation.compile);
+  } else if (invocation.compile) {
+    tokens.push("--compile");
+  }
+  if (invocation.runtime) {
+    tokens.push("--runtime", invocation.runtime);
+  }
+  if (invocation.timeoutMs && invocation.timeoutMs !== 3e4) {
+    tokens.push("--timeout", String(invocation.timeoutMs));
+  }
+  if (invocation.minify) {
+    tokens.push("--minify");
+  }
+  if (invocation.includeTools && invocation.includeTools.length > 0) {
+    tokens.push("--include-tools", invocation.includeTools.join(","));
+  }
+  if (invocation.excludeTools && invocation.excludeTools.length > 0) {
+    tokens.push("--exclude-tools", invocation.excludeTools.join(","));
+  }
+  return tokens.map(shellQuote).join(" ");
+}
+function resolveGenerateRequestFromArtifact(parsed, metadata, globalFlags) {
+  if (!parsed.from) {
+    throw new Error("Missing --from artifact path.");
+  }
+  const invocation = { ...metadata.invocation };
+  const serverRef = parsed.server ?? invocation.serverRef ?? metadata.server.name ?? JSON.stringify(metadata.server.definition);
+  if (!serverRef) {
+    throw new Error("Unable to determine server definition from artifact; pass --server with a target name.");
+  }
+  const includeTools = parsed.includeTools ?? invocation.includeTools;
+  const excludeTools = parsed.excludeTools ?? invocation.excludeTools;
+  if (includeTools && excludeTools) {
+    throw new Error("Cannot combine --include-tools and --exclude-tools.");
+  }
+  if (includeTools && includeTools.length === 0) {
+    throw new Error("--include-tools requires at least one tool name.");
+  }
+  if (excludeTools && excludeTools.length === 0) {
+    throw new Error("--exclude-tools requires at least one tool name.");
+  }
+  return {
+    serverRef,
+    configPath: globalFlags["--config"] ?? invocation.configPath,
+    rootDir: globalFlags["--root"] ?? invocation.rootDir,
+    outputPath: parsed.output ?? invocation.outputPath,
+    runtime: parsed.runtime ?? invocation.runtime,
+    bundler: parsed.bundler ?? invocation.bundler,
+    bundle: parsed.bundle ?? invocation.bundle,
+    timeoutMs: parsed.timeout ?? invocation.timeoutMs,
+    compile: parsed.compile ?? invocation.compile,
+    minify: parsed.minify ?? invocation.minify ?? false,
+    includeTools,
+    excludeTools
+  };
+}
+function shellQuote(value) {
+  if (/^[A-Za-z0-9_./@%-]+$/.test(value)) {
+    return value;
+  }
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+export {
+  readCliMetadata,
+  serializeDefinition,
+  buildGenerateCliCommand,
+  resolveGenerateRequestFromArtifact,
+  shellQuote
+};