@introspection-ai/recipes 0.13.0 → 0.14.0

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

@@ -0,0 +1,152 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  logWarn
+} from "./chunk-UNKB4SBV.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/output-utils.js
+import fs from "node:fs";
+import path from "node:path";
+import { inspect } from "node:util";
+var RAW_INSPECT_DEPTH = 8;
+var PREFERRED_OUTPUT_BY_FORMAT = {
+  auto: ["json", "markdown", "text", "raw"],
+  text: ["text", "markdown", "json", "raw"],
+  markdown: ["markdown", "text", "json", "raw"],
+  json: ["json", "raw"],
+  raw: ["raw"]
+};
+function printCallOutput(wrapped, raw, format) {
+  const preferredKinds = PREFERRED_OUTPUT_BY_FORMAT[format];
+  const renderable = resolveRenderableOutput(wrapped, raw, preferredKinds);
+  emitRenderableOutput(renderable, format);
+}
+function tailLogIfRequested(result, enabled) {
+  if (!enabled) {
+    return;
+  }
+  const candidates = [];
+  if (result && typeof result === "object") {
+    const possibleKeys = ["logPath", "logFile", "logfile"];
+    for (const key of possibleKeys) {
+      const value = result[key];
+      if (typeof value === "string") {
+        candidates.push(value);
+      }
+    }
+  }
+  for (const candidate of candidates) {
+    if (!path.isAbsolute(candidate)) {
+      logWarn(`Refusing to tail non-absolute log path: ${candidate}`);
+      continue;
+    }
+    if (!fs.existsSync(candidate)) {
+      logWarn(`Log path not found: ${candidate}`);
+      continue;
+    }
+    try {
+      const content = fs.readFileSync(candidate, "utf8");
+      const lines = content.trimEnd().split(/\r?\n/);
+      const tail = lines.slice(-20);
+      console.log(`--- tail ${candidate} ---`);
+      for (const line of tail) {
+        console.log(line);
+      }
+    } catch (error) {
+      logWarn(`Failed to read log file ${candidate}: ${error.message}`);
+    }
+  }
+}
+function resolveRenderableOutput(wrapped, raw, preferredKinds) {
+  for (const kind of preferredKinds) {
+    if (kind === "json") {
+      const jsonValue = wrapped.json();
+      if (jsonValue !== null) {
+        return { kind, value: jsonValue };
+      }
+      continue;
+    }
+    if (kind === "markdown") {
+      const markdown = wrapped.markdown();
+      if (typeof markdown === "string") {
+        return { kind, value: markdown };
+      }
+      continue;
+    }
+    if (kind === "text") {
+      const text = wrapped.text();
+      if (typeof text === "string") {
+        return { kind, value: text };
+      }
+      continue;
+    }
+    if (kind === "raw") {
+      return { kind, value: raw };
+    }
+  }
+  return { kind: "raw", value: raw };
+}
+function emitRenderableOutput(renderable, requestedFormat) {
+  if (renderable.kind === "json") {
+    if (!attemptPrintJson(renderable.value)) {
+      printRaw(renderable.value, requestedFormat);
+    }
+    return;
+  }
+  if (renderable.kind === "markdown" || renderable.kind === "text") {
+    console.log(String(renderable.value));
+    return;
+  }
+  printRaw(renderable.value, requestedFormat);
+}
+function attemptPrintJson(value) {
+  if (value === void 0) {
+    return false;
+  }
+  try {
+    if (value === null) {
+      console.log("null");
+    } else {
+      console.log(JSON.stringify(value, null, 2));
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function printRaw(raw, requestedFormat) {
+  if (requestedFormat === "json") {
+    try {
+      const serialized = JSON.stringify(raw, null, 2);
+      console.log(typeof serialized === "string" ? serialized : "null");
+    } catch {
+      console.log(JSON.stringify(String(raw)));
+    }
+    return;
+  }
+  if (typeof raw === "string") {
+    console.log(raw);
+    return;
+  }
+  if (raw === null) {
+    console.log("null");
+    return;
+  }
+  if (raw === void 0) {
+    console.log("undefined");
+    return;
+  }
+  if (typeof raw === "bigint") {
+    console.log(raw.toString());
+    return;
+  }
+  if (typeof raw === "symbol" || typeof raw === "function") {
+    console.log(raw.toString());
+    return;
+  }
+  console.log(inspect(raw, { depth: RAW_INSPECT_DEPTH, maxStringLength: null, breakLength: 80 }));
+}
+
+export {
+  printCallOutput,
+  tailLogIfRequested
+};

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

@@ -0,0 +1,124 @@
+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/ephemeral-flags.js
+function extractEphemeralServerFlags(args, options = {}) {
+  let spec;
+  const ensureSpec = () => {
+    if (!spec) {
+      spec = {};
+    }
+    return spec;
+  };
+  const allowPersist = options.allowPersist ?? true;
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (!token) {
+      index += 1;
+      continue;
+    }
+    if (token === "--http-url" || token === "--sse") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error("Flag '--http-url' requires a value.");
+      }
+      ensureSpec().httpUrl = value;
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--allow-http" || token === "--insecure") {
+      ensureSpec().allowInsecureHttp = true;
+      args.splice(index, 1);
+      continue;
+    }
+    if (token === "--stdio") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error("Flag '--stdio' requires a value.");
+      }
+      ensureSpec().stdioCommand = value;
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--stdio-arg") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error("Flag '--stdio-arg' requires a value.");
+      }
+      const current = ensureSpec();
+      current.stdioArgs = [...current.stdioArgs ?? [], value];
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--env") {
+      const value = args[index + 1];
+      const current = ensureSpec();
+      const envMap = current.env ? { ...current.env } : {};
+      parseKeyValue(value, envMap, "--env");
+      current.env = envMap;
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--header") {
+      const value = args[index + 1];
+      const current = ensureSpec();
+      const headerMap = current.headers ? { ...current.headers } : {};
+      parseKeyValue(value, headerMap, "--header");
+      current.headers = headerMap;
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--cwd") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error("Flag '--cwd' requires a value.");
+      }
+      ensureSpec().cwd = value;
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--name") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error("Flag '--name' requires a value.");
+      }
+      ensureSpec().name = value;
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--description") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error("Flag '--description' requires a value.");
+      }
+      ensureSpec().description = value;
+      args.splice(index, 2);
+      continue;
+    }
+    if (allowPersist && token === "--persist") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error("Flag '--persist' requires a value.");
+      }
+      ensureSpec().persistPath = value;
+      args.splice(index, 2);
+      continue;
+    }
+    index += 1;
+  }
+  return spec;
+}
+function parseKeyValue(value, target, flagName) {
+  if (!value?.includes("=")) {
+    throw new Error(`Flag '${flagName}' requires KEY=value.`);
+  }
+  const [key, ...rest] = value.split("=");
+  if (!key) {
+    throw new Error(`Flag '${flagName}' requires KEY=value.`);
+  }
+  target[key] = rest.join("=");
+}
+
+export {
+  extractEphemeralServerFlags
+};

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

