@introspection-ai/recipes 0.13.0 → 0.14.0

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

@@ -0,0 +1,150 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  UnauthorizedError
+} from "./chunk-P3PSC54P.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/error-classifier.js
+var AUTH_STATUSES = /* @__PURE__ */ new Set([401, 403]);
+var OFFLINE_PATTERNS = [
+  "fetch failed",
+  "econnrefused",
+  "connection refused",
+  "connection closed",
+  "connection reset",
+  "socket hang up",
+  "connect timeout",
+  "network is unreachable",
+  "timed out",
+  "timeout",
+  "timeout after",
+  "getaddrinfo",
+  "enotfound",
+  "enoent",
+  "eai_again",
+  "econnaborted",
+  "ehostunreach",
+  "no such host",
+  "failed to start",
+  "spawn enoent"
+];
+var HTTP_STATUS_FALLBACK = /\bhttps?:\/\/[^\s]+(?:\s+returned\s+)?(?:status|code)?\s*(\d{3})\b/i;
+var STATUS_DIRECT_PATTERN = /\b(?:status(?:\s+code)?|http(?:\s+(?:status|code|error))?)[:\s]*(\d{3})\b/i;
+var STDIO_EXIT_PATTERN = /exit(?:ed)?(?:\s+with)?(?:\s+(?:code|status))\s+(-?\d+)/i;
+var STDIO_SIGNAL_PATTERN = /signal\s+([A-Z0-9]+)/i;
+function analyzeConnectionError(error) {
+  const rawMessage = extractMessage(error);
+  if (error instanceof UnauthorizedError) {
+    return { kind: "auth", rawMessage };
+  }
+  const stdio = extractStdioExit(rawMessage);
+  if (stdio) {
+    return { kind: "stdio-exit", rawMessage, ...stdio };
+  }
+  const errorCode = extractErrorCode(error);
+  const statusCode = errorCode ?? extractStatusCode(rawMessage);
+  const normalized = rawMessage.toLowerCase();
+  if (AUTH_STATUSES.has(statusCode ?? -1) || containsAuthToken(normalized)) {
+    return { kind: "auth", rawMessage, statusCode };
+  }
+  if (statusCode && statusCode >= 400) {
+    return { kind: "http", rawMessage, statusCode };
+  }
+  if (OFFLINE_PATTERNS.some((pattern) => normalized.includes(pattern))) {
+    return { kind: "offline", rawMessage };
+  }
+  return { kind: "other", rawMessage };
+}
+function extractMessage(error) {
+  if (error instanceof Error) {
+    return error.message ?? "";
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error === void 0 || error === null) {
+    return "";
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return "";
+  }
+}
+function extractErrorCode(error) {
+  if (typeof error === "object" && error !== null && "code" in error) {
+    const code = error.code;
+    if (typeof code === "number" && Number.isFinite(code) && code >= 100 && code < 600) {
+      return code;
+    }
+  }
+  return void 0;
+}
+function extractStatusCode(message) {
+  const candidates = [
+    message.match(/status code\s*\((\d{3})\)/i)?.[1],
+    message.match(STATUS_DIRECT_PATTERN)?.[1],
+    message.match(HTTP_STATUS_FALLBACK)?.[1]
+  ].filter(Boolean);
+  for (const candidate of candidates) {
+    const parsed = Number.parseInt(candidate, 10);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  const trimmed = message.trim();
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      const candidate = findStatusInObject(parsed);
+      if (typeof candidate === "number") {
+        return candidate;
+      }
+      if (typeof candidate === "string") {
+        const numeric = Number.parseInt(candidate, 10);
+        if (Number.isFinite(numeric)) {
+          return numeric;
+        }
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function containsAuthToken(normalizedMessage) {
+  return normalizedMessage.includes("401") || normalizedMessage.includes("unauthorized") || normalizedMessage.includes("invalid_token") || normalizedMessage.includes("forbidden");
+}
+function extractStdioExit(message) {
+  if (!message.toLowerCase().includes("stdio") && !STDIO_EXIT_PATTERN.test(message)) {
+    return void 0;
+  }
+  const exitMatch = message.match(STDIO_EXIT_PATTERN);
+  const signalMatch = message.match(STDIO_SIGNAL_PATTERN);
+  if (!exitMatch && !signalMatch) {
+    return void 0;
+  }
+  const exitCode = exitMatch ? Number.parseInt(exitMatch[1] ?? "", 10) : void 0;
+  return {
+    stdioExitCode: Number.isFinite(exitCode) ? exitCode : void 0,
+    stdioSignal: signalMatch?.[1]
+  };
+}
+function findStatusInObject(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const record = value;
+  if (typeof record.status === "number" || typeof record.status === "string") {
+    return record.status;
+  }
+  if (typeof record.code === "number" || typeof record.code === "string") {
+    return record.code;
+  }
+  if (typeof record.error === "object" && record.error !== null) {
+    return findStatusInObject(record.error);
+  }
+  return void 0;
+}
+
+export {
+  analyzeConnectionError
+};

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

@@ -0,0 +1,37 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  createPrefixedConsoleLogger,
+  resolveLogLevelFromEnv
+} from "./chunk-6W5QFASN.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/logger-context.js
+var activeLogLevel = resolveLogLevelFromEnv();
+var activeLogger = createPrefixedConsoleLogger("mcporter", activeLogLevel);
+function getActiveLogLevel() {
+  return activeLogLevel;
+}
+function getActiveLogger() {
+  return activeLogger;
+}
+function setLogLevel(level) {
+  activeLogLevel = level;
+  activeLogger = createPrefixedConsoleLogger("mcporter", activeLogLevel);
+}
+function logInfo(message) {
+  activeLogger.info(message);
+}
+function logWarn(message) {
+  activeLogger.warn(message);
+}
+function logError(message, error) {
+  activeLogger.error(message, error);
+}
+
+export {
+  getActiveLogLevel,
+  getActiveLogger,
+  setLogLevel,
+  logInfo,
+  logWarn,
+  logError
+};

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

@@ -0,0 +1,138 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  findServerByHttpUrl
+} from "./chunk-TEUKFFQL.js";
+import {
+  persistEphemeralServer,
+  resolveEphemeralServer,
+  splitCommandLine
+} from "./chunk-E22DYOW5.js";
+import {
+  looksLikeHttpUrl,
+  normalizeHttpUrlCandidate
+} from "./chunk-M3TPODXI.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/ephemeral-target.js
+async function prepareEphemeralServerTarget(options) {
+  let target = options.target;
+  let spec = options.ephemeral ? { ...options.ephemeral } : void 0;
+  const promoteUrlCandidate = (value) => {
+    if (!value) {
+      return value;
+    }
+    const normalized = normalizeHttpUrlCandidate(value);
+    if (!normalized) {
+      return value;
+    }
+    const reused = findServerByHttpUrl(options.runtime.getDefinitions(), normalized);
+    if (reused) {
+      return reused;
+    }
+    if (!spec) {
+      spec = { httpUrl: normalized };
+    } else if (!spec.httpUrl) {
+      spec = { ...spec, httpUrl: normalized };
+    }
+    return void 0;
+  };
+  target = promoteUrlCandidate(target);
+  if (!spec) {
+    const inferredInline = inferInlineStdioSpec(target);
+    if (inferredInline) {
+      spec = inferredInline;
+      target = void 0;
+    }
+  }
+  if (spec) {
+    applyNameHints(spec, options.nameHints);
+  }
+  if (!spec) {
+    return { target };
+  }
+  if (spec.httpUrl) {
+    const normalized = normalizeHttpUrlCandidate(spec.httpUrl);
+    if (normalized) {
+      spec = { ...spec, httpUrl: normalized };
+      if (options.reuseFromSpec) {
+        const reused = findServerByHttpUrl(options.runtime.getDefinitions(), normalized);
+        if (reused) {
+          return { target: reused };
+        }
+      }
+    }
+  }
+  const resolution = resolveEphemeralServer(spec);
+  options.runtime.registerDefinition(resolution.definition, { overwrite: true });
+  if (spec.persistPath) {
+    await persistEphemeralServer(resolution, spec.persistPath);
+  }
+  const resolvedTarget = target ?? resolution.name;
+  return { target: resolvedTarget, resolution, persistPath: spec.persistPath };
+}
+async function persistPreparedEphemeralServer(runtime, prepared) {
+  if (!prepared?.resolution || !prepared.persistPath) {
+    return;
+  }
+  let currentDefinition;
+  try {
+    currentDefinition = runtime.getDefinition(prepared.resolution.name);
+  } catch {
+    return;
+  }
+  const persistedEntry = { ...prepared.resolution.persistedEntry };
+  if (currentDefinition.auth === "oauth") {
+    persistedEntry.auth = "oauth";
+  }
+  await persistEphemeralServer({
+    ...prepared.resolution,
+    persistedEntry
+  }, prepared.persistPath);
+}
+function applyNameHints(spec, hints) {
+  if (!spec || spec.name || !hints) {
+    return;
+  }
+  for (const hint of hints) {
+    if (!hint) {
+      continue;
+    }
+    if (looksLikeHttpUrl(hint)) {
+      continue;
+    }
+    spec.name = hint;
+    break;
+  }
+}
+function inferInlineStdioSpec(target) {
+  if (!target) {
+    return void 0;
+  }
+  const trimmed = target.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  if (looksLikeHttpUrl(trimmed)) {
+    return void 0;
+  }
+  if (!trimmed.includes(" ")) {
+    return void 0;
+  }
+  try {
+    const parts = splitCommandLine(trimmed);
+    if (parts.length < 2) {
+      return void 0;
+    }
+    const executable = parts[0]?.split(/[\\/]/).pop();
+    if (executable !== "npx") {
+      return void 0;
+    }
+    return { stdioCommand: trimmed };
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  prepareEphemeralServerTarget,
+  persistPreparedEphemeralServer
+};

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

@@ -0,0 +1,73 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  expandHome,
+  mcporterConfigCandidates
+} from "./chunk-ECIVB7P4.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/config/path-discovery.js
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+async function listConfigLayerPaths(options = {}, rootDir = process.cwd()) {
+  const explicitPath = options.configPath ?? process.env.MCPORTER_CONFIG;
+  if (explicitPath) {
+    return [path.resolve(expandHome(explicitPath.trim()))];
+  }
+  const paths = [];
+  const homeCandidates = homeConfigCandidates();
+  const existingHome = homeCandidates.find((candidate) => pathExists(candidate));
+  if (existingHome) {
+    paths.push(existingHome);
+  }
+  const projectPath = path.resolve(rootDir, "config", "mcporter.json");
+  if (pathExists(projectPath)) {
+    paths.push(projectPath);
+  }
+  return paths;
+}
+function resolveConfigPath(configPath, rootDir) {
+  if (configPath) {
+    return { path: path.resolve(configPath), explicit: true };
+  }
+  const envConfig = process.env.MCPORTER_CONFIG;
+  if (envConfig && envConfig.trim().length > 0) {
+    return { path: path.resolve(expandHome(envConfig.trim())), explicit: true };
+  }
+  const projectPath = path.resolve(rootDir, "config", "mcporter.json");
+  if (pathExists(projectPath)) {
+    return { path: projectPath, explicit: false };
+  }
+  const homeCandidates = homeConfigCandidates();
+  const existingHome = homeCandidates.find((candidate) => pathExists(candidate));
+  if (existingHome) {
+    return { path: existingHome, explicit: false };
+  }
+  return { path: projectPath, explicit: false };
+}
+function homeConfigCandidates() {
+  return mcporterConfigCandidates();
+}
+function pathExists(filePath) {
+  try {
+    fsSync.accessSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function pathExistsAsync(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  listConfigLayerPaths,
+  resolveConfigPath,
+  homeConfigCandidates,
+  pathExists,
+  pathExistsAsync
+};