@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-55RMDDFM.js

@@ -0,0 +1,1347 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  buildSafeToolEnv,
+  resolveSafeCwd
+} from "./chunk-M2IPMWCN.js";
+import {
+  clampTimerDelayMs,
+  sleep
+} from "./chunk-6EXUUOSN.js";
+import {
+  clioConfigDir
+} from "./chunk-CTTI7G3T.js";
+import {
+  safeResourceWrite
+} from "./chunk-ZZFWWYLX.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/gateway/mcp/trust.ts
+init_esm_shims();
+import { realpathSync as realpathSync2 } from "node:fs";
+import path2 from "node:path";
+
+// src/domains/gateway/mcp/config.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { createHash } from "node:crypto";
+import { closeSync, constants as fsConstants, fstatSync, openSync, readSync, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+var MCP_CONFIG_VERSION = 1;
+var MCP_USER_CONFIG_FILENAME = "mcp.yaml";
+var MCP_PROJECT_CONFIG_RELATIVE_PATH = ".clio-coder/mcp.yaml";
+var MCP_CONFIG_CAPS = Object.freeze({
+  fileBytes: 256 * 1024,
+  servers: 32,
+  idChars: 32,
+  commandBytes: 512,
+  args: 64,
+  argBytes: 4096,
+  envEntries: 64,
+  envValueBytes: 4096,
+  cwdBytes: 512,
+  timeoutMs: 9e5
+});
+var ID_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
+var ENV_KEY_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
+var ROOT_FIELDS = /* @__PURE__ */ new Set(["version", "servers"]);
+var SERVER_FIELDS = /* @__PURE__ */ new Set(["id", "command", "args", "cwd", "env", "timeoutMs"]);
+var SHELL_EXECUTABLES = /* @__PURE__ */ new Set([
+  "bash",
+  "cmd",
+  "command.com",
+  "dash",
+  "fish",
+  "ksh",
+  "powershell",
+  "pwsh",
+  "sh",
+  "tcsh",
+  "zsh"
+]);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function utf8Bytes(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+function unknownFields(record, allowed) {
+  return Object.keys(record).filter((key) => !allowed.has(key)).sort();
+}
+function mcpServerDigest(fields) {
+  const canonical = JSON.stringify({
+    id: fields.id,
+    command: fields.command,
+    args: [...fields.args],
+    cwd: fields.cwd,
+    env: Object.fromEntries(
+      Object.keys(fields.env).sort().map((key) => [key, fields.env[key]])
+    ),
+    timeoutMs: fields.timeoutMs
+  });
+  return createHash("sha256").update(canonical).digest("hex");
+}
+function mcpConfigPaths(options) {
+  return {
+    user: path.join(options.configDir ?? clioConfigDir(), MCP_USER_CONFIG_FILENAME),
+    project: path.join(path.resolve(options.cwd), MCP_PROJECT_CONFIG_RELATIVE_PATH)
+  };
+}
+function validateId(value, location) {
+  if (typeof value !== "string" || value.length === 0) return new Error(`${location} must be a non-empty string`);
+  if (value.length > MCP_CONFIG_CAPS.idChars) {
+    return new Error(`${location} exceeds the ${MCP_CONFIG_CAPS.idChars}-character cap`);
+  }
+  if (!ID_PATTERN.test(value)) return new Error(`${location} must match /^[a-z0-9][a-z0-9_-]*$/`);
+  return value;
+}
+function validateCommand(value, location) {
+  if (typeof value !== "string" || value.length === 0) return new Error(`${location} must be a non-empty string`);
+  if (value.includes("\0")) return new Error(`${location} must not contain a NUL byte`);
+  if (/\s/u.test(value)) return new Error(`${location} must be one executable token, not a shell command string`);
+  if (utf8Bytes(value) > MCP_CONFIG_CAPS.commandBytes) {
+    return new Error(`${location} exceeds the ${MCP_CONFIG_CAPS.commandBytes}-byte cap`);
+  }
+  const hasSeparator = value.includes("/") || value.includes("\\");
+  if (hasSeparator && !(path.isAbsolute(value) || path.win32.isAbsolute(value))) {
+    return new Error(
+      `${location} must be an executable name resolved on PATH or an absolute path; relative path '${value}' is not allowed`
+    );
+  }
+  const executable = path.basename(value).toLowerCase().replace(/\.exe$/u, "");
+  if (SHELL_EXECUTABLES.has(executable)) {
+    return new Error(`${location} may not invoke shell executable '${value}'`);
+  }
+  return value;
+}
+function validateArgs(value, location) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) return new Error(`${location} must be an array of strings`);
+  if (value.length > MCP_CONFIG_CAPS.args) return new Error(`${location} exceeds the ${MCP_CONFIG_CAPS.args}-entry cap`);
+  const args = [];
+  for (const [index, entry] of value.entries()) {
+    const entryLocation = `${location}[${index}]`;
+    if (typeof entry !== "string") return new Error(`${entryLocation} must be a string`);
+    if (entry.includes("\0")) return new Error(`${entryLocation} must not contain a NUL byte`);
+    if (utf8Bytes(entry) > MCP_CONFIG_CAPS.argBytes) {
+      return new Error(`${entryLocation} exceeds the ${MCP_CONFIG_CAPS.argBytes}-byte cap`);
+    }
+    args.push(entry);
+  }
+  return args;
+}
+function validateEnv(value, location) {
+  if (value === void 0) return {};
+  if (!isRecord(value)) return new Error(`${location} must be an object of string values`);
+  const keys = Object.keys(value);
+  if (keys.length > MCP_CONFIG_CAPS.envEntries) {
+    return new Error(`${location} exceeds the ${MCP_CONFIG_CAPS.envEntries}-entry cap`);
+  }
+  const env = {};
+  for (const key of keys.sort()) {
+    if (!ENV_KEY_PATTERN.test(key)) return new Error(`${location}.${key} is not a valid environment variable name`);
+    const entry = value[key];
+    if (typeof entry !== "string") return new Error(`${location}.${key} must be a string`);
+    if (entry.includes("\0")) return new Error(`${location}.${key} must not contain a NUL byte`);
+    if (utf8Bytes(entry) > MCP_CONFIG_CAPS.envValueBytes) {
+      return new Error(`${location}.${key} exceeds the ${MCP_CONFIG_CAPS.envValueBytes}-byte cap`);
+    }
+    env[key] = entry;
+  }
+  return env;
+}
+function validateTimeout(value, location) {
+  if (value === void 0) return null;
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    return new Error(`${location} must be a positive integer number of milliseconds`);
+  }
+  if (value > MCP_CONFIG_CAPS.timeoutMs) return new Error(`${location} exceeds the ${MCP_CONFIG_CAPS.timeoutMs}ms cap`);
+  return value;
+}
+function realDirectory(candidate, location) {
+  try {
+    if (!statSync(candidate).isDirectory()) return new Error(`${location} is not a directory: '${candidate}'`);
+    return realpathSync(candidate);
+  } catch (error) {
+    return new Error(
+      `${location} cannot be resolved as a directory: '${candidate}' (${error instanceof Error ? error.message : String(error)})`
+    );
+  }
+}
+function resolveCwd(raw, scope, root, location) {
+  if (raw !== null) {
+    if (raw.length === 0) return new Error(`${location} must be a non-empty path when given`);
+    if (raw.includes("\0")) return new Error(`${location} must not contain a NUL byte`);
+    if (utf8Bytes(raw) > MCP_CONFIG_CAPS.cwdBytes) {
+      return new Error(`${location} exceeds the ${MCP_CONFIG_CAPS.cwdBytes}-byte cap`);
+    }
+  }
+  const absolute = raw !== null && (path.isAbsolute(raw) || path.win32.isAbsolute(raw));
+  if (scope === "project" && absolute) {
+    return new Error(`${location} must be repository-relative; absolute cwd '${raw}' is not allowed`);
+  }
+  const realRoot = realDirectory(root, `${location} root`);
+  if (realRoot instanceof Error) return realRoot;
+  if (scope === "user" && absolute && raw !== null) {
+    const real2 = realDirectory(raw, location);
+    if (real2 instanceof Error) return real2;
+    return { cwd: real2, cwdRoot: real2 };
+  }
+  let resolved;
+  try {
+    resolved = resolveSafeCwd(raw ?? void 0, realRoot);
+  } catch {
+    return new Error(`${location} escapes its root: '${raw}'`);
+  }
+  const real = realDirectory(resolved, location);
+  if (real instanceof Error) return real;
+  try {
+    resolveSafeCwd(real, realRoot);
+  } catch {
+    return new Error(`${location} escapes its root through a symbolic link: '${raw}'`);
+  }
+  return { cwd: real, cwdRoot: realRoot };
+}
+function validateServer(value, location) {
+  if (!isRecord(value)) return new Error(`${location} must be an object`);
+  const unknown = unknownFields(value, SERVER_FIELDS);
+  if (unknown.length > 0) return new Error(`${location} has unknown field(s): ${unknown.join(", ")}`);
+  for (const field of ["id", "command"]) {
+    if (!Object.hasOwn(value, field)) return new Error(`${location}.${field} is required`);
+  }
+  const id = validateId(value.id, `${location}.id`);
+  if (id instanceof Error) return id;
+  const command = validateCommand(value.command, `${location}.command`);
+  if (command instanceof Error) return command;
+  const args = validateArgs(value.args, `${location}.args`);
+  if (args instanceof Error) return args;
+  const env = validateEnv(value.env, `${location}.env`);
+  if (env instanceof Error) return env;
+  const timeoutMs = validateTimeout(value.timeoutMs, `${location}.timeoutMs`);
+  if (timeoutMs instanceof Error) return timeoutMs;
+  let declaredCwd = null;
+  if (value.cwd !== void 0) {
+    if (typeof value.cwd !== "string") return new Error(`${location}.cwd must be a string`);
+    declaredCwd = value.cwd;
+  }
+  return { fields: { id, command, args, cwd: declaredCwd, env, timeoutMs }, declaredCwd };
+}
+function parseMcpConfigText(text, input) {
+  const diagnostic = (message) => ({
+    servers: [],
+    diagnostics: [{ scope: input.scope, path: input.path, message }]
+  });
+  if (utf8Bytes(text) > MCP_CONFIG_CAPS.fileBytes) {
+    return diagnostic(`file exceeds the ${MCP_CONFIG_CAPS.fileBytes}-byte cap`);
+  }
+  const document = (0, import_yaml.parseDocument)(text, { prettyErrors: false, strict: true, uniqueKeys: true });
+  if (document.errors.length > 0) {
+    return diagnostic(`invalid YAML: ${document.errors.map((error) => error.message).join("; ")}`);
+  }
+  let parsed;
+  try {
+    parsed = document.toJS({ maxAliasCount: 0 });
+  } catch (error) {
+    return diagnostic(`invalid YAML: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isRecord(parsed)) return diagnostic("root must be an object with version and servers fields");
+  const rootUnknown = unknownFields(parsed, ROOT_FIELDS);
+  if (rootUnknown.length > 0) return diagnostic(`root has unknown field(s): ${rootUnknown.join(", ")}`);
+  if (!Object.hasOwn(parsed, "version")) return diagnostic("root.version is required");
+  if (parsed.version !== MCP_CONFIG_VERSION) {
+    return diagnostic(
+      `unsupported version ${JSON.stringify(parsed.version)}; supported version is ${MCP_CONFIG_VERSION}`
+    );
+  }
+  if (!Object.hasOwn(parsed, "servers")) return diagnostic("root.servers is required");
+  if (!Array.isArray(parsed.servers)) return diagnostic("root.servers must be an array");
+  if (parsed.servers.length > MCP_CONFIG_CAPS.servers) {
+    return diagnostic(`root.servers exceeds the ${MCP_CONFIG_CAPS.servers}-server cap`);
+  }
+  const servers = [];
+  const ids = /* @__PURE__ */ new Map();
+  for (const [index, value] of parsed.servers.entries()) {
+    const location = `servers[${index}]`;
+    const validated = validateServer(value, location);
+    if (validated instanceof Error) return diagnostic(validated.message);
+    const { fields, declaredCwd } = validated;
+    const duplicateIndex = ids.get(fields.id);
+    if (duplicateIndex !== void 0) {
+      return diagnostic(`${location}.id duplicates '${fields.id}' from servers[${duplicateIndex}].id`);
+    }
+    const resolved = resolveCwd(declaredCwd, input.scope, input.root, `${location}.cwd`);
+    if (resolved instanceof Error) return diagnostic(resolved.message);
+    ids.set(fields.id, index);
+    servers.push({
+      id: fields.id,
+      scope: input.scope,
+      path: input.path,
+      command: fields.command,
+      args: fields.args,
+      cwd: resolved.cwd,
+      cwdRoot: resolved.cwdRoot,
+      env: fields.env,
+      timeoutMs: fields.timeoutMs,
+      digest: mcpServerDigest(fields)
+    });
+  }
+  return { servers, diagnostics: [] };
+}
+function readBoundedFileText(filePath, maxBytes) {
+  const describe = (error) => error instanceof Error ? error.message : String(error);
+  let fd;
+  try {
+    fd = openSync(filePath, fsConstants.O_RDONLY | (fsConstants.O_NONBLOCK ?? 0));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { ok: false, reason: "missing", message: "file does not exist" };
+    }
+    return { ok: false, reason: "unreadable", message: `cannot read (${describe(error)})` };
+  }
+  try {
+    const stats = fstatSync(fd);
+    if (!stats.isFile()) return { ok: false, reason: "unreadable", message: "path must be a regular file" };
+    let buffer = Buffer.allocUnsafe(Math.min(Math.max(stats.size, 0), maxBytes) + 1);
+    let total = 0;
+    for (; ; ) {
+      if (total === buffer.length) {
+        if (total > maxBytes) break;
+        buffer = Buffer.concat([buffer], maxBytes + 1);
+      }
+      const read = readSync(fd, buffer, total, buffer.length - total, null);
+      if (read === 0) break;
+      total += read;
+    }
+    if (total > maxBytes) return { ok: false, reason: "oversized", message: `file exceeds the ${maxBytes}-byte cap` };
+    return { ok: true, text: buffer.toString("utf8", 0, total) };
+  } catch (error) {
+    return { ok: false, reason: "unreadable", message: `cannot read (${describe(error)})` };
+  } finally {
+    closeSync(fd);
+  }
+}
+function loadFile(filePath, scope, root) {
+  const read = readBoundedFileText(filePath, MCP_CONFIG_CAPS.fileBytes);
+  if (!read.ok) {
+    if (read.reason === "missing") return { servers: [], diagnostics: [] };
+    return { servers: [], diagnostics: [{ scope, path: filePath, message: read.message }] };
+  }
+  return parseMcpConfigText(read.text, { scope, path: filePath, root });
+}
+function loadMcpServerConfig(options) {
+  const paths = mcpConfigPaths(options);
+  const configDir = options.configDir ?? clioConfigDir();
+  const user = loadFile(paths.user, "user", configDir);
+  const project = loadFile(paths.project, "project", path.resolve(options.cwd));
+  const servers = [...user.servers];
+  const diagnostics = [...user.diagnostics, ...project.diagnostics];
+  const userIds = new Set(user.servers.map((server) => server.id));
+  for (const server of project.servers) {
+    if (userIds.has(server.id)) {
+      diagnostics.push({
+        scope: "project",
+        path: server.path,
+        message: `server '${server.id}' is shadowed by the user declaration in ${paths.user}`
+      });
+      continue;
+    }
+    servers.push(server);
+  }
+  return { servers, diagnostics };
+}
+
+// src/domains/gateway/mcp/trust.ts
+var MCP_TRUST_FILENAME = "mcp-trust.json";
+var MCP_TRUST_VERSION = 1;
+var MCP_TRUST_CAPS = Object.freeze({
+  fileBytes: 1024 * 1024,
+  records: 256
+});
+var MCP_TRUST_ACTION_CLASSES = ["read", "execute", "unknown"];
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isActionClass(value) {
+  return typeof value === "string" && MCP_TRUST_ACTION_CLASSES.includes(value);
+}
+function mcpTrustPath(configDir) {
+  return path2.join(configDir ?? clioConfigDir(), MCP_TRUST_FILENAME);
+}
+function canonicalProjectRoot(cwd) {
+  const resolved = path2.resolve(cwd);
+  try {
+    return realpathSync2(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function parseTrustState(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    return new Error(`invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isRecord2(parsed) || parsed.version !== MCP_TRUST_VERSION) {
+    return new Error(`trust state must be a version ${MCP_TRUST_VERSION} object`);
+  }
+  if (!Array.isArray(parsed.records)) return new Error("trust state records must be an array");
+  if (parsed.records.length > MCP_TRUST_CAPS.records) {
+    return new Error(`trust state exceeds the ${MCP_TRUST_CAPS.records}-record cap`);
+  }
+  const records = [];
+  for (const [index, raw] of parsed.records.entries()) {
+    if (!isRecord2(raw)) return new Error(`records[${index}] must be an object`);
+    for (const field of ["projectRoot", "id", "digest", "trustedAt"]) {
+      if (typeof raw[field] !== "string" || raw[field].length === 0) {
+        return new Error(`records[${index}].${field} must be a non-empty string`);
+      }
+    }
+    if (!isActionClass(raw.actionClass)) {
+      return new Error(`records[${index}].actionClass must be one of ${MCP_TRUST_ACTION_CLASSES.join(", ")}`);
+    }
+    records.push({
+      projectRoot: raw.projectRoot,
+      id: raw.id,
+      digest: raw.digest,
+      actionClass: raw.actionClass,
+      trustedAt: raw.trustedAt
+    });
+  }
+  return { version: MCP_TRUST_VERSION, records };
+}
+function readMcpTrustState(configDir) {
+  const filePath = mcpTrustPath(configDir);
+  const empty = { version: MCP_TRUST_VERSION, records: [] };
+  const read = readBoundedFileText(filePath, MCP_TRUST_CAPS.fileBytes);
+  if (!read.ok) {
+    if (read.reason === "missing") return { state: empty, diagnostics: [] };
+    return { state: empty, diagnostics: [`${filePath}: ${read.message}`] };
+  }
+  const parsed = parseTrustState(read.text);
+  if (parsed instanceof Error) return { state: empty, diagnostics: [`${filePath}: ${parsed.message}`] };
+  return { state: parsed, diagnostics: [] };
+}
+function writeTrustState(records, configDir) {
+  if (records.length > MCP_TRUST_CAPS.records) {
+    return `trust state would exceed the ${MCP_TRUST_CAPS.records}-record cap; untrust servers you no longer use first`;
+  }
+  const sorted = [...records].sort(
+    (left, right) => left.projectRoot.localeCompare(right.projectRoot) || left.id.localeCompare(right.id)
+  );
+  const text = `${JSON.stringify({ version: MCP_TRUST_VERSION, records: sorted }, null, 2)}
+`;
+  if (Buffer.byteLength(text, "utf8") > MCP_TRUST_CAPS.fileBytes) {
+    return `trust state would exceed the ${MCP_TRUST_CAPS.fileBytes}-byte cap; untrust servers you no longer use first`;
+  }
+  safeResourceWrite(mcpTrustPath(configDir), text, { mode: 384 });
+  return null;
+}
+function trustStatusFor(server, projectRoot, state) {
+  if (server.scope === "user") return { status: "trusted", actionClass: "unknown" };
+  const record = state.records.find((entry) => entry.projectRoot === projectRoot && entry.id === server.id);
+  if (record === void 0) {
+    return {
+      status: "untrusted",
+      actionClass: "unknown",
+      reason: `project-scope server '${server.id}' requires explicit trust: clio-coder mcp trust ${server.id}`
+    };
+  }
+  if (record.digest !== server.digest) {
+    return {
+      status: "stale",
+      actionClass: "unknown",
+      reason: `declaration of '${server.id}' changed (command, args, env, cwd, or timeout) since it was trusted; review it and run clio-coder mcp trust ${server.id} again`
+    };
+  }
+  return { status: "trusted", actionClass: record.actionClass };
+}
+function resolveMcpServers(options) {
+  const loaded = loadMcpServerConfig(options);
+  const trust = readMcpTrustState(options.configDir);
+  const projectRoot = canonicalProjectRoot(options.cwd);
+  return {
+    servers: loaded.servers.map((server) => ({ ...server, trust: trustStatusFor(server, projectRoot, trust.state) })),
+    diagnostics: loaded.diagnostics,
+    trustDiagnostics: trust.diagnostics
+  };
+}
+function trustMcpServer(options) {
+  const actionClass = options.actionClass ?? "unknown";
+  if (!isActionClass(actionClass)) {
+    return { ok: false, message: `actionClass must be one of ${MCP_TRUST_ACTION_CLASSES.join(", ")}` };
+  }
+  const loaded = loadMcpServerConfig(options);
+  const server = loaded.servers.find((entry) => entry.id === options.id);
+  if (server === void 0) {
+    const problems = loaded.diagnostics.map((entry) => `${entry.path}: ${entry.message}`);
+    return {
+      ok: false,
+      message: `no declared MCP server with id '${options.id}'` + (problems.length > 0 ? `; config diagnostics: ${problems.join("; ")}` : "")
+    };
+  }
+  if (server.scope !== "project") {
+    return { ok: false, message: `server '${options.id}' is a user-scope declaration; it is trusted by authorship` };
+  }
+  const trust = readMcpTrustState(options.configDir);
+  if (trust.diagnostics.length > 0) {
+    return { ok: false, message: `trust state is unusable; repair or remove it first: ${trust.diagnostics.join("; ")}` };
+  }
+  const projectRoot = canonicalProjectRoot(options.cwd);
+  const record = {
+    projectRoot,
+    id: server.id,
+    digest: server.digest,
+    actionClass,
+    trustedAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString()
+  };
+  const records = trust.state.records.filter((entry) => !(entry.projectRoot === projectRoot && entry.id === server.id));
+  records.push(record);
+  const refused = writeTrustState(records, options.configDir);
+  if (refused !== null) return { ok: false, message: refused };
+  return { ok: true, record };
+}
+function untrustMcpServer(options) {
+  const trust = readMcpTrustState(options.configDir);
+  if (trust.diagnostics.length > 0) {
+    return { ok: false, message: `trust state is unusable; repair or remove it first: ${trust.diagnostics.join("; ")}` };
+  }
+  const projectRoot = canonicalProjectRoot(options.cwd);
+  const records = trust.state.records.filter((entry) => !(entry.projectRoot === projectRoot && entry.id === options.id));
+  const removed = records.length !== trust.state.records.length;
+  if (removed) {
+    const refused = writeTrustState(records, options.configDir);
+    if (refused !== null) return { ok: false, message: refused };
+  }
+  return { ok: true, removed };
+}
+
+// src/domains/gateway/mcp/index.ts
+init_esm_shims();
+
+// src/domains/gateway/mcp/client.ts
+init_esm_shims();
+import { spawn } from "node:child_process";
+import { realpathSync as realpathSync3, statSync as statSync2 } from "node:fs";
+import path3 from "node:path";
+import { performance } from "node:perf_hooks";
+
+// src/domains/gateway/mcp/protocol.ts
+init_esm_shims();
+var MCP_PROTOCOL_VERSION = "2025-06-18";
+var DEFAULT_MAX_LINE_BYTES = 4 * 1024 * 1024;
+var JSON_RPC_METHOD_NOT_FOUND = -32601;
+var McpError = class extends Error {
+  name = "McpError";
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+  }
+};
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isJsonRpcId(value) {
+  return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+var structuredJson = /* @__PURE__ */ new WeakMap();
+function structuredContentJson(result) {
+  return structuredJson.get(result);
+}
+function classifyJsonRpcMessage(value) {
+  if (!isRecord3(value)) return new McpError("protocol", "message is not a JSON object");
+  if (value.jsonrpc !== "2.0") return new McpError("protocol", 'message lacks jsonrpc: "2.0"');
+  if (typeof value.method === "string") {
+    if (value.id === void 0 || value.id === null) {
+      const notification = { jsonrpc: "2.0", method: value.method };
+      if (value.params !== void 0) notification.params = value.params;
+      return { kind: "notification", message: notification };
+    }
+    if (!isJsonRpcId(value.id)) return new McpError("protocol", "request id must be a string or a finite number");
+    const request = { jsonrpc: "2.0", id: value.id, method: value.method };
+    if (value.params !== void 0) request.params = value.params;
+    return { kind: "request", message: request };
+  }
+  const hasResult = Object.hasOwn(value, "result");
+  const hasError = Object.hasOwn(value, "error");
+  if (!hasResult && !hasError) return new McpError("protocol", "message has neither method, result, nor error");
+  if (hasResult && hasError) return new McpError("protocol", "response carries both result and error");
+  if (value.id !== null && !isJsonRpcId(value.id)) {
+    return new McpError("protocol", "response id must be a string, a finite number, or null");
+  }
+  const response = {
+    jsonrpc: "2.0",
+    id: value.id === void 0 ? null : value.id
+  };
+  if (hasResult) response.result = value.result;
+  if (hasError) {
+    const error = value.error;
+    if (!isRecord3(error) || typeof error.code !== "number" || typeof error.message !== "string") {
+      return new McpError("protocol", "response error must carry a numeric code and a message");
+    }
+    const errorObject = { code: error.code, message: error.message };
+    if (error.data !== void 0) errorObject.data = error.data;
+    response.error = errorObject;
+  }
+  return { kind: "response", message: response };
+}
+function parseJsonRpcLine(line) {
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(line);
+  } catch {
+    return new McpError("protocol", "message line is not valid UTF-8");
+  }
+  let parsed;
+  try {
+    const sources = /* @__PURE__ */ new WeakMap();
+    parsed = JSON.parse(text, function(key, value, context) {
+      if (typeof value === "number") {
+        if (context?.source === void 0) throw new Error("JSON numeric source tokens are unavailable");
+        let entries = sources.get(this);
+        if (entries === void 0) {
+          entries = /* @__PURE__ */ new Map();
+          sources.set(this, entries);
+        }
+        entries.set(key, context.source);
+      }
+      return value;
+    });
+    if (isRecord3(parsed) && isRecord3(parsed.result) && isRecord3(parsed.result.structuredContent)) {
+      const content = parsed.result.structuredContent;
+      const rawJSON = JSON.rawJSON;
+      const exact = JSON.stringify(content, function(key, value) {
+        const source = sources.get(this)?.get(key);
+        return source === void 0 ? value : rawJSON(source);
+      });
+      parsed.result.structuredContent = JSON.parse(
+        JSON.stringify(content, function(key, value) {
+          const source = sources.get(this)?.get(key);
+          return source !== void 0 && JSON.stringify(value) !== source ? { $literal: source } : value;
+        })
+      );
+      structuredJson.set(parsed.result, exact);
+    }
+  } catch (error) {
+    return new McpError(
+      "protocol",
+      `message line is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return classifyJsonRpcMessage(parsed);
+}
+function encodeJsonRpcMessage(message) {
+  return Buffer.from(`${JSON.stringify(message)}
+`, "utf8");
+}
+function createLineFramer(maxLineBytes = DEFAULT_MAX_LINE_BYTES) {
+  const pending = [];
+  let pendingBytes = 0;
+  let failed = false;
+  const fail = (message) => {
+    failed = true;
+    pending.length = 0;
+    pendingBytes = 0;
+    return [{ kind: "error", error: new McpError("protocol", message) }];
+  };
+  const frameLine = (line) => {
+    const trimmed = line.length > 0 && line[line.length - 1] === 13 ? line.subarray(0, line.length - 1) : line;
+    if (trimmed.length === 0) return null;
+    const decoded = parseJsonRpcLine(trimmed);
+    if (decoded instanceof McpError) return { kind: "error", error: decoded };
+    return { kind: "message", message: decoded };
+  };
+  return {
+    get pendingBytes() {
+      return pendingBytes;
+    },
+    get failed() {
+      return failed;
+    },
+    push(chunk) {
+      if (failed) return [];
+      const frames = [];
+      let start = 0;
+      for (; ; ) {
+        const newline = chunk.indexOf(10, start);
+        if (newline === -1) break;
+        const tail = chunk.subarray(start, newline);
+        const lineBytes = pendingBytes + tail.length;
+        if (lineBytes > maxLineBytes) return fail(`message line exceeds ${maxLineBytes} bytes`);
+        const line = pending.length === 0 ? tail : Buffer.concat([...pending, tail], lineBytes);
+        pending.length = 0;
+        pendingBytes = 0;
+        const frame = frameLine(line);
+        if (frame !== null) {
+          frames.push(frame);
+          if (frame.kind === "error") {
+            failed = true;
+            return frames;
+          }
+        }
+        start = newline + 1;
+      }
+      if (start < chunk.length) {
+        const rest = chunk.subarray(start);
+        if (pendingBytes + rest.length > maxLineBytes) {
+          frames.push(...fail(`message line exceeds ${maxLineBytes} bytes`));
+          return frames;
+        }
+        pending.push(Buffer.from(rest));
+        pendingBytes += rest.length;
+      }
+      return frames;
+    },
+    flush() {
+      if (failed || pendingBytes === 0) return [];
+      const line = Buffer.concat(pending, pendingBytes);
+      pending.length = 0;
+      pendingBytes = 0;
+      const frame = frameLine(line);
+      if (frame === null) return [];
+      if (frame.kind === "error") failed = true;
+      return [frame];
+    }
+  };
+}
+
+// src/domains/gateway/mcp/client.ts
+var MCP_CLIENT_NAME = "clio-coder";
+var DEFAULT_MCP_CLIENT_VERSION = "0.5.0";
+var DEFAULT_INITIALIZE_TIMEOUT_MS = 15e3;
+var DEFAULT_REQUEST_TIMEOUT_MS = 6e4;
+var DEFAULT_STDERR_TAIL_BYTES = 16 * 1024;
+var DEFAULT_RESULT_TEXT_BYTES = 1024 * 1024;
+var DEFAULT_KILL_GRACE_MS = 3e3;
+var DEFAULT_MAX_OUTBOUND_BYTES = 4 * 1024 * 1024;
+var MCP_TOOL_LIST_CAP = 500;
+var MCP_TOOL_LIST_PAGE_CAP = 100;
+var MIN_OUTBOUND_BYTES = 4096;
+var DEFAULT_TEARDOWN_BOUND_MS = 2e3;
+function isRecord4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function cutUtf8(text, maxBytes) {
+  if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
+  const bytes = Buffer.from(text, "utf8");
+  let cut = Math.max(0, maxBytes);
+  while (cut > 0) {
+    const byte = bytes[cut];
+    if (byte === void 0 || (byte & 192) !== 128) break;
+    cut -= 1;
+  }
+  return bytes.subarray(0, cut).toString("utf8");
+}
+function containedCwd(spec, workspaceRoot) {
+  let lexical;
+  try {
+    lexical = resolveSafeCwd(spec.cwd, workspaceRoot);
+  } catch (error) {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+  let realRoot;
+  let real;
+  try {
+    realRoot = realpathSync3(path3.resolve(workspaceRoot));
+    real = realpathSync3(lexical);
+    if (!statSync2(real).isDirectory()) return new Error(`cwd is not a directory: ${lexical}`);
+  } catch (error) {
+    return new Error(`cwd cannot be resolved: ${lexical} (${errorMessage(error)})`);
+  }
+  try {
+    resolveSafeCwd(real, realRoot);
+  } catch {
+    return new Error(`cwd escapes workspace root through a symbolic link: ${lexical} -> ${real}`);
+  }
+  return real;
+}
+function parseServerInfo(value) {
+  if (!isRecord4(value)) return new McpError("protocol", "initialize result is not an object");
+  if (typeof value.protocolVersion !== "string" || value.protocolVersion.length === 0) {
+    return new McpError("protocol", "initialize result lacks a protocolVersion string");
+  }
+  const capabilities = isRecord4(value.capabilities) ? value.capabilities : {};
+  let serverInfo = null;
+  if (isRecord4(value.serverInfo)) {
+    serverInfo = {
+      name: typeof value.serverInfo.name === "string" ? value.serverInfo.name : "",
+      version: typeof value.serverInfo.version === "string" ? value.serverInfo.version : ""
+    };
+  }
+  return {
+    protocolVersion: value.protocolVersion,
+    serverInfo,
+    capabilities,
+    instructions: typeof value.instructions === "string" ? value.instructions : null
+  };
+}
+function parseToolDescriptor(value) {
+  if (!isRecord4(value)) return new McpError("protocol", "tools/list entry is not an object");
+  if (typeof value.name !== "string" || value.name.length === 0) {
+    return new McpError("protocol", "tools/list entry lacks a name");
+  }
+  const inputSchema = isRecord4(value.inputSchema) ? value.inputSchema : { type: "object" };
+  return {
+    name: value.name,
+    title: typeof value.title === "string" ? value.title : null,
+    description: typeof value.description === "string" ? value.description : "",
+    inputSchema,
+    annotations: isRecord4(value.annotations) ? value.annotations : null
+  };
+}
+function normalizeContentBlock(value) {
+  if (!isRecord4(value) || typeof value.type !== "string") return { type: "other", raw: value };
+  switch (value.type) {
+    case "text":
+      return typeof value.text === "string" ? { type: "text", text: value.text } : { type: "other", raw: value };
+    case "image":
+    case "audio":
+      if (typeof value.data === "string" && typeof value.mimeType === "string") {
+        return { type: value.type, mimeType: value.mimeType, data: value.data };
+      }
+      return { type: "other", raw: value };
+    case "resource": {
+      const resource = value.resource;
+      if (!isRecord4(resource) || typeof resource.uri !== "string") return { type: "other", raw: value };
+      return {
+        type: "resource",
+        uri: resource.uri,
+        ...typeof resource.text === "string" ? { text: resource.text } : {},
+        ...typeof resource.mimeType === "string" ? { mimeType: resource.mimeType } : {}
+      };
+    }
+    case "resource_link":
+      if (typeof value.uri !== "string") return { type: "other", raw: value };
+      return {
+        type: "resource",
+        uri: value.uri,
+        ...typeof value.mimeType === "string" ? { mimeType: value.mimeType } : {}
+      };
+    default:
+      return { type: "other", raw: value };
+  }
+}
+function renderContentBlock(block) {
+  switch (block.type) {
+    case "text":
+      return block.text;
+    case "image":
+    case "audio":
+      return `[${block.type} ${block.mimeType}, ${Buffer.byteLength(block.data, "base64")} bytes]`;
+    case "resource":
+      return block.text === void 0 ? `[resource ${block.uri}]` : `[resource ${block.uri}]
+${block.text}`;
+    case "other": {
+      const type = isRecord4(block.raw) && typeof block.raw.type === "string" ? block.raw.type : "unknown";
+      return `[unsupported content type ${type}]`;
+    }
+  }
+}
+function renderMcpContent(blocks, maxBytes = DEFAULT_RESULT_TEXT_BYTES) {
+  const joined = blocks.map(renderContentBlock).join("\n");
+  if (Buffer.byteLength(joined, "utf8") <= maxBytes) return { text: joined, truncated: false };
+  const marker = `
+[mcp result text truncated at ${maxBytes} bytes]`;
+  const budget = Math.max(0, maxBytes - Buffer.byteLength(marker, "utf8"));
+  return { text: `${cutUtf8(joined, budget)}${marker}`, truncated: true };
+}
+function parseToolCallResult(value, maxTextBytes) {
+  if (!isRecord4(value)) return new McpError("protocol", "tools/call result is not an object");
+  if (!Array.isArray(value.content)) return new McpError("protocol", "tools/call result.content must be an array");
+  if (value.isError !== void 0 && typeof value.isError !== "boolean") {
+    return new McpError("protocol", "tools/call result.isError must be a boolean");
+  }
+  if (value.structuredContent !== void 0 && !isRecord4(value.structuredContent)) {
+    return new McpError("protocol", "tools/call result.structuredContent must be an object");
+  }
+  const content = value.content.map(normalizeContentBlock);
+  const structuredText = structuredContentJson(value);
+  const rendered = renderMcpContent(
+    content.length === 0 && value.structuredContent !== void 0 ? [{ type: "text", text: structuredText ?? JSON.stringify(value.structuredContent) }] : content,
+    maxTextBytes
+  );
+  const result = {
+    content,
+    isError: value.isError === true,
+    text: rendered.text,
+    textTruncated: rendered.truncated
+  };
+  if (value.structuredContent !== void 0) result.structuredContent = value.structuredContent;
+  if (structuredText !== void 0) result.structuredContentJson = structuredText;
+  return result;
+}
+function createMcpStdioClient(spec, options) {
+  const initialCwd = containedCwd(spec, options.workspaceRoot);
+  if (initialCwd instanceof Error) throw new McpError("spawn", `mcp server ${spec.id}: ${initialCwd.message}`);
+  const initializeTimeoutMs = clampTimerDelayMs(options.initializeTimeoutMs ?? DEFAULT_INITIALIZE_TIMEOUT_MS);
+  const requestTimeoutMs = clampTimerDelayMs(options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS);
+  const stderrTailBytes = Math.max(0, options.stderrTailBytes ?? DEFAULT_STDERR_TAIL_BYTES);
+  const maxResultTextBytes = Math.max(64, options.maxResultTextBytes ?? DEFAULT_RESULT_TEXT_BYTES);
+  const maxOutboundBytes = Math.max(MIN_OUTBOUND_BYTES, options.maxOutboundBytes ?? DEFAULT_MAX_OUTBOUND_BYTES);
+  const killGraceMs = clampTimerDelayMs(options.killGraceMs ?? DEFAULT_KILL_GRACE_MS);
+  const teardownBoundMs = clampTimerDelayMs(options.teardownBoundMs ?? DEFAULT_TEARDOWN_BOUND_MS);
+  const clientVersion = options.clientVersion ?? DEFAULT_MCP_CLIENT_VERSION;
+  const framer = createLineFramer(options.maxLineBytes ?? DEFAULT_MAX_LINE_BYTES);
+  let status = "idle";
+  let failure = null;
+  let child = null;
+  let spawned = null;
+  let exited = null;
+  let leaderExited = false;
+  let groupPhase = "unspawned";
+  let groupCleanup = null;
+  let teardown = null;
+  let closing = false;
+  let initializePromise = null;
+  let closePromise = null;
+  let info = null;
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  const outbound = [];
+  let outboundQueuedBytes = 0;
+  let awaitingDrain = false;
+  let notifications = 0;
+  let toolsChangedFlag = false;
+  let stderrTailBuffer = Buffer.alloc(0);
+  const isAlive = () => child !== null && child.exitCode === null && child.signalCode === null;
+  const closedError = () => failure ?? new McpError("closed", `mcp server ${spec.id} is closed`);
+  const rejectAllPending = (error) => {
+    for (const entry of [...pending.values()]) entry.reject(error);
+  };
+  const fail = (error) => {
+    if (status === "closed" || status === "failed") return;
+    status = "failed";
+    failure = error;
+    rejectAllPending(error);
+  };
+  const groupOwned = () => groupPhase === "live" || groupPhase === "cleaning";
+  const signalGroup = (signalName) => {
+    const pid = child?.pid;
+    if (pid !== void 0 && process.platform !== "win32" && groupOwned()) {
+      try {
+        process.kill(-pid, signalName);
+        return;
+      } catch (error) {
+        if (error.code === "ESRCH") groupPhase = "released";
+      }
+    }
+    try {
+      child?.kill(signalName);
+    } catch {
+    }
+  };
+  const groupAlive = () => {
+    const pid = child?.pid;
+    if (pid === void 0 || !groupOwned()) return false;
+    if (process.platform !== "win32") {
+      try {
+        process.kill(-pid, 0);
+        return true;
+      } catch (error) {
+        if (error.code !== "ESRCH") return true;
+        groupPhase = "released";
+        return false;
+      }
+    }
+    return isAlive();
+  };
+  const terminationObserved = () => leaderExited && !groupAlive();
+  const waitForTermination = async (timeoutMs) => {
+    const deadline = performance.now() + timeoutMs;
+    while (!terminationObserved()) {
+      const remaining = deadline - performance.now();
+      if (remaining <= 0) return terminationObserved();
+      const nap = sleep(Math.min(10, remaining));
+      await (leaderExited || exited === null ? nap : Promise.race([exited, nap]));
+    }
+    return true;
+  };
+  const destroyStdio = () => {
+    for (const stream of [child?.stdin, child?.stdout, child?.stderr]) stream?.destroy();
+  };
+  const cleanupGroup = () => {
+    if (groupCleanup !== null) return groupCleanup;
+    groupCleanup = (async () => {
+      let terminated = true;
+      const pgid = child?.pid;
+      if (groupPhase === "live" && pgid !== void 0) {
+        groupPhase = "cleaning";
+        if (groupAlive()) signalGroup("SIGTERM");
+        terminated = await waitForTermination(killGraceMs);
+        if (!terminated) {
+          if (groupAlive()) signalGroup("SIGKILL");
+          terminated = await waitForTermination(teardownBoundMs);
+        }
+      } else {
+        await (exited ?? Promise.resolve());
+      }
+      groupPhase = "released";
+      const outcome = terminated || pgid === void 0 ? { complete: true } : { complete: false, reason: "group-survived-sigkill", pgid, boundMs: killGraceMs + teardownBoundMs };
+      teardown = outcome;
+      if (!outcome.complete) destroyStdio();
+      return outcome;
+    })();
+    return groupCleanup;
+  };
+  const pendingOutboundBytes = () => outboundQueuedBytes + (child?.stdin?.writableLength ?? 0);
+  const flushOutbound = () => {
+    while (!awaitingDrain) {
+      const entry = outbound.shift();
+      if (entry === void 0) return;
+      outboundQueuedBytes -= entry.payload.length;
+      const stdin = child?.stdin;
+      if (!stdin || stdin.destroyed || !stdin.writable) {
+        entry.onError?.(new Error("server stdin is not writable"));
+        continue;
+      }
+      const accepted = stdin.write(entry.payload, (error) => {
+        if (error) entry.onError?.(error);
+      });
+      if (!accepted) {
+        awaitingDrain = true;
+        stdin.once("drain", () => {
+          awaitingDrain = false;
+          flushOutbound();
+        });
+      }
+    }
+  };
+  const enqueueOutbound = (message, requestId, onError) => {
+    const payload = encodeJsonRpcMessage(message);
+    if (payload.length > maxOutboundBytes) return { kind: "oversized", bytes: payload.length };
+    const queued = pendingOutboundBytes();
+    if (queued + payload.length > maxOutboundBytes) {
+      fail(
+        new McpError(
+          "overload",
+          `mcp server ${spec.id} stopped reading its stdin: ${queued} bytes are queued for it and the outbound cap is ${maxOutboundBytes} bytes`
+        )
+      );
+      void close();
+      return { kind: "overloaded" };
+    }
+    outbound.push({ payload, requestId, onError });
+    outboundQueuedBytes += payload.length;
+    flushOutbound();
+    return { kind: "queued" };
+  };
+  const withdrawOutbound = (requestId) => {
+    const index = outbound.findIndex((entry2) => entry2.requestId === requestId);
+    if (index === -1) return;
+    const [entry] = outbound.splice(index, 1);
+    if (entry !== void 0) outboundQueuedBytes -= entry.payload.length;
+  };
+  const dispatch = (frame) => {
+    if (frame.kind === "response") {
+      const id = frame.message.id;
+      if (typeof id !== "number") return;
+      const entry = pending.get(id);
+      if (entry === void 0) return;
+      if (frame.message.error !== void 0) {
+        const error = frame.message.error;
+        entry.reject(new McpError("server", `${entry.method}: ${error.message} (code ${error.code})`, error));
+        return;
+      }
+      entry.resolve(frame.message.result);
+      return;
+    }
+    if (frame.kind === "request") {
+      const request2 = frame.message;
+      const outcome = enqueueOutbound(
+        {
+          jsonrpc: "2.0",
+          id: request2.id,
+          error: { code: JSON_RPC_METHOD_NOT_FOUND, message: `method not found: ${request2.method}` }
+        },
+        null
+      );
+      if (outcome.kind === "oversized") {
+        fail(
+          new McpError(
+            "overload",
+            `mcp server ${spec.id} sent a request whose ${outcome.bytes}-byte reply exceeds the ${maxOutboundBytes}-byte outbound cap`
+          )
+        );
+        void close();
+      }
+      return;
+    }
+    notifications += 1;
+    if (frame.message.method === "notifications/tools/list_changed") toolsChangedFlag = true;
+  };
+  const consumeFrames = (frames) => {
+    for (const frame of frames) {
+      if (status === "closed" || status === "failed") return;
+      if (frame.kind === "message") {
+        dispatch(frame.message);
+        continue;
+      }
+      fail(new McpError("protocol", `protocol error from mcp server ${spec.id}: ${frame.error.message}`));
+      void close();
+      return;
+    }
+  };
+  const spawnChild = () => {
+    const cwd = containedCwd(spec, options.workspaceRoot);
+    if (cwd instanceof Error) {
+      fail(new McpError("spawn", `mcp server ${spec.id} failed to start: ${cwd.message}`));
+      return false;
+    }
+    let proc;
+    try {
+      proc = spawn(spec.command, [...spec.args ?? []], {
+        cwd,
+        env: buildSafeToolEnv({ ...spec.env ?? {} }),
+        detached: process.platform !== "win32",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch (error) {
+      fail(new McpError("spawn", `mcp server ${spec.id} failed to start: ${errorMessage(error)}`));
+      return false;
+    }
+    child = proc;
+    if (proc.pid !== void 0) groupPhase = "live";
+    spawned = new Promise((resolve) => {
+      proc.once("spawn", () => resolve(true));
+      proc.once("error", (error) => {
+        fail(new McpError("spawn", `mcp server ${spec.id} failed to start: ${error.message}`));
+        resolve(false);
+      });
+    });
+    exited = new Promise((resolve) => {
+      proc.once("exit", (code, signal) => {
+        leaderExited = true;
+        if (!closing && status !== "failed") {
+          fail(
+            new McpError(
+              "closed",
+              `mcp server ${spec.id} exited with ${signal !== null ? `signal ${signal}` : `code ${code ?? "?"}`} before the client closed it`
+            )
+          );
+        } else {
+          rejectAllPending(closedError());
+        }
+        resolve();
+        void cleanupGroup();
+      });
+      proc.once("error", () => {
+        if (proc.pid === void 0) {
+          leaderExited = true;
+          resolve();
+        }
+      });
+    });
+    proc.stdin?.on("error", () => {
+    });
+    proc.stdout?.on("data", (chunk) => consumeFrames(framer.push(chunk)));
+    proc.stdout?.on("end", () => consumeFrames(framer.flush()));
+    proc.stderr?.on("data", (chunk) => {
+      if (stderrTailBytes === 0) return;
+      const joined = Buffer.concat([stderrTailBuffer, chunk]);
+      stderrTailBuffer = joined.length > stderrTailBytes ? Buffer.from(joined.subarray(joined.length - stderrTailBytes)) : joined;
+    });
+    return true;
+  };
+  const request = (method, params, timeoutMs, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new McpError("aborted", `${method} aborted before it was sent`));
+      return;
+    }
+    if (child === null || status === "closed" || status === "failed") {
+      reject(closedError());
+      return;
+    }
+    const id = nextId++;
+    let timer = null;
+    const settle = (finish) => {
+      if (!pending.has(id)) return;
+      pending.delete(id);
+      withdrawOutbound(id);
+      if (timer !== null) clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      finish();
+    };
+    const onAbort = () => settle(() => reject(new McpError("aborted", `${method} aborted`)));
+    pending.set(id, {
+      method,
+      resolve: (value) => settle(() => resolve(value)),
+      reject: (error) => settle(() => reject(error))
+    });
+    if (timeoutMs > 0) {
+      timer = setTimeout(
+        () => settle(() => reject(new McpError("timeout", `${method} timed out after ${timeoutMs}ms`))),
+        timeoutMs
+      );
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    const outcome = enqueueOutbound(
+      { jsonrpc: "2.0", id, method, ...params === void 0 ? {} : { params } },
+      id,
+      (error) => {
+        settle(() => reject(failure ?? new McpError("closed", `write to mcp server ${spec.id} failed: ${error.message}`)));
+      }
+    );
+    if (outcome.kind === "oversized") {
+      settle(
+        () => reject(
+          new McpError(
+            "overload",
+            `${method} request of ${outcome.bytes} bytes exceeds the ${maxOutboundBytes}-byte outbound cap`
+          )
+        )
+      );
+    }
+  });
+  const initialize = () => {
+    if (status === "closed" || status === "failed") return Promise.reject(closedError());
+    if (initializePromise !== null) return initializePromise;
+    initializePromise = (async () => {
+      status = "starting";
+      if (!spawnChild()) {
+        await close();
+        throw closedError();
+      }
+      const started = await (spawned ?? Promise.resolve(false));
+      if (!started) {
+        await close();
+        throw closedError();
+      }
+      let result;
+      try {
+        result = await request(
+          "initialize",
+          {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: MCP_CLIENT_NAME, version: clientVersion }
+          },
+          initializeTimeoutMs
+        );
+      } catch (error) {
+        const cause = error instanceof McpError ? error : new McpError("protocol", errorMessage(error));
+        fail(new McpError(cause.code, `initialize failed: ${cause.message}`, cause.data));
+        await close();
+        throw closedError();
+      }
+      const parsed = parseServerInfo(result);
+      if (parsed instanceof McpError) {
+        fail(new McpError("protocol", `initialize failed: ${parsed.message}`));
+        await close();
+        throw closedError();
+      }
+      info = parsed;
+      enqueueOutbound({ jsonrpc: "2.0", method: "notifications/initialized" }, null);
+      if (status === "starting") status = "ready";
+      return parsed;
+    })();
+    return initializePromise;
+  };
+  const ensureReady = async () => {
+    if (status === "ready") return;
+    await initialize();
+  };
+  const listTools = async () => {
+    await ensureReady();
+    const tools = [];
+    let cursor;
+    let pages = 0;
+    for (; ; ) {
+      pages += 1;
+      const result = await request("tools/list", cursor === void 0 ? {} : { cursor }, requestTimeoutMs);
+      if (!isRecord4(result) || !Array.isArray(result.tools)) {
+        throw new McpError("protocol", "tools/list result lacks a tools array");
+      }
+      for (const entry of result.tools) {
+        if (tools.length >= MCP_TOOL_LIST_CAP) return { tools, truncated: true };
+        const descriptor = parseToolDescriptor(entry);
+        if (descriptor instanceof McpError) throw descriptor;
+        tools.push(descriptor);
+      }
+      const next = typeof result.nextCursor === "string" && result.nextCursor.length > 0 ? result.nextCursor : void 0;
+      if (next === void 0) return { tools, truncated: false };
+      if (tools.length >= MCP_TOOL_LIST_CAP || pages >= MCP_TOOL_LIST_PAGE_CAP) return { tools, truncated: true };
+      cursor = next;
+    }
+  };
+  const callTool = async (name, args, callOptions = {}) => {
+    await ensureReady();
+    const timeoutMs = clampTimerDelayMs(callOptions.timeoutMs ?? requestTimeoutMs);
+    const result = await request("tools/call", { name, arguments: args }, timeoutMs, callOptions.signal);
+    const parsed = parseToolCallResult(result, maxResultTextBytes);
+    if (parsed instanceof McpError) throw parsed;
+    return parsed;
+  };
+  const close = () => {
+    if (closePromise !== null) return closePromise;
+    closePromise = (async () => {
+      closing = true;
+      if (status !== "failed") status = "closed";
+      rejectAllPending(closedError());
+      outbound.length = 0;
+      outboundQueuedBytes = 0;
+      if (child === null) {
+        teardown ??= { complete: true };
+        return teardown;
+      }
+      try {
+        child.stdin?.end();
+      } catch {
+      }
+      const outcome = await cleanupGroup();
+      destroyStdio();
+      return outcome;
+    })();
+    return closePromise;
+  };
+  if (options.signal !== void 0) {
+    if (options.signal.aborted) void close();
+    else options.signal.addEventListener("abort", () => void close(), { once: true });
+  }
+  return {
+    id: spec.id,
+    get pid() {
+      return child?.pid;
+    },
+    initialize,
+    listTools,
+    callTool,
+    close,
+    killOwnedOnExit: () => {
+      if (groupOwned()) signalGroup("SIGKILL");
+    },
+    state: () => {
+      const cleanup = { cleanupIncomplete: teardown?.complete === false, teardown };
+      return status === "failed" ? { status, reason: failure?.message ?? `mcp server ${spec.id} failed`, ...cleanup } : { status, ...cleanup };
+    },
+    serverInfo: () => info,
+    toolsChanged: () => toolsChangedFlag,
+    acknowledgeToolsChanged: () => {
+      toolsChangedFlag = false;
+    },
+    notificationCount: () => notifications,
+    stderrTail: () => stderrTailBuffer.toString("utf8")
+  };
+}
+
+export {
+  McpError,
+  DEFAULT_KILL_GRACE_MS,
+  DEFAULT_TEARDOWN_BOUND_MS,
+  createMcpStdioClient,
+  MCP_TRUST_ACTION_CLASSES,
+  resolveMcpServers,
+  trustMcpServer,
+  untrustMcpServer
+};
+//# sourceMappingURL=chunk-55RMDDFM.js.map