@introspection-ai/recipes 0.18.0 → 0.19.0

package/dist/mcp-chunks/chunk-2FSDGCHW.js

@@ -0,0 +1,3299 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  NON_INTERACTIVE_ELICITATION_HINT,
+  createNonInteractiveElicitationResponder,
+  registerElicitationHandler
+} from "./chunk-CA5WFJZA.js";
+import {
+  RecordTransport,
+  resolveRecordingPath
+} from "./chunk-E6T37ED6.js";
+import {
+  OAuthTimeoutError,
+  connectWithAuth,
+  isOAuthFlowError,
+  isPostAuthConnectError,
+  resolveOAuthTimeoutFromEnv
+} from "./chunk-SRZZQ6TL.js";
+import {
+  buildOAuthPersistence,
+  buildStaticClientInformation,
+  readCachedAccessToken
+} from "./chunk-3IZQW4H4.js";
+import {
+  isUnauthorizedError,
+  maybeEnableOAuth
+} from "./chunk-7DH57OKF.js";
+import {
+  STDIO_TRACE_ENABLED,
+  flushStdioLogs,
+  ignoreStdioEmitterError
+} from "./chunk-2MEHGB7D.js";
+import {
+  MCPORTER_VERSION
+} from "./chunk-SFREPU3D.js";
+import {
+  createPrefixedConsoleLogger,
+  resolveLogLevelFromEnv
+} from "./chunk-GFYTST6N.js";
+import {
+  normalizeTimeout,
+  raceWithTimeout,
+  resolveCommandArgument,
+  resolveCommandArguments
+} from "./chunk-ETWN4IIA.js";
+import {
+  analyzeConnectionError
+} from "./chunk-DEUU7WSN.js";
+import {
+  Client,
+  DEFAULT_REQUEST_TIMEOUT_MSEC,
+  ProtocolErrorCode,
+  ReadBuffer,
+  SSEClientTransport,
+  SdkError,
+  SdkErrorCode,
+  SdkHttpError,
+  StreamableHTTPClientTransport,
+  serializeMessage,
+  specTypeSchemas,
+  validateClientMetadataUrl
+} from "./chunk-YPJ5EHXR.js";
+import {
+  loadServerDefinitions
+} from "./chunk-L4VKBFYI.js";
+import {
+  resolveEnvPlaceholders,
+  resolveEnvValue,
+  withEnvOverrides
+} from "./chunk-HAO6PL7Z.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-LRKZP7DJ.js";
+
+// node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
+var require_windows = __commonJS({
+  "node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports, module) {
+    module.exports = isexe;
+    isexe.sync = sync;
+    var fs5 = __require("fs");
+    function checkPathExt(path4, options) {
+      var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+      if (!pathext) {
+        return true;
+      }
+      pathext = pathext.split(";");
+      if (pathext.indexOf("") !== -1) {
+        return true;
+      }
+      for (var i = 0; i < pathext.length; i++) {
+        var p = pathext[i].toLowerCase();
+        if (p && path4.substr(-p.length).toLowerCase() === p) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function checkStat(stat, path4, options) {
+      if (!stat.isSymbolicLink() && !stat.isFile()) {
+        return false;
+      }
+      return checkPathExt(path4, options);
+    }
+    function isexe(path4, options, cb) {
+      fs5.stat(path4, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path4, options));
+      });
+    }
+    function sync(path4, options) {
+      return checkStat(fs5.statSync(path4), path4, options);
+    }
+  }
+});
+
+// node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js
+var require_mode = __commonJS({
+  "node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports, module) {
+    module.exports = isexe;
+    isexe.sync = sync;
+    var fs5 = __require("fs");
+    function isexe(path4, options, cb) {
+      fs5.stat(path4, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, options));
+      });
+    }
+    function sync(path4, options) {
+      return checkStat(fs5.statSync(path4), options);
+    }
+    function checkStat(stat, options) {
+      return stat.isFile() && checkMode(stat, options);
+    }
+    function checkMode(stat, options) {
+      var mod = stat.mode;
+      var uid = stat.uid;
+      var gid = stat.gid;
+      var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+      var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+      var u = parseInt("100", 8);
+      var g = parseInt("010", 8);
+      var o = parseInt("001", 8);
+      var ug = u | g;
+      var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+      return ret;
+    }
+  }
+});
+
+// node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
+var require_isexe = __commonJS({
+  "node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports, module) {
+    var fs5 = __require("fs");
+    var core;
+    if (process.platform === "win32" || global.TESTING_WINDOWS) {
+      core = require_windows();
+    } else {
+      core = require_mode();
+    }
+    module.exports = isexe;
+    isexe.sync = sync;
+    function isexe(path4, options, cb) {
+      if (typeof options === "function") {
+        cb = options;
+        options = {};
+      }
+      if (!cb) {
+        if (typeof Promise !== "function") {
+          throw new TypeError("callback not provided");
+        }
+        return new Promise(function(resolve, reject) {
+          isexe(path4, options || {}, function(er, is) {
+            if (er) {
+              reject(er);
+            } else {
+              resolve(is);
+            }
+          });
+        });
+      }
+      core(path4, options || {}, function(er, is) {
+        if (er) {
+          if (er.code === "EACCES" || options && options.ignoreErrors) {
+            er = null;
+            is = false;
+          }
+        }
+        cb(er, is);
+      });
+    }
+    function sync(path4, options) {
+      try {
+        return core.sync(path4, options || {});
+      } catch (er) {
+        if (options && options.ignoreErrors || er.code === "EACCES") {
+          return false;
+        } else {
+          throw er;
+        }
+      }
+    }
+  }
+});
+
+// node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
+var require_which = __commonJS({
+  "node_modules/.pnpm/which@2.0.2/node_modules/which/which.js"(exports, module) {
+    var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+    var path4 = __require("path");
+    var COLON = isWindows ? ";" : ":";
+    var isexe = require_isexe();
+    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+    var getPathInfo = (cmd, opt) => {
+      const colon = opt.colon || COLON;
+      const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows ? [process.cwd()] : [],
+        ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
+        "").split(colon)
+      ];
+      const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+      const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+      if (isWindows) {
+        if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+          pathExt.unshift("");
+      }
+      return {
+        pathEnv,
+        pathExt,
+        pathExtExe
+      };
+    };
+    var which = (cmd, opt, cb) => {
+      if (typeof opt === "function") {
+        cb = opt;
+        opt = {};
+      }
+      if (!opt)
+        opt = {};
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      const step = (i) => new Promise((resolve, reject) => {
+        if (i === pathEnv.length)
+          return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+        const ppRaw = pathEnv[i];
+        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+        const pCmd = path4.join(pathPart, cmd);
+        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        resolve(subStep(p, i, 0));
+      });
+      const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+        if (ii === pathExt.length)
+          return resolve(step(i + 1));
+        const ext = pathExt[ii];
+        isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+          if (!er && is) {
+            if (opt.all)
+              found.push(p + ext);
+            else
+              return resolve(p + ext);
+          }
+          return resolve(subStep(p, i, ii + 1));
+        });
+      });
+      return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+    };
+    var whichSync = (cmd, opt) => {
+      opt = opt || {};
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (let i = 0; i < pathEnv.length; i++) {
+        const ppRaw = pathEnv[i];
+        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+        const pCmd = path4.join(pathPart, cmd);
+        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        for (let j = 0; j < pathExt.length; j++) {
+          const cur = p + pathExt[j];
+          try {
+            const is = isexe.sync(cur, { pathExt: pathExtExe });
+            if (is) {
+              if (opt.all)
+                found.push(cur);
+              else
+                return cur;
+            }
+          } catch (ex) {
+          }
+        }
+      }
+      if (opt.all && found.length)
+        return found;
+      if (opt.nothrow)
+        return null;
+      throw getNotFoundError(cmd);
+    };
+    module.exports = which;
+    which.sync = whichSync;
+  }
+});
+
+// node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js
+var require_path_key = __commonJS({
+  "node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js"(exports, module) {
+    "use strict";
+    var pathKey = (options = {}) => {
+      const environment = options.env || process.env;
+      const platform = options.platform || process.platform;
+      if (platform !== "win32") {
+        return "PATH";
+      }
+      return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+    };
+    module.exports = pathKey;
+    module.exports.default = pathKey;
+  }
+});
+
+// node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS({
+  "node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module) {
+    "use strict";
+    var path4 = __require("path");
+    var which = require_which();
+    var getPathKey = require_path_key();
+    function resolveCommandAttempt(parsed, withoutPathExt) {
+      const env = parsed.options.env || process.env;
+      const cwd = process.cwd();
+      const hasCustomCwd = parsed.options.cwd != null;
+      const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+      if (shouldSwitchCwd) {
+        try {
+          process.chdir(parsed.options.cwd);
+        } catch (err) {
+        }
+      }
+      let resolved;
+      try {
+        resolved = which.sync(parsed.command, {
+          path: env[getPathKey({ env })],
+          pathExt: withoutPathExt ? path4.delimiter : void 0
+        });
+      } catch (e) {
+      } finally {
+        if (shouldSwitchCwd) {
+          process.chdir(cwd);
+        }
+      }
+      if (resolved) {
+        resolved = path4.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      }
+      return resolved;
+    }
+    function resolveCommand(parsed) {
+      return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+    }
+    module.exports = resolveCommand;
+  }
+});
+
+// node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS({
+  "node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js"(exports, module) {
+    "use strict";
+    var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+    function escapeCommand(arg) {
+      arg = arg.replace(metaCharsRegExp, "^$1");
+      return arg;
+    }
+    function escapeArgument(arg, doubleEscapeMetaChars) {
+      arg = `${arg}`;
+      arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+      arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+      arg = `"${arg}"`;
+      arg = arg.replace(metaCharsRegExp, "^$1");
+      if (doubleEscapeMetaChars) {
+        arg = arg.replace(metaCharsRegExp, "^$1");
+      }
+      return arg;
+    }
+    module.exports.command = escapeCommand;
+    module.exports.argument = escapeArgument;
+  }
+});
+
+// node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS({
+  "node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js"(exports, module) {
+    "use strict";
+    module.exports = /^#!(.*)/;
+  }
+});
+
+// node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS({
+  "node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js"(exports, module) {
+    "use strict";
+    var shebangRegex = require_shebang_regex();
+    module.exports = (string = "") => {
+      const match = string.match(shebangRegex);
+      if (!match) {
+        return null;
+      }
+      const [path4, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path4.split("/").pop();
+      if (binary === "env") {
+        return argument;
+      }
+      return argument ? `${binary} ${argument}` : binary;
+    };
+  }
+});
+
+// node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS({
+  "node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module) {
+    "use strict";
+    var fs5 = __require("fs");
+    var shebangCommand = require_shebang_command();
+    function readShebang(command) {
+      const size = 150;
+      const buffer = Buffer.alloc(size);
+      let fd;
+      try {
+        fd = fs5.openSync(command, "r");
+        fs5.readSync(fd, buffer, 0, size, 0);
+        fs5.closeSync(fd);
+      } catch (e) {
+      }
+      return shebangCommand(buffer.toString());
+    }
+    module.exports = readShebang;
+  }
+});
+
+// node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
+var require_parse = __commonJS({
+  "node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js"(exports, module) {
+    "use strict";
+    var path4 = __require("path");
+    var resolveCommand = require_resolveCommand();
+    var escape = require_escape();
+    var readShebang = require_readShebang();
+    var isWin = process.platform === "win32";
+    var isExecutableRegExp = /\.(?:com|exe)$/i;
+    var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+    function detectShebang(parsed) {
+      parsed.file = resolveCommand(parsed);
+      const shebang = parsed.file && readShebang(parsed.file);
+      if (shebang) {
+        parsed.args.unshift(parsed.file);
+        parsed.command = shebang;
+        return resolveCommand(parsed);
+      }
+      return parsed.file;
+    }
+    function parseNonShell(parsed) {
+      if (!isWin) {
+        return parsed;
+      }
+      const commandFile = detectShebang(parsed);
+      const needsShell = !isExecutableRegExp.test(commandFile);
+      if (parsed.options.forceShell || needsShell) {
+        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+        parsed.command = path4.normalize(parsed.command);
+        parsed.command = escape.command(parsed.command);
+        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+        const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+        parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+        parsed.command = process.env.comspec || "cmd.exe";
+        parsed.options.windowsVerbatimArguments = true;
+      }
+      return parsed;
+    }
+    function parse(command, args, options) {
+      if (args && !Array.isArray(args)) {
+        options = args;
+        args = null;
+      }
+      args = args ? args.slice(0) : [];
+      options = Object.assign({}, options);
+      const parsed = {
+        command,
+        args,
+        options,
+        file: void 0,
+        original: {
+          command,
+          args
+        }
+      };
+      return options.shell ? parsed : parseNonShell(parsed);
+    }
+    module.exports = parse;
+  }
+});
+
+// node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS({
+  "node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js"(exports, module) {
+    "use strict";
+    var isWin = process.platform === "win32";
+    function notFoundError(original, syscall) {
+      return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+        code: "ENOENT",
+        errno: "ENOENT",
+        syscall: `${syscall} ${original.command}`,
+        path: original.command,
+        spawnargs: original.args
+      });
+    }
+    function hookChildProcess(cp, parsed) {
+      if (!isWin) {
+        return;
+      }
+      const originalEmit = cp.emit;
+      cp.emit = function(name, arg1) {
+        if (name === "exit") {
+          const err = verifyENOENT(arg1, parsed);
+          if (err) {
+            return originalEmit.call(cp, "error", err);
+          }
+        }
+        return originalEmit.apply(cp, arguments);
+      };
+    }
+    function verifyENOENT(status, parsed) {
+      if (isWin && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, "spawn");
+      }
+      return null;
+    }
+    function verifyENOENTSync(status, parsed) {
+      if (isWin && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, "spawnSync");
+      }
+      return null;
+    }
+    module.exports = {
+      hookChildProcess,
+      verifyENOENT,
+      verifyENOENTSync,
+      notFoundError
+    };
+  }
+});
+
+// node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS({
+  "node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js"(exports, module) {
+    "use strict";
+    var cp = __require("child_process");
+    var parse = require_parse();
+    var enoent = require_enoent();
+    function spawn3(command, args, options) {
+      const parsed = parse(command, args, options);
+      const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+      enoent.hookChildProcess(spawned, parsed);
+      return spawned;
+    }
+    function spawnSync(command, args, options) {
+      const parsed = parse(command, args, options);
+      const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+      result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+      return result;
+    }
+    module.exports = spawn3;
+    module.exports.spawn = spawn3;
+    module.exports.sync = spawnSync;
+    module.exports._parse = parse;
+    module.exports._enoent = enoent;
+  }
+});
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/runtime-process-utils.js
+import { execFile } from "node:child_process";
+async function closeTransportAndWait(logger, transport, options = {}) {
+  const pidBeforeClose = getTransportPid(transport);
+  const targetsBeforeClose = pidBeforeClose ? await collectProcessTreePids(pidBeforeClose) : [];
+  let closeError;
+  let closeSettled = false;
+  const closePromise = (options.close ?? (() => transport.close()))().catch((error) => {
+    closeError = error;
+    if (!options.throwOnCloseError) {
+      logger.warn(`Failed to close transport cleanly: ${error.message}`);
+    }
+  }).finally(() => {
+    closeSettled = true;
+  });
+  if (pidBeforeClose) {
+    destroyTransportStreams(transport);
+    await ensureProcessTreeTerminated(logger, pidBeforeClose, targetsBeforeClose);
+    if (!closeSettled) {
+      await Promise.race([closePromise, delay(100)]);
+    }
+  } else {
+    await closePromise;
+  }
+  if (closeError && options.throwOnCloseError) {
+    throw closeError;
+  }
+}
+function getTransportPid(transport) {
+  if ("pid" in transport) {
+    const candidate = transport.pid;
+    if (typeof candidate === "number" && candidate > 0) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureProcessTreeTerminated(logger, rootPid, capturedTargets = []) {
+  let targets = uniquePids([...capturedTargets, ...await collectProcessTreePids(rootPid)]);
+  if (targets.length === 0 || await waitForTreeExit(targets, 700)) {
+    return;
+  }
+  await sendSignalToTargets(targets, "SIGTERM");
+  targets = uniquePids([...targets, ...await collectProcessTreePids(rootPid)]);
+  if (await waitForTreeExit(targets, 700)) {
+    return;
+  }
+  targets = uniquePids([...targets, ...await collectProcessTreePids(rootPid)]);
+  await sendSignalToTargets(targets, "SIGKILL");
+  if (await waitForTreeExit(targets, 500)) {
+    return;
+  }
+  logger.warn(`Process tree rooted at pid=${rootPid} did not exit after SIGKILL.`);
+}
+function uniquePids(pids) {
+  return [...new Set(pids.filter((pid) => Number.isInteger(pid) && pid > 0))];
+}
+function destroyTransportStreams(transport) {
+  const candidate = transport;
+  for (const key of ["stdin", "stdout", "stderr"]) {
+    try {
+      const stream = candidate[key];
+      stream?.destroy?.();
+    } catch {
+    }
+  }
+}
+async function sendSignalToTargets(pids, signal) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const pid of pids) {
+    if (seen.has(pid)) {
+      continue;
+    }
+    seen.add(pid);
+    sendSignal(pid, signal);
+  }
+}
+function sendSignal(pid, signal) {
+  try {
+    process.kill(pid, signal);
+  } catch (error) {
+    if (typeof error === "object" && error && "code" in error && error.code === "ESRCH") {
+      return;
+    }
+    throw error;
+  }
+}
+async function listDescendantPids(rootPid) {
+  if (!isProcessAlive(rootPid)) {
+    return [];
+  }
+  if (process.platform === "win32") {
+    return listDescendantPidsWindows(rootPid);
+  }
+  try {
+    const { stdout } = await execFileAsync("ps", ["-eo", "pid=,ppid="]);
+    const children = /* @__PURE__ */ new Map();
+    for (const line of stdout.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        continue;
+      }
+      const [pidText, ppidText] = trimmed.split(/\s+/, 2);
+      const pid = Number.parseInt(pidText ?? "", 10);
+      const ppid = Number.parseInt(ppidText ?? "", 10);
+      if (!Number.isFinite(pid) || !Number.isFinite(ppid)) {
+        continue;
+      }
+      const bucket = children.get(ppid) ?? [];
+      bucket.push(pid);
+      children.set(ppid, bucket);
+    }
+    return collectDescendantsFromChildren(rootPid, children);
+  } catch {
+    return [];
+  }
+}
+async function listDescendantPidsWindows(rootPid) {
+  try {
+    const powershellScript = "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId | ConvertTo-Json -Compress";
+    const { stdout } = await execFileAsync("powershell.exe", ["-NoProfile", "-Command", powershellScript]);
+    const trimmed = stdout.trim();
+    if (!trimmed) {
+      return [];
+    }
+    const parsed = JSON.parse(trimmed);
+    const entries = Array.isArray(parsed) ? parsed : [parsed];
+    const children = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const pidCandidate = entry?.ProcessId;
+      const ppidCandidate = entry?.ParentProcessId;
+      if (typeof pidCandidate !== "number" || typeof ppidCandidate !== "number") {
+        continue;
+      }
+      const pid = Number.isFinite(pidCandidate) ? pidCandidate : void 0;
+      const ppid = Number.isFinite(ppidCandidate) ? ppidCandidate : void 0;
+      if (pid === void 0 || ppid === void 0) {
+        continue;
+      }
+      const bucket = children.get(ppid) ?? [];
+      bucket.push(pid);
+      children.set(ppid, bucket);
+    }
+    return collectDescendantsFromChildren(rootPid, children);
+  } catch {
+    return [];
+  }
+}
+function execFileAsync(command, args) {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, { encoding: "utf8" }, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+async function collectProcessTreePids(rootPid) {
+  const descendants = await listDescendantPids(rootPid);
+  return [...descendants, rootPid];
+}
+function collectDescendantsFromChildren(rootPid, children) {
+  const result = [];
+  const queue = [...children.get(rootPid) ?? []];
+  const seen = new Set(queue);
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === void 0) {
+      continue;
+    }
+    result.push(current);
+    for (const child of children.get(current) ?? []) {
+      if (!seen.has(child)) {
+        seen.add(child);
+        queue.push(child);
+      }
+    }
+  }
+  return result;
+}
+async function waitForTreeExit(pids, durationMs) {
+  const deadline = Date.now() + durationMs;
+  while (true) {
+    if (pids.every((pid) => !isProcessAlive(pid))) {
+      return true;
+    }
+    if (Date.now() >= deadline) {
+      return false;
+    }
+    const remaining = Math.max(10, Math.min(100, deadline - Date.now()));
+    await delay(remaining);
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/runtime/errors.js
+var NON_FATAL_MCP_ERROR_CODES = /* @__PURE__ */ new Set([
+  ProtocolErrorCode.InvalidRequest,
+  ProtocolErrorCode.MethodNotFound,
+  ProtocolErrorCode.InvalidParams
+]);
+function shouldResetConnection(error) {
+  if (!error) {
+    return false;
+  }
+  const code = protocolErrorCode(error);
+  if (code !== void 0) {
+    return !NON_FATAL_MCP_ERROR_CODES.has(code);
+  }
+  return error instanceof Error;
+}
+function protocolErrorCode(error) {
+  if (!error || typeof error !== "object" || !("code" in error))
+    return void 0;
+  return typeof error.code === "number" ? error.code : void 0;
+}
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/runtime/replay-transport.js
+import fs from "node:fs";
+import { isDeepStrictEqual } from "node:util";
+var CLIENT_IDENTITY_META_KEYS = [
+  "io.modelcontextprotocol/clientInfo",
+  "io.modelcontextprotocol/protocolVersion",
+  "io.modelcontextprotocol/clientCapabilities"
+];
+var ReplayTransport = class {
+  opts;
+  hasPerRequestStream = void 0;
+  onclose;
+  onerror;
+  onmessage;
+  sessionId;
+  expectedSends;
+  requiresLegacyNegotiation;
+  constructor(opts) {
+    this.opts = opts;
+    this.expectedSends = buildReplayQueue(readRecordedMessages(opts.recordPath), opts.server);
+    this.requiresLegacyNegotiation = this.expectedSends[0]?.method === "initialize";
+  }
+  async start() {
+  }
+  async send(message, _options) {
+    const request = requestDetails(message);
+    if (!request) {
+      return;
+    }
+    const expected = this.expectedSends[0];
+    if (!expected || expected.method !== request.method || !paramsMatch(request.method, expected.params, request.params)) {
+      throw new Error(formatReplayMismatch(this.opts.server, request, expected));
+    }
+    this.expectedSends.shift();
+    if (expected.response) {
+      const response = withActiveRequestId(adaptInitializeResponse(request.method, expected.response, request.params), request.id);
+      const inbound = [
+        ...expected.notificationsBeforeResponse ?? [],
+        response,
+        ...expected.notificationsAfterResponse ?? []
+      ];
+      queueMicrotask(() => {
+        for (const inboundMessage of inbound)
+          this.onmessage?.(inboundMessage);
+      });
+    }
+  }
+  async close() {
+    if (this.expectedSends.length > 0) {
+      throw new Error(formatReplayRemainder(this.opts.server, this.expectedSends));
+    }
+    this.onclose?.();
+  }
+};
+function readRecordedMessages(recordPath) {
+  try {
+    const contents = fs.readFileSync(recordPath, "utf8");
+    return contents.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).map((line, index) => {
+      try {
+        return JSON.parse(line);
+      } catch (error) {
+        throw new Error(`Invalid JSON on recording line ${index + 1} in ${recordPath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+      }
+    });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Replay recording not found: ${recordPath}`, { cause: error });
+    }
+    throw error;
+  }
+}
+function buildReplayQueue(messages, server) {
+  const pendingRequests = /* @__PURE__ */ new Map();
+  const expected = [];
+  let bufferedNotifications = [];
+  let lastResponse;
+  for (const entry of messages) {
+    if (entry._meta?.server !== server) {
+      continue;
+    }
+    if (entry._meta.dir === "lifecycle") {
+      continue;
+    }
+    const clean = stripMeta(entry);
+    if (entry._meta.dir === "send") {
+      const request = requestDetails(clean);
+      if (!request) {
+        continue;
+      }
+      const expectedSend = {
+        method: request.method,
+        params: request.params,
+        expectsResponse: request.id !== void 0
+      };
+      expected.push(expectedSend);
+      if (request.id !== void 0) {
+        pendingRequests.set(String(request.id), expectedSend);
+      }
+      continue;
+    }
+    if (entry._meta.dir === "recv") {
+      if (isInboundNotification(clean)) {
+        bufferedNotifications.push(clean);
+        continue;
+      }
+      const responseId = responseIdOf(clean);
+      if (responseId === void 0) {
+        continue;
+      }
+      const pending = pendingRequests.get(String(responseId));
+      if (pending) {
+        pendingRequests.delete(String(responseId));
+        pending.notificationsBeforeResponse = bufferedNotifications;
+        bufferedNotifications = [];
+        pending.response = clean;
+        lastResponse = pending;
+      }
+    }
+  }
+  if (lastResponse && bufferedNotifications.length > 0) {
+    lastResponse.notificationsAfterResponse = bufferedNotifications;
+  }
+  return expected.filter((entry) => !entry.expectsResponse || entry.response);
+}
+function isInboundNotification(message) {
+  const record = message;
+  return typeof record.method === "string" && !("id" in record);
+}
+function stripMeta(message) {
+  const { _meta, ...jsonrpc } = message;
+  return jsonrpc;
+}
+function requestDetails(message) {
+  const record = message;
+  if (typeof record.method !== "string") {
+    return void 0;
+  }
+  if (record.method.startsWith("$transport/")) {
+    return void 0;
+  }
+  return {
+    id: typeof record.id === "string" || typeof record.id === "number" ? record.id : void 0,
+    method: record.method,
+    params: record.params
+  };
+}
+function responseIdOf(message) {
+  const record = message;
+  if (!("result" in record) && !("error" in record)) {
+    return void 0;
+  }
+  const id = record.id;
+  return typeof id === "string" || typeof id === "number" ? id : void 0;
+}
+function paramsMatch(method, expected, actual) {
+  if (method === "server/discover") {
+    return true;
+  }
+  const normalizedExpected = normalizeClientIdentityMeta(expected);
+  const normalizedActual = normalizeClientIdentityMeta(actual);
+  if (method !== "initialize") {
+    return isDeepStrictEqual(normalizedExpected, normalizedActual);
+  }
+  return isDeepStrictEqual(normalizeInitializeParams(normalizedExpected), normalizeInitializeParams(normalizedActual));
+}
+function normalizeClientIdentityMeta(params) {
+  if (!isJsonRpcRecord(params) || !isJsonRpcRecord(params._meta)) {
+    return params;
+  }
+  const meta = { ...params._meta };
+  for (const key of CLIENT_IDENTITY_META_KEYS) {
+    delete meta[key];
+  }
+  return { ...params, _meta: meta };
+}
+function normalizeInitializeParams(params) {
+  if (!isJsonRpcRecord(params)) {
+    return params;
+  }
+  const normalized = { ...params };
+  delete normalized.protocolVersion;
+  delete normalized.capabilities;
+  delete normalized.clientInfo;
+  return normalized;
+}
+function adaptInitializeResponse(method, response, requestParams) {
+  if (method !== "initialize" || !isJsonRpcRecord(requestParams) || !("result" in response)) {
+    return response;
+  }
+  const protocolVersion = requestParams.protocolVersion;
+  if (typeof protocolVersion !== "string" || !isJsonRpcRecord(response.result)) {
+    return response;
+  }
+  return {
+    ...response,
+    result: { ...response.result, protocolVersion }
+  };
+}
+function isJsonRpcRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function withActiveRequestId(response, requestId) {
+  if (requestId === void 0) {
+    return response;
+  }
+  return {
+    ...response,
+    id: requestId
+  };
+}
+function formatReplayMismatch(server, request, expected) {
+  const expectedText = expected ? `${expected.method} ${JSON.stringify(expected.params ?? {})}` : "no remaining recorded recv";
+  return `Replay mismatch for server '${server}': request ${request.method} ${JSON.stringify(request.params ?? {})} did not match next expected recv ${expectedText}.`;
+}
+function formatReplayRemainder(server, expectedSends) {
+  const expected = expectedSends[0];
+  const count = expectedSends.length;
+  const requestText = count === 1 ? "request" : "requests";
+  const expectedText = expected ? `${expected.method} ${JSON.stringify(expected.params ?? {})}` : "no remaining recorded recv";
+  return `Replay ended for server '${server}' with ${count} recorded ${requestText} still unused; next expected recv ${expectedText}.`;
+}
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/chrome-devtools-compat.js
+import fs3 from "node:fs";
+import os from "node:os";
+import path2 from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/chrome-devtools-auto-connect-patch.js
+import fs2 from "node:fs";
+import path from "node:path";
+var MARKER = "MCPORTER_DEVTOOLS_TIMEOUT_PATCH";
+var HELPER = `// ${MARKER}
+const MCPORTER_DEVTOOLS_DETECTION_TIMEOUT = 1_000;
+async function mcporterWithTimeout(promise, fallback) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise(resolve => {
+                timer = setTimeout(resolve, MCPORTER_DEVTOOLS_DETECTION_TIMEOUT, fallback);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    }
+}
+`;
+var DETECTION_BLOCK = `if (await page.hasDevTools()) {
+                    mcpPage.devToolsPage = await page.openDevTools();
+                }`;
+var PATCHED_DETECTION_BLOCK = `if (await mcporterWithTimeout(page.hasDevTools(), false)) {
+                    mcpPage.devToolsPage = await mcporterWithTimeout(page.openDevTools(), undefined);
+                }`;
+patchChromeDevtoolsMcp();
+function patchChromeDevtoolsMcp(mainPath = process.argv[1]) {
+  patchChromeDevtoolsMcpWithDependencies(mainPath, fs2, path, MARKER, HELPER, DETECTION_BLOCK, PATCHED_DETECTION_BLOCK);
+}
+function renderChromeDevtoolsAutoConnectPatchSource() {
+  return `import fs from 'node:fs';
+import path from 'node:path';
+
+const patchChromeDevtoolsMcp = ${patchChromeDevtoolsMcpWithDependencies.toString()};
+
+patchChromeDevtoolsMcp(
+  process.argv[1],
+  fs,
+  path,
+  ${JSON.stringify(MARKER)},
+  ${JSON.stringify(HELPER)},
+  ${JSON.stringify(DETECTION_BLOCK)},
+  ${JSON.stringify(PATCHED_DETECTION_BLOCK)}
+);
+`;
+}
+function patchChromeDevtoolsMcpWithDependencies(mainPath, fsApi, pathApi, marker, helper, detectionBlock, patchedDetectionBlock) {
+  if (!mainPath || !mainPath.includes("chrome-devtools-mcp")) {
+    return;
+  }
+  let resolvedMainPath;
+  try {
+    resolvedMainPath = fsApi.realpathSync(mainPath);
+  } catch {
+    return;
+  }
+  if (!resolvedMainPath.endsWith(pathApi.join("bin", "chrome-devtools-mcp.js"))) {
+    return;
+  }
+  const contextPath = pathApi.resolve(pathApi.dirname(resolvedMainPath), "..", "McpContext.js");
+  let source;
+  try {
+    source = fsApi.readFileSync(contextPath, "utf8");
+  } catch {
+    return;
+  }
+  if (source.includes(marker)) {
+    return;
+  }
+  if (!source.includes(detectionBlock)) {
+    return;
+  }
+  const withHelper = source.replace("const NAVIGATION_TIMEOUT = 10_000;\n", `const NAVIGATION_TIMEOUT = 10_000;
+${helper}`);
+  const patched = withHelper.replace(detectionBlock, patchedDetectionBlock);
+  try {
+    fsApi.writeFileSync(contextPath, patched);
+  } catch {
+    return;
+  }
+}
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/chrome-devtools-compat.js
+var AUTO_CONNECT_FLAGS = /* @__PURE__ */ new Set(["--autoConnect", "--auto-connect"]);
+var FALLBACK_PATCH_FILENAME = "mcporter-chrome-devtools-auto-connect-patch.js";
+function applyChromeDevtoolsCompat(env, command, args) {
+  if (!shouldApplyChromeDevtoolsCompat(command, args, env)) {
+    return { env, applied: false };
+  }
+  const patchPath = resolveChromeDevtoolsCompatPatchPath();
+  if (!patchPath) {
+    return { env, applied: false };
+  }
+  const importFlag = `--import=${pathToFileURL(patchPath).href}`;
+  const existingOptions = env.NODE_OPTIONS?.trim();
+  if (existingOptions?.includes(importFlag)) {
+    return { env, applied: true, patchPath };
+  }
+  return {
+    env: {
+      ...env,
+      NODE_OPTIONS: existingOptions ? `${existingOptions} ${importFlag}` : importFlag
+    },
+    applied: true,
+    patchPath
+  };
+}
+function shouldApplyChromeDevtoolsCompat(command, args, env = process.env) {
+  if (env.MCPORTER_DISABLE_CHROME_DEVTOOLS_COMPAT === "1") {
+    return false;
+  }
+  const tokens = [command, ...args];
+  return tokens.some(isChromeDevtoolsToken) && args.some((arg) => AUTO_CONNECT_FLAGS.has(arg));
+}
+function isChromeDevtoolsToken(token) {
+  return token === "chrome-devtools-mcp" || token.startsWith("chrome-devtools-mcp@") || token.includes("/chrome-devtools-mcp");
+}
+function resolveChromeDevtoolsCompatPatchPath(candidates = defaultChromeDevtoolsPatchCandidates(), fallbackDir = os.tmpdir()) {
+  const existing = candidates.find((candidate) => fs3.existsSync(candidate));
+  if (existing) {
+    return existing;
+  }
+  return writeFallbackPatch(fallbackDir);
+}
+function defaultChromeDevtoolsPatchCandidates() {
+  const here = path2.dirname(fileURLToPath(import.meta.url));
+  return [
+    path2.join(here, "chrome-devtools-auto-connect-patch.js"),
+    path2.resolve(here, "..", "dist", "chrome-devtools-auto-connect-patch.js")
+  ];
+}
+function writeFallbackPatch(fallbackDir) {
+  const patchPath = path2.join(fallbackDir, FALLBACK_PATCH_FILENAME);
+  try {
+    fs3.writeFileSync(patchPath, renderChromeDevtoolsAutoConnectPatchSource(), { mode: 384 });
+    return patchPath;
+  } catch {
+    return void 0;
+  }
+}
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/chrome-devtools-relay.js
+import fs4 from "node:fs";
+import os2 from "node:os";
+import path3 from "node:path";
+var AUTO_CONNECT_FLAGS2 = /* @__PURE__ */ new Set(["--autoConnect", "--auto-connect"]);
+var RELAY_PROBE_TIMEOUT_MS = 750;
+var DEFAULT_RELAY_URL = "http://127.0.0.1:18799";
+function isChromeDevtoolsToken2(token) {
+  return token === "chrome-devtools-mcp" || token.startsWith("chrome-devtools-mcp@") || token.includes("/chrome-devtools-mcp");
+}
+function relayBaseUrl(env) {
+  const raw = env.MCPORTER_CHROME_DEVTOOLS_RELAY_URL?.trim() || DEFAULT_RELAY_URL;
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return void 0;
+  }
+  if (url.protocol !== "http:" || !["127.0.0.1", "localhost", "[::1]", "::1"].includes(url.hostname)) {
+    return void 0;
+  }
+  return url;
+}
+function defaultReadToken(env) {
+  const stateDir = env.OPENCLAW_STATE_DIR?.trim() || path3.join(os2.homedir(), ".openclaw");
+  const secretPath = path3.join(stateDir, "credentials", "browser-extension-relay.secret");
+  let raw;
+  try {
+    raw = fs4.readFileSync(secretPath, "utf8");
+  } catch {
+    return void 0;
+  }
+  const token = raw.trim();
+  return /^[0-9a-f]{64}$/.test(token) ? token : void 0;
+}
+async function defaultProbe(versionUrl, token) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), RELAY_PROBE_TIMEOUT_MS);
+  timer.unref?.();
+  try {
+    const response = await fetch(versionUrl, {
+      headers: { Authorization: `Bearer ${token}` },
+      signal: controller.signal
+    });
+    return response.status === 200;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function shouldAttemptChromeDevtoolsRelay(command, args, env = process.env) {
+  if (env.MCPORTER_DISABLE_CHROME_DEVTOOLS_RELAY === "1") {
+    return false;
+  }
+  const tokens = [command, ...args];
+  return tokens.some(isChromeDevtoolsToken2) && args.some((arg) => AUTO_CONNECT_FLAGS2.has(arg));
+}
+async function rewriteChromeDevtoolsArgsForRelay(command, args, env = process.env, options = {}) {
+  if (!shouldAttemptChromeDevtoolsRelay(command, args, env)) {
+    return { args, applied: false };
+  }
+  const base = relayBaseUrl(env);
+  if (!base) {
+    return { args, applied: false };
+  }
+  const token = (options.readToken ?? (() => defaultReadToken(env)))();
+  if (!token) {
+    return { args, applied: false };
+  }
+  const versionUrl = new URL("/json/version", base).toString();
+  const alive = await (options.probe ?? defaultProbe)(versionUrl, token);
+  if (!alive) {
+    return { args, applied: false };
+  }
+  const wsEndpoint = `ws://${base.host}/cdp`;
+  const rewritten = args.filter((arg) => !AUTO_CONNECT_FLAGS2.has(arg));
+  rewritten.push("--wsEndpoint", wsEndpoint, "--wsHeaders", JSON.stringify({ Authorization: `Bearer ${token}` }));
+  return { args: rewritten, applied: true, endpoint: wsEndpoint };
+}
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/runtime/cached-auth.js
+function hasAuthorizationHeader(headers) {
+  return Boolean(headers && Object.keys(headers).some((key) => key.toLowerCase() === "authorization"));
+}
+async function applyCachedAuthIfAvailable(definition, logger, allowCachedAuth) {
+  if (!allowCachedAuth && definition.auth !== "refreshable_bearer") {
+    return definition;
+  }
+  if (definition.auth === "refreshable_bearer" && definition.command.kind === "stdio" && !definition.refresh?.accessTokenEnv) {
+    throw new Error(`Server '${definition.name}' uses refreshable_bearer stdio auth but is missing refresh.accessTokenEnv.`);
+  }
+  if (definition.command.kind === "http" && hasAuthorizationHeader(definition.command.headers)) {
+    return definition;
+  }
+  try {
+    const cached = await readCachedAccessToken(definition, logger);
+    if (!cached) {
+      if (definition.auth === "refreshable_bearer") {
+        throw new Error(`Server '${definition.name}' uses refreshable_bearer auth but has no cached access token.`);
+      }
+      return definition;
+    }
+    if (definition.command.kind === "stdio") {
+      if (definition.auth !== "refreshable_bearer") {
+        return definition;
+      }
+      const accessTokenEnv = definition.refresh?.accessTokenEnv;
+      if (!accessTokenEnv) {
+        throw new Error(`Server '${definition.name}' uses refreshable_bearer stdio auth but is missing refresh.accessTokenEnv.`);
+      }
+      logger.debug?.(`Using cached bearer access token for '${definition.name}' stdio env.`);
+      return {
+        ...definition,
+        env: {
+          ...definition.env,
+          [accessTokenEnv]: cached
+        }
+      };
+    }
+    const existingHeaders = definition.command.headers ?? {};
+    if (hasAuthorizationHeader(existingHeaders)) {
+      return definition;
+    }
+    logger.debug?.(`Using cached OAuth access token for '${definition.name}' (non-interactive).`);
+    return {
+      ...definition,
+      command: {
+        ...definition.command,
+        headers: {
+          ...existingHeaders,
+          Authorization: `Bearer ${cached}`
+        }
+      }
+    };
+  } catch (error) {
+    if (definition.auth === "refreshable_bearer") {
+      throw error;
+    }
+    logger.debug?.(`Failed to read cached OAuth token for '${definition.name}': ${error instanceof Error ? error.message : String(error)}`);
+    return definition;
+  }
+}
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/oauth.js
+import { spawn } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import http from "node:http";
+import { URL as URL2 } from "node:url";
+var CALLBACK_HOST = "127.0.0.1";
+var CALLBACK_PATH = "/callback";
+var INTERACTIVE_AUTHORIZATION_TTL_MS = 3e5;
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+function openExternal(url, platform = process.platform, launch = spawn) {
+  const stdio = "ignore";
+  try {
+    if (platform === "darwin") {
+      const child = launch("open", [url], { stdio, detached: true });
+      child.unref();
+    } else if (platform === "win32") {
+      const child = launch("rundll32", ["url.dll,FileProtocolHandler", url], {
+        stdio,
+        detached: true,
+        windowsHide: true
+      });
+      child.unref();
+    } else {
+      try {
+        const child = launch("xdg-open", [url], { stdio, detached: true });
+        child.on("error", () => {
+        });
+        child.unref();
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+var PersistentOAuthClientProvider = class _PersistentOAuthClientProvider {
+  definition;
+  options;
+  metadata;
+  logger;
+  persistence;
+  redirectUrlValue;
+  authorizationDeferred = null;
+  authorizationRedirectStarted = false;
+  // One interactive authorization transaction per provider: concurrent SDK auth() flows
+  // (background GET reconnect + bridged POST both hitting 401) must not each open a
+  // prompt, because only one persisted PKCE verifier can complete (issue #247).
+  interactiveAuthorization = null;
+  pendingVerifiersByChallenge = /* @__PURE__ */ new Map();
+  server;
+  constructor(definition, persistence, redirectUrl, logger, options = {}) {
+    this.definition = definition;
+    this.options = options;
+    this.redirectUrlValue = redirectUrl;
+    this.logger = logger;
+    this.persistence = persistence;
+    this.metadata = {
+      client_name: definition.clientName ?? `mcporter (${definition.name})`,
+      redirect_uris: [this.redirectUrlValue.toString()],
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none",
+      // Omit scope so the MCP SDK can derive it from the server's metadata
+      // (resource metadata scopes_supported or auth server scopes_supported).
+      // Hardcoding 'mcp:tools' breaks providers like Granola whose auth server
+      // does not recognise that scope value.
+      // If oauthScope is explicitly configured, prefer that exact value.
+      ...definition.oauthScope !== void 0 ? { scope: definition.oauthScope || void 0 } : {}
+    };
+  }
+  static async create(definition, logger, options = {}) {
+    validateClientMetadataUrl(definition.oauthClientMetadataUrl);
+    const persistence = await buildOAuthPersistence(definition, logger);
+    const server = http.createServer();
+    const overrideRedirect = definition.oauthRedirectUrl ? new URL2(definition.oauthRedirectUrl) : null;
+    const listenHost = overrideRedirect?.hostname ?? CALLBACK_HOST;
+    const overridePort = overrideRedirect?.port ?? "";
+    const usesDynamicPort = !overrideRedirect || overridePort === "" || overridePort === "0";
+    const desiredPort = usesDynamicPort ? void 0 : Number.parseInt(overridePort, 10);
+    const callbackPath = overrideRedirect?.pathname && overrideRedirect.pathname !== "/" ? overrideRedirect.pathname : CALLBACK_PATH;
+    const port = await new Promise((resolve, reject) => {
+      server.listen(desiredPort ?? 0, listenHost, () => {
+        const address = server.address();
+        if (typeof address === "object" && address && "port" in address) {
+          resolve(address.port);
+        } else {
+          reject(new Error("Failed to determine callback port"));
+        }
+      });
+      server.once("error", (error) => reject(error));
+    });
+    const redirectUrl = overrideRedirect ? new URL2(overrideRedirect.toString()) : new URL2(`http://${listenHost}:${port}${callbackPath}`);
+    if (usesDynamicPort) {
+      redirectUrl.port = String(port);
+    }
+    if (!overrideRedirect || overrideRedirect.pathname === "/" || overrideRedirect.pathname === "") {
+      redirectUrl.pathname = callbackPath;
+    }
+    if (usesDynamicPort) {
+      try {
+        const cachedClient = await persistence.readClientInfo();
+        const cachedRedirect = firstRedirectUri(cachedClient);
+        if (cachedRedirect && cachedRedirect !== redirectUrl.toString()) {
+          logger.info(`Redirect URI changed (${cachedRedirect} \u2192 ${redirectUrl.toString()}); clearing stale client registration.`);
+          await persistence.clear("client");
+        }
+      } catch (error) {
+        await new Promise((resolve) => {
+          server.close(() => resolve());
+        });
+        throw error;
+      }
+    }
+    const provider = new _PersistentOAuthClientProvider(definition, persistence, redirectUrl, logger, options);
+    provider.attachServer(server);
+    return {
+      provider,
+      close: async () => {
+        await provider.close();
+      }
+    };
+  }
+  // attachServer listens for the OAuth redirect and resolves/rejects the deferred code promise.
+  attachServer(server) {
+    this.server = server;
+    server.on("request", async (req, res) => {
+      try {
+        const url = req.url ?? "";
+        const parsed = new URL2(url, this.redirectUrlValue);
+        const expectedPath = this.redirectUrlValue.pathname || "/callback";
+        if (parsed.pathname !== expectedPath) {
+          res.statusCode = 404;
+          res.end("Not found");
+          return;
+        }
+        const code = parsed.searchParams.get("code");
+        const error = parsed.searchParams.get("error");
+        const receivedState = parsed.searchParams.get("state");
+        const iss = parsed.searchParams.get("iss") ?? void 0;
+        const expectedState = await this.persistence.readState();
+        if (expectedState && receivedState !== expectedState) {
+          res.statusCode = 400;
+          res.setHeader("Content-Type", "text/html");
+          res.end("<html><body><h1>Authorization failed</h1><p>Invalid OAuth state</p></body></html>");
+          this.authorizationDeferred?.reject(new Error("Invalid OAuth state"));
+          this.authorizationDeferred = null;
+          this.clearInteractiveAuthorization();
+          return;
+        }
+        if (code) {
+          this.logger.info(`Received OAuth authorization code for ${this.definition.name}`);
+          res.statusCode = 200;
+          res.setHeader("Content-Type", "text/html");
+          res.end("<html><body><h1>Authorization successful</h1><p>You can return to the CLI.</p></body></html>");
+          this.authorizationDeferred?.resolve({ code, iss });
+          this.authorizationDeferred = null;
+          this.clearInteractiveAuthorization();
+        } else if (error) {
+          res.statusCode = 400;
+          res.setHeader("Content-Type", "text/html");
+          res.end("<html><body><h1>Authorization failed</h1><p>Return to the CLI for details.</p></body></html>");
+          this.authorizationDeferred?.reject(new Error("OAuth authorization failed."));
+          this.authorizationDeferred = null;
+          this.clearInteractiveAuthorization();
+        } else {
+          res.statusCode = 400;
+          res.end("Missing authorization code");
+          this.authorizationDeferred?.reject(new Error("Missing authorization code"));
+          this.authorizationDeferred = null;
+          this.clearInteractiveAuthorization();
+        }
+      } catch (error) {
+        this.authorizationDeferred?.reject(error);
+        this.authorizationDeferred = null;
+        this.clearInteractiveAuthorization();
+      }
+    });
+  }
+  get redirectUrl() {
+    return this.redirectUrlValue;
+  }
+  get clientMetadata() {
+    return this.metadata;
+  }
+  get clientMetadataUrl() {
+    return this.definition.oauthClientMetadataUrl;
+  }
+  async state() {
+    const existing = await this.persistence.readState();
+    if (existing) {
+      return existing;
+    }
+    const state = randomUUID();
+    await this.persistence.saveState(state);
+    return state;
+  }
+  async clientInformation(ctx) {
+    const staticClient = buildStaticClientInformation(this.definition, { redirectUrl: this.redirectUrlValue });
+    if (staticClient) {
+      return { ...staticClient, ...ctx ? { issuer: ctx.issuer } : {} };
+    }
+    const stored = await this.persistence.readClientInfo();
+    if (ctx && stored?.issuer && !issuersMatch(stored.issuer, ctx.issuer)) {
+      await this.persistence.clear("client");
+      this.logger.info(`Discarded OAuth client registration for ${this.definition.name} after issuer changed.`);
+      return void 0;
+    }
+    return stored;
+  }
+  async saveClientInformation(clientInformation) {
+    await this.persistence.saveClientInfo(clientInformation);
+  }
+  async tokens(ctx) {
+    const stored = await this.persistence.readTokens();
+    if (ctx && stored?.issuer && !issuersMatch(stored.issuer, ctx.issuer)) {
+      await this.persistence.clear("tokens");
+      this.logger.info(`Discarded OAuth tokens for ${this.definition.name} after issuer changed.`);
+      return void 0;
+    }
+    return stored;
+  }
+  async saveTokens(tokens) {
+    await this.persistence.saveTokens(tokens);
+    this.logger.info(`Saved OAuth tokens for ${this.definition.name} (${this.persistence.describe()})`);
+  }
+  async redirectToAuthorization(authorizationUrl) {
+    this.authorizationRedirectStarted = true;
+    this.ensureAuthorizationDeferred();
+    const challenge = authorizationUrl.searchParams.get("code_challenge");
+    if (this.hasActiveInteractiveAuthorization()) {
+      if (challenge) {
+        this.pendingVerifiersByChallenge.delete(challenge);
+      }
+      this.logger.info(`Authorization already pending for ${this.definition.name}; suppressing duplicate prompt.`);
+      return;
+    }
+    this.interactiveAuthorization = { challenge, claimedAt: Date.now() };
+    const claimedVerifier = challenge ? this.pendingVerifiersByChallenge.get(challenge) : void 0;
+    if (challenge) {
+      this.pendingVerifiersByChallenge.delete(challenge);
+    }
+    if (claimedVerifier) {
+      await this.persistence.saveCodeVerifier(claimedVerifier);
+    }
+    const request = {
+      authorizationUrl: authorizationUrl.toString(),
+      redirectUrl: this.redirectUrlValue.toString()
+    };
+    if (this.options.suppressBrowserLaunch) {
+      await this.options.onAuthorizationUrl?.(request);
+      return;
+    }
+    this.logger.info(`Authorization required for ${this.definition.name}. Opening browser...`);
+    __oauthInternals.openExternal(request.authorizationUrl);
+    this.logger.warn(`If the browser did not open, visit ${request.authorizationUrl} manually.`);
+  }
+  hasAuthorizationRedirectStarted() {
+    return this.authorizationRedirectStarted;
+  }
+  async saveCodeVerifier(codeVerifier) {
+    this.pendingVerifiersByChallenge.set(challengeForVerifier(codeVerifier), codeVerifier);
+    if (this.hasActiveInteractiveAuthorization()) {
+      return;
+    }
+    await this.persistence.saveCodeVerifier(codeVerifier);
+  }
+  async codeVerifier() {
+    const value = await this.persistence.readCodeVerifier();
+    if (!value) {
+      throw new Error(`Missing PKCE code verifier for ${this.definition.name}`);
+    }
+    return value.trim();
+  }
+  // invalidateCredentials removes cached files to force the next OAuth flow.
+  async invalidateCredentials(scope) {
+    if (scope === "all" || scope === "verifier") {
+      this.clearInteractiveAuthorization();
+    }
+    await this.persistence.clear(scope);
+  }
+  async saveDiscoveryState(state) {
+    await this.persistence.saveDiscoveryState(state);
+  }
+  async discoveryState() {
+    return this.persistence.readDiscoveryState();
+  }
+  async saveAuthorizationServerUrl(url) {
+    await this.persistence.saveAuthorizationServerUrl(url);
+  }
+  async authorizationServerUrl() {
+    return this.persistence.readAuthorizationServerUrl();
+  }
+  async saveResourceUrl(url) {
+    await this.persistence.saveResourceUrl(url);
+  }
+  async resourceUrl() {
+    return this.persistence.readResourceUrl();
+  }
+  // waitForAuthorizationCode resolves once the local callback server captures a redirect.
+  // The same deferred is shared with redirectToAuthorization so callback resolution is stable.
+  async waitForAuthorizationCode() {
+    return (await this.waitForAuthorizationResponse()).code;
+  }
+  async waitForAuthorizationResponse() {
+    return this.ensureAuthorizationDeferred().promise;
+  }
+  // close stops the temporary callback server created for the OAuth session.
+  async close() {
+    if (this.authorizationDeferred) {
+      this.authorizationDeferred.reject(new Error("OAuth session closed before receiving authorization code."));
+      this.authorizationDeferred = null;
+      this.clearInteractiveAuthorization();
+    }
+    if (!this.server) {
+      return;
+    }
+    this.server.closeAllConnections?.();
+    const server = this.server;
+    this.server = void 0;
+    await new Promise((resolve) => {
+      server.close(() => resolve());
+    });
+  }
+  ensureAuthorizationDeferred() {
+    if (!this.authorizationDeferred) {
+      this.authorizationDeferred = createDeferred();
+    }
+    return this.authorizationDeferred;
+  }
+  hasActiveInteractiveAuthorization() {
+    if (!this.interactiveAuthorization) {
+      return false;
+    }
+    if (Date.now() - this.interactiveAuthorization.claimedAt > INTERACTIVE_AUTHORIZATION_TTL_MS) {
+      this.interactiveAuthorization = null;
+      return false;
+    }
+    return true;
+  }
+  clearInteractiveAuthorization() {
+    this.interactiveAuthorization = null;
+    this.pendingVerifiersByChallenge.clear();
+  }
+};
+async function createOAuthSession(definition, logger, options = {}) {
+  const { provider, close } = await PersistentOAuthClientProvider.create(definition, logger, options);
+  const waitForAuthorizationCode = () => provider.waitForAuthorizationCode();
+  const waitForAuthorizationResponse = () => provider.waitForAuthorizationResponse();
+  const hasAuthorizationRedirectStarted = () => provider.hasAuthorizationRedirectStarted();
+  return {
+    provider,
+    waitForAuthorizationCode,
+    waitForAuthorizationResponse,
+    hasAuthorizationRedirectStarted,
+    close
+  };
+}
+function challengeForVerifier(verifier) {
+  return createHash("sha256").update(verifier).digest("base64url");
+}
+function firstRedirectUri(client) {
+  if (!client || typeof client !== "object") {
+    return void 0;
+  }
+  const redirectUris = client.redirect_uris;
+  if (!Array.isArray(redirectUris)) {
+    return void 0;
+  }
+  const [first] = redirectUris;
+  return typeof first === "string" ? first : void 0;
+}
+function issuersMatch(first, second) {
+  return first === second || first.endsWith("/") && first.slice(0, -1) === second || second.endsWith("/") && second.slice(0, -1) === first;
+}
+var __oauthInternals = {
+  openExternal
+};
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/runtime-header-utils.js
+function materializeHeaders(headers, serverName) {
+  if (!headers) {
+    return void 0;
+  }
+  const resolved = {};
+  for (const [key, value] of Object.entries(headers)) {
+    try {
+      resolved[key] = resolveEnvPlaceholders(value);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to resolve header '${key}' for server '${serverName}': ${message}`, { cause: error });
+    }
+  }
+  return resolved;
+}
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/runtime/node-http-fetch.js
+import http2 from "node:http";
+import https from "node:https";
+import { Buffer as Buffer2 } from "node:buffer";
+import { Readable } from "node:stream";
+var MAX_REDIRECTS = 20;
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var NULL_BODY_STATUSES = /* @__PURE__ */ new Set([204, 205, 304]);
+var nodeHttp1Fetch = async (input, init = {}) => {
+  return nodeHttp1FetchWithRedirects(input, init, 0);
+};
+function createSseIsolatedFetch(defaultFetch) {
+  return (input, init = {}) => {
+    const method = (init.method ?? "GET").toUpperCase();
+    const acceptsSse = new Headers(init.headers).get("accept")?.toLowerCase().includes("text/event-stream") ?? false;
+    if (method === "GET" && acceptsSse) {
+      return nodeHttp1Fetch(input, init);
+    }
+    return defaultFetch(input, init);
+  };
+}
+var sseIsolatedFetch = createSseIsolatedFetch((input, init) => fetch(input, init));
+async function nodeHttp1FetchWithRedirects(input, init, redirectCount) {
+  const url = input instanceof URL ? input : new URL(input);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new TypeError(`node-http1 fetch only supports http: and https: URLs, got ${url.protocol}`);
+  }
+  if (init.signal?.aborted) {
+    throw new DOMException("The operation was aborted.", "AbortError");
+  }
+  const headers = normalizeRequestHeaders(init.headers);
+  const body = await materializeRequestBody(init.body);
+  if (body !== void 0 && !hasHeader(headers, "content-length") && !hasHeader(headers, "transfer-encoding")) {
+    headers["content-length"] = String(Buffer2.byteLength(body));
+  }
+  return new Promise((resolve, reject) => {
+    const client = url.protocol === "https:" ? https : http2;
+    const request = client.request(url, {
+      method: init.method ?? "GET",
+      headers
+    }, (response) => {
+      const responseHeaders = new Headers();
+      for (const [key, value] of Object.entries(response.headers)) {
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            responseHeaders.append(key, item);
+          }
+        } else if (value !== void 0) {
+          responseHeaders.set(key, String(value));
+        }
+      }
+      const status = response.statusCode ?? 502;
+      const location = responseHeaders.get("location");
+      if (REDIRECT_STATUSES.has(status) && location && init.redirect !== "manual") {
+        response.resume();
+        if (init.redirect === "error") {
+          reject(new TypeError(`Redirect encountered for ${url.href}`));
+          return;
+        }
+        if (redirectCount >= MAX_REDIRECTS) {
+          reject(new TypeError(`Too many redirects while fetching ${url.href}`));
+          return;
+        }
+        let nextUrl;
+        try {
+          nextUrl = new URL(location, url);
+        } catch (error) {
+          reject(error);
+          return;
+        }
+        resolve(nodeHttp1FetchWithRedirects(nextUrl, buildRedirectInit(init, status, url, nextUrl), redirectCount + 1));
+        return;
+      }
+      if (NULL_BODY_STATUSES.has(status)) {
+        response.resume();
+      }
+      resolve(new Response(NULL_BODY_STATUSES.has(status) ? null : Readable.toWeb(response), {
+        status,
+        statusText: response.statusMessage,
+        headers: responseHeaders
+      }));
+    });
+    const abort = () => {
+      request.destroy(new DOMException("The operation was aborted.", "AbortError"));
+    };
+    init.signal?.addEventListener("abort", abort, { once: true });
+    request.once("close", () => init.signal?.removeEventListener("abort", abort));
+    request.once("error", reject);
+    if (body !== void 0) {
+      request.write(body);
+    }
+    request.end();
+  });
+}
+function buildRedirectInit(init, status, currentUrl, nextUrl) {
+  const method = (init.method ?? "GET").toUpperCase();
+  const headers = new Headers(init.headers);
+  if (currentUrl.origin !== nextUrl.origin) {
+    stripCrossOriginRedirectHeaders(headers);
+  }
+  if ((status === 301 || status === 302 || status === 303) && method !== "GET" && method !== "HEAD") {
+    headers.delete("content-length");
+    headers.delete("content-type");
+    return {
+      ...init,
+      method: "GET",
+      body: null,
+      headers
+    };
+  }
+  return {
+    ...init,
+    headers
+  };
+}
+function stripCrossOriginRedirectHeaders(headers) {
+  headers.delete("authorization");
+  headers.delete("cookie");
+  headers.delete("proxy-authorization");
+}
+function normalizeRequestHeaders(headers) {
+  const normalized = {};
+  if (!headers) {
+    return normalized;
+  }
+  new Headers(headers).forEach((value, key) => {
+    normalized[key] = value;
+  });
+  return normalized;
+}
+function hasHeader(headers, name) {
+  const lower = name.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === lower);
+}
+async function materializeRequestBody(body) {
+  if (body == null) {
+    return void 0;
+  }
+  if (typeof body === "string") {
+    return body;
+  }
+  if (body instanceof URLSearchParams) {
+    return body.toString();
+  }
+  if (body instanceof Blob) {
+    return Buffer2.from(await body.arrayBuffer());
+  }
+  if (body instanceof ArrayBuffer) {
+    return Buffer2.from(body);
+  }
+  if (ArrayBuffer.isView(body)) {
+    return Buffer2.from(body.buffer, body.byteOffset, body.byteLength);
+  }
+  throw new TypeError("node-http1 fetch does not support streaming request bodies.");
+}
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/runtime/http-transport.js
+function extractTransportStatusCode(error) {
+  if (!error || typeof error !== "object")
+    return void 0;
+  const record = error;
+  for (const candidate of [record.code, record.status, record.statusCode]) {
+    if (typeof candidate === "number")
+      return candidate;
+    if (typeof candidate === "string") {
+      const parsed = Number.parseInt(candidate, 10);
+      if (Number.isFinite(parsed))
+        return parsed;
+    }
+  }
+  return void 0;
+}
+function isLegacySseTransportMismatch(error) {
+  if (error instanceof SdkHttpError)
+    return error.status === 404 || error.status === 405;
+  const directStatusCode = extractTransportStatusCode(error);
+  if (directStatusCode === 404 || directStatusCode === 405)
+    return true;
+  const issue = analyzeConnectionError(error);
+  return issue.kind === "http" && (issue.statusCode === 404 || issue.statusCode === 405);
+}
+function removeAuthorizationHeader(headers) {
+  if (!headers)
+    return void 0;
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === "authorization")
+      delete headers[key];
+  }
+  return Object.keys(headers).length > 0 ? headers : void 0;
+}
+var NODE_HTTP1_FETCH_HOSTS = /* @__PURE__ */ new Set(["api.sunsama.com"]);
+function resolveHttpFetchOverride(definition) {
+  if (definition.command.kind !== "http" || definition.httpFetch === "default")
+    return void 0;
+  if (definition.httpFetch === "node-http1")
+    return nodeHttp1Fetch;
+  if (NODE_HTTP1_FETCH_HOSTS.has(definition.command.url.hostname.toLowerCase()))
+    return nodeHttp1Fetch;
+  if ("bun" in process.versions)
+    return void 0;
+  return sseIsolatedFetch;
+}
+function createHttpTransportOptions(definition, oauthSession, shouldEstablishOAuth) {
+  const command = definition.command;
+  if (command.kind !== "http")
+    throw new Error(`Server '${definition.name}' is not configured for HTTP transport.`);
+  const resolvedHeaders = materializeHeaders(command.headers, definition.name);
+  const effectiveHeaders = shouldEstablishOAuth ? removeAuthorizationHeader(resolvedHeaders) : resolvedHeaders;
+  const trackedFetch = trackStandaloneSseFetch(resolveHttpFetchOverride(definition));
+  return {
+    requestInit: effectiveHeaders ? { headers: effectiveHeaders } : void 0,
+    authProvider: oauthSession?.provider,
+    fetch: trackedFetch.fetch,
+    standaloneSseStarted: trackedFetch.started
+  };
+}
+function trackStandaloneSseFetch(fetchOverride) {
+  let markStarted;
+  const started = new Promise((resolve) => {
+    markStarted = resolve;
+  });
+  const baseFetch = fetchOverride ?? ((input, init) => fetch(input, init));
+  return {
+    started,
+    fetch: async (input, init = {}) => {
+      const isStandaloneSse = (init.method ?? "GET").toUpperCase() === "GET" && (new Headers(init.headers).get("accept")?.toLowerCase().includes("text/event-stream") ?? false);
+      try {
+        return await baseFetch(input, init);
+      } finally {
+        if (isStandaloneSse)
+          markStarted();
+      }
+    }
+  };
+}
+async function closeOAuthSession(oauthSession) {
+  await oauthSession?.close().catch(() => {
+  });
+}
+function shouldAbortSseFallback(error) {
+  if (isPostAuthConnectError(error))
+    return !isLegacySseTransportMismatch(error);
+  return isOAuthFlowError(error) || error instanceof OAuthTimeoutError;
+}
+function isEraNegotiationFailure(error) {
+  return !!error && typeof error === "object" && "code" in error && error.code === SdkErrorCode.EraNegotiationFailed;
+}
+function maybePromoteHttpDefinition(definition, logger, options) {
+  if (options.maxOAuthAttempts === 0 || options.disableOAuth === true)
+    return void 0;
+  return maybeEnableOAuth(definition, logger);
+}
+async function connectHttpTransport(client, transport, oauthSession, logger, connectOptions) {
+  try {
+    return await connectWithAuth(client, transport, oauthSession, logger, connectOptions);
+  } catch (error) {
+    if (!connectOptions.signal?.aborted) {
+      await closeTransportAndWait(logger, transport).catch(() => {
+      });
+    }
+    throw error;
+  }
+}
+async function createHttpClientContext(definition, logger, options, wrapRecordTransport2, clientFactory) {
+  let activeDefinition = definition;
+  while (true) {
+    const attempt = await attemptHttpClientContext(clientFactory.create(activeDefinition), activeDefinition, logger, options, wrapRecordTransport2, clientFactory);
+    if (!attempt.nextDefinition)
+      return attempt.context;
+    activeDefinition = attempt.nextDefinition;
+    options.onDefinitionPromoted?.(activeDefinition);
+  }
+}
+async function attemptHttpClientContext(client, activeDefinition, logger, options, wrapRecordTransport2, clientFactory) {
+  const command = activeDefinition.command;
+  if (command.kind !== "http")
+    throw new Error(`Server '${activeDefinition.name}' is not configured for HTTP transport.`);
+  let oauthSession;
+  const shouldEstablishOAuth = activeDefinition.auth === "oauth" && options.maxOAuthAttempts !== 0 && options.disableOAuth !== true;
+  if (shouldEstablishOAuth)
+    oauthSession = await createOAuthSession(activeDefinition, logger, options.oauthSessionOptions);
+  const transportOptions = createHttpTransportOptions(activeDefinition, oauthSession, shouldEstablishOAuth);
+  try {
+    return {
+      context: await connectPrimaryHttpTransport(client, activeDefinition, command, transportOptions, oauthSession, logger, options, wrapRecordTransport2)
+    };
+  } catch (primaryError) {
+    if (options.signal?.aborted || isEraNegotiationFailure(primaryError)) {
+      await closeOAuthSession(oauthSession);
+      throw primaryError;
+    }
+    if (shouldAbortSseFallback(primaryError)) {
+      await closeOAuthSession(oauthSession);
+      throw primaryError;
+    }
+    if (isUnauthorizedError(primaryError)) {
+      await closeOAuthSession(oauthSession);
+      const promoted = maybePromoteHttpDefinition(activeDefinition, logger, options);
+      if (promoted)
+        return { nextDefinition: promoted };
+      if (activeDefinition.auth)
+        throw primaryError;
+      oauthSession = void 0;
+    }
+    if (primaryError instanceof Error) {
+      logger.info(`Falling back to SSE transport for '${activeDefinition.name}': ${primaryError.message}`);
+    }
+    return {
+      context: await connectSseFallbackTransport(clientFactory.createLegacy(activeDefinition), activeDefinition, command, transportOptions, oauthSession, logger, options, wrapRecordTransport2, clientFactory)
+    };
+  }
+}
+async function connectPrimaryHttpTransport(client, definition, command, transportOptions, oauthSession, logger, options, wrapRecordTransport2) {
+  const createStreamableTransport = () => wrapRecordTransport2(new StreamableHTTPClientTransport(command.url, transportOptions), definition, options);
+  const transport = await connectHttpTransport(client, createStreamableTransport(), oauthSession, logger, {
+    serverName: definition.name,
+    serverUrl: command.url,
+    maxAttempts: options.maxOAuthAttempts,
+    oauthTimeoutMs: options.oauthTimeoutMs,
+    signal: options.signal,
+    recreateTransport: async () => createStreamableTransport()
+  });
+  if (typeof client.getProtocolEra === "function" && client.getProtocolEra() === "legacy") {
+    await transportOptions.standaloneSseStarted;
+  }
+  return { client, transport, definition, oauthSession };
+}
+async function connectSseFallbackTransport(client, definition, command, transportOptions, oauthSession, logger, options, wrapRecordTransport2, clientFactory) {
+  try {
+    const transport = await connectHttpTransport(client, wrapRecordTransport2(new SSEClientTransport(command.url, transportOptions), definition, options), oauthSession, logger, {
+      serverName: definition.name,
+      serverUrl: command.url,
+      maxAttempts: options.maxOAuthAttempts,
+      oauthTimeoutMs: options.oauthTimeoutMs,
+      signal: options.signal
+    });
+    return { client, transport, definition, oauthSession };
+  } catch (sseError) {
+    await closeOAuthSession(oauthSession);
+    if (sseError instanceof OAuthTimeoutError)
+      throw sseError;
+    if (isUnauthorizedError(sseError)) {
+      const promoted = maybePromoteHttpDefinition(definition, logger, options);
+      if (promoted) {
+        options.onDefinitionPromoted?.(promoted);
+        return createHttpClientContext(promoted, logger, options, wrapRecordTransport2, clientFactory);
+      }
+      if (definition.auth)
+        throw sseError;
+    }
+    throw sseError;
+  }
+}
+
+// node_modules/.pnpm/@modelcontextprotocol+client@2.0.0/node_modules/@modelcontextprotocol/client/dist/stdio.mjs
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
+import process2 from "node:process";
+import { PassThrough } from "node:stream";
+var DEFAULT_INHERITED_ENV_VARS = process2.platform === "win32" ? [
+  "APPDATA",
+  "HOMEDRIVE",
+  "HOMEPATH",
+  "LOCALAPPDATA",
+  "PATH",
+  "PROCESSOR_ARCHITECTURE",
+  "SYSTEMDRIVE",
+  "SYSTEMROOT",
+  "TEMP",
+  "USERNAME",
+  "USERPROFILE",
+  "PROGRAMFILES"
+] : [
+  "HOME",
+  "LOGNAME",
+  "PATH",
+  "SHELL",
+  "TERM",
+  "USER"
+];
+function getDefaultEnvironment() {
+  const env = {};
+  for (const key of DEFAULT_INHERITED_ENV_VARS) {
+    const value = process2.env[key];
+    if (value === void 0) continue;
+    if (value.startsWith("()")) continue;
+    env[key] = value;
+  }
+  return env;
+}
+var StdioClientTransport = class {
+  _process;
+  _readBuffer;
+  _serverParams;
+  _stderrStream = null;
+  onclose;
+  onerror;
+  onmessage;
+  constructor(server) {
+    this._serverParams = server;
+    this._readBuffer = new ReadBuffer({ maxBufferSize: server.maxBufferSize });
+    if (server.stderr === "pipe" || server.stderr === "overlapped") this._stderrStream = new PassThrough();
+  }
+  /**
+  * Starts the server process and prepares to communicate with it.
+  */
+  async start() {
+    if (this._process) throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+    return new Promise((resolve, reject) => {
+      this._process = (0, import_cross_spawn.default)(this._serverParams.command, this._serverParams.args ?? [], {
+        env: {
+          ...getDefaultEnvironment(),
+          ...this._serverParams.env
+        },
+        stdio: [
+          "pipe",
+          "pipe",
+          this._serverParams.stderr ?? "inherit"
+        ],
+        shell: false,
+        windowsHide: process2.platform === "win32",
+        cwd: this._serverParams.cwd
+      });
+      this._process.on("error", (error) => {
+        reject(error);
+        this.onerror?.(error);
+      });
+      this._process.on("spawn", () => {
+        resolve();
+      });
+      this._process.on("close", (_code) => {
+        this._process = void 0;
+        this.onclose?.();
+      });
+      this._process.stdin?.on("error", (error) => {
+        this.onerror?.(error);
+      });
+      this._process.stdout?.on("data", (chunk) => {
+        try {
+          this._readBuffer.append(chunk);
+          this.processReadBuffer();
+        } catch (error) {
+          this.onerror?.(error);
+          this.close().catch(() => {
+          });
+        }
+      });
+      this._process.stdout?.on("error", (error) => {
+        this.onerror?.(error);
+      });
+      if (this._stderrStream && this._process.stderr) this._process.stderr.pipe(this._stderrStream);
+    });
+  }
+  /**
+  * The `stderr` stream of the child process, if {@linkcode StdioServerParameters.stderr} was set to `"pipe"` or `"overlapped"`.
+  *
+  * If `stderr` piping was requested, a `PassThrough` stream is returned _immediately_, allowing callers to
+  * attach listeners before the `start` method is invoked. This prevents loss of any early
+  * error output emitted by the child process.
+  */
+  get stderr() {
+    if (this._stderrStream) return this._stderrStream;
+    return this._process?.stderr ?? null;
+  }
+  /**
+  * The child process pid spawned by this transport.
+  *
+  * This is only available after the transport has been started.
+  */
+  get pid() {
+    return this._process?.pid ?? null;
+  }
+  processReadBuffer() {
+    while (true) try {
+      const message = this._readBuffer.readMessage();
+      if (message === null) break;
+      this.onmessage?.(message);
+    } catch (error) {
+      this.onerror?.(error);
+    }
+  }
+  /**
+  * Reap a disposable probe sibling (see the version-negotiation sibling
+  * flow): signal-first teardown awaiting process `exit` — never the `close`
+  * event, so a helper process holding the child's stdio pipes can never
+  * block disposal. Not part of the public transport lifecycle.
+  *
+  * @internal
+  */
+  async _dispose() {
+    const proc = this._process;
+    this._process = void 0;
+    if (proc && proc.exitCode === null && proc.signalCode === null) {
+      const exited = new Promise((resolve) => proc.once("exit", () => resolve()));
+      try {
+        proc.stdin?.end();
+      } catch {
+      }
+      try {
+        proc.kill("SIGTERM");
+      } catch {
+      }
+      await Promise.race([exited, new Promise((resolve) => setTimeout(resolve, 1e3).unref())]);
+      if (proc.exitCode === null && proc.signalCode === null) try {
+        proc.kill("SIGKILL");
+      } catch {
+      }
+      await exited;
+    }
+    try {
+      proc?.stdout?.destroy();
+    } catch {
+    }
+    try {
+      proc?.stdin?.destroy();
+    } catch {
+    }
+    try {
+      proc?.stderr?.destroy();
+    } catch {
+    }
+    this._readBuffer.clear();
+  }
+  async close() {
+    if (this._process) {
+      const processToClose = this._process;
+      this._process = void 0;
+      const closePromise = new Promise((resolve) => {
+        processToClose.once("close", () => {
+          resolve();
+        });
+      });
+      try {
+        processToClose.stdin?.end();
+      } catch {
+      }
+      await Promise.race([closePromise, new Promise((resolve) => setTimeout(resolve, 2e3).unref())]);
+      if (processToClose.exitCode === null) {
+        try {
+          processToClose.kill("SIGTERM");
+        } catch {
+        }
+        await Promise.race([closePromise, new Promise((resolve) => setTimeout(resolve, 2e3).unref())]);
+      }
+      if (processToClose.exitCode === null) try {
+        processToClose.kill("SIGKILL");
+      } catch {
+      }
+    }
+    this._readBuffer.clear();
+  }
+  send(message) {
+    return new Promise((resolve) => {
+      if (!this._process?.stdin) throw new SdkError(SdkErrorCode.NotConnected, "Not connected");
+      const json = serializeMessage(message);
+      if (this._process.stdin.write(json)) resolve();
+      else this._process.stdin.once("drain", resolve);
+    });
+  }
+};
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/runtime/stdio-transport.js
+var McporterStdioTransport = class extends StdioClientTransport {
+  meta;
+  closing = false;
+  closeDelegate;
+  messageDelegate;
+  closeInterceptor = () => {
+    this.meta.code = this.closing ? 0 : 1;
+    flushStdioLogs(this.meta);
+    this.closeDelegate?.();
+  };
+  messageInterceptor = (message) => {
+    if (STDIO_TRACE_ENABLED)
+      this.meta.stdoutChunks?.push(JSON.stringify(message));
+    this.messageDelegate?.(message);
+  };
+  constructor(parameters) {
+    super({ ...parameters, stderr: "pipe" });
+    this.meta = {
+      stderrChunks: [],
+      stdoutChunks: STDIO_TRACE_ENABLED ? [] : void 0,
+      stdinChunks: STDIO_TRACE_ENABLED ? [] : void 0,
+      command: parameters.command,
+      code: null,
+      listeners: []
+    };
+    const stderr = this.stderr;
+    if (stderr) {
+      stderr.setEncoding?.("utf8");
+      const handleChunk = (chunk) => {
+        this.meta.stderrChunks.push(Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk));
+      };
+      stderr.on("data", handleChunk);
+      stderr.on("error", ignoreStdioEmitterError);
+      this.meta.listeners.push({ stream: stderr, event: "data", handler: handleChunk }, { stream: stderr, event: "error", handler: ignoreStdioEmitterError });
+    }
+  }
+  async start() {
+    if (STDIO_TRACE_ENABLED)
+      console.log("[mcporter] STDIO trace: start() invoked for stdio transport.");
+    this.installInterceptors();
+    await super.start();
+    if (STDIO_TRACE_ENABLED) {
+      console.log(`[mcporter] STDIO trace: spawned ${this.meta.command ?? "stdio server"} (pid=${this.pid ?? "unknown"}).`);
+    }
+  }
+  async send(message) {
+    this.installInterceptors();
+    if (STDIO_TRACE_ENABLED)
+      this.meta.stdinChunks?.push(JSON.stringify(message));
+    await super.send(message);
+  }
+  async close() {
+    this.closing = true;
+    this.installInterceptors();
+    try {
+      await super.close();
+    } finally {
+      this.meta.code ??= 0;
+      flushStdioLogs(this.meta);
+    }
+  }
+  installInterceptors() {
+    if (this.onclose !== this.closeInterceptor) {
+      this.closeDelegate = this.onclose;
+      this.onclose = this.closeInterceptor;
+    }
+    if (this.onmessage !== this.messageInterceptor) {
+      this.messageDelegate = this.onmessage;
+      this.onmessage = this.messageInterceptor;
+    }
+  }
+};
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/runtime/transport.js
+function shouldUseModeForServer(definition, serverFilter) {
+  return !serverFilter || serverFilter === definition.name;
+}
+var wrapRecordTransport = (transport, definition, options) => {
+  const wrapped = options.recordPath && shouldUseModeForServer(definition, process.env.MCPORTER_RECORD_SERVER) ? new RecordTransport({
+    inner: transport,
+    recordPath: options.recordPath,
+    server: definition.name
+  }) : transport;
+  options.onTransportCreated?.(wrapped);
+  return wrapped;
+};
+var LIST_MAX_PAGES = 100;
+function resolveStdioProbeTimeoutMs() {
+  const raw = process.env.MCPORTER_STDIO_PROBE_TIMEOUT_MS;
+  if (!raw || !/^[1-9]\d*$/.test(raw))
+    return DEFAULT_REQUEST_TIMEOUT_MSEC;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : DEFAULT_REQUEST_TIMEOUT_MSEC;
+}
+function resolveNegotiationMode(definition) {
+  switch (definition.protocolVersion) {
+    case "legacy":
+      return "legacy";
+    case "2026-07-28":
+      return { pin: "2026-07-28" };
+    default:
+      return "auto";
+  }
+}
+function shouldRetryStdioAsLegacy(error, definition) {
+  return resolveNegotiationMode(definition) === "auto" && !!error && typeof error === "object" && "code" in error && error.code === SdkErrorCode.EraNegotiationFailed;
+}
+function createClient(definition, clientInfo, options = {}) {
+  const mode = options.forceLegacy ? "legacy" : resolveNegotiationMode(definition);
+  const clientOptions = {
+    capabilities: { elicitation: { form: {}, url: {} } },
+    listMaxPages: LIST_MAX_PAGES,
+    versionNegotiation: {
+      mode,
+      ...options.stdio && mode !== "legacy" ? { probe: { timeoutMs: resolveStdioProbeTimeoutMs() } } : {}
+    }
+  };
+  const client = new Client(clientInfo, clientOptions);
+  if (options.elicitationHandler) {
+    registerElicitationHandler(client, options.elicitationHandler, { server: definition.name });
+  }
+  return client;
+}
+async function createReplayClientContext(definition, replayPath, clientInfo, options) {
+  const transport = new ReplayTransport({ recordPath: replayPath, server: definition.name });
+  options.onTransportCreated?.(transport);
+  const client = createClient(definition, clientInfo, {
+    forceLegacy: transport.requiresLegacyNegotiation,
+    elicitationHandler: options.elicitationHandler ?? createNonInteractiveElicitationResponder().handler
+  });
+  await client.connect(transport, { signal: options.signal });
+  return { client, transport, definition, oauthSession: void 0 };
+}
+async function createStdioClientContext(client, definition, logger, options) {
+  const resolvedEnvOverrides = definition.env && Object.keys(definition.env).length > 0 ? Object.fromEntries(Object.entries(definition.env).map(([key, raw]) => [key, resolveEnvValue(raw)]).filter(([, value]) => value !== "")) : void 0;
+  const mergedEnv = resolvedEnvOverrides && Object.keys(resolvedEnvOverrides).length > 0 ? { ...process.env, ...resolvedEnvOverrides } : { ...process.env };
+  const command = resolveCommandArgument(definition.command.command);
+  const resolvedArgs = resolveCommandArguments(definition.command.args);
+  const relay = await rewriteChromeDevtoolsArgsForRelay(command, resolvedArgs, mergedEnv);
+  if (relay.applied) {
+    logger.info(`Routing chrome-devtools-mcp through the OpenClaw extension relay at ${relay.endpoint} (no dialog).`);
+  }
+  const commandArgs = [...relay.args];
+  const compat = applyChromeDevtoolsCompat(mergedEnv, command, commandArgs);
+  if (compat.applied) {
+    logger.info(`Injecting chrome-devtools-mcp --autoConnect compatibility patch from ${compat.patchPath}.`);
+  }
+  const rawTransport = new McporterStdioTransport({
+    command,
+    args: commandArgs,
+    cwd: definition.command.cwd,
+    env: compat.env
+  });
+  const transport = wrapRecordTransport(rawTransport, definition, options);
+  try {
+    await client.connect(transport, { signal: options.signal });
+  } catch (error) {
+    if (!options.signal?.aborted) {
+      await closeTransportAndWait(logger, transport).catch(() => {
+      });
+    }
+    throw error;
+  }
+  return { client, transport, definition, oauthSession: void 0 };
+}
+async function createClientContext(definition, logger, clientInfo, options = {}) {
+  if (options.replayPath && shouldUseModeForServer(definition, process.env.MCPORTER_REPLAY_SERVER)) {
+    return createReplayClientContext(definition, options.replayPath, clientInfo, options);
+  }
+  const activeDefinition = await applyCachedAuthIfAvailable(definition, logger, options.allowCachedAuth);
+  return withEnvOverrides(activeDefinition.env, async () => {
+    if (activeDefinition.command.kind === "stdio") {
+      const stdioDefinition = activeDefinition;
+      try {
+        return await createStdioClientContext(createClient(stdioDefinition, clientInfo, { stdio: true, elicitationHandler: options.elicitationHandler }), stdioDefinition, logger, options);
+      } catch (error) {
+        if (!shouldRetryStdioAsLegacy(error, stdioDefinition))
+          throw error;
+        logger.info(`Retrying '${stdioDefinition.name}' in legacy mode after its stdio process exited during version negotiation.`);
+        return createStdioClientContext(createClient(stdioDefinition, clientInfo, {
+          stdio: true,
+          forceLegacy: true,
+          elicitationHandler: options.elicitationHandler
+        }), stdioDefinition, logger, options);
+      }
+    }
+    const httpClientFactory = {
+      create: (httpDefinition) => createClient(httpDefinition, clientInfo, { elicitationHandler: options.elicitationHandler }),
+      createLegacy: (httpDefinition) => createClient(httpDefinition, clientInfo, {
+        forceLegacy: true,
+        elicitationHandler: options.elicitationHandler
+      })
+    };
+    return createHttpClientContext(activeDefinition, logger, options, wrapRecordTransport, httpClientFactory);
+  });
+}
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/runtime/connection-cache.js
+var RuntimeConnectionCache = class {
+  definitions;
+  options;
+  clients = /* @__PURE__ */ new Map();
+  activeClientKeys = /* @__PURE__ */ new Map();
+  contextCacheKeys = /* @__PURE__ */ new WeakMap();
+  contextCachePromises = /* @__PURE__ */ new WeakMap();
+  connectionSetupTails = /* @__PURE__ */ new Map();
+  serverGenerations = /* @__PURE__ */ new Map();
+  retirementPromises = /* @__PURE__ */ new Map();
+  lastConnectionInfo = /* @__PURE__ */ new Map();
+  constructor(definitions, options) {
+    this.definitions = definitions;
+    this.options = options;
+  }
+  get logger() {
+    return this.options.logger;
+  }
+  get clientInfo() {
+    return this.options.clientInfo;
+  }
+  get oauthTimeoutMs() {
+    return this.options.oauthTimeoutMs;
+  }
+  get recordPath() {
+    return this.options.recordPath;
+  }
+  get replayPath() {
+    return this.options.replayPath;
+  }
+  supersedeDefinition(server, replace) {
+    this.bumpServerGeneration(server);
+    this.lastConnectionInfo.delete(server.trim());
+    replace();
+    this.retireCachedEntriesForServer(server);
+  }
+  async getInstructions(server) {
+    const active = this.activeClientForServer(server);
+    const fallbackEntries = active ? [] : this.cachedEntriesForServer(server);
+    const cached = active ?? (fallbackEntries.length === 1 ? fallbackEntries[0] : void 0);
+    if (!cached)
+      return void 0;
+    try {
+      const context = await cached.promise;
+      const instructions = typeof context.client.getInstructions === "function" ? context.client.getInstructions() : void 0;
+      if (typeof instructions !== "string")
+        return void 0;
+      const trimmed = instructions.trim();
+      return trimmed.length > 0 ? trimmed : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  async getConnectionInfo(server) {
+    const normalized = server.trim();
+    const active = this.activeClientForServer(server);
+    const fallbackEntries = active ? [] : this.cachedEntriesForServer(server);
+    const cached = active ?? (fallbackEntries.length === 1 ? fallbackEntries[0] : void 0);
+    if (!cached)
+      return this.lastConnectionInfo.get(normalized);
+    try {
+      const { client } = await cached.promise;
+      const info = connectionInfoFromClient(client);
+      this.lastConnectionInfo.set(normalized, info);
+      return info;
+    } catch {
+      return this.lastConnectionInfo.get(normalized);
+    }
+  }
+  effectiveDisableOAuthForOperation(server, requested) {
+    if (requested !== void 0) {
+      return requested;
+    }
+    const cached = this.cachedEntriesForServer(server);
+    const active = this.activeClientForServer(server);
+    if (active) {
+      return active.disableOAuth;
+    }
+    if (cached.length === 0) {
+      return void 0;
+    }
+    const [first] = cached;
+    return cached.every((entry) => entry.disableOAuth === first?.disableOAuth) ? first?.disableOAuth : void 0;
+  }
+  effectiveAllowCachedAuthForOperation(server, requested, disableOAuth, defaultValue) {
+    if (requested !== void 0) {
+      return requested;
+    }
+    if (disableOAuth !== true) {
+      return defaultValue;
+    }
+    const active = this.activeClientForServer(server);
+    if (active?.disableOAuth === true) {
+      return active.allowCachedAuth;
+    }
+    const cached = this.cachedEntriesForServer(server).filter((entry) => entry.disableOAuth);
+    return cached.length === 1 ? cached[0]?.allowCachedAuth : defaultValue;
+  }
+  cachedEntriesForServer(server) {
+    const normalized = server.trim();
+    return [...this.clients.values()].filter((entry) => entry.server === normalized);
+  }
+  retireCachedEntriesForServer(server) {
+    const normalized = server.trim();
+    const retired = [];
+    for (const [key, cached] of this.clients.entries()) {
+      if (cached.server === normalized) {
+        this.clients.delete(key);
+        retired.push(cached);
+      }
+    }
+    this.activeClientKeys.delete(normalized);
+    if (retired.length > 0) {
+      const retirement = this.trackRetirement(normalized, this.closeCachedEntries(retired));
+      void retirement.catch((error) => {
+        const detail = error instanceof Error ? error.message : String(error);
+        this.logger.warn(`Failed to close retired '${normalized}' connection: ${detail}`);
+      });
+    }
+  }
+  activeClientForServer(server) {
+    const normalized = server.trim();
+    const activeKey = this.activeClientKeys.get(normalized);
+    if (!activeKey) {
+      return void 0;
+    }
+    const active = this.clients.get(activeKey);
+    return active?.server === normalized ? active : void 0;
+  }
+  serverGeneration(server) {
+    return this.serverGenerations.get(server.trim()) ?? 0;
+  }
+  bumpServerGeneration(server) {
+    const normalized = server.trim();
+    this.serverGenerations.set(normalized, this.serverGeneration(normalized) + 1);
+  }
+  bumpAllServerGenerations() {
+    const servers = /* @__PURE__ */ new Set([
+      ...this.definitions.keys(),
+      ...[...this.clients.values()].map((entry) => entry.server),
+      ...this.connectionSetupTails.keys()
+    ]);
+    for (const server of servers) {
+      this.bumpServerGeneration(server);
+    }
+  }
+  // connect lazily instantiates a client context per server and memoizes it.
+  async connect(server, options = {}) {
+    const normalized = server.trim();
+    let definition = this.definitions.get(normalized);
+    if (!definition) {
+      throw new Error(`Unknown MCP server '${normalized}'.`);
+    }
+    const generation = this.serverGeneration(normalized);
+    const disableOAuth = options.disableOAuth === true;
+    const effectiveAllowCachedAuth = options.allowCachedAuth ?? (disableOAuth ? true : void 0);
+    const useCache = options.skipCache !== true && options.maxOAuthAttempts === void 0;
+    let ignoresAuthCachePolicy = this.ignoresAuthCachePolicy(definition);
+    let cacheAllowCachedAuth = ignoresAuthCachePolicy ? void 0 : effectiveAllowCachedAuth;
+    let cacheDisableOAuth = ignoresAuthCachePolicy ? false : disableOAuth;
+    let cacheKey = this.cacheKey(normalized, cacheAllowCachedAuth, cacheDisableOAuth);
+    if (useCache) {
+      const existing = this.findCachedEntryForRequest(normalized, definition, ignoresAuthCachePolicy ? void 0 : options.allowCachedAuth, cacheAllowCachedAuth, cacheDisableOAuth);
+      if (existing) {
+        const [existingKey, cached] = existing;
+        const activeEntry = ignoresAuthCachePolicy ? {
+          ...cached,
+          allowCachedAuth: effectiveAllowCachedAuth,
+          disableOAuth
+        } : cached;
+        if (activeEntry !== cached) {
+          this.clients.set(existingKey, activeEntry);
+        }
+        this.activeClientKeys.set(normalized, existingKey);
+        return activeEntry.promise;
+      }
+    }
+    let releaseConnectionSetup;
+    if (useCache && this.shouldSerializeConnectionSetup(definition, disableOAuth)) {
+      releaseConnectionSetup = await this.enterConnectionSetup(normalized);
+      try {
+        if (this.serverGeneration(normalized) !== generation) {
+          throw new Error(`Connection setup for MCP server '${normalized}' was superseded.`);
+        }
+        const refreshedDefinition = this.definitions.get(normalized);
+        if (!refreshedDefinition) {
+          throw new Error(`Unknown MCP server '${normalized}'.`);
+        }
+        definition = refreshedDefinition;
+        ignoresAuthCachePolicy = this.ignoresAuthCachePolicy(definition);
+        cacheAllowCachedAuth = ignoresAuthCachePolicy ? void 0 : effectiveAllowCachedAuth;
+        cacheDisableOAuth = ignoresAuthCachePolicy ? false : disableOAuth;
+        cacheKey = this.cacheKey(normalized, cacheAllowCachedAuth, cacheDisableOAuth);
+        const existing = this.findCachedEntryForRequest(normalized, definition, ignoresAuthCachePolicy ? void 0 : options.allowCachedAuth, cacheAllowCachedAuth, cacheDisableOAuth);
+        if (existing) {
+          releaseConnectionSetup();
+          releaseConnectionSetup = void 0;
+          const [existingKey, cached] = existing;
+          this.activeClientKeys.set(normalized, existingKey);
+          return cached.promise;
+        }
+        await this.retireConflictingOAuthEntries(normalized, cacheKey);
+        if (this.serverGeneration(normalized) !== generation) {
+          throw new Error(`Connection setup for MCP server '${normalized}' was superseded.`);
+        }
+        const latestDefinition = this.definitions.get(normalized);
+        if (!latestDefinition) {
+          throw new Error(`Unknown MCP server '${normalized}'.`);
+        }
+        definition = latestDefinition;
+      } catch (error) {
+        releaseConnectionSetup?.();
+        releaseConnectionSetup = void 0;
+        throw error;
+      }
+    }
+    let connectionDefinition = definition;
+    const abortController = new AbortController();
+    const transportRef = {};
+    const contextRef = {};
+    let contextPromise = createClientContext(definition, this.logger, this.clientInfo, {
+      maxOAuthAttempts: options.maxOAuthAttempts,
+      oauthTimeoutMs: options.oauthTimeoutMs ?? this.oauthTimeoutMs,
+      onDefinitionPromoted: (promoted) => {
+        if (this.serverGeneration(normalized) === generation && this.definitions.get(normalized) === connectionDefinition) {
+          this.definitions.set(promoted.name, promoted);
+          connectionDefinition = promoted;
+        }
+      },
+      allowCachedAuth: effectiveAllowCachedAuth,
+      oauthSessionOptions: options.oauthSessionOptions,
+      disableOAuth,
+      recordPath: this.recordPath,
+      replayPath: this.replayPath,
+      elicitationHandler: this.options.elicitationHandler,
+      signal: abortController.signal,
+      onTransportCreated: (transport) => {
+        transportRef.current = transport;
+      }
+    }).then((context) => {
+      contextRef.current = context;
+      this.lastConnectionInfo.set(normalized, connectionInfoFromClient(context.client));
+      return context;
+    });
+    if (useCache) {
+      const previousActiveKey = this.activeClientKeys.get(normalized);
+      contextPromise = contextPromise.then((context) => {
+        this.contextCacheKeys.set(context, cacheKey);
+        this.contextCachePromises.set(context, contextPromise);
+        return context;
+      });
+      let connection;
+      connection = contextPromise.then((context) => {
+        const stillCached = this.clients.get(cacheKey)?.promise === connection;
+        if (this.serverGeneration(normalized) !== generation || !stillCached) {
+          this.contextCacheKeys.delete(context);
+          this.contextCachePromises.delete(context);
+          throw new Error(`Connection setup for MCP server '${normalized}' was superseded.`);
+        }
+        return context;
+      });
+      this.activeClientKeys.set(normalized, cacheKey);
+      this.clients.set(cacheKey, {
+        server: normalized,
+        promise: connection,
+        contextPromise,
+        allowCachedAuth: ignoresAuthCachePolicy ? effectiveAllowCachedAuth : cacheAllowCachedAuth,
+        disableOAuth: ignoresAuthCachePolicy ? disableOAuth : cacheDisableOAuth,
+        abortController,
+        transportRef,
+        contextRef
+      });
+      try {
+        return await connection;
+      } catch (error) {
+        const ownsCacheEntry = this.clients.get(cacheKey)?.promise === connection;
+        if (ownsCacheEntry) {
+          this.clients.delete(cacheKey);
+          if (this.activeClientKeys.get(normalized) === cacheKey && previousActiveKey && this.clients.has(previousActiveKey)) {
+            this.activeClientKeys.set(normalized, previousActiveKey);
+          } else if (this.activeClientKeys.get(normalized) === cacheKey || this.cachedEntriesForServer(normalized).length === 0) {
+            this.activeClientKeys.delete(normalized);
+          }
+        }
+        throw error;
+      } finally {
+        releaseConnectionSetup?.();
+      }
+    }
+    releaseConnectionSetup?.();
+    return contextPromise;
+  }
+  // close tears down transports (and OAuth sessions) for a single server or all servers.
+  async close(server) {
+    if (server) {
+      const normalized = server.trim();
+      this.bumpServerGeneration(normalized);
+      const entries2 = [...this.clients.entries()].filter(([, cached]) => cached.server === normalized);
+      if (entries2.length === 0) {
+        this.activeClientKeys.delete(normalized);
+      }
+      for (const [key] of entries2) {
+        this.clients.delete(key);
+      }
+      this.activeClientKeys.delete(normalized);
+      if (entries2.length > 0) {
+        void this.trackRetirement(normalized, this.closeCachedEntries(entries2.map(([, cached]) => cached)));
+      }
+      await this.awaitRetirements(normalized);
+      return;
+    }
+    this.bumpAllServerGenerations();
+    const entries = [...this.clients.entries()];
+    this.clients.clear();
+    this.activeClientKeys.clear();
+    const byServer = /* @__PURE__ */ new Map();
+    for (const [, cached] of entries) {
+      const serverEntries = byServer.get(cached.server) ?? [];
+      serverEntries.push(cached);
+      byServer.set(cached.server, serverEntries);
+    }
+    for (const [serverName, serverEntries] of byServer) {
+      void this.trackRetirement(serverName, this.closeCachedEntries(serverEntries));
+    }
+    await this.awaitRetirements();
+  }
+  contextPromiseFor(cached) {
+    return cached.contextPromise ?? cached.promise;
+  }
+  async closeCachedEntries(entries) {
+    for (const cached of entries) {
+      cached.abortController?.abort();
+    }
+    const results = await Promise.allSettled(entries.map(async (cached) => {
+      const readyContext = cached.contextRef?.current;
+      if (readyContext) {
+        try {
+          await this.closeContext(readyContext);
+        } finally {
+          this.contextCacheKeys.delete(readyContext);
+          this.contextCachePromises.delete(readyContext);
+        }
+        return;
+      }
+      const pendingContext = this.contextPromiseFor(cached);
+      const pendingTransport = cached.transportRef?.current;
+      if (pendingTransport) {
+        await closeTransportAndWait(this.logger, pendingTransport);
+        void pendingContext.then(async (context) => {
+          await context.client.close().catch(() => {
+          });
+          await context.oauthSession?.close().catch(() => {
+          });
+          this.contextCacheKeys.delete(context);
+          this.contextCachePromises.delete(context);
+        }, () => {
+        });
+        return;
+      }
+      try {
+        const context = await pendingContext;
+        await this.closeContext(context);
+        this.contextCacheKeys.delete(context);
+        this.contextCachePromises.delete(context);
+      } catch (error) {
+        if (!cached.abortController?.signal.aborted) {
+          throw error;
+        }
+      }
+    }));
+    const firstFailure = results.find((result) => result.status === "rejected");
+    if (firstFailure) {
+      throw firstFailure.reason;
+    }
+  }
+  async closeContext(context) {
+    const propagateReplayCloseErrors = context.transport instanceof ReplayTransport;
+    let closeError;
+    try {
+      await closeTransportAndWait(this.logger, context.transport, {
+        throwOnCloseError: propagateReplayCloseErrors,
+        close: async () => {
+          let firstError;
+          const clientClose = context.client.close;
+          if (clientClose) {
+            try {
+              await clientClose.call(context.client);
+            } catch (error) {
+              firstError = error;
+            }
+          }
+          try {
+            await context.transport.close();
+          } catch (error) {
+            firstError ??= error;
+          }
+          if (firstError) {
+            throw firstError;
+          }
+        }
+      });
+    } catch (error) {
+      if (propagateReplayCloseErrors) {
+        closeError ??= error;
+      }
+    }
+    await context.oauthSession?.close().catch(() => {
+    });
+    if (closeError) {
+      throw closeError;
+    }
+  }
+  async resetConnectionOnError(server, error, failedContext) {
+    if (!shouldResetConnection(error)) {
+      return;
+    }
+    const normalized = server.trim();
+    if (!failedContext) {
+      return;
+    }
+    try {
+      const failedKey = this.contextCacheKeys.get(failedContext);
+      const failedEntry = failedKey ? this.clients.get(failedKey) : void 0;
+      const failedContextPromise = this.contextCachePromises.get(failedContext);
+      if (!failedKey || failedEntry?.server !== normalized || !failedContextPromise || this.contextPromiseFor(failedEntry) !== failedContextPromise) {
+        return;
+      }
+      if (this.clients.get(failedKey)?.promise !== failedEntry.promise) {
+        return;
+      }
+      this.clients.delete(failedKey);
+      if (this.activeClientKeys.get(normalized) === failedKey || this.cachedEntriesForServer(normalized).length === 0) {
+        this.activeClientKeys.delete(normalized);
+      }
+      try {
+        await this.closeContext(failedContext);
+      } finally {
+        this.contextCacheKeys.delete(failedContext);
+        this.contextCachePromises.delete(failedContext);
+      }
+    } catch (closeError) {
+      const detail = closeError instanceof Error ? closeError.message : String(closeError);
+      this.logger.warn(`Failed to reset '${normalized}' after error: ${detail}`);
+    }
+  }
+  findCachedEntryForRequest(server, definition, requestedAllowCachedAuth, effectiveAllowCachedAuth, disableOAuth) {
+    const exactKey = this.cacheKey(server, effectiveAllowCachedAuth, disableOAuth);
+    if (this.ignoresAuthCachePolicy(definition)) {
+      const exact2 = this.clients.get(exactKey);
+      return exact2 ? [exactKey, exact2] : void 0;
+    }
+    if (requestedAllowCachedAuth !== void 0) {
+      const exact2 = this.clients.get(exactKey);
+      return exact2 ? [exactKey, exact2] : void 0;
+    }
+    const activeKey = this.activeClientKeys.get(server);
+    const active = activeKey ? this.clients.get(activeKey) : void 0;
+    const policyMatches = (cached) => effectiveAllowCachedAuth === void 0 || cached.allowCachedAuth === effectiveAllowCachedAuth;
+    if (activeKey && active?.server === server && active.disableOAuth === disableOAuth && policyMatches(active)) {
+      return [activeKey, active];
+    }
+    const matches = [...this.clients.entries()].filter(([, cached]) => cached.server === server && cached.disableOAuth === disableOAuth && policyMatches(cached));
+    if (matches.length === 1) {
+      return matches[0];
+    }
+    const exact = this.clients.get(exactKey);
+    return exact ? [exactKey, exact] : void 0;
+  }
+  async retireConflictingOAuthEntries(server, keepKey) {
+    const conflicting = [...this.clients.entries()].filter(([key, cached]) => key !== keepKey && cached.server === server && !cached.disableOAuth);
+    if (conflicting.length === 0) {
+      return;
+    }
+    for (const [key] of conflicting) {
+      this.clients.delete(key);
+      if (this.activeClientKeys.get(server) === key) {
+        this.activeClientKeys.delete(server);
+      }
+    }
+    await this.trackRetirement(server, this.closeCachedEntries(conflicting.map(([, cached]) => cached)));
+  }
+  shouldSerializeConnectionSetup(definition, disableOAuth) {
+    return definition.command.kind === "http" && !disableOAuth && !this.ignoresAuthCachePolicy(definition);
+  }
+  ignoresAuthCachePolicy(definition) {
+    const replayServer = process.env.MCPORTER_REPLAY_SERVER;
+    const replaysDefinition = Boolean(this.replayPath) && (!replayServer || replayServer === definition.name);
+    return definition.command.kind === "stdio" || replaysDefinition;
+  }
+  trackRetirement(server, retirement) {
+    const pending = this.retirementPromises.get(server) ?? /* @__PURE__ */ new Set();
+    pending.add(retirement);
+    this.retirementPromises.set(server, pending);
+    const cleanup = () => {
+      pending.delete(retirement);
+      if (pending.size === 0) {
+        this.retirementPromises.delete(server);
+      }
+    };
+    retirement.then(cleanup, cleanup);
+    return retirement;
+  }
+  async awaitRetirements(server) {
+    const pending = server ? [...this.retirementPromises.get(server) ?? []] : [];
+    if (!server) {
+      for (const retirements of this.retirementPromises.values()) {
+        pending.push(...retirements);
+      }
+    }
+    const results = await Promise.allSettled(pending);
+    const firstFailure = results.find((result) => result.status === "rejected");
+    if (firstFailure) {
+      throw firstFailure.reason;
+    }
+  }
+  async enterConnectionSetup(server) {
+    const previous = this.connectionSetupTails.get(server) ?? Promise.resolve();
+    let releaseCurrent;
+    const current = new Promise((resolve) => {
+      releaseCurrent = resolve;
+    });
+    const tail = previous.catch(() => {
+    }).then(() => current);
+    this.connectionSetupTails.set(server, tail);
+    await previous.catch(() => {
+    });
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      releaseCurrent();
+      void tail.finally(() => {
+        if (this.connectionSetupTails.get(server) === tail) {
+          this.connectionSetupTails.delete(server);
+        }
+      });
+    };
+  }
+  cacheKey(server, allowCachedAuth, disableOAuth) {
+    const cachedAuthKey = allowCachedAuth === true ? "cached-auth-on" : allowCachedAuth === false ? "cached-auth-off" : "cached-auth-unset";
+    return `${server}\0oauth-disabled:${disableOAuth ? "1" : "0"}\0${cachedAuthKey}`;
+  }
+};
+function connectionInfoFromClient(client) {
+  return {
+    protocolVersion: typeof client.getNegotiatedProtocolVersion === "function" ? client.getNegotiatedProtocolVersion() : void 0,
+    era: typeof client.getProtocolEra === "function" ? client.getProtocolEra() : void 0
+  };
+}
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/tool-filters.js
+function validateToolFilters(name, filter) {
+  if (filter.allowedTools !== void 0 && filter.blockedTools !== void 0) {
+    throw new Error(`Server '${name}' cannot specify both allowedTools and blockedTools.`);
+  }
+}
+function isToolAllowed(toolName, filter) {
+  if (!filter) {
+    return true;
+  }
+  if (filter.allowedTools !== void 0) {
+    return filter.allowedTools.includes(toolName);
+  }
+  if (filter.blockedTools !== void 0) {
+    return !filter.blockedTools.includes(toolName);
+  }
+  return true;
+}
+function filterTools(tools, filter) {
+  return tools.filter((tool) => isToolAllowed(tool.name, filter));
+}
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/runtime.js
+var PACKAGE_NAME = "mcporter";
+var OAUTH_CODE_TIMEOUT_MS = resolveOAuthTimeoutFromEnv();
+var MAX_RESOURCE_LIST_PAGES = 100;
+async function createRuntime(options = {}) {
+  const servers = options.servers ?? await loadServerDefinitions({
+    configPath: options.configPath,
+    rootDir: options.rootDir
+  });
+  const runtime = new McpRuntime(servers, options);
+  return runtime;
+}
+async function callOnce(params) {
+  const runtime = await createRuntime({ configPath: params.configPath });
+  try {
+    return await runtime.callTool(params.server, params.toolName, {
+      args: params.args,
+      disableOAuth: params.disableOAuth
+    });
+  } finally {
+    await runtime.close(params.server);
+  }
+}
+var McpRuntime = class {
+  definitions;
+  connectionCache;
+  logger;
+  constructor(servers, options = {}) {
+    for (const server of servers) {
+      validateToolFilters(server.name, server);
+    }
+    this.definitions = new Map(servers.map((entry) => [entry.name, entry]));
+    this.logger = options.logger ?? createConsoleLogger();
+    const clientInfo = options.clientInfo ?? {
+      name: PACKAGE_NAME,
+      version: MCPORTER_VERSION
+    };
+    const recordSession = process.env.MCPORTER_RECORD;
+    const replaySession = process.env.MCPORTER_REPLAY;
+    if (recordSession && replaySession) {
+      this.logger.warn("Both MCPORTER_RECORD and MCPORTER_REPLAY are set; recording mode wins.");
+    }
+    const recordPath = recordSession ? resolveRecordingPath(recordSession) : void 0;
+    const replayPath = !recordSession && replaySession ? resolveRecordingPath(replaySession) : void 0;
+    let nonInteractiveHintPrinted = false;
+    const defaultResponder = createNonInteractiveElicitationResponder({
+      onDecline: () => {
+        if (nonInteractiveHintPrinted)
+          return;
+        nonInteractiveHintPrinted = true;
+        this.logger.warn(NON_INTERACTIVE_ELICITATION_HINT);
+      }
+    });
+    this.connectionCache = new RuntimeConnectionCache(this.definitions, {
+      logger: this.logger,
+      clientInfo,
+      oauthTimeoutMs: options.oauthTimeoutMs ?? OAUTH_CODE_TIMEOUT_MS,
+      recordPath,
+      replayPath,
+      elicitationHandler: options.elicitationHandler ?? defaultResponder.handler
+    });
+  }
+  // listServers returns configured names sorted alphabetically for stable CLI output.
+  listServers() {
+    return [...this.definitions.keys()].toSorted((a, b) => a.localeCompare(b));
+  }
+  // getDefinitions exposes raw server metadata to consumers such as the CLI.
+  getDefinitions() {
+    return [...this.definitions.values()];
+  }
+  // getDefinition throws when the caller requests an unknown server name.
+  getDefinition(server) {
+    const definition = this.definitions.get(server);
+    if (!definition) {
+      throw new Error(`Unknown MCP server '${server}'.`);
+    }
+    return definition;
+  }
+  registerDefinition(definition, options = {}) {
+    validateToolFilters(definition.name, definition);
+    if (!options.overwrite && this.definitions.has(definition.name)) {
+      throw new Error(`MCP server '${definition.name}' already exists.`);
+    }
+    this.connectionCache.supersedeDefinition(definition.name, () => {
+      this.definitions.set(definition.name, definition);
+    });
+  }
+  async getInstructions(server) {
+    return this.connectionCache.getInstructions(server);
+  }
+  async getConnectionInfo(server) {
+    return this.connectionCache.getConnectionInfo(server);
+  }
+  // listTools queries tool metadata and optionally includes schemas when requested.
+  async listTools(server, options = {}) {
+    const autoAuthorize = options.autoAuthorize !== false;
+    const disableOAuth = this.effectiveDisableOAuthForOperation(server, options.disableOAuth);
+    const allowCachedAuth = this.effectiveAllowCachedAuthForOperation(server, options.allowCachedAuth, disableOAuth, true);
+    const useLegacyNoAuthorize = !autoAuthorize && disableOAuth !== true;
+    const timeoutMs = normalizeTimeout(options.timeoutMs);
+    const context = await this.connect(server, {
+      maxOAuthAttempts: useLegacyNoAuthorize ? 0 : void 0,
+      skipCache: useLegacyNoAuthorize,
+      allowCachedAuth,
+      oauthSessionOptions: options.oauthSessionOptions,
+      disableOAuth,
+      oauthTimeoutMs: timeoutMs
+    });
+    let closeError;
+    let tools = [];
+    try {
+      const listPromise = context.client.listTools(void 0, timeoutMs ? { timeout: timeoutMs, resetTimeoutOnProgress: true, maxTotalTimeout: timeoutMs } : void 0);
+      const response = timeoutMs ? await raceWithTimeout(listPromise, timeoutMs) : await listPromise;
+      tools = (response.tools ?? []).map((tool) => ({
+        name: tool.name,
+        description: tool.description ?? void 0,
+        inputSchema: options.includeSchema ? tool.inputSchema : void 0,
+        outputSchema: options.includeSchema ? tool.outputSchema : void 0
+      }));
+    } catch (error) {
+      await this.resetConnectionOnError(server, error, context);
+      throw error;
+    } finally {
+      if (useLegacyNoAuthorize) {
+        try {
+          await this.closeContext(context);
+        } catch (error) {
+          closeError = error;
+        }
+      }
+    }
+    if (closeError !== void 0) {
+      throw closeError;
+    }
+    return filterTools(tools, this.definitions.get(server.trim()));
+  }
+  // callTool executes a tool using the args provided by the caller.
+  async callTool(server, toolName, options = {}) {
+    const definition = this.definitions.get(server.trim());
+    if (definition && !isToolAllowed(toolName, definition)) {
+      throw new Error(`Tool '${toolName}' is not accessible on server '${definition.name}' (blocked by configuration).`);
+    }
+    let context;
+    try {
+      const disableOAuth = this.effectiveDisableOAuthForOperation(server, options.disableOAuth);
+      context = await this.connect(server, {
+        allowCachedAuth: this.effectiveAllowCachedAuthForOperation(server, void 0, disableOAuth, true),
+        disableOAuth
+      });
+      const { client } = context;
+      const params = {
+        name: toolName,
+        arguments: options.args ?? {}
+      };
+      const timeoutMs = normalizeTimeout(options.timeoutMs);
+      const resultPromise = client.callTool(params, {
+        timeout: timeoutMs,
+        // Long runs (e.g., GPT-5 Pro) emit progress/logging; allow that to refresh the timer.
+        resetTimeoutOnProgress: true,
+        maxTotalTimeout: timeoutMs
+      });
+      if (!timeoutMs) {
+        return await resultPromise;
+      }
+      return await raceWithTimeout(resultPromise, timeoutMs);
+    } catch (error) {
+      await this.resetConnectionOnError(server, error, context);
+      throw error;
+    }
+  }
+  // listResources delegates to the MCP resources/list method with passthrough params.
+  async listResources(server, options = {}) {
+    const { allowCachedAuth, disableOAuth, oauthSessionOptions, ...params } = options;
+    let context;
+    try {
+      const effectiveDisableOAuth = this.effectiveDisableOAuthForOperation(server, disableOAuth);
+      context = await this.connect(server, {
+        allowCachedAuth: this.effectiveAllowCachedAuthForOperation(server, allowCachedAuth, effectiveDisableOAuth, void 0),
+        oauthSessionOptions,
+        disableOAuth: effectiveDisableOAuth
+      });
+      const { client } = context;
+      const requestParams = params;
+      if (requestParams.cursor !== void 0) {
+        return await client.listResources(requestParams);
+      }
+      let response = await client.request({ method: "resources/list", params: requestParams }, specTypeSchemas.ListResourcesResult);
+      const resources = [...response.resources];
+      const seenCursors = /* @__PURE__ */ new Set();
+      for (let page = 1; page < MAX_RESOURCE_LIST_PAGES && response.nextCursor; page += 1) {
+        if (seenCursors.has(response.nextCursor))
+          break;
+        seenCursors.add(response.nextCursor);
+        response = await client.request({ method: "resources/list", params: { ...requestParams, cursor: response.nextCursor } }, specTypeSchemas.ListResourcesResult);
+        resources.push(...response.resources);
+      }
+      return { ...response, resources };
+    } catch (error) {
+      await this.resetConnectionOnError(server, error, context);
+      throw error;
+    }
+  }
+  async readResource(server, uri, options = {}) {
+    let context;
+    try {
+      const effectiveDisableOAuth = this.effectiveDisableOAuthForOperation(server, options.disableOAuth);
+      context = await this.connect(server, {
+        allowCachedAuth: this.effectiveAllowCachedAuthForOperation(server, options.allowCachedAuth, effectiveDisableOAuth, void 0),
+        oauthSessionOptions: options.oauthSessionOptions,
+        disableOAuth: effectiveDisableOAuth
+      });
+      const { client } = context;
+      return await client.readResource({ uri });
+    } catch (error) {
+      await this.resetConnectionOnError(server, error, context);
+      throw error;
+    }
+  }
+  effectiveDisableOAuthForOperation(server, requested) {
+    return this.connectionCache.effectiveDisableOAuthForOperation(server, requested);
+  }
+  effectiveAllowCachedAuthForOperation(server, requested, disableOAuth, defaultValue) {
+    return this.connectionCache.effectiveAllowCachedAuthForOperation(server, requested, disableOAuth, defaultValue);
+  }
+  async connect(server, options = {}) {
+    return this.connectionCache.connect(server, options);
+  }
+  async close(server) {
+    await this.connectionCache.close(server);
+  }
+  async closeContext(context) {
+    await this.connectionCache.closeContext(context);
+  }
+  async resetConnectionOnError(server, error, context) {
+    await this.connectionCache.resetConnectionOnError(server, error, context);
+  }
+};
+function createConsoleLogger(level = resolveLogLevelFromEnv()) {
+  return createPrefixedConsoleLogger("mcporter", level);
+}
+
+export {
+  createRuntime,
+  callOnce
+};