@introspection-ai/recipes 0.13.0 → 0.14.0

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

@@ -0,0 +1,251 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  __configInternals
+} from "./chunk-2U4BSDC4.js";
+import {
+  withFileLock,
+  writeTextFileAtomic
+} from "./chunk-2XL7MG7R.js";
+import {
+  expandHome
+} from "./chunk-ECIVB7P4.js";
+import {
+  canonicalKeepAliveName,
+  resolveLifecycle
+} from "./chunk-LS7PMWSR.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/adhoc-server.js
+import fs from "node:fs/promises";
+import path from "node:path";
+var TEMP_SOURCE = { kind: "local", path: "<adhoc>" };
+function resolveEphemeralServer(spec) {
+  if (!spec.httpUrl && !spec.stdioCommand) {
+    throw new Error("Ad-hoc servers require either --http-url or --stdio.");
+  }
+  if (spec.httpUrl && spec.stdioCommand) {
+    throw new Error("Cannot combine --http-url and --stdio in the same ad-hoc server.");
+  }
+  if (spec.httpUrl) {
+    const url = new URL(spec.httpUrl);
+    if (url.protocol !== "https:" && url.protocol !== "http:") {
+      throw new Error(`Unsupported protocol '${url.protocol}' for --http-url.`);
+    }
+    if (url.protocol === "http:" && !spec.allowInsecureHttp) {
+      throw new Error("HTTP endpoints require --allow-http to confirm insecure usage.");
+    }
+    const command2 = {
+      kind: "http",
+      url,
+      headers: __configInternals.ensureHttpAcceptHeader(spec.headers)
+    };
+    const canonical2 = spec.name ? void 0 : canonicalKeepAliveName(command2);
+    const name2 = normalizeEphemeralName(spec.name ?? canonical2 ?? inferNameFromUrl(url));
+    const lifecycle2 = resolveLifecycle(name2, void 0, command2);
+    const definition2 = {
+      name: name2,
+      description: spec.description,
+      command: command2,
+      env: spec.env && Object.keys(spec.env).length > 0 ? spec.env : void 0,
+      source: TEMP_SOURCE,
+      lifecycle: lifecycle2
+    };
+    const persistedEntry2 = {
+      baseUrl: url.href,
+      ...spec.description ? { description: spec.description } : {},
+      ...spec.env && Object.keys(spec.env).length > 0 ? { env: spec.env } : {},
+      ...spec.headers && Object.keys(spec.headers).length > 0 ? { headers: spec.headers } : {},
+      ...lifecycle2 ? { lifecycle: serializeLifecycle(lifecycle2) } : {}
+    };
+    return { definition: definition2, name: name2, persistedEntry: persistedEntry2 };
+  }
+  const stdioCommand = spec.stdioCommand;
+  const parts = splitCommandLine(stdioCommand);
+  if (parts.length === 0) {
+    throw new Error("--stdio requires a non-empty command.");
+  }
+  const [commandBinary, ...commandRest] = parts;
+  const commandArgs = commandRest.concat(spec.stdioArgs ?? []);
+  const cwd = spec.cwd ? path.resolve(spec.cwd) : process.cwd();
+  const command = {
+    kind: "stdio",
+    command: commandBinary,
+    args: commandArgs,
+    cwd
+  };
+  const canonical = spec.name ? void 0 : canonicalKeepAliveName(command);
+  const name = normalizeEphemeralName(spec.name ?? canonical ?? inferNameFromCommand(parts));
+  const lifecycle = resolveLifecycle(name, void 0, command);
+  const definition = {
+    name,
+    description: spec.description,
+    command,
+    env: spec.env && Object.keys(spec.env).length > 0 ? spec.env : void 0,
+    source: TEMP_SOURCE,
+    lifecycle
+  };
+  const persistedEntry = {
+    command: commandBinary,
+    ...commandArgs.length > 0 ? { args: commandArgs } : {},
+    ...spec.description ? { description: spec.description } : {},
+    ...spec.env && Object.keys(spec.env).length > 0 ? { env: spec.env } : {},
+    ...lifecycle ? { lifecycle: serializeLifecycle(lifecycle) } : {}
+  };
+  if (spec.cwd) {
+    persistedEntry.cwd = spec.cwd;
+  }
+  return { definition, name, persistedEntry };
+}
+async function persistEphemeralServer(resolution, rawPath) {
+  const resolvedPath = path.resolve(expandHome(rawPath));
+  await withFileLock(resolvedPath, async () => {
+    let existing;
+    try {
+      const buffer = await fs.readFile(resolvedPath, "utf8");
+      existing = JSON.parse(buffer);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+      existing = { mcpServers: {} };
+    }
+    if (typeof existing.mcpServers !== "object" || existing.mcpServers === null) {
+      existing.mcpServers = {};
+    }
+    const servers = existing.mcpServers;
+    servers[resolution.name] = resolution.persistedEntry;
+    const serialized = `${JSON.stringify(existing, null, 2)}
+`;
+    await writeTextFileAtomic(resolvedPath, serialized);
+  });
+}
+function inferNameFromUrl(url) {
+  const host = url.hostname.replace(/^www\./, "");
+  const pathSegments = url.pathname.split("/").filter(Boolean);
+  if (pathSegments.length === 0) {
+    return host;
+  }
+  return `${host}-${pathSegments[pathSegments.length - 1]}`;
+}
+function inferNameFromCommand(parts) {
+  const wrapperPackage = inferPackageFromWrapper(parts);
+  if (wrapperPackage) {
+    return wrapperPackage;
+  }
+  const executable = path.basename(parts[0] ?? "command");
+  if (parts.length === 1) {
+    return executable;
+  }
+  const script = parts.find((segment) => segment.endsWith(".ts") || segment.endsWith(".js"));
+  if (script) {
+    return `${executable}-${path.basename(script, path.extname(script))}`;
+  }
+  const fallback = parts[1] ?? "tool";
+  return `${executable}-${fallback}`;
+}
+function inferPackageFromWrapper(parts) {
+  if (parts.length < 2) {
+    return void 0;
+  }
+  const executable = path.basename(parts[0] ?? "");
+  if (executable !== "npx") {
+    return void 0;
+  }
+  for (let index = 1; index < parts.length; index += 1) {
+    const token = parts[index];
+    if (!token) {
+      continue;
+    }
+    if (token === "--") {
+      break;
+    }
+    if (token.startsWith("-")) {
+      continue;
+    }
+    return stripPackageVersion(token);
+  }
+  return void 0;
+}
+function stripPackageVersion(token) {
+  if (token.startsWith("@")) {
+    const secondAt = token.indexOf("@", 1);
+    if (secondAt !== -1) {
+      return token.slice(0, secondAt);
+    }
+    return token;
+  }
+  const versionAt = token.indexOf("@");
+  if (versionAt > 0) {
+    return token.slice(0, versionAt);
+  }
+  return token;
+}
+function slugify(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+}
+function normalizeEphemeralName(value) {
+  const name = slugify(value);
+  if (!name) {
+    throw new Error("Ad-hoc server name must contain at least one letter or digit.");
+  }
+  return name;
+}
+function splitCommandLine(input) {
+  const result = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < input.length; i += 1) {
+    const char = input.charAt(i);
+    if (char === "'" && !inDouble) {
+      inSingle = !inSingle;
+      continue;
+    }
+    if (char === '"' && !inSingle) {
+      inDouble = !inDouble;
+      continue;
+    }
+    if (!inSingle && !inDouble && /\s/.test(char)) {
+      if (current !== "") {
+        result.push(current);
+        current = "";
+      }
+      continue;
+    }
+    if (char === "\\" && !inSingle && i + 1 < input.length) {
+      const next = input.charAt(i + 1);
+      if (inDouble && next !== '"' && next !== "\\" && next !== "$") {
+        current += char;
+        continue;
+      }
+      current += next;
+      i += 1;
+      continue;
+    }
+    current += char;
+  }
+  if (inSingle || inDouble) {
+    throw new Error("Unterminated quote in --stdio command.");
+  }
+  if (current !== "") {
+    result.push(current);
+  }
+  return result;
+}
+function serializeLifecycle(lifecycle) {
+  if (!lifecycle) {
+    return void 0;
+  }
+  if (lifecycle.mode === "keep-alive" && lifecycle.idleTimeoutMs === void 0) {
+    return "keep-alive";
+  }
+  if (lifecycle.mode === "keep-alive") {
+    return { mode: "keep-alive", idleTimeoutMs: lifecycle.idleTimeoutMs };
+  }
+  return "ephemeral";
+}
+
+export {
+  resolveEphemeralServer,
+  persistEphemeralServer,
+  splitCommandLine
+};

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