@@ -0,0 +1,47 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM
+};

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

@@ -0,0 +1,109 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/lifecycle.js
+var DEFAULT_KEEP_ALIVE = /* @__PURE__ */ new Set(["chrome-devtools", "mobile-mcp", "playwright", "cloudbase"]);
+var includeOverride = parseList(process.env.MCPORTER_KEEPALIVE);
+var excludeOverride = parseList(process.env.MCPORTER_DISABLE_KEEPALIVE ?? process.env.MCPORTER_NO_KEEPALIVE);
+var KEEP_ALIVE_COMMANDS = [
+  { label: "chrome-devtools", fragments: ["chrome-devtools-mcp"] },
+  { label: "mobile-mcp", fragments: ["@mobilenext/mobile-mcp", "mobile-mcp"] },
+  { label: "playwright", fragments: ["@playwright/mcp", "playwright/mcp"] },
+  { label: "cloudbase", fragments: ["@cloudbase/cloudbase-mcp", "cloudbase-mcp"] }
+];
+var CHROME_DEVTOOLS_URL_PLACEHOLDERS = [String.raw`\${CHROME_DEVTOOLS_URL}`, "$env:CHROME_DEVTOOLS_URL"];
+function resolveLifecycle(name, rawLifecycle, command) {
+  const normalizedName = name.toLowerCase();
+  const canonicalName = canonicalKeepAliveName(command);
+  const candidateNames = /* @__PURE__ */ new Set([normalizedName]);
+  if (canonicalName) {
+    candidateNames.add(canonicalName);
+  }
+  const forcedDisable = excludeOverride.all || matchesOverride(excludeOverride.names, candidateNames);
+  const forcedEnable = includeOverride.all || matchesOverride(includeOverride.names, candidateNames);
+  if (forcedEnable) {
+    return { mode: "keep-alive" };
+  }
+  if (forcedDisable) {
+    return void 0;
+  }
+  const lifecycle = rawLifecycle ? coerceLifecycle(rawLifecycle) : void 0;
+  if (lifecycle) {
+    return lifecycle;
+  }
+  if (commandRequiresDynamicChromePort(command)) {
+    return { mode: "ephemeral" };
+  }
+  if (Array.from(candidateNames).some((candidate) => DEFAULT_KEEP_ALIVE.has(candidate))) {
+    return { mode: "keep-alive" };
+  }
+  return void 0;
+}
+function canonicalKeepAliveName(command) {
+  if (command.kind !== "stdio") {
+    return void 0;
+  }
+  const tokens = [command.command, ...command.args].map((token) => token.toLowerCase());
+  const match = KEEP_ALIVE_COMMANDS.find((signature) => signature.fragments.some((fragment) => tokens.some((token) => token.includes(fragment))));
+  return match?.label;
+}
+function commandRequiresDynamicChromePort(command) {
+  if (command.kind !== "stdio") {
+    return false;
+  }
+  const tokens = [command.command, ...command.args];
+  return tokens.some((token) => CHROME_DEVTOOLS_URL_PLACEHOLDERS.some((placeholder) => token.includes(placeholder)));
+}
+function parseList(value) {
+  if (!value) {
+    return { all: false, names: /* @__PURE__ */ new Set() };
+  }
+  const names = value.split(",").map((token) => token.trim().toLowerCase()).filter((token) => token.length > 0);
+  if (names.includes("*")) {
+    return { all: true, names: /* @__PURE__ */ new Set() };
+  }
+  return { all: false, names: new Set(names) };
+}
+function matchesOverride(names, candidates) {
+  for (const candidate of candidates) {
+    if (names.has(candidate)) {
+      return true;
+    }
+  }
+  return false;
+}
+function coerceLifecycle(raw) {
+  if (typeof raw === "string") {
+    if (raw === "keep-alive") {
+      return { mode: "keep-alive" };
+    }
+    if (raw === "ephemeral") {
+      return { mode: "ephemeral" };
+    }
+    return void 0;
+  }
+  if (raw.mode === "keep-alive") {
+    const timeout = typeof raw.idleTimeoutMs === "number" && Number.isFinite(raw.idleTimeoutMs) && raw.idleTimeoutMs > 0 ? Math.trunc(raw.idleTimeoutMs) : void 0;
+    return timeout ? { mode: "keep-alive", idleTimeoutMs: timeout } : { mode: "keep-alive" };
+  }
+  if (raw.mode === "ephemeral") {
+    return { mode: "ephemeral" };
+  }
+  return void 0;
+}
+function isKeepAliveServer(definition) {
+  return definition?.lifecycle?.mode === "keep-alive";
+}
+function keepAliveIdleTimeout(definition) {
+  if (definition.lifecycle?.mode !== "keep-alive") {
+    return void 0;
+  }
+  return definition.lifecycle.idleTimeoutMs;
+}
+
+export {
+  DEFAULT_KEEP_ALIVE,
+  resolveLifecycle,
+  canonicalKeepAliveName,
+  isKeepAliveServer,
+  keepAliveIdleTimeout
+};

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

