@introspection-ai/recipes 0.13.0 → 0.14.0

package/dist/mcp-chunks/cli-UV4QJZZM.js

@@ -0,0 +1,929 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  extractFlags
+} from "./chunk-XQK2JSW4.js";
+import {
+  isRecordReplayModeActive,
+  isReplayModeActive
+} from "./chunk-J6LYIZXN.js";
+import {
+  extractListFlags
+} from "./chunk-LEZSACDE.js";
+import {
+  DEBUG_HANG,
+  dumpActiveHandles,
+  terminateChildProcesses
+} from "./chunk-BTLAWHTA.js";
+import {
+  parseCallArguments
+} from "./chunk-PIIYJR44.js";
+import {
+  CliUsageError
+} from "./chunk-BV56DXPW.js";
+import {
+  getActiveLogLevel,
+  getActiveLogger,
+  logError,
+  logInfo,
+  setLogLevel
+} from "./chunk-UNKB4SBV.js";
+import {
+  chooseClosestIdentifier,
+  renderIdentifierResolutionMessages
+} from "./chunk-BWHIA4PC.js";
+import {
+  boldText,
+  dimText,
+  extraDimText,
+  supportsAnsiColor,
+  yellowText
+} from "./chunk-N46NEFAF.js";
+import {
+  parsePositiveInteger,
+  resolveCallTimeout
+} from "./chunk-BNV3TPE4.js";
+import "./chunk-LQQEYD76.js";
+import {
+  looksLikeHttpUrl,
+  splitHttpToolSelector
+} from "./chunk-M3TPODXI.js";
+import "./chunk-YVZKMV5H.js";
+import {
+  MCPORTER_VERSION
+} from "./chunk-4SQKWYFF.js";
+import {
+  parseLogLevel
+} from "./chunk-6W5QFASN.js";
+import {
+  resolveConfigPath
+} from "./chunk-WQJZMCJN.js";
+import "./chunk-ECIVB7P4.js";
+import "./chunk-LRKZP7DJ.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/cli-factory.js
+function buildGlobalContext(argv) {
+  const globalFlags = extractFlags(argv, ["--config", "--root", "--log-level", "--oauth-timeout"]);
+  if (globalFlags["--log-level"]) {
+    try {
+      const parsedLevel = parseLogLevel(globalFlags["--log-level"], getActiveLogLevel());
+      setLogLevel(parsedLevel);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logError(message, error instanceof Error ? error : void 0);
+      return { exit: true, code: 1 };
+    }
+  }
+  let oauthTimeoutOverride;
+  if (globalFlags["--oauth-timeout"]) {
+    const parsed = parsePositiveInteger(globalFlags["--oauth-timeout"]);
+    if (parsed === void 0) {
+      logError("Flag '--oauth-timeout' must be a positive integer (milliseconds).");
+      return { exit: true, code: 1 };
+    }
+    oauthTimeoutOverride = parsed;
+  }
+  const rootOverride = globalFlags["--root"];
+  const configResolution = resolveConfigPath(globalFlags["--config"], rootOverride ?? process.cwd());
+  const runtimeOptions = {
+    configPath: configResolution.explicit ? configResolution.path : void 0,
+    rootDir: rootOverride,
+    logger: getActiveLogger(),
+    oauthTimeoutMs: oauthTimeoutOverride
+  };
+  return { globalFlags, oauthTimeoutOverride, runtimeOptions };
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/command-inference.js
+var CALL_TOKEN_PATTERN = /[.(]/;
+function inferCommandRouting(token, args, definitions) {
+  if (!token) {
+    return { kind: "command", command: token, args };
+  }
+  if (token === "describe") {
+    return { kind: "command", command: "list", args };
+  }
+  if (token === "list-tools") {
+    return { kind: "command", command: "list", args };
+  }
+  if (isExplicitCommand(token)) {
+    return { kind: "command", command: token, args };
+  }
+  if (isHttpToolToken(token)) {
+    return { kind: "command", command: "call", args: [token, ...args] };
+  }
+  if (isUrlToken(token)) {
+    return { kind: "command", command: "list", args: [token, ...args] };
+  }
+  if (isCallLikeToken(token)) {
+    return { kind: "command", command: "call", args: [token, ...args] };
+  }
+  if (definitions.length === 0) {
+    return { kind: "command", command: token, args };
+  }
+  const serverNames = definitions.map((entry) => entry.name);
+  if (serverNames.includes(token)) {
+    return { kind: "command", command: "list", args: [token, ...args] };
+  }
+  const resolution = chooseClosestIdentifier(token, serverNames);
+  if (!resolution) {
+    return { kind: "command", command: token, args };
+  }
+  const messages = renderIdentifierResolutionMessages({
+    entity: "server",
+    attempted: token,
+    resolution
+  });
+  if (resolution.kind === "auto" && messages.auto) {
+    console.log(dimText(messages.auto));
+    return { kind: "command", command: "list", args: [resolution.value, ...args] };
+  }
+  if (messages.suggest) {
+    console.error(yellowText(messages.suggest));
+  }
+  console.error(`Unknown MCP server '${token}'.`);
+  return { kind: "abort", exitCode: 1 };
+}
+function isCallLikeToken(token) {
+  if (!token) {
+    return false;
+  }
+  if (looksLikeHttpUrl(token)) {
+    return false;
+  }
+  return CALL_TOKEN_PATTERN.test(token);
+}
+function isExplicitCommand(token) {
+  return token === "list" || token === "call" || token === "auth" || token === "vault" || token === "resource" || token === "resources";
+}
+function isUrlToken(token) {
+  return looksLikeHttpUrl(token);
+}
+function isHttpToolToken(token) {
+  if (!token) {
+    return false;
+  }
+  return splitHttpToolSelector(token) !== null;
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/help-output.js
+import fsPromises from "node:fs/promises";
+function printHelp(message) {
+  if (message) {
+    console.error(message);
+    console.error("");
+  }
+  const colorize = supportsAnsiColor;
+  const sections = buildCommandSections(colorize);
+  const globalFlags = formatGlobalFlags(colorize);
+  const quickStart = formatQuickStart(colorize);
+  const footer = formatHelpFooter(colorize);
+  const title = colorize ? `${boldText("mcporter")} ${dimText("\u2014 Model Context Protocol CLI & generator")}` : "mcporter \u2014 Model Context Protocol CLI & generator";
+  const lines = [
+    title,
+    "",
+    "Usage: mcporter <command> [options]",
+    "",
+    ...sections,
+    "",
+    globalFlags,
+    "",
+    quickStart,
+    "",
+    footer
+  ];
+  console.error(lines.join("\n"));
+}
+function buildCommandSections(colorize) {
+  const sections = [
+    {
+      title: "Core commands",
+      entries: [
+        {
+          name: "list",
+          summary: "List configured servers (add --schema for tool docs)",
+          usage: "mcporter list [name] [--schema] [--json]"
+        },
+        {
+          name: "call",
+          summary: "Call a tool by selector (server.tool) or HTTP URL; key=value flags supported",
+          usage: "mcporter call <selector> [key=value ...]"
+        },
+        {
+          name: "resource",
+          summary: "List or read MCP resources exposed by a server",
+          usage: "mcporter resource <server> [uri]"
+        },
+        {
+          name: "auth",
+          summary: "Complete OAuth for a server without listing tools",
+          usage: "mcporter auth <server | url> [--reset]"
+        },
+        {
+          name: "vault",
+          summary: "Seed or clear OAuth credentials non-interactively",
+          usage: "mcporter vault set <server> --tokens-file <path>"
+        },
+        {
+          name: "record",
+          summary: "Capture MCP JSON-RPC traffic to NDJSON",
+          usage: "mcporter record <session-name> [--server <name>] [-- <command>]"
+        },
+        {
+          name: "replay",
+          summary: "Replay recorded MCP JSON-RPC traffic deterministically",
+          usage: "mcporter replay <session-name> [--server <name>] [-- <command>]"
+        }
+      ]
+    },
+    {
+      title: "Generator & tooling",
+      entries: [
+        {
+          name: "generate-cli",
+          summary: "Emit a standalone CLI (supports HTTP, stdio, and inline commands)",
+          usage: "mcporter generate-cli --server <name> | --command <ref> [options]"
+        },
+        {
+          name: "inspect-cli",
+          summary: "Show metadata and regen instructions for a generated CLI",
+          usage: "mcporter inspect-cli <path> [--json]"
+        },
+        {
+          name: "emit-ts",
+          summary: "Generate TypeScript client/types for a server",
+          usage: "mcporter emit-ts <server> --mode client|types [options]"
+        }
+      ]
+    },
+    {
+      title: "Configuration",
+      entries: [
+        {
+          name: "config",
+          summary: "Inspect or edit config files (list, get, add, remove, import, login, logout)",
+          usage: "mcporter config <command> [options]"
+        }
+      ]
+    },
+    {
+      title: "Daemon",
+      entries: [
+        {
+          name: "daemon",
+          summary: "Manage the keep-alive daemon (start | status | stop | restart)",
+          usage: "mcporter daemon <subcommand>"
+        },
+        {
+          name: "serve",
+          summary: "Expose daemon-managed keep-alive servers as one MCP server",
+          usage: "mcporter serve [--servers a,b,c] [--stdio | --http <port>]"
+        }
+      ]
+    }
+  ];
+  return sections.flatMap((section) => formatCommandSection(section, colorize));
+}
+function formatCommandSection(section, colorize) {
+  const maxNameLength = Math.max(...section.entries.map((entry) => entry.name.length));
+  const header = colorize ? boldText(section.title) : section.title;
+  const lines = [header];
+  section.entries.forEach((entry) => {
+    const paddedName = entry.name.padEnd(maxNameLength);
+    const renderedName = colorize ? boldText(paddedName) : paddedName;
+    const summary = colorize ? dimText(entry.summary) : entry.summary;
+    lines.push(`  ${renderedName}  ${summary}`);
+    lines.push(`    ${extraDimText("usage:")} ${entry.usage}`);
+  });
+  return [...lines, ""];
+}
+function formatGlobalFlags(colorize) {
+  const title = colorize ? boldText("Global flags") : "Global flags";
+  const entries = [
+    {
+      flag: "--config <path>",
+      summary: "Path to mcporter.json (defaults to ./config/mcporter.json)"
+    },
+    {
+      flag: "--root <path>",
+      summary: "Working directory for stdio servers"
+    },
+    {
+      flag: "--log-level <debug|info|warn|error>",
+      summary: "Adjust CLI logging (defaults to warn)"
+    },
+    {
+      flag: "--oauth-timeout <ms>",
+      summary: "Time to wait for browser-based OAuth before giving up (default 300000)"
+    }
+  ];
+  const formatted = entries.map((entry) => `  ${entry.flag.padEnd(34)}${entry.summary}`);
+  return [title, ...formatted].join("\n");
+}
+function formatQuickStart(colorize) {
+  const title = colorize ? boldText("Quick start") : "Quick start";
+  const entries = [
+    ["mcporter list", "show configured servers"],
+    ["mcporter list linear --schema", "view Linear tool docs"],
+    ["mcporter call linear.list_issues limit:5", "invoke a tool with key=value arguments"],
+    ["mcporter generate-cli --command https://host/mcp --compile ./my-cli", "build a standalone CLI/binary"]
+  ];
+  const formatted = entries.map(([cmd, note]) => {
+    const comment = colorize ? dimText(`# ${note}`) : `# ${note}`;
+    return `  ${cmd}
+    ${comment}`;
+  });
+  return [title, ...formatted].join("\n");
+}
+function formatHelpFooter(colorize) {
+  const pointer = "Run `mcporter <command> --help` for detailed flags.";
+  const autoLoad = "mcporter auto-loads servers from ./config/mcporter.json and editor imports (Cursor, Claude, Codex, etc.).";
+  if (!colorize) {
+    return `${pointer}
+${autoLoad}`;
+  }
+  return `${dimText(pointer)}
+${extraDimText(autoLoad)}`;
+}
+function isHelpToken(token) {
+  return token === "--help" || token === "-h" || token === "help";
+}
+function consumeHelpTokens(args) {
+  let found = false;
+  for (let index = args.length - 1; index >= 0; index -= 1) {
+    const token = args[index];
+    if (token && isHelpToken(token)) {
+      args.splice(index, 1);
+      found = true;
+    }
+  }
+  return found;
+}
+function isVersionToken(token) {
+  return token === "--version" || token === "-v" || token === "-V";
+}
+async function printVersion() {
+  console.log(await resolveCliVersion());
+}
+async function resolveCliVersion() {
+  try {
+    const packageJsonPath = new URL("../../package.json", import.meta.url);
+    const buffer = await fsPromises.readFile(packageJsonPath, "utf8");
+    const pkg = JSON.parse(buffer);
+    return pkg.version ?? MCPORTER_VERSION;
+  } catch {
+    return MCPORTER_VERSION;
+  }
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli.js
+var FORCE_EXIT_GRACE_MS = 50;
+var STDOUT_FLUSH_TIMEOUT_MS = 2e3;
+var DAEMON_FAST_PATH_SERVERS = /* @__PURE__ */ new Set(["chrome-devtools", "mobile-mcp", "playwright"]);
+function handleStdioError(error) {
+  if (error.code === "EPIPE") {
+    return;
+  }
+  throw error;
+}
+function installStdioErrorHandlers() {
+  process.stdout.on("error", handleStdioError);
+  process.stderr.on("error", handleStdioError);
+}
+function flushWriteStreamForExit(stream) {
+  return new Promise((resolve) => {
+    if (!stream.writable || stream.destroyed || stream.writableEnded) {
+      resolve();
+      return;
+    }
+    stream.write("", () => {
+      resolve();
+    });
+  });
+}
+function flushStdioThenForceExit() {
+  let exited = false;
+  const exit = () => {
+    if (exited) {
+      return;
+    }
+    exited = true;
+    process.exit(process.exitCode ?? 0);
+  };
+  const fallback = setTimeout(exit, STDOUT_FLUSH_TIMEOUT_MS);
+  fallback.unref?.();
+  void Promise.allSettled([flushWriteStreamForExit(process.stdout), flushWriteStreamForExit(process.stderr)]).then(() => {
+    clearTimeout(fallback);
+    exit();
+  });
+}
+async function handleAuth(...args) {
+  const { handleAuth: imported } = await import("./auth-command-ZLGYIEUY.js");
+  return imported(...args);
+}
+async function printAuthHelp() {
+  const { printAuthHelp: imported } = await import("./auth-command-ZLGYIEUY.js");
+  imported();
+}
+async function handleCall(...args) {
+  const { handleCall: imported } = await import("./call-command-LKTKSYTH.js");
+  return imported(...args);
+}
+async function handleGenerateCli(...args) {
+  const { handleGenerateCli: imported } = await import("./generate-cli-runner-6CAZZA3P.js");
+  return imported(...args);
+}
+async function handleInspectCli(...args) {
+  const { handleInspectCli: imported } = await import("./inspect-cli-command-3ZORTOR7.js");
+  return imported(...args);
+}
+async function handleList(...args) {
+  const { handleList: imported } = await import("./list-command-2MEGGNFQ.js");
+  return imported(...args);
+}
+async function handleResource(...args) {
+  const { handleResource: imported } = await import("./resource-command-OO4NYF5C.js");
+  return imported(...args);
+}
+async function runCli(argv) {
+  const args = [...argv];
+  if (args.length === 0) {
+    printHelp();
+    process.exit(1);
+    return;
+  }
+  const context = buildGlobalContext(args);
+  if ("exit" in context) {
+    process.exit(context.code);
+    return;
+  }
+  const { globalFlags, runtimeOptions } = context;
+  const command = args.shift();
+  if (!command) {
+    printHelp();
+    process.exit(1);
+    return;
+  }
+  if (isHelpToken(command)) {
+    printHelp();
+    process.exitCode = 0;
+    return;
+  }
+  if (isVersionToken(command)) {
+    await printVersion();
+    return;
+  }
+  if (command === "generate-cli") {
+    if (consumeHelpTokens(args)) {
+      const { printGenerateCliHelp } = await import("./generate-cli-runner-6CAZZA3P.js");
+      printGenerateCliHelp();
+      process.exitCode = 0;
+      return;
+    }
+    const { handleGenerateCli: importedHandleGenerateCli } = await import("./generate-cli-runner-6CAZZA3P.js");
+    await importedHandleGenerateCli(args, globalFlags);
+    return;
+  }
+  if (command === "inspect-cli") {
+    if (consumeHelpTokens(args)) {
+      const { printInspectCliHelp } = await import("./inspect-cli-command-3ZORTOR7.js");
+      printInspectCliHelp();
+      process.exitCode = 0;
+      return;
+    }
+    const { handleInspectCli: importedHandleInspectCli } = await import("./inspect-cli-command-3ZORTOR7.js");
+    await importedHandleInspectCli(args);
+    return;
+  }
+  const rootOverride = globalFlags["--root"];
+  const configPath = runtimeOptions.configPath ?? globalFlags["--config"];
+  const configResolution = resolveConfigPath(globalFlags["--config"], rootOverride ?? process.cwd());
+  const configPathResolved = configPath ?? configResolution.path;
+  const runtimeOptionsWithPath = {
+    ...runtimeOptions,
+    configPath: configResolution.explicit ? configPathResolved : runtimeOptions.configPath
+  };
+  if (command === "daemon") {
+    const { handleDaemonCli } = await import("./daemon-command-U242Z6VY.js");
+    await handleDaemonCli(args, {
+      configPath: configPathResolved,
+      configExplicit: configResolution.explicit,
+      rootDir: rootOverride
+    });
+    return;
+  }
+  if (command === "serve") {
+    const { handleServeCli, printServeHelp } = await import("./serve-command-DHXJZMMN.js");
+    if (consumeHelpTokens(args)) {
+      printServeHelp();
+      process.exitCode = 0;
+      return;
+    }
+    await handleServeCli(args, {
+      configPath: configPathResolved,
+      configExplicit: configResolution.explicit,
+      rootDir: rootOverride
+    });
+    return;
+  }
+  if (command === "record") {
+    const { handleRecordCli, printRecordHelp } = await import("./record-command-YXHTTTT5.js");
+    if (consumeHelpTokens(wrapperArgsBeforeSeparator(args))) {
+      printRecordHelp();
+      process.exitCode = 0;
+      return;
+    }
+    await handleRecordCli(args);
+    return;
+  }
+  if (command === "replay") {
+    const { handleReplayCli, printReplayHelp } = await import("./replay-command-25HJ6AQU.js");
+    if (consumeHelpTokens(wrapperArgsBeforeSeparator(args))) {
+      printReplayHelp();
+      process.exitCode = 0;
+      return;
+    }
+    await handleReplayCli(args);
+    return;
+  }
+  if (command === "config") {
+    const { handleConfigCli } = await import("./config-command-NLAGKID5.js");
+    await handleConfigCli({
+      loadOptions: { configPath, rootDir: rootOverride },
+      invokeAuth: (authArgs) => invokeAuthCommand(runtimeOptionsWithPath, authArgs)
+    }, args);
+    return;
+  }
+  if (command === "emit-ts") {
+    if (consumeHelpTokens(args)) {
+      const { printEmitTsHelp } = await import("./emit-ts-command-VBXVXO6V.js");
+      printEmitTsHelp();
+      process.exitCode = 0;
+      return;
+    }
+    const [{ createRuntime: createRuntime2 }, { handleEmitTs }] = await Promise.all([
+      import("./runtime-5WJ3G25Y.js"),
+      import("./emit-ts-command-VBXVXO6V.js")
+    ]);
+    const runtime2 = await createRuntime2(runtimeOptionsWithPath);
+    try {
+      await handleEmitTs(runtime2, args);
+    } finally {
+      await runtime2.close().catch(() => {
+      });
+    }
+    return;
+  }
+  if (await maybeHandleDaemonFastCall(command, args, configResolution, rootOverride)) {
+    return;
+  }
+  const [{ createRuntime }, { DaemonClient }, { createKeepAliveRuntime }, { isKeepAliveServer }] = await Promise.all([
+    import("./runtime-5WJ3G25Y.js"),
+    import("./client-S7RQUG5U.js"),
+    import("./runtime-wrapper-RPWDIDBF.js"),
+    import("./lifecycle-XVKRHPH3.js")
+  ]);
+  const baseRuntime = await createRuntime(runtimeOptionsWithPath);
+  const recordReplayModeActive = isRecordReplayModeActive();
+  const keepAliveServers = recordReplayModeActive ? /* @__PURE__ */ new Set() : new Set(baseRuntime.getDefinitions().filter(isKeepAliveServer).map((entry) => entry.name));
+  const daemonClient = !recordReplayModeActive && keepAliveServers.size > 0 ? new DaemonClient({
+    configPath: configResolution.path,
+    configExplicit: configResolution.explicit,
+    rootDir: rootOverride
+  }) : null;
+  const runtime = createKeepAliveRuntime(baseRuntime, { daemonClient, keepAliveServers });
+  let primaryError;
+  try {
+    const inference = inferCommandRouting(command, args, runtime.getDefinitions());
+    if (inference.kind === "abort") {
+      process.exitCode = inference.exitCode;
+      return;
+    }
+    const resolvedCommand = inference.command;
+    const resolvedArgs = inference.args;
+    if (resolvedCommand === "list") {
+      if (consumeHelpTokens(resolvedArgs)) {
+        const { printListHelp } = await import("./list-command-2MEGGNFQ.js");
+        printListHelp();
+        process.exitCode = 0;
+        return;
+      }
+      const { handleList: importedHandleList } = await import("./list-command-2MEGGNFQ.js");
+      await importedHandleList(runtime, resolvedArgs);
+      return;
+    }
+    if (resolvedCommand === "call") {
+      if (consumeHelpTokens(resolvedArgs)) {
+        const { printCallHelp } = await import("./call-command-LKTKSYTH.js");
+        printCallHelp();
+        process.exitCode = 0;
+        return;
+      }
+      const { handleCall: runHandleCall } = await import("./call-command-LKTKSYTH.js");
+      await runHandleCall(runtime, resolvedArgs);
+      return;
+    }
+    if (resolvedCommand === "auth") {
+      if (consumeHelpTokens(resolvedArgs)) {
+        const { printAuthHelp: importedPrintAuthHelp } = await import("./auth-command-ZLGYIEUY.js");
+        importedPrintAuthHelp();
+        process.exitCode = 0;
+        return;
+      }
+      const { handleAuth: importedHandleAuth } = await import("./auth-command-ZLGYIEUY.js");
+      await importedHandleAuth(runtime, resolvedArgs);
+      return;
+    }
+    if (resolvedCommand === "vault") {
+      if (consumeHelpTokens(resolvedArgs)) {
+        const { printVaultHelp } = await import("./vault-command-PIYIUEZL.js");
+        printVaultHelp();
+        process.exitCode = 0;
+        return;
+      }
+      const { handleVault } = await import("./vault-command-PIYIUEZL.js");
+      await handleVault(runtime, resolvedArgs);
+      return;
+    }
+    if (resolvedCommand === "resource" || resolvedCommand === "resources") {
+      if (consumeHelpTokens(resolvedArgs)) {
+        const { printResourceHelp } = await import("./resource-command-OO4NYF5C.js");
+        printResourceHelp();
+        process.exitCode = 0;
+        return;
+      }
+      const { handleResource: importedHandleResource } = await import("./resource-command-OO4NYF5C.js");
+      await importedHandleResource(runtime, resolvedArgs);
+      return;
+    }
+    printHelp(`Unknown command '${resolvedCommand}'.`);
+    process.exit(1);
+  } catch (error) {
+    primaryError = error;
+    throw error;
+  } finally {
+    await closeRuntimeAfterCommand(runtime, { suppressReplayCloseError: primaryError !== void 0 });
+  }
+}
+async function closeRuntimeAfterCommand(runtime, options = {}) {
+  const closeStart = Date.now();
+  let closeError;
+  if (DEBUG_HANG) {
+    logInfo("[debug] beginning runtime.close()");
+    dumpActiveHandles("before runtime.close");
+  }
+  try {
+    await runtime.close();
+    if (DEBUG_HANG) {
+      const duration = Date.now() - closeStart;
+      logInfo(`[debug] runtime.close() completed in ${duration}ms`);
+      dumpActiveHandles("after runtime.close");
+    }
+  } catch (error) {
+    if (DEBUG_HANG) {
+      logError("[debug] runtime.close() failed", error);
+    }
+    if (isReplayModeActive() && !options.suppressReplayCloseError) {
+      closeError = error;
+    }
+  } finally {
+    terminateChildProcesses("runtime.finally");
+    const disableForceExit = process.env.MCPORTER_NO_FORCE_EXIT === "1";
+    const shouldForceExit = !disableForceExit || process.env.MCPORTER_FORCE_EXIT === "1";
+    const scheduleForcedExit = () => {
+      if (shouldForceExit) {
+        setTimeout(flushStdioThenForceExit, FORCE_EXIT_GRACE_MS);
+      }
+    };
+    if (DEBUG_HANG) {
+      dumpActiveHandles("after terminateChildProcesses");
+      scheduleForcedExit();
+    } else {
+      setImmediate(scheduleForcedExit);
+    }
+  }
+  if (closeError) {
+    throw closeError;
+  }
+}
+function wrapperArgsBeforeSeparator(args) {
+  const separatorIndex = args.indexOf("--");
+  return separatorIndex === -1 ? [...args] : args.slice(0, separatorIndex);
+}
+async function main() {
+  await runCli(process.argv.slice(2));
+}
+if (process.env.MCPORTER_DISABLE_AUTORUN !== "1") {
+  installStdioErrorHandlers();
+  main().catch((error) => {
+    if (error instanceof CliUsageError) {
+      logError(error.message);
+      process.exit(1);
+      return;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    logError(message, error instanceof Error ? error : void 0);
+    process.exit(1);
+  });
+}
+async function invokeAuthCommand(runtimeOptions, args) {
+  const [{ createRuntime }, { handleAuth: importedHandleAuth }] = await Promise.all([
+    import("./runtime-5WJ3G25Y.js"),
+    import("./auth-command-ZLGYIEUY.js")
+  ]);
+  const runtime = await createRuntime(runtimeOptions);
+  try {
+    await importedHandleAuth(runtime, args);
+  } finally {
+    await runtime.close().catch(() => {
+    });
+  }
+}
+async function maybeHandleDaemonFastCall(command, args, configResolution, rootDir) {
+  if (isRecordReplayModeActive()) {
+    return false;
+  }
+  const callArgs = resolveDaemonFastCallArgs(command, args);
+  if (!callArgs) {
+    return false;
+  }
+  const server = resolveExplicitCallServer(callArgs);
+  if (!server || !DAEMON_FAST_PATH_SERVERS.has(server) || isFastPathKeepAliveDisabled(server)) {
+    return false;
+  }
+  if (await maybeHandleSimpleDaemonFastCall(callArgs, configResolution, rootDir)) {
+    return true;
+  }
+  const [{ DaemonClient }, { handleCall: importedHandleCall }] = await Promise.all([
+    import("./client-S7RQUG5U.js"),
+    import("./call-command-LKTKSYTH.js")
+  ]);
+  const daemonClient = new DaemonClient({
+    configPath: configResolution.path,
+    configExplicit: configResolution.explicit,
+    rootDir
+  });
+  await importedHandleCall(createDaemonOnlyRuntime(daemonClient), callArgs);
+  return true;
+}
+async function maybeHandleSimpleDaemonFastCall(callArgs, configResolution, rootDir) {
+  const [{ parseCallArguments: parseCallArguments2 }, { resolveCallTimeout: resolveCallTimeout2 }] = await Promise.all([
+    import("./call-arguments-LU3W6D3K.js"),
+    import("./timeouts-W2XWCCXR.js")
+  ]);
+  let parsed;
+  try {
+    parsed = parseCallArguments2([...callArgs]);
+  } catch {
+    return false;
+  }
+  if (!parsed.server || !parsed.tool || parsed.ephemeral || parsed.tailLog || parsed.saveImagesDir || (parsed.positionalArgs?.length ?? 0) > 0 || parsed.schemaStringCoercionCandidates || parsed.schemaArrayCoercionCandidates) {
+    return false;
+  }
+  const [{ DaemonClient }, { wrapCallResult }, { printCallOutput }] = await Promise.all([
+    import("./client-S7RQUG5U.js"),
+    import("./result-utils-MOHHLNM7.js"),
+    import("./output-utils-NKESLAJ6.js")
+  ]);
+  const daemonClient = new DaemonClient({
+    configPath: configResolution.path,
+    configExplicit: configResolution.explicit,
+    rootDir
+  });
+  const result = await daemonClient.callTool({
+    server: parsed.server,
+    tool: parsed.tool,
+    args: Object.keys(parsed.args).length > 0 ? parsed.args : void 0,
+    timeoutMs: resolveCallTimeout2(parsed.timeoutMs),
+    disableOAuth: parsed.disableOAuth
+  });
+  const { callResult } = wrapCallResult(result);
+  printCallOutput(callResult, result, parsed.output);
+  return true;
+}
+function resolveDaemonFastCallArgs(command, args) {
+  if (command === "call") {
+    return args;
+  }
+  if (isExplicitNonCallCommand(command) || command.includes("://")) {
+    return void 0;
+  }
+  if (!/[.(]/.test(command)) {
+    return void 0;
+  }
+  return [command, ...args];
+}
+function isExplicitNonCallCommand(command) {
+  return command === "list" || command === "auth" || command === "resource" || command === "resources" || command === "daemon" || command === "serve" || command === "record" || command === "replay" || command === "config" || command === "emit-ts" || command === "generate-cli" || command === "inspect-cli" || command === "describe";
+}
+function resolveExplicitCallServer(args) {
+  let serverFlag;
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (!token) {
+      continue;
+    }
+    if (isHelpToken(token)) {
+      return void 0;
+    }
+    if (token === "--http-url" || token === "--stdio") {
+      return void 0;
+    }
+    if (token === "--server") {
+      serverFlag = args[index + 1];
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("--server=")) {
+      serverFlag = token.slice("--server=".length);
+      continue;
+    }
+    if (token.startsWith("-")) {
+      continue;
+    }
+    if (token.includes("://")) {
+      return void 0;
+    }
+    const separator = token.indexOf(".");
+    if (separator > 0) {
+      return token.slice(0, separator);
+    }
+    return serverFlag;
+  }
+  return serverFlag;
+}
+function isFastPathKeepAliveDisabled(server) {
+  const raw = process.env.MCPORTER_DISABLE_KEEPALIVE ?? process.env.MCPORTER_NO_KEEPALIVE;
+  if (!raw) {
+    return false;
+  }
+  const disabled = new Set(raw.split(",").map((entry) => entry.trim().toLowerCase()).filter(Boolean));
+  return disabled.has("*") || disabled.has(server.toLowerCase());
+}
+function createDaemonOnlyRuntime(daemonClient) {
+  return {
+    listServers: () => [],
+    getDefinitions: () => [],
+    getDefinition: (server) => {
+      throw new Error(`Server '${server}' is only available through the keep-alive daemon fast path.`);
+    },
+    registerDefinition: () => {
+      throw new Error("Ad-hoc servers are not supported by the keep-alive daemon fast path.");
+    },
+    getInstructions: async () => void 0,
+    listTools: async (server, options) => await daemonClient.listTools({
+      server,
+      includeSchema: options?.includeSchema,
+      autoAuthorize: options?.autoAuthorize,
+      allowCachedAuth: options?.allowCachedAuth,
+      disableOAuth: options?.disableOAuth
+    }),
+    callTool: (server, toolName, options) => daemonClient.callTool({
+      server,
+      tool: toolName,
+      args: options?.args,
+      timeoutMs: options?.timeoutMs,
+      disableOAuth: options?.disableOAuth
+    }),
+    listResources: (server, options) => {
+      const params = { ...options };
+      delete params.allowCachedAuth;
+      delete params.disableOAuth;
+      delete params.oauthSessionOptions;
+      return daemonClient.listResources({
+        server,
+        params,
+        allowCachedAuth: options?.allowCachedAuth,
+        disableOAuth: options?.disableOAuth
+      });
+    },
+    readResource: (server, uri, options) => daemonClient.readResource({
+      server,
+      uri,
+      allowCachedAuth: options?.allowCachedAuth,
+      disableOAuth: options?.disableOAuth
+    }),
+    connect: async (server) => {
+      throw new Error(`Server '${server}' is only available through daemon request methods.`);
+    },
+    close: async (server) => {
+      if (server) {
+        await daemonClient.closeServer({ server }).catch(() => {
+        });
+      }
+    }
+  };
+}
+export {
+  extractListFlags,
+  handleAuth,
+  handleCall,
+  handleGenerateCli,
+  handleInspectCli,
+  handleList,
+  handleResource,
+  parseCallArguments,
+  printAuthHelp,
+  resolveCallTimeout,
+  runCli
+};