@ai-ecoverse/mcpcat 0.1.0 → 0.3.0

package/dist/host/mcpcat.mjs

@@ -1,9 +1,3312 @@
 #!/usr/bin/env node
+import { createRequire as __mcpcat_createRequire } from 'node:module';
+const require = __mcpcat_createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/isexe/windows.js
+var require_windows = __commonJS({
+  "node_modules/isexe/windows.js"(exports, module) {
+    module.exports = isexe;
+    isexe.sync = sync;
+    var fs = __require("fs");
+    function checkPathExt(path, 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 && path.substr(-p.length).toLowerCase() === p) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function checkStat(stat2, path, options) {
+      if (!stat2.isSymbolicLink() && !stat2.isFile()) {
+        return false;
+      }
+      return checkPathExt(path, options);
+    }
+    function isexe(path, options, cb) {
+      fs.stat(path, function(er, stat2) {
+        cb(er, er ? false : checkStat(stat2, path, options));
+      });
+    }
+    function sync(path, options) {
+      return checkStat(fs.statSync(path), path, options);
+    }
+  }
+});
+
+// node_modules/isexe/mode.js
+var require_mode = __commonJS({
+  "node_modules/isexe/mode.js"(exports, module) {
+    module.exports = isexe;
+    isexe.sync = sync;
+    var fs = __require("fs");
+    function isexe(path, options, cb) {
+      fs.stat(path, function(er, stat2) {
+        cb(er, er ? false : checkStat(stat2, options));
+      });
+    }
+    function sync(path, options) {
+      return checkStat(fs.statSync(path), options);
+    }
+    function checkStat(stat2, options) {
+      return stat2.isFile() && checkMode(stat2, options);
+    }
+    function checkMode(stat2, options) {
+      var mod = stat2.mode;
+      var uid = stat2.uid;
+      var gid = stat2.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/isexe/index.js
+var require_isexe = __commonJS({
+  "node_modules/isexe/index.js"(exports, module) {
+    var fs = __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(path, 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(path, options || {}, function(er, is) {
+            if (er) {
+              reject(er);
+            } else {
+              resolve(is);
+            }
+          });
+        });
+      }
+      core(path, options || {}, function(er, is) {
+        if (er) {
+          if (er.code === "EACCES" || options && options.ignoreErrors) {
+            er = null;
+            is = false;
+          }
+        }
+        cb(er, is);
+      });
+    }
+    function sync(path, options) {
+      try {
+        return core.sync(path, options || {});
+      } catch (er) {
+        if (options && options.ignoreErrors || er.code === "EACCES") {
+          return false;
+        } else {
+          throw er;
+        }
+      }
+    }
+  }
+});
+
+// node_modules/which/which.js
+var require_which = __commonJS({
+  "node_modules/which/which.js"(exports, module) {
+    var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+    var path = __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 = path.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 = path.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/path-key/index.js
+var require_path_key = __commonJS({
+  "node_modules/path-key/index.js"(exports, module) {
+    "use strict";
+    var pathKey = (options = {}) => {
+      const environment = options.env || process.env;
+      const platform2 = options.platform || process.platform;
+      if (platform2 !== "win32") {
+        return "PATH";
+      }
+      return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+    };
+    module.exports = pathKey;
+    module.exports.default = pathKey;
+  }
+});
+
+// node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS({
+  "node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module) {
+    "use strict";
+    var path = __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 ? path.delimiter : void 0
+        });
+      } catch (e) {
+      } finally {
+        if (shouldSwitchCwd) {
+          process.chdir(cwd);
+        }
+      }
+      if (resolved) {
+        resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      }
+      return resolved;
+    }
+    function resolveCommand(parsed) {
+      return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+    }
+    module.exports = resolveCommand;
+  }
+});
+
+// node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS({
+  "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/shebang-regex/index.js
+var require_shebang_regex = __commonJS({
+  "node_modules/shebang-regex/index.js"(exports, module) {
+    "use strict";
+    module.exports = /^#!(.*)/;
+  }
+});
+
+// node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS({
+  "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 [path, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path.split("/").pop();
+      if (binary === "env") {
+        return argument;
+      }
+      return argument ? `${binary} ${argument}` : binary;
+    };
+  }
+});
+
+// node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS({
+  "node_modules/cross-spawn/lib/util/readShebang.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var shebangCommand = require_shebang_command();
+    function readShebang(command) {
+      const size = 150;
+      const buffer = Buffer.alloc(size);
+      let fd;
+      try {
+        fd = fs.openSync(command, "r");
+        fs.readSync(fd, buffer, 0, size, 0);
+        fs.closeSync(fd);
+      } catch (e) {
+      }
+      return shebangCommand(buffer.toString());
+    }
+    module.exports = readShebang;
+  }
+});
+
+// node_modules/cross-spawn/lib/parse.js
+var require_parse = __commonJS({
+  "node_modules/cross-spawn/lib/parse.js"(exports, module) {
+    "use strict";
+    var path = __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 = path.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, args2, options) {
+      if (args2 && !Array.isArray(args2)) {
+        options = args2;
+        args2 = null;
+      }
+      args2 = args2 ? args2.slice(0) : [];
+      options = Object.assign({}, options);
+      const parsed = {
+        command,
+        args: args2,
+        options,
+        file: void 0,
+        original: {
+          command,
+          args: args2
+        }
+      };
+      return options.shell ? parsed : parseNonShell(parsed);
+    }
+    module.exports = parse;
+  }
+});
+
+// node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS({
+  "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/cross-spawn/index.js
+var require_cross_spawn = __commonJS({
+  "node_modules/cross-spawn/index.js"(exports, module) {
+    "use strict";
+    var cp = __require("child_process");
+    var parse = require_parse();
+    var enoent = require_enoent();
+    function spawn2(command, args2, options) {
+      const parsed = parse(command, args2, options);
+      const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+      enoent.hookChildProcess(spawned, parsed);
+      return spawned;
+    }
+    function spawnSync(command, args2, options) {
+      const parsed = parse(command, args2, options);
+      const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+      result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+      return result;
+    }
+    module.exports = spawn2;
+    module.exports.spawn = spawn2;
+    module.exports.sync = spawnSync;
+    module.exports._parse = parse;
+    module.exports._enoent = enoent;
+  }
+});
+
+// node_modules/@earendil-works/pi-mcp/dist/protocol/jsonrpc.js
+var JSON_RPC_ERROR_CODES = {
+  parseError: -32700,
+  invalidRequest: -32600,
+  methodNotFound: -32601,
+  invalidParams: -32602,
+  internalError: -32603
+};
+var McpError = class extends Error {
+  code;
+  data;
+  constructor(code2, message, data) {
+    super(message);
+    this.name = "McpError";
+    this.code = code2;
+    this.data = data;
+  }
+};
+var McpConnectionClosedError = class extends Error {
+  constructor(message = "MCP connection closed") {
+    super(message);
+    this.name = "McpConnectionClosedError";
+  }
+};
+var McpTimeoutError = class extends Error {
+  timeoutMs;
+  constructor(timeoutMs) {
+    super(`MCP request timed out after ${timeoutMs}ms`);
+    this.name = "McpTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+var McpAbortError = class extends Error {
+  constructor(message = "MCP request aborted") {
+    super(message);
+    this.name = "AbortError";
+  }
+};
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+function isJsonRpcId(value) {
+  return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+function isJsonRpcRequest(message) {
+  return isObject(message) && message.jsonrpc === "2.0" && isJsonRpcId(message.id) && typeof message.method === "string";
+}
+function isJsonRpcNotification(message) {
+  return isObject(message) && message.jsonrpc === "2.0" && !("id" in message) && typeof message.method === "string";
+}
+function isJsonRpcResponse(message) {
+  if (!isObject(message) || message.jsonrpc !== "2.0" || !isJsonRpcId(message.id))
+    return false;
+  if ("result" in message)
+    return !("error" in message);
+  if (!("error" in message) || !isObject(message.error))
+    return false;
+  return typeof message.error.code === "number" && typeof message.error.message === "string";
+}
+function parseJsonRpcMessage(value) {
+  if (isJsonRpcRequest(value) || isJsonRpcNotification(value) || isJsonRpcResponse(value))
+    return value;
+  throw new McpError(JSON_RPC_ERROR_CODES.invalidRequest, "Invalid JSON-RPC message");
+}
+
+// node_modules/@earendil-works/pi-mcp/dist/protocol/types.js
+var LATEST_PROTOCOL_VERSION = "2025-11-25";
+var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05"];
+
+// node_modules/@earendil-works/pi-mcp/dist/client.js
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var MAX_LIST_PAGES = 1e3;
+function validateInitializeResult(value) {
+  if (!isObject(value) || typeof value.protocolVersion !== "string" || !isObject(value.capabilities) || !isObject(value.serverInfo) || typeof value.serverInfo.name !== "string" || typeof value.serverInfo.version !== "string" || value.instructions !== void 0 && typeof value.instructions !== "string") {
+    throw new McpError(JSON_RPC_ERROR_CODES.invalidRequest, "Invalid MCP initialize result");
+  }
+  return value;
+}
+function invalid(message) {
+  return new McpError(JSON_RPC_ERROR_CODES.invalidRequest, message);
+}
+function validateListPage(method, key, value, isItem) {
+  const items = isObject(value) ? value[key] : void 0;
+  if (!isObject(value) || !Array.isArray(items))
+    throw invalid(`Invalid MCP ${method} result`);
+  for (const item of items) {
+    if (!isObject(item) || !isItem(item))
+      throw invalid(`Invalid entry in MCP ${method} result`);
+  }
+  const nextCursor = value.nextCursor === null || value.nextCursor === "" ? void 0 : value.nextCursor;
+  if (nextCursor !== void 0 && typeof nextCursor !== "string")
+    throw invalid(`Invalid MCP ${method} cursor`);
+  return { items, ...nextCursor === void 0 ? {} : { nextCursor } };
+}
+var isTool = (tool) => typeof tool.name === "string" && isObject(tool.inputSchema);
+var isResource = (resource) => typeof resource.uri === "string" && (resource.name === void 0 || typeof resource.name === "string");
+var isResourceTemplate = (template) => typeof template.uriTemplate === "string" && (template.name === void 0 || typeof template.name === "string");
+function toResource(item) {
+  return { ...item, name: item.name ?? item.uri };
+}
+function toResourceTemplate(item) {
+  return { ...item, name: item.name ?? item.uriTemplate };
+}
+function pageCursor(page) {
+  return page.nextCursor === void 0 ? {} : { nextCursor: page.nextCursor };
+}
+function validateReadResourceResult(value) {
+  if (!isObject(value) || !Array.isArray(value.contents))
+    throw invalid("Invalid MCP resources/read result");
+  for (const contents of value.contents) {
+    if (!isObject(contents) || typeof contents.uri !== "string" || typeof contents.text !== "string" && typeof contents.blob !== "string") {
+      throw invalid("Invalid contents in MCP resources/read result");
+    }
+  }
+  return value;
+}
+function validateCallToolResult(value) {
+  if (!isObject(value) || value.content !== void 0 && !Array.isArray(value.content)) {
+    throw new McpError(JSON_RPC_ERROR_CODES.invalidRequest, "Invalid MCP tools/call result");
+  }
+  return value.content === void 0 ? { ...value, content: [] } : value;
+}
+var McpClient = class {
+  options;
+  state = "idle";
+  transport;
+  nextRequestId = 1;
+  serverInfoValue;
+  serverCapabilitiesValue;
+  instructionsValue;
+  protocolVersionValue;
+  pending = /* @__PURE__ */ new Map();
+  progressRequests = /* @__PURE__ */ new Map();
+  incoming = /* @__PURE__ */ new Map();
+  requestHandlers = /* @__PURE__ */ new Map();
+  notificationListeners = /* @__PURE__ */ new Map();
+  errorListeners = /* @__PURE__ */ new Set();
+  closeListeners = /* @__PURE__ */ new Set();
+  disposers = [];
+  constructor(options) {
+    this.options = Object.freeze({ ...options });
+    this.requestHandlers.set("ping", () => ({}));
+    const roots = options.roots;
+    if (roots) {
+      this.requestHandlers.set("roots/list", async () => ({
+        roots: [...typeof roots === "function" ? await roots() : roots]
+      }));
+    }
+  }
+  get connectionState() {
+    return this.state;
+  }
+  get serverInfo() {
+    return this.serverInfoValue;
+  }
+  get serverCapabilities() {
+    return this.serverCapabilitiesValue;
+  }
+  get instructions() {
+    return this.instructionsValue;
+  }
+  get protocolVersion() {
+    return this.protocolVersionValue;
+  }
+  async connect(transport) {
+    if (this.state !== "idle")
+      throw new Error(`Cannot connect MCP client in ${this.state} state`);
+    this.state = "connecting";
+    this.transport = transport;
+    this.disposers = [
+      transport.onMessage((message) => this.handleMessage(message)),
+      // Transport errors are reported only. Pending requests fail when the transport closes.
+      transport.onError((error) => this.emitError(error)),
+      transport.onClose(() => this.handleTransportClose())
+    ];
+    try {
+      await transport.start();
+      const capabilities = { ...this.options.capabilities };
+      if (this.options.roots && capabilities.roots === void 0)
+        capabilities.roots = {};
+      const result = validateInitializeResult(await this.requestInternal("initialize", {
+        protocolVersion: this.options.protocolVersion ?? LATEST_PROTOCOL_VERSION,
+        capabilities,
+        clientInfo: {
+          name: this.options.name,
+          version: this.options.version,
+          ...this.options.title === void 0 ? {} : { title: this.options.title }
+        }
+      }, {}, true));
+      if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion)) {
+        throw new Error(`MCP server selected unsupported protocol version ${result.protocolVersion}`);
+      }
+      this.protocolVersionValue = result.protocolVersion;
+      this.serverInfoValue = result.serverInfo;
+      this.serverCapabilitiesValue = result.capabilities;
+      this.instructionsValue = result.instructions;
+      transport.setProtocolVersion?.(result.protocolVersion);
+      await this.notifyInternal("notifications/initialized", void 0, true);
+      this.state = "connected";
+      return result;
+    } catch (error) {
+      await this.close().catch(() => {
+      });
+      throw error;
+    }
+  }
+  request(method, params, options = {}) {
+    return this.requestInternal(method, params, options, false);
+  }
+  notify(method, params) {
+    return this.notifyInternal(method, params, false);
+  }
+  setRequestHandler(method, handler) {
+    this.requestHandlers.set(method, handler);
+    return () => {
+      if (this.requestHandlers.get(method) === handler)
+        this.requestHandlers.delete(method);
+    };
+  }
+  onNotification(method, listener) {
+    const listeners = this.notificationListeners.get(method) ?? /* @__PURE__ */ new Set();
+    this.notificationListeners.set(method, listeners);
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0)
+        this.notificationListeners.delete(method);
+    };
+  }
+  onError(listener) {
+    this.errorListeners.add(listener);
+    return () => this.errorListeners.delete(listener);
+  }
+  /** Called once when the connection closes, whether the transport dropped or `close()` was called. */
+  onClose(listener) {
+    this.closeListeners.add(listener);
+    return () => this.closeListeners.delete(listener);
+  }
+  async ping(options = {}) {
+    await this.request("ping", void 0, options);
+  }
+  async listTools(options = {}) {
+    return await this.listAll("tools/list", "tools", isTool, options);
+  }
+  /** Every resource, following `nextCursor` through all pages. */
+  async listResources(options = {}) {
+    return (await this.listAll("resources/list", "resources", isResource, options)).map(toResource);
+  }
+  /** One page of resources, starting at `cursor`. */
+  async listResourcesPage(cursor, options = {}) {
+    const page = await this.listPage("resources/list", "resources", isResource, cursor, options);
+    return { resources: page.items.map(toResource), ...pageCursor(page) };
+  }
+  /** Every resource template, following `nextCursor` through all pages. */
+  async listResourceTemplates(options = {}) {
+    const templates = await this.listAll("resources/templates/list", "resourceTemplates", isResourceTemplate, options);
+    return templates.map(toResourceTemplate);
+  }
+  /** One page of resource templates, starting at `cursor`. */
+  async listResourceTemplatesPage(cursor, options = {}) {
+    const page = await this.listPage("resources/templates/list", "resourceTemplates", isResourceTemplate, cursor, options);
+    return { resourceTemplates: page.items.map(toResourceTemplate), ...pageCursor(page) };
+  }
+  async readResource(uri, options = {}) {
+    return validateReadResourceResult(await this.request("resources/read", { uri }, options));
+  }
+  async listPage(method, key, isItem, cursor, options) {
+    return validateListPage(method, key, await this.request(method, cursor === void 0 ? void 0 : { cursor }, options), isItem);
+  }
+  /** Every item of a paginated list method. */
+  async listAll(method, key, isItem, options) {
+    const items = [];
+    const cursors = /* @__PURE__ */ new Set();
+    let cursor;
+    for (let pageNumber = 0; pageNumber < MAX_LIST_PAGES; pageNumber++) {
+      const page = await this.listPage(method, key, isItem, cursor, options);
+      items.push(...page.items);
+      if (page.nextCursor === void 0)
+        return items;
+      if (cursors.has(page.nextCursor))
+        throw new Error(`MCP ${method} returned duplicate cursor: ${page.nextCursor}`);
+      cursors.add(page.nextCursor);
+      cursor = page.nextCursor;
+    }
+    throw new Error(`MCP ${method} exceeded ${MAX_LIST_PAGES} pages`);
+  }
+  async callTool(name, args2, options = {}) {
+    return validateCallToolResult(await this.request("tools/call", { name, ...args2 === void 0 ? {} : { arguments: args2 } }, options));
+  }
+  async close() {
+    const transport = this.transport;
+    this.transport = void 0;
+    this.disposeTransportListeners();
+    this.markClosed(new McpConnectionClosedError());
+    await transport?.close();
+  }
+  async requestInternal(method, params, options, allowConnecting) {
+    const transport = this.requireTransport(allowConnecting);
+    if (options.signal?.aborted)
+      throw new McpAbortError();
+    const id = this.nextRequestId++;
+    const progressToken = options.onProgress ? id : void 0;
+    const requestParams = progressToken === void 0 ? params : { ...params, _meta: { ...isObject(params?._meta) ? params._meta : {}, progressToken } };
+    const message = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      ...requestParams === void 0 ? {} : { params: requestParams }
+    };
+    return new Promise((resolve, reject) => {
+      const entry = {
+        resolve,
+        reject,
+        timeoutMs: options.timeoutMs ?? this.options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
+        timer: void 0,
+        signal: options.signal,
+        // The spec forbids cancelling `initialize`.
+        onAbort: () => this.cancelPending(id, new McpAbortError(), method !== "initialize", String(options.signal?.reason ?? "Aborted")),
+        sendController: new AbortController(),
+        cancellable: method !== "initialize",
+        onProgress: options.onProgress,
+        progressToken
+      };
+      this.pending.set(id, entry);
+      if (progressToken !== void 0)
+        this.progressRequests.set(progressToken, id);
+      options.signal?.addEventListener("abort", entry.onAbort, { once: true });
+      this.armTimeout(id, entry);
+      transport.send(message, { signal: entry.sendController.signal }).catch((error) => this.cancelPending(id, error, false));
+    });
+  }
+  async notifyInternal(method, params, allowConnecting) {
+    await this.requireTransport(allowConnecting).send({
+      jsonrpc: "2.0",
+      method,
+      ...params === void 0 ? {} : { params }
+    });
+  }
+  requireTransport(allowConnecting) {
+    if (this.transport && (this.state === "connected" || allowConnecting && this.state === "connecting")) {
+      return this.transport;
+    }
+    throw new McpConnectionClosedError(`MCP client is ${this.state}`);
+  }
+  handleMessage(message) {
+    if (isJsonRpcResponse(message)) {
+      this.handleResponse(message);
+      return;
+    }
+    if (isJsonRpcRequest(message)) {
+      void this.handleRequest(message);
+      return;
+    }
+    if (isJsonRpcNotification(message)) {
+      this.handleNotification(message.method, message.params);
+      return;
+    }
+    this.emitError(new McpError(JSON_RPC_ERROR_CODES.invalidRequest, "Received invalid JSON-RPC message"));
+  }
+  handleResponse(message) {
+    const entry = this.pending.get(message.id);
+    if (!entry) {
+      this.emitError(new Error(`Received response for unknown MCP request ${String(message.id)}`));
+      return;
+    }
+    this.removePending(message.id, entry);
+    if ("error" in message)
+      entry.reject(new McpError(message.error.code, message.error.message, message.error.data));
+    else
+      entry.resolve(message.result);
+  }
+  async handleRequest(message) {
+    const transport = this.transport;
+    if (!transport)
+      return;
+    const handler = this.requestHandlers.get(message.method);
+    if (!handler) {
+      await transport.send({
+        jsonrpc: "2.0",
+        id: message.id,
+        error: { code: JSON_RPC_ERROR_CODES.methodNotFound, message: `Method not found: ${message.method}` }
+      }).catch((error) => this.emitError(error));
+      return;
+    }
+    const controller = new AbortController();
+    this.incoming.set(message.id, controller);
+    try {
+      const result = await handler(message.params, { signal: controller.signal });
+      await transport.send({ jsonrpc: "2.0", id: message.id, result: result ?? {} });
+    } catch (error) {
+      const responseError = error instanceof McpError ? { code: error.code, message: error.message, data: error.data } : { code: JSON_RPC_ERROR_CODES.internalError, message: toError(error).message };
+      await transport.send({ jsonrpc: "2.0", id: message.id, error: responseError }).catch((sendError) => this.emitError(sendError));
+    } finally {
+      this.incoming.delete(message.id);
+    }
+  }
+  handleNotification(method, params) {
+    if (method === "notifications/progress")
+      this.handleProgress(params);
+    else if (method === "notifications/cancelled")
+      this.handleCancelled(params);
+    for (const listener of this.notificationListeners.get(method) ?? []) {
+      try {
+        listener(params);
+      } catch (error) {
+        this.emitError(error);
+      }
+    }
+  }
+  handleProgress(params) {
+    if (!isObject(params) || !isJsonRpcId(params.progressToken) || typeof params.progress !== "number")
+      return;
+    const requestId = this.progressRequests.get(params.progressToken);
+    const entry = requestId === void 0 ? void 0 : this.pending.get(requestId);
+    if (requestId === void 0 || !entry)
+      return;
+    this.armTimeout(requestId, entry);
+    try {
+      entry.onProgress?.(params);
+    } catch (error) {
+      this.emitError(error);
+    }
+  }
+  handleCancelled(params) {
+    if (isObject(params) && isJsonRpcId(params.requestId))
+      this.incoming.get(params.requestId)?.abort(params.reason);
+  }
+  armTimeout(id, entry) {
+    if (entry.timer)
+      clearTimeout(entry.timer);
+    if (!Number.isFinite(entry.timeoutMs) || entry.timeoutMs <= 0)
+      return;
+    entry.timer = setTimeout(() => {
+      this.cancelPending(id, new McpTimeoutError(entry.timeoutMs), entry.cancellable, "Request timed out");
+    }, entry.timeoutMs);
+  }
+  cancelPending(id, error, notifyServer, reason) {
+    const entry = this.pending.get(id);
+    if (!entry)
+      return;
+    this.removePending(id, entry);
+    entry.reject(error);
+    if (notifyServer && this.transport) {
+      void this.transport.send({
+        jsonrpc: "2.0",
+        method: "notifications/cancelled",
+        params: { requestId: id, ...reason ? { reason } : {} }
+      }).catch((sendError) => this.emitError(sendError));
+    }
+  }
+  removePending(id, entry) {
+    this.pending.delete(id);
+    if (entry.timer)
+      clearTimeout(entry.timer);
+    if (entry.progressToken !== void 0)
+      this.progressRequests.delete(entry.progressToken);
+    entry.signal?.removeEventListener("abort", entry.onAbort);
+    entry.sendController.abort();
+  }
+  rejectPending(error) {
+    for (const [id, entry] of this.pending) {
+      this.removePending(id, entry);
+      entry.reject(error);
+    }
+  }
+  handleTransportClose() {
+    this.markClosed(new McpConnectionClosedError());
+  }
+  /** Idempotent: rejects in-flight requests, aborts server requests we are serving, and flips the state. */
+  markClosed(error) {
+    const wasClosed = this.state === "closed";
+    this.state = "closed";
+    this.rejectPending(error);
+    for (const controller of this.incoming.values())
+      controller.abort(error);
+    this.incoming.clear();
+    if (wasClosed)
+      return;
+    for (const listener of [...this.closeListeners]) {
+      try {
+        listener();
+      } catch (listenerError) {
+        this.emitError(listenerError);
+      }
+    }
+  }
+  emitError(error) {
+    const normalized = toError(error);
+    for (const listener of this.errorListeners)
+      listener(normalized);
+  }
+  disposeTransportListeners() {
+    for (const dispose of this.disposers.splice(0))
+      dispose();
+  }
+};
+
+// node_modules/@earendil-works/pi-mcp/dist/transports/stdio.js
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
+import { spawn } from "node:child_process";
+import process2 from "node:process";
+
+// node_modules/@earendil-works/pi-mcp/dist/transports/transport.js
+var DEFAULT_MAX_MESSAGE_BYTES = 16 * 1024 * 1024;
+var TransportEvents = class {
+  messageListeners = /* @__PURE__ */ new Set();
+  errorListeners = /* @__PURE__ */ new Set();
+  closeListeners = /* @__PURE__ */ new Set();
+  closeEmitted = false;
+  onMessage(listener) {
+    this.messageListeners.add(listener);
+    return () => this.messageListeners.delete(listener);
+  }
+  onError(listener) {
+    this.errorListeners.add(listener);
+    return () => this.errorListeners.delete(listener);
+  }
+  onClose(listener) {
+    this.closeListeners.add(listener);
+    return () => this.closeListeners.delete(listener);
+  }
+  emitMessage(message) {
+    for (const listener of this.messageListeners)
+      listener(message);
+  }
+  emitError(error) {
+    const normalized = toError(error);
+    for (const listener of this.errorListeners)
+      listener(normalized);
+  }
+  emitClose() {
+    if (this.closeEmitted)
+      return;
+    this.closeEmitted = true;
+    for (const listener of this.closeListeners)
+      listener();
+  }
+};
+
+// node_modules/@earendil-works/pi-mcp/dist/transports/stdio.js
+var DEFAULT_MAX_STDERR_BYTES = 64 * 1024;
+var DEFAULT_CLOSE_TIMEOUT_MS = 2e3;
+var STDIN_CLOSE_GRACE_MS = 500;
+var USE_PROCESS_GROUPS = process2.platform !== "win32";
+var liveProcessGroups = /* @__PURE__ */ new Set();
+var exitHookInstalled = false;
+function killProcessTree(child, signal) {
+  const pid = child.pid;
+  if (process2.platform === "win32" && pid !== void 0) {
+    if (child.exitCode !== null)
+      return;
+    spawn("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true }).on("error", () => {
+    });
+    return;
+  }
+  if (USE_PROCESS_GROUPS && pid !== void 0) {
+    try {
+      process2.kill(-pid, signal);
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
+function installExitHook() {
+  if (exitHookInstalled)
+    return;
+  exitHookInstalled = true;
+  process2.once("exit", () => {
+    for (const pid of liveProcessGroups) {
+      try {
+        process2.kill(-pid, "SIGTERM");
+      } catch {
+      }
+    }
+  });
+}
+var StdioTransport = class extends TransportEvents {
+  options;
+  child;
+  stdoutBuffer = Buffer.alloc(0);
+  stderrBuffer = Buffer.alloc(0);
+  started = false;
+  closed = false;
+  constructor(options) {
+    super();
+    this.options = Object.freeze({ ...options, args: options.args ? [...options.args] : void 0 });
+  }
+  get pid() {
+    return this.child?.pid;
+  }
+  get stderr() {
+    return this.stderrBuffer.toString("utf8");
+  }
+  async start() {
+    if (this.started)
+      throw new Error("MCP stdio transport already started");
+    if (this.closed)
+      throw new McpConnectionClosedError();
+    this.started = true;
+    const env = this.options.inheritEnv === false ? { ...this.options.env } : { ...process2.env, ...this.options.env };
+    const child = (0, import_cross_spawn.default)(this.options.command, this.options.args ?? [], {
+      cwd: this.options.cwd,
+      env,
+      stdio: ["pipe", "pipe", this.options.stderr === "inherit" ? "inherit" : "pipe"],
+      windowsHide: true,
+      // Own process group, so closing the transport can terminate the server's children too.
+      detached: USE_PROCESS_GROUPS
+    });
+    this.child = child;
+    const pid = child.pid;
+    if (USE_PROCESS_GROUPS && pid !== void 0) {
+      installExitHook();
+      liveProcessGroups.add(pid);
+      child.once("exit", () => liveProcessGroups.delete(pid));
+    }
+    child.stdout?.on("data", (chunk) => this.handleStdout(chunk));
+    child.stdout?.on("error", (error) => this.emitError(error));
+    child.stdin?.on("error", (error) => {
+      if (!this.closed)
+        this.emitError(error);
+    });
+    child.stderr?.on("data", (chunk) => this.handleStderr(chunk));
+    child.stderr?.on("error", (error) => this.emitError(error));
+    child.on("close", () => {
+      this.child = void 0;
+      if (this.stdoutBuffer.toString("utf8").trim()) {
+        this.emitError(new Error("MCP stdio server closed with an incomplete JSON-RPC message"));
+      }
+      this.stdoutBuffer = Buffer.alloc(0);
+      this.emitClose();
+    });
+    await new Promise((resolve, reject) => {
+      const onSpawn = () => {
+        child.off("error", onError);
+        resolve();
+      };
+      const onError = (error) => {
+        child.off("spawn", onSpawn);
+        reject(error);
+      };
+      child.once("spawn", onSpawn);
+      child.once("error", onError);
+    });
+    child.on("error", (error) => {
+      if (!this.closed)
+        this.emitError(error);
+    });
+  }
+  async send(message) {
+    const stdin = this.child?.stdin;
+    if (!this.started || this.closed || !stdin?.writable)
+      throw new McpConnectionClosedError();
+    const payload = `${JSON.stringify(message)}
+`;
+    await new Promise((resolve, reject) => {
+      stdin.write(payload, (error) => error ? reject(error) : resolve());
+    });
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    const child = this.child;
+    if (!child) {
+      this.emitClose();
+      return;
+    }
+    if (child.exitCode !== null || child.signalCode !== null) {
+      child.stdin?.end();
+      return;
+    }
+    const closeTimeoutMs = this.options.closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS;
+    await new Promise((resolve) => {
+      const timers = [];
+      child.once("close", () => {
+        for (const timer of timers)
+          clearTimeout(timer);
+        killProcessTree(child, "SIGTERM");
+        resolve();
+      });
+      const grace = Math.min(STDIN_CLOSE_GRACE_MS, closeTimeoutMs);
+      timers.push(setTimeout(() => killProcessTree(child, "SIGTERM"), grace));
+      timers.push(setTimeout(() => killProcessTree(child, "SIGKILL"), grace + closeTimeoutMs));
+      child.stdin?.end();
+    });
+  }
+  handleStdout(chunk) {
+    this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+    const maxMessageBytes = this.options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES;
+    while (true) {
+      const newline = this.stdoutBuffer.indexOf(10);
+      if (newline < 0) {
+        if (this.stdoutBuffer.length > maxMessageBytes) {
+          this.stdoutBuffer = Buffer.alloc(0);
+          this.emitError(new Error(`MCP stdio message exceeds ${maxMessageBytes} bytes`));
+        }
+        return;
+      }
+      const line = this.stdoutBuffer.subarray(0, newline);
+      this.stdoutBuffer = this.stdoutBuffer.subarray(newline + 1);
+      if (line.length > maxMessageBytes) {
+        this.emitError(new Error(`MCP stdio message exceeds ${maxMessageBytes} bytes`));
+        continue;
+      }
+      const text = line.toString("utf8").replace(/\r$/, "");
+      if (!text.trim())
+        continue;
+      try {
+        this.emitMessage(parseJsonRpcMessage(JSON.parse(text)));
+      } catch (error) {
+        this.emitError(error);
+      }
+    }
+  }
+  handleStderr(chunk) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    const maxStderrBytes = this.options.maxStderrBytes ?? DEFAULT_MAX_STDERR_BYTES;
+    this.stderrBuffer = Buffer.concat([this.stderrBuffer, buffer]);
+    if (this.stderrBuffer.length > maxStderrBytes)
+      this.stderrBuffer = this.stderrBuffer.subarray(-maxStderrBytes);
+    this.options.onStderr?.(buffer.toString("utf8"));
+  }
+};
+
+// node_modules/@earendil-works/pi-mcp/dist/transports/streamable-http.js
+var MAX_ERROR_BODY_BYTES = 8 * 1024;
+var ERROR_MESSAGE_BODY_CHARS = 500;
+var DEFAULT_RECONNECT_INITIAL_DELAY_MS = 1e3;
+var DEFAULT_RECONNECT_MAX_DELAY_MS = 3e4;
+var DEFAULT_RECONNECT_MAX_RETRIES = 5;
+async function consumeSseStream(stream, options) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffered = "";
+  let eventName;
+  let eventId;
+  let dataLines = [];
+  let dataBytes = 0;
+  const maxEventBytes = options.maxEventBytes ?? DEFAULT_MAX_MESSAGE_BYTES;
+  const dispatch = () => {
+    if (dataLines.length === 0) {
+      eventName = void 0;
+      eventId = void 0;
+      return;
+    }
+    const data = dataLines.join("\n");
+    options.onEvent({ ...eventName ? { event: eventName } : {}, data, ...eventId ? { id: eventId } : {} });
+    eventName = void 0;
+    eventId = void 0;
+    dataLines = [];
+    dataBytes = 0;
+  };
+  const processLine = (rawLine) => {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    if (line === "") {
+      dispatch();
+      return;
+    }
+    if (line.startsWith(":"))
+      return;
+    const colon = line.indexOf(":");
+    const field = colon < 0 ? line : line.slice(0, colon);
+    let value = colon < 0 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" "))
+      value = value.slice(1);
+    if (field === "data") {
+      dataBytes += Buffer.byteLength(value) + (dataLines.length > 0 ? 1 : 0);
+      if (dataBytes > maxEventBytes)
+        throw new Error(`MCP SSE event exceeds ${maxEventBytes} bytes`);
+      dataLines.push(value);
+    } else if (field === "event")
+      eventName = value;
+    else if (field === "id" && !value.includes("\0")) {
+      eventId = value;
+      options.onId?.(value);
+    } else if (field === "retry" && /^\d+$/.test(value))
+      options.onRetry?.(Number(value));
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffered += decoder.decode(value, { stream: true });
+      let newline = buffered.indexOf("\n");
+      while (newline >= 0) {
+        processLine(buffered.slice(0, newline));
+        buffered = buffered.slice(newline + 1);
+        newline = buffered.indexOf("\n");
+      }
+      if (Buffer.byteLength(buffered) > maxEventBytes)
+        throw new Error(`MCP SSE event exceeds ${maxEventBytes} bytes`);
+    }
+    buffered += decoder.decode();
+    if (buffered)
+      processLine(buffered);
+    dispatch();
+  } finally {
+    reader.releaseLock();
+  }
+}
+var McpHttpError = class extends Error {
+  status;
+  body;
+  constructor(status, message, body = "") {
+    super(message);
+    this.name = "McpHttpError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var McpAuthRequiredError = class extends McpHttpError {
+  wwwAuthenticate;
+  constructor(response, body = "") {
+    super(401, "MCP server requires authentication", body);
+    this.name = "McpAuthRequiredError";
+    this.wwwAuthenticate = response.headers.get("www-authenticate");
+  }
+};
+var McpSessionExpiredError = class extends McpHttpError {
+  constructor(body = "") {
+    super(404, "MCP session expired", body);
+    this.name = "McpSessionExpiredError";
+  }
+};
+function contentType(response) {
+  return response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+}
+function needsAuthorization(response) {
+  if (response.status === 401)
+    return true;
+  if (response.status !== 403)
+    return false;
+  return /(?:^|[\s,])error="?insufficient_scope"?/i.test(response.headers.get("www-authenticate") ?? "");
+}
+function isTransientStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+function discard(response) {
+  return response.body?.cancel().catch(() => {
+  }) ?? Promise.resolve();
+}
+function describeHttpFailure(status, body) {
+  const text = body.trim();
+  const snippet = text.length > ERROR_MESSAGE_BODY_CHARS ? `${text.slice(0, ERROR_MESSAGE_BODY_CHARS - 3)}...` : text;
+  return `MCP HTTP request failed with status ${status}${snippet ? `: ${snippet}` : ""}`;
+}
+var StreamableHttpTransport = class extends TransportEvents {
+  url;
+  options;
+  fetch;
+  controller = new AbortController();
+  started = false;
+  closed = false;
+  sessionIdValue;
+  protocolVersion;
+  getStreamStarted = false;
+  /** Access token of the latest request, which `close()` reuses instead of asking the auth provider. */
+  lastToken;
+  constructor(options) {
+    super();
+    this.options = Object.freeze({ ...options, headers: options.headers ? { ...options.headers } : void 0 });
+    this.url = new URL(options.url);
+    const fetch = options.fetch ?? globalThis.fetch;
+    this.fetch = (input, init) => fetch(input, init);
+  }
+  get sessionId() {
+    return this.sessionIdValue;
+  }
+  async start() {
+    if (this.started)
+      throw new Error("MCP Streamable HTTP transport already started");
+    if (this.closed)
+      throw new McpConnectionClosedError();
+    this.started = true;
+  }
+  setProtocolVersion(version) {
+    this.protocolVersion = version;
+  }
+  async send(message, { signal } = {}) {
+    if (!this.started || this.closed)
+      throw new McpConnectionClosedError();
+    const response = await this.authorizedFetch("POST", {
+      headers: { accept: "application/json, text/event-stream", "content-type": "application/json" },
+      body: JSON.stringify(message)
+    }, signal);
+    await this.checkResponse(response);
+    this.captureSession(response);
+    if (!isJsonRpcRequest(message)) {
+      await discard(response);
+      if ("method" in message && message.method === "notifications/initialized")
+        this.startGetStream();
+      return;
+    }
+    if (response.status === 202 || response.status === 204) {
+      throw new McpHttpError(response.status, `MCP server accepted request ${message.method} without a response`);
+    }
+    const type = contentType(response);
+    if (type === "application/json") {
+      const body = await response.json();
+      for (const item of Array.isArray(body) ? body : [body])
+        this.emitMessage(parseJsonRpcMessage(item));
+      return;
+    }
+    if (type === "text/event-stream" && response.body) {
+      void this.consumeResponseStream(response.body, message.id);
+      return;
+    }
+    await discard(response);
+    throw new McpHttpError(response.status, `Unsupported MCP response content type: ${type ?? "missing"}`);
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    this.controller.abort();
+    if (this.started && this.sessionIdValue) {
+      try {
+        const response = await this.fetch(this.url, {
+          method: "DELETE",
+          headers: this.buildHeaders({}, this.lastToken),
+          signal: AbortSignal.timeout(1e3)
+        });
+        await discard(response);
+      } catch {
+      }
+    }
+    this.emitClose();
+  }
+  /**
+   * Fetch with auth headers. A 401 (or a 403 asking for more scope) is handed to the auth provider
+   * once, and the request is retried with whatever credentials it left behind.
+   *
+   * `signal` only stops dispatch: getting a token or the authorization recovery can take a while, and a
+   * request its sender gave up on in the meantime must not reach the server. It does not abort the shared
+   * recovery, which other requests may wait for.
+   */
+  async authorizedFetch(method, init, signal) {
+    const onUnauthorized = this.options.authProvider?.onUnauthorized?.bind(this.options.authProvider);
+    for (let attempt = 0; ; attempt++) {
+      const { headers, token } = await this.headers(init.headers);
+      if (signal?.aborted)
+        throw new McpAbortError();
+      const response = await this.fetch(this.url, {
+        method,
+        headers,
+        body: init.body,
+        signal: this.controller.signal
+      });
+      if (attempt > 0 || !onUnauthorized || !needsAuthorization(response))
+        return response;
+      try {
+        await onUnauthorized({ response, serverUrl: this.url, fetch: this.fetch, token });
+      } finally {
+        await discard(response);
+      }
+    }
+  }
+  async headers(extra = {}) {
+    const token = await this.options.authProvider?.token();
+    this.lastToken = token;
+    return { headers: this.buildHeaders(extra, token), ...token ? { token } : {} };
+  }
+  buildHeaders(extra, token) {
+    const headers = new Headers(this.options.headers);
+    for (const [name, value] of Object.entries(extra))
+      headers.set(name, value);
+    if (this.sessionIdValue)
+      headers.set("Mcp-Session-Id", this.sessionIdValue);
+    if (this.protocolVersion)
+      headers.set("MCP-Protocol-Version", this.protocolVersion);
+    if (token)
+      headers.set("Authorization", `Bearer ${token}`);
+    return headers;
+  }
+  captureSession(response) {
+    const sessionId = response.headers.get("mcp-session-id");
+    if (sessionId)
+      this.sessionIdValue = sessionId;
+  }
+  async checkResponse(response) {
+    if (response.ok)
+      return;
+    const body = (await response.text().catch(() => "")).slice(0, MAX_ERROR_BODY_BYTES);
+    if (response.status === 401)
+      throw new McpAuthRequiredError(response, body);
+    if (response.status === 404 && this.sessionIdValue)
+      throw new McpSessionExpiredError(body);
+    throw new McpHttpError(response.status, describeHttpFailure(response.status, body), body);
+  }
+  async consumeSse(stream, cursor, onMessage) {
+    await consumeSseStream(stream, {
+      maxEventBytes: this.options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES,
+      onId: (id) => {
+        cursor.lastEventId = id;
+      },
+      onRetry: (delayMs) => {
+        cursor.retryMs = delayMs;
+      },
+      onEvent: (event) => {
+        cursor.received = true;
+        if (!event.data.trim() || event.event !== void 0 && event.event !== "message")
+          return;
+        let message;
+        try {
+          message = parseJsonRpcMessage(JSON.parse(event.data));
+        } catch (error) {
+          this.emitError(error);
+          return;
+        }
+        onMessage?.(message);
+        this.emitMessage(message);
+      }
+    });
+  }
+  /**
+   * Read the SSE stream answering one request. When the stream ends or breaks before the response
+   * arrives and the server assigned event IDs, resume it with GET and `Last-Event-ID`, as the
+   * server may close response streams at will. Otherwise only this request fails.
+   */
+  async consumeResponseStream(body, requestId) {
+    const cursor = { lastEventId: void 0, retryMs: void 0, received: false };
+    let answered = false;
+    const onMessage = (message) => {
+      if (isJsonRpcResponse(message) && message.id === requestId)
+        answered = true;
+    };
+    let stream = body;
+    let failure;
+    for (let attempt = 0; ; ) {
+      if (stream) {
+        try {
+          await this.consumeSse(stream, cursor, onMessage);
+          failure = void 0;
+        } catch (error) {
+          failure = error;
+        }
+      }
+      if (answered || this.closed)
+        return;
+      if (failure !== void 0 && !this.isRetryable(failure))
+        break;
+      if (cursor.lastEventId === void 0 || attempt >= this.maxRetries())
+        break;
+      if (cursor.received)
+        attempt = 0;
+      cursor.received = false;
+      if (!await this.sleep(this.reconnectDelay(attempt++, cursor.retryMs)))
+        return;
+      try {
+        stream = await this.openSseStream(cursor.lastEventId);
+      } catch (error) {
+        failure = error;
+        if (!this.isRetryable(error))
+          break;
+        stream = void 0;
+      }
+    }
+    if (this.closed)
+      return;
+    const reason = failure === void 0 ? "stream ended without a response" : toError(failure).message;
+    this.emitMessage({
+      jsonrpc: "2.0",
+      id: requestId,
+      error: { code: JSON_RPC_ERROR_CODES.internalError, message: `MCP response stream failed: ${reason}` }
+    });
+  }
+  startGetStream() {
+    if (this.options.openGetStream === false || this.getStreamStarted || this.closed)
+      return;
+    this.getStreamStarted = true;
+    void this.runGetStream();
+  }
+  /** Keep the server-to-client stream open, reconnecting with backoff when it drops. */
+  async runGetStream() {
+    const cursor = { lastEventId: void 0, retryMs: void 0, received: false };
+    for (let attempt = 0; !this.closed; ) {
+      try {
+        const stream = await this.openSseStream(cursor.lastEventId);
+        if (!stream)
+          return;
+        const openedAt = Date.now();
+        await this.consumeSse(stream, cursor);
+        if (cursor.received || Date.now() - openedAt > this.maxDelay())
+          attempt = 0;
+      } catch (error) {
+        if (this.closed)
+          return;
+        if (!this.isRetryable(error)) {
+          this.emitError(error);
+          return;
+        }
+      }
+      cursor.received = false;
+      if (attempt >= this.maxRetries()) {
+        this.emitError(new Error("MCP server-to-client stream dropped and could not be reopened"));
+        return;
+      }
+      if (!await this.sleep(this.reconnectDelay(attempt++, cursor.retryMs)))
+        return;
+    }
+  }
+  /** Open a GET SSE stream. Resolves to undefined when the server answers 405 (no GET stream). */
+  async openSseStream(lastEventId) {
+    const response = await this.authorizedFetch("GET", {
+      headers: {
+        accept: "text/event-stream",
+        ...lastEventId === void 0 ? {} : { "last-event-id": lastEventId }
+      }
+    });
+    if (response.status === 405) {
+      await discard(response);
+      return void 0;
+    }
+    await this.checkResponse(response);
+    this.captureSession(response);
+    const type = contentType(response);
+    if (type !== "text/event-stream" || !response.body) {
+      await discard(response);
+      throw new McpHttpError(response.status, `Unsupported MCP GET response content type: ${type ?? "missing"}`);
+    }
+    return response.body;
+  }
+  /**
+   * Network failures and transient statuses are retried; auth, session, and protocol errors are not.
+   * `fetch` reports network failures, including a connection dropped mid-body, as `TypeError`.
+   */
+  isRetryable(error) {
+    if (error instanceof McpHttpError)
+      return isTransientStatus(error.status);
+    if (error instanceof TypeError)
+      return true;
+    const code2 = error?.code;
+    return typeof code2 === "string" && (code2.startsWith("E") || code2.startsWith("UND_ERR"));
+  }
+  reconnectDelay(attempt, serverDelayMs) {
+    if (serverDelayMs !== void 0)
+      return serverDelayMs;
+    const initial = this.options.reconnect?.initialDelayMs ?? DEFAULT_RECONNECT_INITIAL_DELAY_MS;
+    return Math.min(initial * 2 ** attempt, this.maxDelay());
+  }
+  maxDelay() {
+    return this.options.reconnect?.maxDelayMs ?? DEFAULT_RECONNECT_MAX_DELAY_MS;
+  }
+  maxRetries() {
+    return this.options.reconnect?.maxRetries ?? DEFAULT_RECONNECT_MAX_RETRIES;
+  }
+  /** Resolves false when the transport closed while waiting. */
+  sleep(ms) {
+    const signal = this.controller.signal;
+    if (signal.aborted)
+      return Promise.resolve(false);
+    return new Promise((resolve) => {
+      const onAbort = () => {
+        clearTimeout(timer);
+        resolve(false);
+      };
+      const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(true);
+      }, ms);
+      timer.unref?.();
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+};
+
+// src/client/pi-connection.ts
+async function createPiConnection(options) {
+  const clientOptions = {
+    name: "mcpcat",
+    version: options.version ?? "0.0.0"
+  };
+  const client = new McpClient(clientOptions);
+  let transport;
+  if (options.url) {
+    transport = new StreamableHttpTransport({
+      url: options.url,
+      headers: options.headers
+    });
+  } else if (options.command) {
+    transport = new StdioTransport({
+      command: options.command,
+      args: options.args,
+      env: options.env,
+      cwd: options.cwd,
+      inheritEnv: true,
+      stderr: "pipe"
+    });
+  } else {
+    throw new Error("PiConnection requires either a url or a command");
+  }
+  const initResult = await client.connect(transport);
+  return {
+    async info() {
+      return {
+        name: initResult.serverInfo?.name,
+        version: initResult.serverInfo?.version,
+        title: initResult.serverInfo?.title,
+        protocolVersion: initResult.protocolVersion,
+        capabilities: initResult.capabilities,
+        instructions: initResult.instructions
+      };
+    },
+    async listTools() {
+      return client.listTools();
+    },
+    async callTool(name, args2) {
+      return client.callTool(name, args2);
+    },
+    async close() {
+      await client.close();
+    }
+  };
+}
+
+// src/client/stateless-connection.ts
+var STATELESS_PROTOCOL_VERSION = "2026-07-28";
+var StatelessRpcError = class extends Error {
+  code;
+  data;
+  constructor(code2, message, data) {
+    super(`MCP RPC error ${code2}: ${message}`);
+    this.name = "StatelessRpcError";
+    this.code = code2;
+    this.data = data;
+  }
+};
+var StatelessHttpError = class extends Error {
+  status;
+  constructor(status, statusText, method, snippet) {
+    super(`MCP HTTP ${status} ${statusText} for ${method}: ${snippet || "(empty body)"}`);
+    this.name = "StatelessHttpError";
+    this.status = status;
+  }
+};
+var InputRequiredError = class extends Error {
+  requestJson;
+  constructor(requestJson) {
+    super("Server requires input (resultType: input_required)");
+    this.name = "InputRequiredError";
+    this.requestJson = requestJson;
+  }
+};
+function selectSseFrame(body, targetId) {
+  const text = new TextDecoder().decode(body);
+  const blocks = text.replace(/\r\n/g, "\n").split(/\n\n/);
+  for (const block of blocks) {
+    if (!block.trim()) continue;
+    const dataLines = [];
+    for (const line of block.split("\n")) {
+      if (line.startsWith("data:")) dataLines.push(line.slice(5).trimStart());
+    }
+    if (dataLines.length === 0) continue;
+    try {
+      const parsed = JSON.parse(dataLines.join("\n"));
+      if (parsed.id === targetId) return parsed;
+    } catch {
+    }
+  }
+  throw new Error(`SSE stream ended without response for id ${targetId}`);
+}
+function mcpNameForMethod(method, params) {
+  if (method === "tools/call") return params.name;
+  if (method === "prompts/get") return params.name;
+  if (method === "resources/read") return params.uri;
+  return void 0;
+}
+async function createStatelessConnection(options) {
+  const {
+    url,
+    headers: extraHeaders,
+    fetchImpl,
+    timeoutMs = 6e4,
+    clientInfo = { name: "mcpcat", version: "0.0.0" }
+  } = options;
+  let nextId = 1;
+  let negotiatedVersion;
+  async function request(method, params) {
+    const id = nextId++;
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      "Mcp-Method": method,
+      ...extraHeaders
+    };
+    const mcpName = mcpNameForMethod(method, params);
+    if (mcpName) {
+      headers["Mcp-Name"] = mcpName;
+    }
+    if (negotiatedVersion) {
+      headers["Mcp-Protocol-Version"] = negotiatedVersion;
+    }
+    const meta = {
+      protocolVersion: negotiatedVersion ?? STATELESS_PROTOCOL_VERSION,
+      clientInfo
+    };
+    const body = JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      method,
+      params: { ...params, _meta: meta }
+    });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let res;
+    try {
+      res = await fetchImpl(url, {
+        method: "POST",
+        headers,
+        body,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (res.status === 401) {
+      throw new StatelessHttpError(401, "Unauthorized", method, "");
+    }
+    if (res.status >= 400) {
+      const text = await res.text();
+      let rpcError;
+      try {
+        const parsed = JSON.parse(text);
+        if (parsed.error && typeof parsed.error.code === "number") {
+          rpcError = parsed.error;
+        }
+      } catch {
+      }
+      if (rpcError) {
+        throw new StatelessRpcError(rpcError.code, rpcError.message, rpcError.data);
+      }
+      throw new StatelessHttpError(res.status, res.statusText, method, text.slice(0, 512));
+    }
+    const ct = res.headers.get("content-type") ?? "";
+    let frame;
+    if (ct.toLowerCase().includes("text/event-stream")) {
+      const bytes = new Uint8Array(await res.arrayBuffer());
+      frame = selectSseFrame(bytes, id);
+    } else {
+      frame = await res.json();
+    }
+    if (frame.error) {
+      throw new StatelessRpcError(frame.error.code, frame.error.message, frame.error.data);
+    }
+    return frame.result;
+  }
+  const discoverResult = await request("server/discover", {
+    protocolVersion: STATELESS_PROTOCOL_VERSION
+  });
+  const supported = Array.isArray(discoverResult?.supportedVersions) ? discoverResult.supportedVersions.filter((v) => typeof v === "string") : [];
+  if (!supported.includes(STATELESS_PROTOCOL_VERSION)) {
+    throw new Error(
+      `Server does not support ${STATELESS_PROTOCOL_VERSION} (advertised: ${supported.join(", ") || "none"})`
+    );
+  }
+  negotiatedVersion = STATELESS_PROTOCOL_VERSION;
+  let serverInfoCache;
+  return {
+    async info() {
+      if (serverInfoCache) return serverInfoCache;
+      const result = discoverResult;
+      serverInfoCache = {
+        name: result?.serverInfo?.name,
+        version: result?.serverInfo?.version,
+        title: result?.serverInfo?.title,
+        protocolVersion: STATELESS_PROTOCOL_VERSION,
+        capabilities: result?.capabilities ?? {},
+        instructions: result?.instructions
+      };
+      return serverInfoCache;
+    },
+    async listTools() {
+      const result = await request("tools/list", {});
+      return result?.tools ?? [];
+    },
+    async callTool(name, args2) {
+      const result = await request("tools/call", {
+        name,
+        arguments: args2 ?? {}
+      });
+      const resultType = result.resultType ?? "complete";
+      if (resultType === "input_required") {
+        throw new InputRequiredError(
+          JSON.stringify({ name, arguments: args2 ?? {}, result }, null, 2)
+        );
+      }
+      return result;
+    },
+    async close() {
+    }
+  };
+}
+
+// src/client/connect.ts
+async function connect(platform2, options) {
+  if (options.command) {
+    return createPiConnection({
+      command: options.command,
+      args: options.args,
+      env: options.env,
+      cwd: options.cwd,
+      version: options.version
+    });
+  }
+  if (!options.url) {
+    throw new Error("connect requires either a url or a command");
+  }
+  if (options.protocolVersion && !options.protocolVersion.startsWith("2026")) {
+    return createPiConnection({
+      url: options.url,
+      headers: options.headers,
+      version: options.version
+    });
+  }
+  try {
+    return await createStatelessConnection({
+      url: options.url,
+      headers: options.headers,
+      fetchImpl: platform2.fetch,
+      clientInfo: { name: "mcpcat", version: options.version ?? "0.0.0" }
+    });
+  } catch (err) {
+    const isMethodNotFound = err instanceof StatelessRpcError && err.code === -32601 || err instanceof StatelessHttpError && err.status >= 400 && err.status < 500;
+    if (options.protocolVersion?.startsWith("2026")) {
+      throw err;
+    }
+    if (isMethodNotFound) {
+      return createPiConnection({
+        url: options.url,
+        headers: options.headers,
+        version: options.version
+      });
+    }
+    throw err;
+  }
+}
+
+// src/client/targets.ts
+function splitShellStyle(input) {
+  const result = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < input.length; i++) {
+    const c = input[i];
+    if (inSingle) {
+      if (c === "'") {
+        inSingle = false;
+      } else {
+        current += c;
+      }
+    } else if (inDouble) {
+      if (c === '"') {
+        inDouble = false;
+      } else if (c === "\\" && i + 1 < input.length) {
+        current += input[++i];
+      } else {
+        current += c;
+      }
+    } else if (c === "'") {
+      inSingle = true;
+    } else if (c === '"') {
+      inDouble = true;
+    } else if (c === " " || c === "	") {
+      if (current.length > 0) {
+        result.push(current);
+        current = "";
+      }
+    } else if (c === "\\" && i + 1 < input.length) {
+      current += input[++i];
+    } else {
+      current += c;
+    }
+  }
+  if (current.length > 0) result.push(current);
+  return result;
+}
+function normalizeUrl(raw) {
+  if (raw.startsWith("http://") || raw.startsWith("https://")) return raw;
+  if (raw.startsWith("localhost") || raw.startsWith("127.0.0.1") || raw.startsWith("[::1]")) {
+    return `http://${raw}`;
+  }
+  return `https://${raw}`;
+}
+function looksLikeUrl(value) {
+  if (value.startsWith("http://") || value.startsWith("https://")) return true;
+  if (value.includes(".") && !value.includes(" ")) return true;
+  if (value.startsWith("localhost") || value.startsWith("127.0.0.1") || value.startsWith("[::1]"))
+    return true;
+  return false;
+}
+async function resolveTarget(target, trailingArgs, config) {
+  if (trailingArgs && trailingArgs.length > 0) {
+    return { command: trailingArgs[0], args: trailingArgs.slice(1) };
+  }
+  if (!target) {
+    throw new Error("no target given");
+  }
+  if (target.startsWith("stdio:")) {
+    const rest = target.slice(6);
+    const parts = splitShellStyle(rest);
+    if (parts.length === 0) throw new Error("stdio: target requires a command");
+    return { command: parts[0], args: parts.slice(1) };
+  }
+  if (looksLikeUrl(target)) {
+    return { url: normalizeUrl(target) };
+  }
+  const entry = await config.get(target);
+  if (entry) {
+    return configToTarget(entry);
+  }
+  throw new Error(`unknown target '${target}': not a URL and not found in mcp.json`);
+}
+function configToTarget(entry) {
+  if (entry.url) {
+    return {
+      url: entry.url,
+      headers: entry.headers
+    };
+  }
+  if (entry.command) {
+    return {
+      command: entry.command,
+      args: entry.args,
+      env: entry.env,
+      cwd: entry.cwd
+    };
+  }
+  throw new Error("config entry has neither url nor command");
+}
+
+// src/config/parse.ts
+var SERVER_NAME = /^[A-Za-z0-9_-]+$/;
+var EXPOSURES = ["codemode", "deferred", "direct", "hidden"];
+var EXPOSURE_ALIASES = { "codemode-deferred": "codemode" };
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringRecord(value) {
+  return isRecord(value) && Object.values(value).every((v) => typeof v === "string");
+}
+function isExposure(value) {
+  return typeof value === "string" && EXPOSURES.includes(value);
+}
+function resolveAlias(value) {
+  return typeof value === "string" ? EXPOSURE_ALIASES[value] ?? value : value;
+}
+function resolveAliases(value) {
+  const out = { ...value };
+  if (out.exposure !== void 0) out.exposure = resolveAlias(out.exposure);
+  if (isRecord(out.toolExposure)) {
+    out.toolExposure = Object.fromEntries(
+      Object.entries(out.toolExposure).map(([k, v]) => [k, resolveAlias(v)])
+    );
+  }
+  return out;
+}
+function fail(server, message, field) {
+  return { server, ...field ? { field } : {}, message };
+}
+function validateCommon(name, value) {
+  const exposures = EXPOSURES.map((e) => `"${e}"`).join(", ");
+  if (value.exposure !== void 0 && !isExposure(value.exposure))
+    return fail(name, `exposure must be one of ${exposures}`, "exposure");
+  if (value.toolExposure !== void 0) {
+    if (!isRecord(value.toolExposure))
+      return fail(name, "toolExposure must map tool names to exposures", "toolExposure");
+    for (const [tool, exp] of Object.entries(value.toolExposure))
+      if (!isExposure(exp))
+        return fail(
+          name,
+          `toolExposure "${tool}" must be one of ${exposures}`,
+          `toolExposure.${tool}`
+        );
+  }
+  if (value.enabled !== void 0 && typeof value.enabled !== "boolean")
+    return fail(name, "enabled must be a boolean", "enabled");
+  if (value.description !== void 0 && typeof value.description !== "string")
+    return fail(name, "description must be a string", "description");
+  if (value.timeout !== void 0 && (typeof value.timeout !== "number" || !(value.timeout > 0)))
+    return fail(name, "timeout must be a positive number of seconds", "timeout");
+  return void 0;
+}
+function validateOAuthFields(name, oauth) {
+  if (oauth.clientId !== void 0 && typeof oauth.clientId !== "string")
+    return fail(name, "oauth.clientId must be a string", "oauth.clientId");
+  if (oauth.clientSecret !== void 0 && typeof oauth.clientSecret !== "string")
+    return fail(name, "oauth.clientSecret must be a string", "oauth.clientSecret");
+  const port = oauth.callbackPort;
+  if (port !== void 0 && (typeof port !== "number" || !Number.isInteger(port) || port < 1 || port > 65535))
+    return fail(name, "oauth.callbackPort must be a port number", "oauth.callbackPort");
+  if (oauth.callbackUrl !== void 0 && typeof oauth.callbackUrl !== "string")
+    return fail(name, "oauth.callbackUrl must be a string", "oauth.callbackUrl");
+  if (oauth.scope !== void 0 && typeof oauth.scope !== "string")
+    return fail(name, "oauth.scope must be a string", "oauth.scope");
+  if (oauth.clientName !== void 0 && (typeof oauth.clientName !== "string" || !oauth.clientName.trim()))
+    return fail(name, "oauth.clientName must be a non-empty string", "oauth.clientName");
+  return void 0;
+}
+function validateOAuthExtras(name, oauth) {
+  if (oauth.clientRegistration !== void 0 && oauth.clientRegistration !== "dcr" && oauth.clientRegistration !== "cimd")
+    return fail(
+      name,
+      'oauth.clientRegistration must be "dcr" or "cimd"',
+      "oauth.clientRegistration"
+    );
+  if (oauth.authServerMetadataUrl !== void 0) {
+    const url = typeof oauth.authServerMetadataUrl === "string" && URL.canParse(oauth.authServerMetadataUrl) ? new URL(oauth.authServerMetadataUrl) : void 0;
+    if (!url || url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname)))
+      return fail(
+        name,
+        "oauth.authServerMetadataUrl must be an https URL",
+        "oauth.authServerMetadataUrl"
+      );
+  }
+  return void 0;
+}
+function validateOAuth(name, value) {
+  const { oauth } = value;
+  if (oauth === void 0) return void 0;
+  if (!isRecord(oauth)) return fail(name, "oauth must be an object", "oauth");
+  return validateOAuthFields(name, oauth) ?? validateOAuthExtras(name, oauth);
+}
+function validateHttpServer(name, value) {
+  if (typeof value.url !== "string" || value.type !== void 0 && value.type !== "http" && value.type !== "streamable-http")
+    return void 0;
+  if (!URL.canParse(value.url) || !/^https?:$/.test(new URL(value.url).protocol))
+    return fail(name, "url must be an http or https URL", "url");
+  if (value.headers !== void 0 && !isStringRecord(value.headers))
+    return fail(name, "headers must map names to strings", "headers");
+  const oauthErr = validateOAuth(name, value);
+  if (oauthErr) return oauthErr;
+  return value;
+}
+function validateStdioServer(name, value) {
+  if (typeof value.command !== "string" || value.type !== void 0 && value.type !== "stdio")
+    return void 0;
+  if (value.args !== void 0 && !(Array.isArray(value.args) && value.args.every((a) => typeof a === "string")))
+    return fail(name, "args must be an array of strings", "args");
+  if (value.env !== void 0 && !isStringRecord(value.env))
+    return fail(name, "env must map names to strings", "env");
+  if (value.cwd !== void 0 && typeof value.cwd !== "string")
+    return fail(name, "cwd must be a string", "cwd");
+  return value;
+}
+function validateServer(name, raw) {
+  if (!SERVER_NAME.test(name))
+    return fail(name, `invalid server name "${name}" (use letters, digits, "_" and "-")`);
+  if (!isRecord(raw)) return fail(name, "must be an object");
+  const value = resolveAliases(raw);
+  if (value.type === "sse")
+    return fail(name, "legacy SSE transport is not supported; use the streamable HTTP URL", "type");
+  const common = validateCommon(name, value);
+  if (common) return common;
+  const httpResult = validateHttpServer(name, value);
+  if (httpResult) return httpResult;
+  const stdioResult = validateStdioServer(name, value);
+  if (stdioResult) return stdioResult;
+  if (value.type !== void 0 && !["http", "streamable-http", "stdio"].includes(value.type))
+    return fail(name, 'type must be "stdio", "http", or "streamable-http"', "type");
+  return fail(name, 'needs a "url" or "command"');
+}
+function isOverride(value) {
+  return value.command === void 0 && value.url === void 0 && value.type === void 0;
+}
+function canonical(name) {
+  return name.replace(/-/g, "_");
+}
+function parseMcpJson(text) {
+  const result = { servers: [], overrides: [], problems: [] };
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    result.problems.push({ message: `not valid JSON: ${error.message}` });
+    return result;
+  }
+  if (!isRecord(parsed) || parsed.mcpServers !== void 0 && !isRecord(parsed.mcpServers)) {
+    result.problems.push({ message: "mcpServers must be an object" });
+    return result;
+  }
+  if (typeof parsed.autoEnableCodemode === "boolean")
+    result.autoEnableCodemode = parsed.autoEnableCodemode;
+  else if (parsed.autoEnableCodemode !== void 0)
+    result.problems.push({ message: "autoEnableCodemode must be a boolean" });
+  const seen = /* @__PURE__ */ new Set();
+  for (const [name, raw] of Object.entries(parsed.mcpServers ?? {})) {
+    if (!SERVER_NAME.test(name)) {
+      result.problems.push(
+        fail(name, `invalid server name "${name}" (use letters, digits, "_" and "-")`)
+      );
+      continue;
+    }
+    if (seen.has(canonical(name))) {
+      result.problems.push(
+        fail(name, 'names that differ only in "-" and "_" count as the same server')
+      );
+      continue;
+    }
+    seen.add(canonical(name));
+    if (isRecord(raw) && isOverride(raw)) {
+      result.overrides.push({ name, raw });
+      continue;
+    }
+    const checked = validateServer(name, raw);
+    if ("message" in checked) {
+      result.problems.push(checked);
+      continue;
+    }
+    result.servers.push({ name, config: checked });
+  }
+  return result;
+}
+
+// src/config/merge.ts
+var OVERRIDE_KEYS = /* @__PURE__ */ new Set(["enabled", "exposure", "toolExposure"]);
+async function readFile(fs, path) {
+  try {
+    const data = await fs.readFile(path);
+    return new TextDecoder().decode(data);
+  } catch {
+    return void 0;
+  }
+}
+function applyOverride(servers, problems, name, override, projectPath) {
+  const raw = override;
+  const base = servers.get(name);
+  const extra = Object.keys(raw).filter((k) => !OVERRIDE_KEYS.has(k));
+  if (!base) {
+    problems.push({
+      server: name,
+      message: 'needs "command" or "url", or a user server to override'
+    });
+    return;
+  }
+  if (extra.length > 0) {
+    problems.push({
+      server: name,
+      message: "an override can only set enabled, exposure, toolExposure"
+    });
+    return;
+  }
+  const merged = { ...base.config, ...raw };
+  servers.set(name, { ...base, config: merged, override: projectPath });
+}
+function applyProjectEntry(servers, problems, name, config, projectPath) {
+  const clash = [...servers.keys()].find(
+    (other) => other !== name && canonical(other) === canonical(name)
+  );
+  if (clash) {
+    problems.push({
+      server: name,
+      message: `conflicts with "${clash}" (names differ only in "-"/"_")`
+    });
+    return;
+  }
+  servers.set(name, { name, config, source: projectPath, scope: "project" });
+}
+function loadUserServers(parsed, userPath, servers, problems) {
+  for (const p of parsed.problems) problems.push(p);
+  for (const { name, config } of parsed.servers) {
+    servers.set(name, { name, config, source: userPath, scope: "user" });
+  }
+}
+function loadProjectServers(parsed, projectPath, servers, problems) {
+  for (const p of parsed.problems) problems.push(p);
+  for (const { name, raw } of parsed.overrides) {
+    applyOverride(servers, problems, name, raw, projectPath);
+  }
+  for (const { name, config } of parsed.servers) {
+    applyProjectEntry(servers, problems, name, config, projectPath);
+  }
+}
+async function loadConfig(input) {
+  const servers = /* @__PURE__ */ new Map();
+  const problems = [];
+  let autoEnableCodemode;
+  const userText = await readFile(input.fs, input.userPath);
+  if (userText !== void 0) {
+    const parsed = parseMcpJson(userText);
+    if (parsed.autoEnableCodemode !== void 0) autoEnableCodemode = parsed.autoEnableCodemode;
+    loadUserServers(parsed, input.userPath, servers, problems);
+  }
+  if (input.projectPath && input.trustProject) {
+    const projectText = await readFile(input.fs, input.projectPath);
+    if (projectText !== void 0) {
+      const parsed = parseMcpJson(projectText);
+      if (parsed.autoEnableCodemode !== void 0) autoEnableCodemode = parsed.autoEnableCodemode;
+      loadProjectServers(parsed, input.projectPath, servers, problems);
+    }
+  }
+  return {
+    servers: [...servers.values()],
+    problems,
+    ...autoEnableCodemode !== void 0 ? { autoEnableCodemode } : {}
+  };
+}
+
+// src/config/paths.ts
+function userConfigDir(platform2) {
+  const piDir = platform2.env.PI_CODING_AGENT_DIR;
+  if (piDir) return piDir;
+  const home = platform2.env.HOME ?? platform2.env.USERPROFILE ?? "/";
+  return `${home}/.pi/agent`;
+}
+function userConfigPath(platform2) {
+  return `${userConfigDir(platform2)}/mcp.json`;
+}
+function projectConfigPath(platform2) {
+  return `${platform2.cwd}/.pi/mcp.json`;
+}
+
+// src/config/index.ts
+var MergedConfigSource = class _MergedConfigSource {
+  entries;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.entries = /* @__PURE__ */ new Map();
+    for (const entry of config.servers) {
+      this.entries.set(entry.name, entry);
+    }
+  }
+  async get(name) {
+    const normalizedName = name.replace(/[-_]/g, "").toLowerCase();
+    for (const [key, entry] of this.entries) {
+      if (key.replace(/[-_]/g, "").toLowerCase() === normalizedName) {
+        return entry.config;
+      }
+    }
+    return void 0;
+  }
+  entry(name) {
+    return this.entries.get(name);
+  }
+  list() {
+    return [...this.entries.values()];
+  }
+  static async load(platform2, options) {
+    const userPath = options?.configFile ?? userConfigPath(platform2);
+    const projectPath = options?.configFile ? void 0 : projectConfigPath(platform2);
+    const config = await loadConfig({
+      userPath,
+      projectPath,
+      trustProject: options?.trustProject ?? false,
+      fs: platform2.fs
+    });
+    return new _MergedConfigSource(config);
+  }
+};
+
+// src/config/lock.ts
+var LOCK_STALE_MS = 1e4;
+var LOCK_POLL_MS = 50;
+var LOCK_MAX_WAIT_MS = 5e3;
+function isEexist(err) {
+  if (err instanceof Error && "code" in err)
+    return err.code === "EEXIST";
+  if (err instanceof Error) return err.message.includes("EEXIST");
+  return false;
+}
+async function removeStaleLock(fs, lockPath) {
+  try {
+    const s = await fs.stat(lockPath);
+    if (Date.now() - s.mtimeMs > LOCK_STALE_MS) {
+      try {
+        await fs.rmdir(lockPath);
+      } catch {
+      }
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+async function acquireLock(fs, configPath) {
+  const lockPath = `${configPath}.lock`;
+  const start = Date.now();
+  while (true) {
+    try {
+      await fs.mkdirExclusive(lockPath);
+      break;
+    } catch (err) {
+      if (!isEexist(err)) throw err;
+      await removeStaleLock(fs, lockPath);
+    }
+    if (Date.now() - start > LOCK_MAX_WAIT_MS) {
+      throw new Error(`mcpcat: could not acquire lock ${lockPath} within ${LOCK_MAX_WAIT_MS}ms`);
+    }
+    await new Promise((r) => setTimeout(r, LOCK_POLL_MS));
+  }
+  let released = false;
+  return async () => {
+    if (released) return;
+    released = true;
+    try {
+      await fs.rmdir(lockPath);
+    } catch {
+    }
+  };
+}
+
+// src/config/edit.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function detectIndent(text) {
+  const match = /^([ \t]+)\S/m.exec(text);
+  return match ? match[1] : "  ";
+}
+async function readText(fs, path) {
+  try {
+    const data = await fs.readFile(path);
+    return new TextDecoder().decode(data);
+  } catch {
+    return void 0;
+  }
+}
+async function editMcpServers(fs, path, edit) {
+  const release = await acquireLock(fs, path);
+  try {
+    const text = await readText(fs, path);
+    const parsed = text === void 0 ? {} : JSON.parse(text);
+    if (!isRecord2(parsed) || parsed.mcpServers !== void 0 && !isRecord2(parsed.mcpServers))
+      throw new Error(`${path}: expected an object with an "mcpServers" object`);
+    const servers = isRecord2(parsed.mcpServers) ? parsed.mcpServers : void 0;
+    if (!edit(servers, parsed)) return { changed: false };
+    const indent = text ? detectIndent(text) : "  ";
+    const output = `${JSON.stringify(parsed, null, indent)}
+`;
+    const dir = path.slice(0, path.lastIndexOf("/"));
+    if (dir) {
+      try {
+        await fs.mkdir(dir);
+      } catch {
+      }
+    }
+    const tmpPath = `${path}.tmp.${Date.now()}`;
+    await fs.writeFile(tmpPath, output);
+    await fs.rename(tmpPath, path);
+    return { changed: true };
+  } finally {
+    await release();
+  }
+}
+async function addServer(fs, path, name, config) {
+  let replaced = false;
+  await editMcpServers(fs, path, (servers, parsed) => {
+    const target = servers ?? {};
+    replaced = target[name] !== void 0;
+    target[name] = config;
+    parsed.mcpServers = target;
+    return true;
+  });
+  return { replaced };
+}
+async function removeServer(fs, path, name) {
+  let removed = false;
+  await editMcpServers(fs, path, (servers) => {
+    if (!servers || servers[name] === void 0) return false;
+    delete servers[name];
+    removed = true;
+    return true;
+  });
+  return removed;
+}
+async function updateServer(fs, path, name, patch) {
+  let updated = false;
+  await editMcpServers(fs, path, (servers) => {
+    if (!servers || !isRecord2(servers[name])) return false;
+    const entry = servers[name];
+    if (patch.enabled !== void 0) entry.enabled = patch.enabled;
+    if (patch.exposure !== void 0) entry.exposure = patch.exposure;
+    if (patch.toolExposure !== void 0) entry.toolExposure = patch.toolExposure;
+    updated = true;
+    return true;
+  });
+  return updated;
+}
+async function setExposure(fs, path, name, exposure, toolGlob) {
+  let updated = false;
+  await editMcpServers(fs, path, (servers) => {
+    if (!servers || !isRecord2(servers[name])) return false;
+    const entry = servers[name];
+    if (toolGlob) {
+      const te = isRecord2(entry.toolExposure) ? { ...entry.toolExposure } : {};
+      te[toolGlob] = exposure;
+      entry.toolExposure = te;
+    } else {
+      entry.exposure = exposure;
+    }
+    updated = true;
+    return true;
+  });
+  return updated;
+}
+
+// src/config/import.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringRecord2(value) {
+  return isRecord3(value) && Object.values(value).every((v) => typeof v === "string");
+}
+function tryParse(text) {
+  try {
+    return { parsed: JSON.parse(text) };
+  } catch (e) {
+    return { parsed: void 0, error: `not valid JSON: ${e.message}` };
+  }
+}
+function filterNames(entries, names) {
+  const result = [];
+  for (const [name, value] of entries) {
+    if (names && names.length > 0 && !names.includes(name)) continue;
+    result.push([name, value]);
+  }
+  return result;
+}
+function replaceInputVars(value) {
+  return value.replace(
+    /\$\{input:([^}]+)\}/g,
+    (_, name) => `\${${name.toUpperCase().replace(/[^A-Z0-9]/g, "_")}}`
+  );
+}
+function importClaude(text, names) {
+  const result = { servers: [], errors: [] };
+  const { parsed, error } = tryParse(text);
+  if (error) {
+    result.errors.push(error);
+    return result;
+  }
+  if (!isRecord3(parsed)) {
+    result.errors.push("expected an object");
+    return result;
+  }
+  const mcpServers = parsed.mcpServers;
+  if (!isRecord3(mcpServers)) {
+    result.errors.push('no "mcpServers" object');
+    return result;
+  }
+  for (const [name, entry] of filterNames(Object.entries(mcpServers), names)) {
+    if (!isRecord3(entry)) {
+      result.errors.push(`${name}: not an object`);
+      continue;
+    }
+    result.servers.push({ name, config: entry });
+  }
+  return result;
+}
+function importVSCode(text, names) {
+  const result = { servers: [], errors: [] };
+  const { parsed, error } = tryParse(text);
+  if (error) {
+    result.errors.push(error);
+    return result;
+  }
+  if (!isRecord3(parsed)) {
+    result.errors.push("expected an object");
+    return result;
+  }
+  const servers = parsed.servers ?? parsed.mcpServers;
+  if (!isRecord3(servers)) {
+    result.errors.push('no "servers" or "mcpServers" object');
+    return result;
+  }
+  for (const [name, entry] of filterNames(Object.entries(servers), names)) {
+    if (!isRecord3(entry)) {
+      result.errors.push(`${name}: not an object`);
+      continue;
+    }
+    result.servers.push({ name, config: convertVSCodeEntry(entry) });
+  }
+  return result;
+}
+function convertVSCodeEntry(entry) {
+  const config = {};
+  for (const [key, value] of Object.entries(entry)) {
+    if (key === "type" || key === "command" || key === "args" || key === "cwd" || key === "url") {
+      config[key] = value;
+    } else if (key === "headers" && isStringRecord2(value)) {
+      const headers = {};
+      for (const [h, v] of Object.entries(value)) headers[h] = replaceInputVars(v);
+      config.headers = headers;
+    } else if (key === "env" && isStringRecord2(value)) {
+      const env = {};
+      for (const [k, v] of Object.entries(value)) env[k] = replaceInputVars(v);
+      config.env = env;
+    } else {
+      config[key] = value;
+    }
+  }
+  return config;
+}
+function importSixServers(text, names) {
+  const result = { servers: [], errors: [] };
+  const { parsed, error } = tryParse(text);
+  if (error) {
+    result.errors.push(error);
+    return result;
+  }
+  if (!isRecord3(parsed)) {
+    result.errors.push("expected an object");
+    return result;
+  }
+  const servers = parsed.servers;
+  if (!isRecord3(servers)) {
+    result.errors.push('no "servers" object');
+    return result;
+  }
+  for (const [name, entry] of filterNames(Object.entries(servers), names)) {
+    if (!isRecord3(entry)) {
+      result.errors.push(`${name}: not an object`);
+      continue;
+    }
+    const config = {};
+    if (typeof entry.url === "string") config.url = entry.url;
+    if (isStringRecord2(entry.headers)) config.headers = entry.headers;
+    if (typeof entry.exposure === "string") config.exposure = entry.exposure;
+    if (isRecord3(entry.toolExposure)) config.toolExposure = entry.toolExposure;
+    result.servers.push({ name, config });
+  }
+  return result;
+}
+function importCodexToml(text, names) {
+  const result = { servers: [], errors: [] };
+  const sections = parseTomlSections(text);
+  for (const [sectionName, fields] of sections) {
+    const prefix = "mcp_servers.";
+    if (!sectionName.startsWith(prefix)) continue;
+    const name = sectionName.slice(prefix.length);
+    if (names && names.length > 0 && !names.includes(name)) continue;
+    const config = {};
+    if (fields.command) config.command = fields.command;
+    if (fields.args) config.args = fields.args;
+    if (fields.url) config.url = fields.url;
+    if (fields.env && isRecord3(fields.env)) config.env = fields.env;
+    result.servers.push({ name, config });
+  }
+  return result;
+}
+function parseTomlSections(text) {
+  const sections = [];
+  let current;
+  let currentName = "";
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || trimmed === "") continue;
+    const sectionMatch = /^\[([^\]]+)\]/.exec(trimmed);
+    if (sectionMatch) {
+      if (current) sections.push([currentName, current]);
+      currentName = sectionMatch[1].trim();
+      current = {};
+      continue;
+    }
+    if (!current) continue;
+    const kvMatch = /^(\w+)\s*=\s*(.+)/.exec(trimmed);
+    if (kvMatch) {
+      current[kvMatch[1]] = parseTomlValue(kvMatch[2].trim());
+    }
+  }
+  if (current) sections.push([currentName, current]);
+  return sections;
+}
+function parseTomlValue(raw) {
+  if (raw.startsWith('"') && raw.endsWith('"')) return raw.slice(1, -1);
+  if (raw.startsWith("'") && raw.endsWith("'")) return raw.slice(1, -1);
+  if (raw.startsWith("[")) {
+    try {
+      return JSON.parse(raw.replace(/'/g, '"'));
+    } catch {
+      return raw;
+    }
+  }
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  const num = Number(raw);
+  if (!Number.isNaN(num)) return num;
+  return raw;
+}
+function convertOpenCodeLocal(entry) {
+  const config = {};
+  if (Array.isArray(entry.command) && entry.command.length > 0) {
+    config.command = entry.command[0];
+    if (entry.command.length > 1) config.args = entry.command.slice(1);
+  } else if (typeof entry.command === "string") {
+    config.command = entry.command;
+  }
+  if (isRecord3(entry.environment)) {
+    const env = {};
+    for (const [k, v] of Object.entries(entry.environment)) {
+      if (typeof v === "string")
+        env[k] = v.replace(/\{env:([^}]+)\}/g, (_, n) => `\${${n}}`);
+    }
+    config.env = env;
+  }
+  return config;
+}
+function convertOpenCodeRemote(entry) {
+  const config = {};
+  config.url = entry.url;
+  if (isStringRecord2(entry.headers)) config.headers = entry.headers;
+  return config;
+}
+function importOpenCode(text, names) {
+  const result = { servers: [], errors: [] };
+  const { parsed, error } = tryParse(text);
+  if (error) {
+    result.errors.push(error);
+    return result;
+  }
+  if (!isRecord3(parsed)) {
+    result.errors.push("expected an object");
+    return result;
+  }
+  const mcpServers = parsed.mcpServers ?? parsed.mcp;
+  if (!isRecord3(mcpServers)) {
+    result.errors.push("no mcp servers found");
+    return result;
+  }
+  for (const [name, entry] of filterNames(Object.entries(mcpServers), names)) {
+    if (!isRecord3(entry)) {
+      result.errors.push(`${name}: not an object`);
+      continue;
+    }
+    const isLocal = entry.type === "local" || entry.command;
+    const config = isLocal ? convertOpenCodeLocal(entry) : convertOpenCodeRemote(entry);
+    result.servers.push({ name, config });
+  }
+  return result;
+}
+function detectFormat(text, filename) {
+  if (filename.endsWith(".toml")) return "codex";
+  if (filename.includes("servers.json")) return "six";
+  if (filename.includes(".vscode")) return "vscode";
+  try {
+    const parsed = JSON.parse(text);
+    if (isRecord3(parsed)) {
+      if (parsed.servers && isRecord3(parsed.servers) && parsed.version !== void 0) return "six";
+      if (parsed.servers && isRecord3(parsed.servers)) return "vscode";
+      if (parsed.mcpServers) return "claude";
+      if (parsed.mcp) return "opencode";
+    }
+  } catch {
+  }
+  if (text.includes("[mcp_servers.")) return "codex";
+  return "claude";
+}
+function importFile(text, filename, names) {
+  const format = detectFormat(text, filename);
+  switch (format) {
+    case "claude":
+      return importClaude(text, names);
+    case "vscode":
+      return importVSCode(text, names);
+    case "six":
+      return importSixServers(text, names);
+    case "codex":
+      return importCodexToml(text, names);
+    case "opencode":
+      return importOpenCode(text, names);
+    default:
+      return importClaude(text, names);
+  }
+}
+
+// src/config/warnings.ts
+var SECRET_HEADER = /authorization|cookie|token|key|secret|password|session/i;
+var PLACEHOLDER = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+var SCHEME = /^\s*(?:bearer|basic|token|apikey|api-key)\s+/i;
+var SECRET_PARAM = /token|key|secret|password|signature|sig|auth|code/i;
+function literalSecret(header, value) {
+  if (!SECRET_HEADER.test(header)) return false;
+  return value.replace(PLACEHOLDER, "").replace(SCHEME, "").trim() !== "";
+}
+function urlHasSecret(url) {
+  if (!URL.canParse(url)) return void 0;
+  const parsed = new URL(url);
+  if (parsed.username || parsed.password) return "url";
+  for (const name of parsed.searchParams.keys()) if (SECRET_PARAM.test(name)) return `url ?${name}`;
+  return void 0;
+}
+var SLICC_OAUTH_REFUSED = {
+  clientSecret: "a client secret would have to live in mcp.json; SLICC signs in as a public client",
+  callbackPort: "SLICC signs in through its own page, not a loopback port",
+  callbackUrl: "SLICC signs in through its own page, not a loopback URL",
+  clientRegistration: "SLICC registers dynamically or uses oauth.clientId"
+};
+function checkAgentWarnings(name, config) {
+  const warnings = [];
+  if ("command" in config && config.command) {
+    warnings.push({
+      server: name,
+      message: "stdio servers need slicc-kernel#68, so the agent will skip this entry",
+      advice: "use mcpcat serve --proxy to bridge it as HTTP"
+    });
+  }
+  if ("headers" in config && config.headers) {
+    for (const [h, v] of Object.entries(config.headers)) {
+      if (v.trim().startsWith("!")) {
+        warnings.push({
+          server: name,
+          message: `headers.${h} runs a command, which the agent can't do`,
+          advice: "use ${NAME} and set the value in Settings > MCP servers"
+        });
+      }
+      if (literalSecret(h, v)) {
+        warnings.push({
+          server: name,
+          message: `headers.${h} holds a literal secret`,
+          advice: "write ${NAME} instead, and add the value in Settings > MCP servers"
+        });
+      }
+    }
+  }
+  if ("url" in config && config.url) {
+    const secret = urlHasSecret(config.url);
+    if (secret) {
+      warnings.push({
+        server: name,
+        message: `${secret} holds a literal secret`,
+        advice: "put it in a header as ${NAME}"
+      });
+    }
+  }
+  if ("oauth" in config && config.oauth) {
+    for (const key of Object.keys(config.oauth)) {
+      const reason = SLICC_OAUTH_REFUSED[key];
+      if (reason) {
+        warnings.push({
+          server: name,
+          message: `oauth.${key} is not supported by the agent: ${reason}`,
+          advice: `remove oauth.${key}`
+        });
+      }
+    }
+  }
+  return warnings;
+}
+
+// src/cli/config-verbs.ts
+function parseHeader(hdr) {
+  const colonIdx = hdr.indexOf(":");
+  if (colonIdx < 1) return `invalid header '${hdr}'`;
+  return [hdr.slice(0, colonIdx).trim(), hdr.slice(colonIdx + 1).trim()];
+}
+function parseEnvPair(pair) {
+  const eqIdx = pair.indexOf("=");
+  if (eqIdx < 1) return `invalid --env '${pair}'`;
+  return [pair.slice(0, eqIdx), pair.slice(eqIdx + 1)];
+}
+function parseAddFlagAt(flagArgs, i, flags) {
+  const arg = flagArgs[i];
+  if (arg === "-l" || arg === "--local") {
+    flags.local = true;
+    return { next: i + 1 };
+  }
+  if (arg === "--no-probe") {
+    flags.noProbe = true;
+    return { next: i + 1 };
+  }
+  if (arg === "--config" && i + 1 < flagArgs.length) {
+    flags.configFile = flagArgs[i + 1];
+    return { next: i + 2 };
+  }
+  if (arg === "--description" && i + 1 < flagArgs.length) {
+    flags.description = flagArgs[i + 1];
+    return { next: i + 2 };
+  }
+  if (arg === "--exposure" && i + 1 < flagArgs.length) {
+    flags.exposure = flagArgs[i + 1];
+    return { next: i + 2 };
+  }
+  if ((arg === "-H" || arg === "--header") && i + 1 < flagArgs.length) {
+    const result = parseHeader(flagArgs[i + 1]);
+    if (typeof result === "string") return { next: i + 2, error: result };
+    flags.headers.push(result);
+    return { next: i + 2 };
+  }
+  if (arg === "--env" && i + 1 < flagArgs.length) {
+    const result = parseEnvPair(flagArgs[i + 1]);
+    if (typeof result === "string") return { next: i + 2, error: result };
+    flags.envPairs.push(result);
+    return { next: i + 2 };
+  }
+  if (arg === "--cwd" && i + 1 < flagArgs.length) {
+    flags.cwd = flagArgs[i + 1];
+    return { next: i + 2 };
+  }
+  if (arg.startsWith("-")) return { next: i + 1, error: `unknown option '${arg}'` };
+  flags.positional.push(arg);
+  return { next: i + 1 };
+}
+function parseAddFlags(args2) {
+  const flags = {
+    local: false,
+    noProbe: false,
+    headers: [],
+    envPairs: [],
+    positional: [],
+    cmdArgs: []
+  };
+  const dashDashIdx = args2.indexOf("--");
+  const flagArgs = dashDashIdx >= 0 ? args2.slice(0, dashDashIdx) : args2;
+  flags.cmdArgs = dashDashIdx >= 0 ? args2.slice(dashDashIdx + 1) : [];
+  let i = 0;
+  while (i < flagArgs.length) {
+    const step = parseAddFlagAt(flagArgs, i, flags);
+    if (step.error) return step.error;
+    i = step.next;
+  }
+  return flags;
+}
+function buildStdioConfig(flags) {
+  const config = {
+    command: flags.cmdArgs[0],
+    ...flags.cmdArgs.length > 1 ? { args: flags.cmdArgs.slice(1) } : {}
+  };
+  if (flags.envPairs.length > 0) {
+    const env = {};
+    for (const [k, v] of flags.envPairs) env[k] = v;
+    config.env = env;
+  }
+  if (flags.cwd) config.cwd = flags.cwd;
+  if (flags.description) config.description = flags.description;
+  if (flags.exposure) config.exposure = flags.exposure;
+  return config;
+}
+function buildHttpConfig(urlStr, flags) {
+  const config = { url: urlStr };
+  if (flags.headers.length > 0) {
+    const hdrs = {};
+    for (const [k, v] of flags.headers) {
+      if (literalSecret(k, v)) return `header '${k}' holds a literal secret; use \${NAME} instead`;
+      hdrs[k] = v;
+    }
+    config.headers = hdrs;
+  }
+  if (flags.description) config.description = flags.description;
+  if (flags.exposure) config.exposure = flags.exposure;
+  return config;
+}
+async function runAdd(platform2, args2, probe) {
+  const flags = parseAddFlags(args2);
+  if (typeof flags === "string") {
+    await platform2.write(2, `mcpcat add: ${flags}
+`);
+    return 2;
+  }
+  if (flags.positional.length < 1) {
+    await platform2.write(2, "mcpcat add: requires a server name\n");
+    return 2;
+  }
+  let name;
+  let config;
+  if (flags.cmdArgs.length > 0) {
+    name = flags.positional[0];
+    config = buildStdioConfig(flags);
+  } else if (flags.positional.length >= 2) {
+    let urlStr;
+    if (URL.canParse(flags.positional[0]) && !URL.canParse(flags.positional[1])) {
+      urlStr = flags.positional[0];
+      name = flags.positional[1];
+    } else {
+      name = flags.positional[0];
+      urlStr = flags.positional[1];
+    }
+    if (!URL.canParse(urlStr)) {
+      await platform2.write(2, `mcpcat add: '${urlStr}' is not a valid URL
+`);
+      return 2;
+    }
+    const secret = urlHasSecret(urlStr);
+    if (secret) {
+      await platform2.write(
+        2,
+        `mcpcat add: ${secret} holds a literal secret; use \${NAME} in a header instead
+`
+      );
+      return 2;
+    }
+    const httpResult = buildHttpConfig(urlStr, flags);
+    if (typeof httpResult === "string") {
+      await platform2.write(2, `mcpcat add: ${httpResult}
+`);
+      return 2;
+    }
+    config = httpResult;
+  } else {
+    await platform2.write(2, "mcpcat add: requires a URL or -- <command>\n");
+    return 2;
+  }
+  const validation = validateServer(name, config);
+  if ("message" in validation) {
+    await platform2.write(2, `mcpcat add: ${validation.message}
+`);
+    return 2;
+  }
+  const path = flags.configFile ?? (flags.local ? projectConfigPath(platform2) : userConfigPath(platform2));
+  const { replaced } = await addServer(platform2.fs, path, name, config);
+  const warnings = checkAgentWarnings(name, config);
+  for (const w of warnings) {
+    await platform2.write(2, `mcpcat add: warning: ${w.message}; ${w.advice}
+`);
+  }
+  await platform2.write(1, `${replaced ? "replaced" : "added"} ${name} in ${path}
+`);
+  if (!flags.noProbe && probe) {
+    const reason = await probe(name, config, platform2);
+    if (reason) {
+      await platform2.write(2, `mcpcat add: probe failed: ${reason}
+`);
+      return 3;
+    }
+  }
+  return 0;
+}
+async function runRm(platform2, args2) {
+  let configFile;
+  let local = false;
+  const names = [];
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "--config" && i + 1 < args2.length) {
+      configFile = args2[++i];
+      continue;
+    }
+    if (arg === "-l" || arg === "--local") {
+      local = true;
+      continue;
+    }
+    if (arg === "--logout") continue;
+    if (arg.startsWith("-")) {
+      await platform2.write(2, `mcpcat rm: unknown option '${arg}'
+`);
+      return 2;
+    }
+    names.push(arg);
+  }
+  if (names.length === 0) {
+    await platform2.write(2, "mcpcat rm: requires a server name\n");
+    return 2;
+  }
+  const path = configFile ?? (local ? projectConfigPath(platform2) : userConfigPath(platform2));
+  for (const name of names) {
+    const removed = await removeServer(platform2.fs, path, name);
+    if (!removed) {
+      await platform2.write(2, `mcpcat rm: '${name}' not found in ${path}
+`);
+      return 1;
+    }
+    await platform2.write(1, `removed ${name} from ${path}
+`);
+  }
+  return 0;
+}
+function formatListEntry(entry) {
+  const c = entry.config;
+  const transport = "url" in c ? "http" : "stdio";
+  const target = "url" in c ? c.url : c.command;
+  const enabled = "enabled" in c && c.enabled === false ? " (disabled)" : "";
+  const exp = c.exposure ? ` [${c.exposure}]` : "";
+  return `${entry.name}  ${transport}  ${target}${enabled}${exp}  (${entry.source})`;
+}
+async function printListJson(platform2, config) {
+  const entries = {};
+  for (const entry of config.servers) {
+    entries[entry.name] = {
+      ...entry.config,
+      source: entry.source,
+      ...entry.scope ? { scope: entry.scope } : {},
+      ...entry.override ? { override: entry.override } : {}
+    };
+  }
+  await platform2.write(1, `${JSON.stringify(entries, null, 2)}
+`);
+}
+async function printListText(platform2, config) {
+  if (config.servers.length === 0 && config.problems.length === 0) {
+    await platform2.write(1, "no servers configured\n");
+    return;
+  }
+  for (const entry of config.servers) {
+    await platform2.write(1, `${formatListEntry(entry)}
+`);
+  }
+}
+async function runList(platform2, args2) {
+  let json = false;
+  let configFile;
+  let trustProject = false;
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--config" && i + 1 < args2.length) {
+      configFile = args2[++i];
+      continue;
+    }
+    if (arg === "--trust-project") {
+      trustProject = true;
+    }
+  }
+  const source = await MergedConfigSource.load(platform2, { trustProject, configFile });
+  const { config } = source;
+  if (json) {
+    await printListJson(platform2, config);
+  } else {
+    await printListText(platform2, config);
+  }
+  let hasProblems = false;
+  for (const p of config.problems) {
+    hasProblems = true;
+    const prefix = p.server ? `${p.server}: ` : "";
+    await platform2.write(2, `mcpcat list: ${prefix}${p.message}
+`);
+  }
+  return hasProblems ? 1 : 0;
+}
+async function runEnable(platform2, args2, enable) {
+  let configFile;
+  let local = false;
+  const names = [];
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "--config" && i + 1 < args2.length) {
+      configFile = args2[++i];
+      continue;
+    }
+    if (arg === "-l" || arg === "--local") {
+      local = true;
+      continue;
+    }
+    if (arg.startsWith("-")) continue;
+    names.push(arg);
+  }
+  if (names.length === 0) {
+    await platform2.write(2, `mcpcat ${enable ? "enable" : "disable"}: requires a server name
+`);
+    return 2;
+  }
+  const path = configFile ?? (local ? projectConfigPath(platform2) : userConfigPath(platform2));
+  for (const name of names) {
+    const ok = await updateServer(platform2.fs, path, name, { enabled: enable });
+    if (!ok) {
+      await platform2.write(
+        2,
+        `mcpcat ${enable ? "enable" : "disable"}: '${name}' not found in ${path}
+`
+      );
+      return 1;
+    }
+    await platform2.write(1, `${enable ? "enabled" : "disabled"} ${name} in ${path}
+`);
+  }
+  return 0;
+}
+async function runExposure(platform2, args2) {
+  let configFile;
+  let local = false;
+  let toolGlob;
+  const positional = [];
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "--config" && i + 1 < args2.length) {
+      configFile = args2[++i];
+      continue;
+    }
+    if (arg === "-l" || arg === "--local") {
+      local = true;
+      continue;
+    }
+    if (arg === "--tool" && i + 1 < args2.length) {
+      toolGlob = args2[++i];
+      continue;
+    }
+    if (arg.startsWith("-")) continue;
+    positional.push(arg);
+  }
+  if (positional.length < 2) {
+    await platform2.write(2, "mcpcat exposure: requires <name> <mode>\n");
+    return 2;
+  }
+  const [name, mode] = positional;
+  const validModes = ["codemode", "deferred", "direct", "hidden"];
+  if (!validModes.includes(mode)) {
+    await platform2.write(2, `mcpcat exposure: mode must be one of ${validModes.join(", ")}
+`);
+    return 2;
+  }
+  const path = configFile ?? (local ? projectConfigPath(platform2) : userConfigPath(platform2));
+  const ok = await setExposure(platform2.fs, path, name, mode, toolGlob);
+  if (!ok) {
+    await platform2.write(2, `mcpcat exposure: '${name}' not found in ${path}
+`);
+    return 1;
+  }
+  const what = toolGlob ? `${name} tool ${toolGlob}` : name;
+  await platform2.write(1, `set ${what} to ${mode} in ${path}
+`);
+  return 0;
+}
+async function runImport(platform2, args2) {
+  let configFile;
+  let local = false;
+  const positional = [];
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "--config" && i + 1 < args2.length) {
+      configFile = args2[++i];
+      continue;
+    }
+    if (arg === "-l" || arg === "--local") {
+      local = true;
+      continue;
+    }
+    if (arg.startsWith("-")) continue;
+    positional.push(arg);
+  }
+  if (positional.length < 1) {
+    await platform2.write(2, "mcpcat import: requires a file path\n");
+    return 2;
+  }
+  const filePath = positional[0];
+  const names = positional.slice(1);
+  let text;
+  try {
+    const data = await platform2.fs.readFile(filePath);
+    text = new TextDecoder().decode(data);
+  } catch {
+    await platform2.write(2, `mcpcat import: cannot read '${filePath}'
+`);
+    return 2;
+  }
+  const result = importFile(text, filePath, names.length > 0 ? names : void 0);
+  for (const err of result.errors) {
+    await platform2.write(2, `mcpcat import: ${err}
+`);
+  }
+  if (result.servers.length === 0) {
+    await platform2.write(2, "mcpcat import: no servers found\n");
+    return 1;
+  }
+  const destPath = configFile ?? (local ? projectConfigPath(platform2) : userConfigPath(platform2));
+  for (const { name, config } of result.servers) {
+    const validation = validateServer(name, config);
+    if ("message" in validation) {
+      await platform2.write(2, `mcpcat import: ${name}: ${validation.message}
+`);
+      continue;
+    }
+    const { replaced } = await addServer(platform2.fs, destPath, name, config);
+    await platform2.write(1, `${replaced ? "replaced" : "imported"} ${name}
+`);
+  }
+  return 0;
+}
 
 // src/cli/main.ts
 var VERBS = [
   "info",
   "tools",
+  "ls",
   "call",
   "describe",
   "resources",
@@ -28,6 +3331,31 @@ var VERBS = [
   "inbox",
   "help"
 ];
+var CONFIG_VERBS = {
+  add: true,
+  rm: true,
+  list: true,
+  enable: true,
+  disable: true,
+  exposure: true,
+  import: true
+};
+var UNIMPLEMENTED_VERBS = /* @__PURE__ */ new Set([
+  "resources",
+  "read",
+  "prompts",
+  "prompt",
+  "grep",
+  "complete",
+  "task",
+  "login",
+  "logout",
+  "serve",
+  "code",
+  "discover",
+  "inbox"
+]);
+var CLIENT_VERBS = /* @__PURE__ */ new Set(["info", "tools", "call", "describe"]);
 function helpText(version) {
   return `mcpcat ${version} \u2013 a curl for the Model Context Protocol
 
@@ -35,25 +3363,18 @@ Usage: mcpcat [options] <target> [<tool> [args\u2026]]
        mcpcat [options] <verb> \u2026
 
 Client verbs:
-  info <target>              Server identity and capabilities (not implemented yet)
-  tools <target>             List tools (not implemented yet)
-  call <target> <tool>       Call a tool (not implemented yet)
-  describe <target> [tool]   Tool schema and help (not implemented yet)
-  resources <target>         List resources (not implemented yet)
-  read <target> <uri>        Read a resource (not implemented yet)
-  prompts <target>           List prompts (not implemented yet)
-  prompt <target> <name>     Render a prompt (not implemented yet)
-  grep <pattern>             Search across servers (not implemented yet)
-  complete <target> \u2026        Completion (not implemented yet)
-  task get|cancel \u2026          Task extension (not implemented yet)
+  info <target>              Server identity and capabilities
+  tools <target>             List tools
+  call <target> <tool>       Call a tool
+  describe <target> [tool]   Tool schema and help
 
 Configuration verbs:
-  add <name> <url>           Add a server to mcp.json (not implemented yet)
-  rm <name>                  Remove a server (not implemented yet)
-  list                       List configured servers (not implemented yet)
-  enable|disable <name>      Toggle a server (not implemented yet)
-  exposure <name> <mode>     Set exposure mode (not implemented yet)
-  import <file>              Import from other configs (not implemented yet)
+  add <name> <url>           Add a server to mcp.json
+  rm <name>                  Remove a server
+  list                       List configured servers
+  enable|disable <name>      Toggle a server
+  exposure <name> <mode>     Set exposure mode
+  import <file>              Import from other configs
   login <target>             OAuth sign-in (not implemented yet)
   logout <target>            Remove tokens (not implemented yet)
 
@@ -67,7 +3388,10 @@ Server and code verbs:
 Options:
   --json                     JSON output
   -H, --header 'N: V'       Extra header
+  -d <json>                  Tool arguments as JSON (or @file, @- for stdin)
   -m, --timeout <s>          Request timeout (default 60)
+  --protocol-version <v>     Pin protocol version
+  --schema                   Print raw JSON Schema (describe)
   -v, --verbose              Trace on stderr
   -s, --silent               Suppress progress
   -o, --output <path>        Write result to file
@@ -75,6 +3399,289 @@ Options:
   -h, --help                 Show this help
 `;
 }
+function parseFlags(args2) {
+  const headers = {};
+  let dataArg;
+  let protocolVersion;
+  let showSchema = false;
+  const positional = [];
+  let trailingCommand;
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "--") {
+      trailingCommand = args2.slice(i + 1);
+      break;
+    }
+    if ((arg === "-H" || arg === "--header") && args2[i + 1]) {
+      const val = args2[++i];
+      const colonIdx = val.indexOf(":");
+      if (colonIdx > 0) {
+        headers[val.slice(0, colonIdx).trim()] = val.slice(colonIdx + 1).trim();
+      }
+    } else if (arg === "-d" && args2[i + 1]) {
+      dataArg = args2[++i];
+    } else if (arg === "--protocol-version" && args2[i + 1]) {
+      protocolVersion = args2[++i];
+    } else if (arg === "--schema") {
+      showSchema = true;
+    } else if (!arg.startsWith("-")) {
+      positional.push(arg);
+    }
+  }
+  return { headers, dataArg, protocolVersion, showSchema, positional, trailingCommand };
+}
+function resolveVerb(positional, trailingCommand) {
+  let verb;
+  let target;
+  let toolName;
+  if (positional.length >= 1 && VERBS.includes(positional[0])) {
+    verb = positional[0];
+    if (verb === "ls") verb = "tools";
+    target = positional[1];
+    toolName = positional[2];
+  } else if (positional.length >= 2) {
+    target = positional[0];
+    toolName = positional[1];
+    verb = "call";
+  } else if (positional.length === 1) {
+    target = positional[0];
+    verb = "info";
+  }
+  if (!target && trailingCommand && trailingCommand.length > 0) {
+    target = "__trailing__";
+  }
+  return {
+    verb,
+    target,
+    toolName,
+    dataArg: void 0,
+    headers: {},
+    protocolVersion: void 0,
+    showSchema: false,
+    trailingCommand
+  };
+}
+function parseArgs(args2) {
+  const flags = parseFlags(args2);
+  const resolved = resolveVerb(flags.positional, flags.trailingCommand);
+  return {
+    ...resolved,
+    headers: flags.headers,
+    dataArg: flags.dataArg,
+    protocolVersion: flags.protocolVersion,
+    showSchema: flags.showSchema
+  };
+}
+function formatToolLine(tool) {
+  const desc = tool.description ? `  ${tool.description}` : "";
+  return `${tool.name}${desc}`;
+}
+function formatToolSchema(tool) {
+  const lines = [];
+  lines.push(`${tool.name}`);
+  if (tool.description) lines.push(`  ${tool.description}`);
+  if (tool.inputSchema) {
+    lines.push("  Input schema:");
+    lines.push(`    ${JSON.stringify(tool.inputSchema, null, 2).split("\n").join("\n    ")}`);
+  }
+  const annotations = tool.annotations;
+  if (annotations) {
+    lines.push("  Annotations:");
+    for (const [k, v] of Object.entries(annotations)) {
+      lines.push(`    ${k}: ${JSON.stringify(v)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function renderCallResult(result) {
+  const parts = [];
+  if (result.content) {
+    for (const block of result.content) {
+      if (block.type === "text") parts.push(block.text);
+      else if (block.type === "image")
+        parts.push(`[image: ${block.mimeType}, ${Math.ceil(block.data.length * 3 / 4)} bytes]`);
+      else if (block.type === "resource_link") parts.push(`[resource: ${block.uri}]`);
+      else if (block.type === "resource") {
+        parts.push(
+          "text" in block.resource ? block.resource.text : `[blob: ${block.resource.uri}]`
+        );
+      }
+    }
+  }
+  if (parts.length === 0 && result.structuredContent !== void 0) {
+    parts.push(JSON.stringify(result.structuredContent, null, 2));
+  }
+  return parts.join("\n");
+}
+async function readDataArg(platform2, dataArg) {
+  let raw;
+  if (dataArg.startsWith("@-")) {
+    const reader = platform2.stdin.getReader();
+    const chunks = [];
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+    reader.releaseLock();
+    const total = chunks.reduce((s, c) => s + c.length, 0);
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const c of chunks) {
+      merged.set(c, offset);
+      offset += c.length;
+    }
+    raw = new TextDecoder().decode(merged);
+  } else if (dataArg.startsWith("@")) {
+    const data = await platform2.fs.readFile(dataArg.slice(1));
+    raw = new TextDecoder().decode(data);
+  } else {
+    raw = dataArg;
+  }
+  return JSON.parse(raw);
+}
+async function runInfo(platform2, conn) {
+  const info = await conn.info();
+  const lines = [];
+  if (info.name) lines.push(`Server: ${info.name}${info.version ? ` ${info.version}` : ""}`);
+  if (info.title) lines.push(`Title: ${info.title}`);
+  lines.push(`Protocol: ${info.protocolVersion}`);
+  if (info.instructions) lines.push(`Instructions: ${info.instructions}`);
+  const caps = Object.keys(info.capabilities).filter(
+    (k) => info.capabilities[k] != null && info.capabilities[k] !== false
+  );
+  if (caps.length > 0) lines.push(`Capabilities: ${caps.join(", ")}`);
+  try {
+    const tools = await conn.listTools();
+    lines.push(`Tools: ${tools.length}`);
+  } catch {
+  }
+  await platform2.write(1, `${lines.join("\n")}
+`);
+  return 0;
+}
+async function runTools(platform2, conn) {
+  const tools = await conn.listTools();
+  if (tools.length === 0) {
+    await platform2.write(1, "(no tools)\n");
+  } else {
+    await platform2.write(1, `${tools.map(formatToolLine).join("\n")}
+`);
+  }
+  return 0;
+}
+async function runCall(platform2, conn, toolName, dataArg) {
+  let toolArgs = {};
+  if (dataArg) {
+    try {
+      toolArgs = await readDataArg(platform2, dataArg);
+    } catch (err) {
+      await platform2.write(2, `mcpcat: invalid -d argument: ${err.message}
+`);
+      return 2;
+    }
+  }
+  const result = await conn.callTool(toolName, toolArgs);
+  const output = renderCallResult(result);
+  if (result.isError) {
+    await platform2.write(2, `${output}
+`);
+    return 1;
+  }
+  await platform2.write(1, `${output}
+`);
+  return 0;
+}
+async function runDescribe(platform2, conn, toolName, showSchema) {
+  const tools = await conn.listTools();
+  if (toolName) {
+    const tool = tools.find((t) => t.name === toolName);
+    if (!tool) {
+      await platform2.write(2, `mcpcat: tool '${toolName}' not found
+`);
+      return 2;
+    }
+    if (showSchema && tool.inputSchema) {
+      await platform2.write(1, `${JSON.stringify(tool.inputSchema, null, 2)}
+`);
+    } else {
+      await platform2.write(1, `${formatToolSchema(tool)}
+`);
+    }
+  } else {
+    for (const tool of tools) {
+      await platform2.write(1, `${formatToolSchema(tool)}
+
+`);
+    }
+  }
+  return 0;
+}
+async function runVerb(platform2, parsed, conn) {
+  switch (parsed.verb) {
+    case "info":
+      return runInfo(platform2, conn);
+    case "tools":
+      return runTools(platform2, conn);
+    case "call":
+      return runCall(platform2, conn, parsed.toolName, parsed.dataArg);
+    case "describe":
+      return runDescribe(platform2, conn, parsed.toolName, parsed.showSchema);
+    default:
+      await platform2.write(2, `mcpcat: unknown command '${parsed.verb}'
+`);
+      return 2;
+  }
+}
+async function probeServer(_name, config, platform2) {
+  try {
+    const opts = { version: "probe" };
+    if ("url" in config && config.url) {
+      opts.url = config.url;
+      if ("headers" in config) opts.headers = config.headers;
+    } else if ("command" in config && config.command) {
+      opts.command = config.command;
+      if ("args" in config) opts.args = config.args;
+      if ("env" in config) opts.env = config.env;
+      if ("cwd" in config) opts.cwd = config.cwd;
+    } else {
+      return void 0;
+    }
+    const conn = await connect(platform2, opts);
+    try {
+      await conn.info();
+    } finally {
+      try {
+        await conn.close();
+      } catch {
+      }
+    }
+    return void 0;
+  } catch (err) {
+    return err.message;
+  }
+}
+async function dispatchConfigVerb(platform2, verb, args2) {
+  const rest = args2.slice(1);
+  switch (verb) {
+    case "add":
+      return runAdd(platform2, rest, probeServer);
+    case "rm":
+      return runRm(platform2, rest);
+    case "list":
+      return runList(platform2, rest);
+    case "enable":
+      return runEnable(platform2, rest, true);
+    case "disable":
+      return runEnable(platform2, rest, false);
+    case "exposure":
+      return runExposure(platform2, rest);
+    case "import":
+      return runImport(platform2, rest);
+    default:
+      return 1;
+  }
+}
 async function run(platform2, version, args2) {
   if (args2.includes("--version") || args2.includes("-V")) {
     await platform2.write(1, `${version}
@@ -89,21 +3696,82 @@ async function run(platform2, version, args2) {
     await platform2.write(1, helpText(version));
     return 0;
   }
-  const verb = args2[0];
-  if (VERBS.includes(verb)) {
-    await platform2.write(2, `mcpcat: '${verb}' is not implemented yet
+  const parsed = parseArgs(args2);
+  if (!parsed.verb) {
+    await platform2.write(2, "mcpcat: no verb or target given\n");
+    return 2;
+  }
+  if (parsed.verb in CONFIG_VERBS) {
+    return dispatchConfigVerb(platform2, parsed.verb, args2);
+  }
+  if (UNIMPLEMENTED_VERBS.has(parsed.verb)) {
+    await platform2.write(2, `mcpcat: '${parsed.verb}' is not implemented yet
 `);
     return 1;
   }
-  await platform2.write(2, `mcpcat: unknown command '${verb}'
+  if (!CLIENT_VERBS.has(parsed.verb)) {
+    await platform2.write(2, `mcpcat: unknown command '${parsed.verb}'
+`);
+    return 2;
+  }
+  if (parsed.verb === "call" && !parsed.toolName) {
+    await platform2.write(2, "mcpcat: call requires a tool name\n");
+    return 2;
+  }
+  if (!parsed.target) {
+    await platform2.write(2, `mcpcat: ${parsed.verb} requires a target
+`);
+    return 2;
+  }
+  const config = await MergedConfigSource.load(platform2);
+  let resolved;
+  try {
+    resolved = await resolveTarget(
+      parsed.target === "__trailing__" ? "" : parsed.target,
+      parsed.trailingCommand,
+      config
+    );
+  } catch (err) {
+    await platform2.write(2, `mcpcat: ${err.message}
+`);
+    return 2;
+  }
+  let conn;
+  try {
+    conn = await connect(platform2, {
+      ...resolved,
+      headers: { ...resolved.headers, ...parsed.headers },
+      protocolVersion: parsed.protocolVersion,
+      version
+    });
+  } catch (err) {
+    await platform2.write(2, `mcpcat: connection failed: ${err.message}
+`);
+    return 3;
+  }
+  try {
+    return await runVerb(platform2, parsed, conn);
+  } catch (err) {
+    if (err instanceof InputRequiredError) {
+      await platform2.write(2, `${err.requestJson}
 `);
-  return 2;
+      return 6;
+    }
+    await platform2.write(2, `mcpcat: ${err.message}
+`);
+    return 5;
+  } finally {
+    try {
+      await conn.close();
+    } catch {
+    }
+  }
 }
 
 // src/platform/host.ts
 import { spawn as cpSpawn } from "node:child_process";
 import { constants } from "node:fs";
-import { access, mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { access, mkdir, readFile as readFile2, rename, rmdir, stat, writeFile } from "node:fs/promises";
 import { Readable, Writable } from "node:stream";
 import * as tty from "node:tty";
 function nodeSpawn(options) {
@@ -146,7 +3814,7 @@ function signalNumber(sig) {
 }
 var hostFs = {
   async readFile(path) {
-    return new Uint8Array(await readFile(path));
+    return new Uint8Array(await readFile2(path));
   },
   async writeFile(path, data) {
     await writeFile(path, data);
@@ -168,6 +3836,12 @@ var hostFs = {
     } catch {
       return false;
     }
+  },
+  async mkdirExclusive(path) {
+    await mkdir(path, { recursive: false });
+  },
+  async rmdir(path) {
+    await rmdir(path);
   }
 };
 function createStdinStream() {
@@ -209,5 +3883,5 @@ function createHostPlatform() {
 // src/host.ts
 var platform = createHostPlatform();
 var args = process.argv.slice(2);
-var code = await run(platform, "0.1.0", args);
+var code = await run(platform, "0.3.0", args);
 process.exit(code);