@@ -0,0 +1,139 @@
+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
+import os from "node:os";
+import path from "node:path";
+var ENV_DEFAULT_PATTERN = /^\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-|:|-)?([^}]*)\}$/;
+var ENV_INTERPOLATION_PATTERN = /\\?\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-(.*?))?\}/g;
+var ENV_DIRECT_PREFIX = "$env:";
+function expandHome(input) {
+  if (!input.startsWith("~")) {
+    return input;
+  }
+  const home = os.homedir();
+  if (input === "~") {
+    return home;
+  }
+  if (input.startsWith("~/") || input.startsWith("~\\")) {
+    return path.join(home, input.slice(2));
+  }
+  return input;
+}
+function resolveEnvValue(raw) {
+  if (typeof raw !== "string") {
+    return String(raw);
+  }
+  const match = ENV_DEFAULT_PATTERN.exec(raw);
+  if (match) {
+    const envName = match[1];
+    const defaultValue = match[2] ?? "";
+    if (!envName) {
+      return raw;
+    }
+    const existing = process.env[envName];
+    if (existing && existing !== "") {
+      return existing;
+    }
+    return defaultValue;
+  }
+  if (raw.startsWith("$")) {
+    return resolveEnvPlaceholders(raw);
+  }
+  return raw;
+}
+function resolveEnvPlaceholders(value) {
+  if (value.startsWith(ENV_DIRECT_PREFIX)) {
+    const envName = value.slice(ENV_DIRECT_PREFIX.length);
+    const envValue = process.env[envName];
+    if (envValue === void 0) {
+      throw new Error(`Environment variable '${envName}' is required for MCP header substitution.`);
+    }
+    return envValue;
+  }
+  const missing = /* @__PURE__ */ new Set();
+  const replaced = value.replace(ENV_INTERPOLATION_PATTERN, (placeholder, envName, fallback) => {
+    const envValue = process.env[envName];
+    if (envValue !== void 0 && envValue !== "") {
+      return envValue;
+    }
+    if (fallback !== void 0) {
+      return fallback;
+    }
+    if (envValue === void 0) {
+      missing.add(envName);
+      return placeholder;
+    }
+    return envValue;
+  });
+  if (missing.size > 0) {
+    const names = [...missing].toSorted().join(", ");
+    throw new Error(`Environment variable(s) ${names} must be set for MCP header substitution.`);
+  }
+  return replaced;
+}
+async function withEnvOverrides(envOverrides, fn) {
+  if (!envOverrides || Object.keys(envOverrides).length === 0) {
+    return await fn();
+  }
+  const applied = [];
+  for (const [key, rawValue] of Object.entries(envOverrides)) {
+    if (process.env[key]) {
+      continue;
+    }
+    const resolved = resolveEnvValue(rawValue);
+    if (resolved === "") {
+      continue;
+    }
+    process.env[key] = resolved;
+    applied.push(key);
+  }
+  try {
+    return await fn();
+  } finally {
+    for (const key of applied) {
+      delete process.env[key];
+    }
+  }
+}
+
+// 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
+};