@@ -0,0 +1,95 @@
+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/http-utils.js
+var DOMAIN_WITH_PATH_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9.-]*)(?::\d+)?\//;
+function normalizeHttpUrlCandidate(value) {
+  if (!value) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const hasScheme = /^https?:\/\//i.test(trimmed);
+  const candidate = hasScheme ? trimmed : DOMAIN_WITH_PATH_PATTERN.test(trimmed) ? `https://${trimmed}` : null;
+  if (!candidate) {
+    return void 0;
+  }
+  try {
+    const url = new URL(candidate);
+    return url.href;
+  } catch {
+    return void 0;
+  }
+}
+function looksLikeHttpUrl(value) {
+  return Boolean(normalizeHttpUrlCandidate(value));
+}
+function splitHttpToolSelector(input) {
+  const trimmed = input.trim();
+  const candidate = (() => {
+    const openParen = trimmed.indexOf("(");
+    if (openParen === -1) {
+      return trimmed;
+    }
+    return trimmed.slice(0, openParen);
+  })();
+  const normalized = normalizeHttpUrlCandidate(candidate);
+  if (!normalized) {
+    return null;
+  }
+  let url;
+  try {
+    url = new URL(normalized);
+  } catch {
+    return null;
+  }
+  const pathname = url.pathname || "/";
+  const lastSlash = pathname.lastIndexOf("/");
+  const segment = pathname.slice(lastSlash + 1);
+  const dotIndex = segment.lastIndexOf(".");
+  if (dotIndex <= 0) {
+    return null;
+  }
+  const tool = segment.slice(dotIndex + 1);
+  if (!tool || !/^[A-Za-z0-9_-]+$/.test(tool)) {
+    return null;
+  }
+  const baseSegment = segment.slice(0, dotIndex);
+  if (!baseSegment) {
+    return null;
+  }
+  const basePath = `${pathname.slice(0, Math.max(0, lastSlash + 1))}${baseSegment}`;
+  const normalizedPath = basePath.startsWith("/") ? basePath : `/${basePath}`;
+  const baseUrl = `${url.origin}${normalizedPath}`;
+  return { baseUrl, tool };
+}
+function normalizeHttpUrl(value) {
+  try {
+    const url = value instanceof URL ? new URL(value.href) : new URL(value);
+    url.protocol = url.protocol.toLowerCase();
+    url.hostname = url.hostname.replace(/^www\./i, "").toLowerCase();
+    if (!url.pathname) {
+      url.pathname = "/";
+    }
+    return url.href.replace(/\/$/, "/");
+  } catch {
+    return void 0;
+  }
+}
+function extractHttpServerTarget(value) {
+  const split = splitHttpToolSelector(value);
+  if (split) {
+    return split.baseUrl;
+  }
+  const normalized = normalizeHttpUrlCandidate(value);
+  return normalized ?? void 0;
+}
+
+export {
+  normalizeHttpUrlCandidate,
+  looksLikeHttpUrl,
+  splitHttpToolSelector,
+  normalizeHttpUrl,
+  extractHttpServerTarget
+};