@introspection-ai/recipes 0.13.0 → 0.14.0

package/dist/mcp-chunks/call-command-LKTKSYTH.js

@@ -0,0 +1,612 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  dumpActiveHandles
+} from "./chunk-BTLAWHTA.js";
+import {
+  CALL_HELP_ADHOC_SERVER_LINES,
+  CALL_HELP_ARGUMENT_LINES,
+  CALL_HELP_EXAMPLE_LINES,
+  CALL_HELP_RUNTIME_FLAG_LINES,
+  parseCallArguments
+} from "./chunk-PIIYJR44.js";
+import "./chunk-BV56DXPW.js";
+import {
+  printCallOutput,
+  tailLogIfRequested
+} from "./chunk-LNH5LAJD.js";
+import "./chunk-UNKB4SBV.js";
+import {
+  loadToolMetadata
+} from "./chunk-IABRYROW.js";
+import "./chunk-XANPGTLI.js";
+import {
+  chooseClosestIdentifier,
+  normalizeIdentifier,
+  renderIdentifierResolutionMessages
+} from "./chunk-BWHIA4PC.js";
+import {
+  dimText,
+  redText,
+  yellowText
+} from "./chunk-N46NEFAF.js";
+import {
+  resolveCallTimeout,
+  withTimeout
+} from "./chunk-BNV3TPE4.js";
+import {
+  persistPreparedEphemeralServer,
+  prepareEphemeralServerTarget
+} from "./chunk-WD6BOD24.js";
+import "./chunk-TEUKFFQL.js";
+import "./chunk-E22DYOW5.js";
+import {
+  buildConnectionIssueEnvelope
+} from "./chunk-SJCCBNZ4.js";
+import "./chunk-LQQEYD76.js";
+import {
+  looksLikeHttpUrl,
+  normalizeHttpUrlCandidate
+} from "./chunk-M3TPODXI.js";
+import "./chunk-YVZKMV5H.js";
+import {
+  wrapCallResult
+} from "./chunk-5QOSCSQB.js";
+import "./chunk-6W5QFASN.js";
+import "./chunk-2U4BSDC4.js";
+import {
+  analyzeConnectionError
+} from "./chunk-UKYNQGNE.js";
+import "./chunk-P3PSC54P.js";
+import "./chunk-2XL7MG7R.js";
+import "./chunk-WQJZMCJN.js";
+import "./chunk-ECIVB7P4.js";
+import "./chunk-LS7PMWSR.js";
+import "./chunk-D3MRAZ6H.js";
+import "./chunk-LRKZP7DJ.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/image-output.js
+import fs from "node:fs";
+import path from "node:path";
+function saveCallImagesIfRequested(wrapped, outputDir) {
+  if (!outputDir) {
+    return;
+  }
+  const images = wrapped.images();
+  if (!images || images.length === 0) {
+    return;
+  }
+  fs.mkdirSync(outputDir, { recursive: true });
+  const writtenPaths = [];
+  const timestamp = Date.now();
+  for (const [index, image] of images.entries()) {
+    const extension = extensionFromMimeType(image.mimeType);
+    const baseName = `mcp-image-${timestamp}-${index + 1}`;
+    const outputPath = resolveImageOutputPath(outputDir, baseName, extension);
+    fs.writeFileSync(outputPath, Buffer.from(image.data, "base64"));
+    writtenPaths.push(outputPath);
+  }
+  for (const outputPath of writtenPaths) {
+    console.error(`[mcporter] Saved image: ${outputPath}`);
+  }
+}
+function extensionFromMimeType(mimeType) {
+  if (!mimeType) {
+    return ".bin";
+  }
+  const normalized = mimeType.toLowerCase().split(";", 1)[0]?.trim() ?? "";
+  const mapping = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/jpg": ".jpg",
+    "image/webp": ".webp",
+    "image/gif": ".gif",
+    "image/svg+xml": ".svg",
+    "image/bmp": ".bmp",
+    "image/tiff": ".tiff",
+    "image/x-icon": ".ico"
+  };
+  return mapping[normalized] ?? ".bin";
+}
+function resolveImageOutputPath(outputDir, baseName, extension) {
+  let candidate = path.join(outputDir, `${baseName}${extension}`);
+  if (!fs.existsSync(candidate)) {
+    return candidate;
+  }
+  let suffix = 2;
+  while (true) {
+    candidate = path.join(outputDir, `${baseName}-${suffix}${extension}`);
+    if (!fs.existsSync(candidate)) {
+      return candidate;
+    }
+    suffix += 1;
+  }
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/call-command.js
+async function handleCall(runtime, args) {
+  let prepared;
+  try {
+    prepared = await prepareCallRequest(runtime, args);
+    if (!prepared) {
+      return;
+    }
+    const invocation = await invokePreparedCall(runtime, prepared);
+    if (!invocation) {
+      return;
+    }
+    renderCallResult(invocation.result, prepared.parsed);
+  } finally {
+    await persistPreparedEphemeralServer(runtime, prepared?.ephemeralTarget);
+  }
+}
+async function prepareCallRequest(runtime, args) {
+  const parsed = parseCallArguments(args);
+  const ephemeralTarget = await normalizeParsedCallArguments(runtime, parsed);
+  const { server, tool } = await resolveServerAndTool(runtime, parsed);
+  if (await maybeDescribeServer(runtime, server, tool, parsed.output, parsed.disableOAuth)) {
+    return void 0;
+  }
+  const timeoutMs = resolveCallTimeout(parsed.timeoutMs);
+  const hydratedArgs = await hydratePositionalArguments(runtime, server, tool, parsed.args, parsed.positionalArgs, parsed.disableOAuth);
+  const schemaAwareArgs = await enforceSchemaAwareArgumentTypes(runtime, server, tool, hydratedArgs, parsed.schemaStringCoercionCandidates, parsed.schemaArrayCoercionCandidates, timeoutMs, parsed.disableOAuth);
+  return {
+    parsed,
+    server,
+    tool,
+    hydratedArgs: schemaAwareArgs,
+    timeoutMs,
+    disableOAuth: parsed.disableOAuth,
+    ephemeralTarget
+  };
+}
+async function normalizeParsedCallArguments(runtime, parsed) {
+  let ephemeralSpec = parsed.ephemeral ? { ...parsed.ephemeral } : void 0;
+  const nameHints = [];
+  const absorbUrlCandidate = (value) => {
+    if (!value) {
+      return value;
+    }
+    const normalized = normalizeHttpUrlCandidate(value);
+    if (!normalized) {
+      return value;
+    }
+    if (!ephemeralSpec) {
+      ephemeralSpec = { httpUrl: normalized };
+    } else if (!ephemeralSpec.httpUrl) {
+      ephemeralSpec = { ...ephemeralSpec, httpUrl: normalized };
+    }
+    return void 0;
+  };
+  parsed.server = absorbUrlCandidate(parsed.server);
+  parsed.selector = absorbUrlCandidate(parsed.selector);
+  if (ephemeralSpec && parsed.server && !looksLikeHttpUrl(parsed.server)) {
+    nameHints.push(parsed.server);
+    parsed.server = void 0;
+  }
+  if (ephemeralSpec?.httpUrl && parsed.selector && !looksLikeHttpUrl(parsed.selector)) {
+    const selector = splitServerToolSelector(parsed.selector);
+    if (selector) {
+      if (!ephemeralSpec.name) {
+        nameHints.push(selector.server);
+      }
+      parsed.tool ??= selector.tool;
+      parsed.selector = void 0;
+    } else if (parsed.tool) {
+      if (!ephemeralSpec.name) {
+        nameHints.push(parsed.selector);
+      }
+      parsed.selector = void 0;
+    }
+  }
+  const prepared = await prepareEphemeralServerTarget({
+    runtime,
+    target: parsed.server,
+    ephemeral: ephemeralSpec,
+    nameHints,
+    reuseFromSpec: true
+  });
+  parsed.server = prepared.target;
+  if (!parsed.selector) {
+    parsed.selector = prepared.target;
+  }
+  return prepared;
+}
+async function resolveServerAndTool(runtime, parsed) {
+  const target = resolveCallTarget(parsed, { allowMissingTool: true });
+  const server = target.server;
+  let tool = target.tool;
+  if (!server) {
+    throw new Error("Missing server name. Provide it via <server>.<tool> or --server.");
+  }
+  if (!tool) {
+    tool = await inferSingleToolName(runtime, server, parsed.disableOAuth);
+    if (!tool) {
+      throw new Error("Missing tool name. Provide it via <server>.<tool> or --tool.");
+    }
+  }
+  return { server, tool };
+}
+async function invokePreparedCall(runtime, prepared) {
+  let invocation;
+  try {
+    invocation = await invokeWithAutoCorrection(runtime, prepared.server, prepared.tool, prepared.hydratedArgs, prepared.timeoutMs, prepared.parsed.output, prepared.disableOAuth);
+  } catch (error) {
+    const issue = maybeReportConnectionIssue(prepared.server, prepared.tool, error);
+    if (prepared.parsed.output === "json" || prepared.parsed.output === "raw") {
+      const payload = buildConnectionIssueEnvelope({ server: prepared.server, tool: prepared.tool, error, issue });
+      console.log(JSON.stringify(payload, null, 2));
+      process.exitCode = 1;
+      return void 0;
+    }
+    throw error;
+  }
+  return invocation;
+}
+function renderCallResult(result, parsed) {
+  const { callResult: wrapped } = wrapCallResult(result);
+  if (isErrorCallResult(result)) {
+    process.exitCode = 1;
+  }
+  printCallOutput(wrapped, result, parsed.output);
+  saveCallImagesIfRequested(wrapped, parsed.saveImagesDir);
+  tailLogIfRequested(result, parsed.tailLog);
+  dumpActiveHandles("after call (formatted result)");
+}
+function isErrorCallResult(result) {
+  return !!result && typeof result === "object" && result.isError === true;
+}
+function printCallHelp() {
+  const lines = [
+    "Usage: mcporter call <server.tool | url> [arguments] [flags]",
+    "",
+    "Selectors:",
+    "  server.tool            Use a configured server and tool (e.g., linear.list_issues).",
+    "  https://host/mcp.tool  Call a tool by full HTTP URL (auto-registers ad-hoc).",
+    "  --server <name>        Override the server name.",
+    "  --tool <name>          Override the tool name.",
+    "",
+    "Arguments:",
+    ...CALL_HELP_ARGUMENT_LINES,
+    "",
+    "Runtime flags:",
+    ...CALL_HELP_RUNTIME_FLAG_LINES,
+    "",
+    "Ad-hoc servers:",
+    ...CALL_HELP_ADHOC_SERVER_LINES,
+    "",
+    "Examples:",
+    ...CALL_HELP_EXAMPLE_LINES
+  ];
+  console.error(lines.join("\n"));
+}
+async function maybeDescribeServer(runtime, server, tool, outputFormat, disableOAuth) {
+  if (tool === "list_tools") {
+    console.log(dimText(`[mcporter] ${server}.list_tools is a shortcut for 'mcporter list ${server}'.`));
+    const listArgs2 = [server];
+    if (disableOAuth) {
+      listArgs2.push("--no-oauth");
+    }
+    if (outputFormat === "json") {
+      listArgs2.push("--json");
+    }
+    const { handleList: handleList2 } = await import("./list-command-2MEGGNFQ.js");
+    await handleList2(runtime, listArgs2);
+    return true;
+  }
+  if (tool !== "help") {
+    return false;
+  }
+  const tools = await runtime.listTools(server, { includeSchema: false, autoAuthorize: false, disableOAuth }).catch(() => void 0);
+  if (!tools) {
+    return false;
+  }
+  const hasHelpTool = tools.some((entry) => entry.name === "help");
+  if (hasHelpTool) {
+    return false;
+  }
+  console.log(dimText(`[mcporter] ${server} does not expose a 'help' tool; showing mcporter list output instead.`));
+  const listArgs = [server];
+  if (disableOAuth) {
+    listArgs.push("--no-oauth");
+  }
+  if (outputFormat === "json") {
+    listArgs.push("--json");
+  }
+  const { handleList } = await import("./list-command-2MEGGNFQ.js");
+  await handleList(runtime, listArgs);
+  return true;
+}
+function resolveCallTarget(parsed, options = {}) {
+  const selector = parsed.selector;
+  let server = parsed.server;
+  let tool = parsed.tool;
+  if (selector && !server && selector.includes(".")) {
+    const [left, right] = selector.split(".", 2);
+    server = left;
+    tool = right;
+  } else if (selector && !server) {
+    server = selector;
+  } else if (selector && !tool && selector !== server) {
+    tool = selector;
+  }
+  if (!server) {
+    throw new Error("Missing server name. Provide it via <server>.<tool> or --server.");
+  }
+  if (!tool && !options.allowMissingTool) {
+    throw new Error("Missing tool name. Provide it via <server>.<tool> or --tool.");
+  }
+  return { server, tool };
+}
+function splitServerToolSelector(selector) {
+  const dotIndex = selector.indexOf(".");
+  if (dotIndex <= 0 || dotIndex === selector.length - 1) {
+    return void 0;
+  }
+  return {
+    server: selector.slice(0, dotIndex),
+    tool: selector.slice(dotIndex + 1)
+  };
+}
+async function enforceSchemaAwareArgumentTypes(runtime, server, tool, args, stringCandidates, arrayCandidates, timeoutMs, disableOAuth) {
+  if ((!stringCandidates || Object.keys(stringCandidates).length === 0) && (!arrayCandidates || Object.keys(arrayCandidates).length === 0)) {
+    return args;
+  }
+  const tools = await withTimeout(loadToolMetadata(runtime, server, { includeSchema: true, disableOAuth }), timeoutMs).catch(() => void 0);
+  if (!tools) {
+    return args;
+  }
+  const toolInfo = tools.find((entry) => entry.tool.name === tool);
+  const schema = toolInfo?.tool.inputSchema;
+  if (!schema?.properties) {
+    return args;
+  }
+  let corrected;
+  for (const [key, rawValue] of Object.entries(stringCandidates ?? {})) {
+    if (typeof args[key] !== "number") {
+      continue;
+    }
+    if (!schemaAllowsString(schema.properties[key])) {
+      continue;
+    }
+    corrected ??= { ...args };
+    corrected[key] = rawValue;
+  }
+  for (const [key, rawValue] of Object.entries(arrayCandidates ?? {})) {
+    if (typeof args[key] !== "string") {
+      continue;
+    }
+    const descriptor = schema.properties[key];
+    if (!schemaAllowsArray(descriptor) || schemaAllowsString(descriptor)) {
+      continue;
+    }
+    corrected ??= { ...args };
+    corrected[key] = [rawValue];
+  }
+  return corrected ?? args;
+}
+function schemaAllowsString(descriptor) {
+  if (!descriptor || typeof descriptor !== "object") {
+    return false;
+  }
+  const record = descriptor;
+  const type = record.type;
+  if (type === "string") {
+    return true;
+  }
+  if (Array.isArray(type) && type.includes("string")) {
+    return true;
+  }
+  for (const key of ["anyOf", "oneOf", "allOf"]) {
+    const variants = record[key];
+    if (Array.isArray(variants) && variants.some(schemaAllowsString)) {
+      return true;
+    }
+  }
+  return false;
+}
+function schemaAllowsArray(descriptor) {
+  if (!descriptor || typeof descriptor !== "object") {
+    return false;
+  }
+  const record = descriptor;
+  const type = record.type;
+  if (type === "array") {
+    return true;
+  }
+  if (Array.isArray(type) && type.includes("array")) {
+    return true;
+  }
+  for (const key of ["anyOf", "oneOf", "allOf"]) {
+    const variants = record[key];
+    if (Array.isArray(variants) && variants.some(schemaAllowsArray)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function hydratePositionalArguments(runtime, server, tool, namedArgs, positionalArgs, disableOAuth) {
+  if (!positionalArgs || positionalArgs.length === 0) {
+    return namedArgs;
+  }
+  const tools = await loadToolMetadata(runtime, server, { includeSchema: true, disableOAuth }).catch(() => void 0);
+  if (!tools) {
+    throw new Error("Unable to load tool metadata; name positional arguments explicitly.");
+  }
+  const toolInfo = tools.find((entry) => entry.tool.name === tool);
+  if (!toolInfo) {
+    throw new Error(`Unknown tool '${tool}' on server '${server}'. Double-check the name or run mcporter list ${server}.`);
+  }
+  if (!toolInfo.tool.inputSchema) {
+    throw new Error(`Tool '${tool}' does not expose an input schema; name positional arguments explicitly.`);
+  }
+  const options = toolInfo.options;
+  if (options.length === 0) {
+    throw new Error(`Tool '${tool}' has no declared parameters; remove positional arguments.`);
+  }
+  const remaining = options.filter((option) => !(option.property in namedArgs));
+  if (positionalArgs.length > remaining.length) {
+    throw new Error(`Too many positional arguments (${positionalArgs.length}) supplied; only ${remaining.length} parameter${remaining.length === 1 ? "" : "s"} remain on ${tool}.`);
+  }
+  const hydrated = { ...namedArgs };
+  positionalArgs.forEach((value, index) => {
+    const target = remaining[index];
+    if (!target) {
+      return;
+    }
+    hydrated[target.property] = value;
+  });
+  return hydrated;
+}
+async function inferSingleToolName(runtime, server, disableOAuth) {
+  const tools = await loadToolMetadata(runtime, server, { includeSchema: false, disableOAuth });
+  if (tools.length !== 1) {
+    return void 0;
+  }
+  const name = tools[0]?.tool.name;
+  if (!name) {
+    return void 0;
+  }
+  console.log(dimText(`[auto] ${server} exposes a single tool (${name}); using it.`));
+  return name;
+}
+async function invokeWithAutoCorrection(runtime, server, tool, args, timeoutMs, outputFormat, disableOAuth) {
+  return attemptCall(runtime, server, tool, args, timeoutMs, outputFormat, true, disableOAuth);
+}
+async function attemptCall(runtime, server, tool, args, timeoutMs, outputFormat, allowCorrection, disableOAuth) {
+  try {
+    const result = await withTimeout(runtime.callTool(server, tool, { args, timeoutMs, disableOAuth }), timeoutMs);
+    if (allowCorrection && isErrorCallResult(result)) {
+      const resolution = await maybeResolveToolName(runtime, server, tool, result, disableOAuth);
+      if (resolution) {
+        const retry = await maybeRetryResolvedTool(runtime, server, tool, args, timeoutMs, outputFormat, resolution, disableOAuth);
+        if (retry) {
+          return retry;
+        }
+      }
+    }
+    return { result, resolvedTool: tool };
+  } catch (error) {
+    if (error instanceof Error && error.message === "Timeout") {
+      const timeoutDisplay = `${timeoutMs}ms`;
+      await runtime.close(server).catch(() => {
+      });
+      throw new Error(`Call to ${server}.${tool} timed out after ${timeoutDisplay}. Override MCPORTER_CALL_TIMEOUT or pass --timeout to adjust.`, { cause: error });
+    }
+    if (!allowCorrection) {
+      throw error;
+    }
+    const resolution = await maybeResolveToolName(runtime, server, tool, error, disableOAuth);
+    if (!resolution) {
+      maybeReportConnectionIssue(server, tool, error);
+      throw error;
+    }
+    const retry = await maybeRetryResolvedTool(runtime, server, tool, args, timeoutMs, outputFormat, resolution, disableOAuth);
+    if (!retry) {
+      throw error;
+    }
+    return retry;
+  }
+}
+async function maybeRetryResolvedTool(runtime, server, tool, args, timeoutMs, outputFormat, resolution, disableOAuth) {
+  const messages = renderIdentifierResolutionMessages({
+    entity: "tool",
+    attempted: tool,
+    resolution,
+    scope: server
+  });
+  if (resolution.kind === "suggest") {
+    if (messages.suggest) {
+      console.error(dimText(messages.suggest));
+    }
+    return void 0;
+  }
+  if (messages.auto) {
+    const emitAutoMessage = outputFormat === "json" || outputFormat === "raw" ? console.error : console.log;
+    emitAutoMessage(dimText(messages.auto));
+  }
+  return attemptCall(runtime, server, resolution.value, args, timeoutMs, outputFormat, false, disableOAuth);
+}
+async function maybeResolveToolName(runtime, server, attemptedTool, error, disableOAuth) {
+  const missingName = extractMissingToolFromError(error);
+  if (!missingName) {
+    return void 0;
+  }
+  if (normalizeIdentifier(missingName) !== normalizeIdentifier(attemptedTool)) {
+    return void 0;
+  }
+  const tools = await loadToolMetadata(runtime, server, { includeSchema: false, disableOAuth }).catch(() => void 0);
+  if (!tools) {
+    return void 0;
+  }
+  const resolution = chooseClosestIdentifier(attemptedTool, tools.map((entry) => entry.tool.name));
+  if (!resolution) {
+    return void 0;
+  }
+  return resolution;
+}
+function extractMissingToolFromError(error) {
+  const message = extractErrorMessageText(error);
+  if (!message) {
+    return void 0;
+  }
+  const match = message.match(/Tool\s+([A-Za-z0-9._-]+)\s+not found/i) ?? message.match(/Unknown tool:?\s+([A-Za-z0-9._-]+)/i);
+  return match?.[1];
+}
+function extractErrorMessageText(value) {
+  if (value instanceof Error) {
+    return value.message;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const content = value.content;
+  if (!Array.isArray(content)) {
+    return void 0;
+  }
+  return content.map((entry) => entry && typeof entry === "object" && typeof entry.text === "string" ? entry.text : "").filter(Boolean).join("\n");
+}
+function maybeReportConnectionIssue(server, tool, error) {
+  const issue = analyzeConnectionError(error);
+  const detail = summarizeIssueMessage(issue.rawMessage);
+  if (issue.kind === "auth") {
+    const authCommand = `mcporter auth ${server}`;
+    const hint = `[mcporter] Authorization required for ${server}. Run '${authCommand}'.${detail ? ` (${detail})` : ""}`;
+    console.error(yellowText(hint));
+    return issue;
+  }
+  if (issue.kind === "offline") {
+    const hint = `[mcporter] ${server} appears offline${detail ? ` (${detail})` : ""}.`;
+    console.error(redText(hint));
+    return issue;
+  }
+  if (issue.kind === "http") {
+    const status = issue.statusCode ? `HTTP ${issue.statusCode}` : "an HTTP error";
+    const hint = `[mcporter] ${server}.${tool} responded with ${status}${detail ? ` (${detail})` : ""}.`;
+    console.error(dimText(hint));
+    return issue;
+  }
+  if (issue.kind === "stdio-exit") {
+    const exit = typeof issue.stdioExitCode === "number" ? `code ${issue.stdioExitCode}` : "an unknown status";
+    const signal = issue.stdioSignal ? ` (signal ${issue.stdioSignal})` : "";
+    const hint = `[mcporter] STDIO server for ${server} exited with ${exit}${signal}.`;
+    console.error(redText(hint));
+  }
+  return issue;
+}
+function summarizeIssueMessage(message) {
+  if (!message) {
+    return "";
+  }
+  const trimmed = message.trim();
+  if (trimmed.length <= 120) {
+    return trimmed;
+  }
+  return `${trimmed.slice(0, 117)}\u2026`;
+}
+export {
+  handleCall,
+  printCallHelp
+};