@shareai-lab/kode 2.0.2 → 2.0.3

package/dist/chunks/chunk-ZBVLKZ5V.js

@@ -0,0 +1,1062 @@
+import {
+  getSessionPlugins
+} from "./chunk-M7P3QNRU.js";
+import {
+  PRODUCT_COMMAND,
+  logError,
+  logMCPError
+} from "./chunk-3OEJVB5A.js";
+import {
+  getCwd
+} from "./chunk-BBJFHTBC.js";
+import {
+  addMcprcServerForTesting,
+  getCurrentProjectConfig,
+  getGlobalConfig,
+  getProjectMcpServerDefinitions,
+  removeMcprcServerForTesting,
+  saveCurrentProjectConfig,
+  saveGlobalConfig
+} from "./chunk-XR2W3MAM.js";
+
+// packages/core/src/mcp/client/config.ts
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+// packages/core/src/utils/json.ts
+function safeParseJSON(json) {
+  if (!json) {
+    return null;
+  }
+  try {
+    return JSON.parse(json);
+  } catch (e) {
+    logError(e);
+    return null;
+  }
+}
+
+// packages/core/src/mcp/client/utils.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stripJsonComments(input) {
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    const next = i + 1 < input.length ? input[i + 1] : "";
+    if (inLineComment) {
+      if (ch === "\n") {
+        inLineComment = false;
+        out += ch;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      out += ch;
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      inLineComment = true;
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      inBlockComment = true;
+      i++;
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+function parseJsonOrJsonc(text) {
+  const raw = String(text ?? "");
+  if (!raw.trim()) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    try {
+      return JSON.parse(stripJsonComments(raw));
+    } catch {
+      return null;
+    }
+  }
+}
+function expandTemplateString(value, pluginRoot) {
+  return value.replace(/\$\{([^}]+)\}/g, (match, key) => {
+    const k = String(key ?? "").trim();
+    if (!k) return match;
+    if (k === "CLAUDE_PLUGIN_ROOT") return pluginRoot;
+    const env = process.env[k];
+    return env !== void 0 ? env : match;
+  });
+}
+function expandTemplateDeep(value, pluginRoot) {
+  if (typeof value === "string") return expandTemplateString(value, pluginRoot);
+  if (Array.isArray(value))
+    return value.map((v) => expandTemplateDeep(v, pluginRoot));
+  if (isRecord(value)) {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = expandTemplateDeep(v, pluginRoot);
+    }
+    return out;
+  }
+  return value;
+}
+
+// packages/core/src/mcp/client/config.ts
+var VALID_SCOPES = ["project", "global", "mcprc", "mcpjson"];
+var EXTERNAL_SCOPES = [
+  "project",
+  "global",
+  "mcprc",
+  "mcpjson"
+];
+function parseEnvVars(rawEnvArgs) {
+  const parsedEnv = {};
+  if (!rawEnvArgs) return parsedEnv;
+  for (const envStr of rawEnvArgs) {
+    const [key, ...valueParts] = envStr.split("=");
+    if (!key || valueParts.length === 0) {
+      throw new Error(
+        `Invalid environment variable format: ${envStr}, environment variables should be added as: -e KEY1=value1 -e KEY2=value2`
+      );
+    }
+    parsedEnv[key] = valueParts.join("=");
+  }
+  return parsedEnv;
+}
+function ensureConfigScope(scope) {
+  if (!scope) return "project";
+  const scopesToCheck = process.env.USER_TYPE === "external" ? EXTERNAL_SCOPES : VALID_SCOPES;
+  if (!scopesToCheck.includes(scope)) {
+    throw new Error(
+      `Invalid scope: ${scope}. Must be one of: ${scopesToCheck.join(", ")}`
+    );
+  }
+  return scope;
+}
+function listPluginMCPServers() {
+  const plugins = getSessionPlugins();
+  if (plugins.length === 0) return {};
+  const out = {};
+  for (const plugin of plugins) {
+    const pluginRoot = plugin.rootDir;
+    const pluginName = plugin.name;
+    const configs = [];
+    for (const configPath of plugin.mcpConfigFiles ?? []) {
+      try {
+        const raw = readFileSync(configPath, "utf8");
+        const parsed = parseJsonOrJsonc(raw);
+        if (!isRecord(parsed)) continue;
+        const maybeNested = parsed["mcpServers"];
+        const rawServers = isRecord(maybeNested) ? maybeNested : parsed;
+        if (!isRecord(rawServers)) continue;
+        const servers = {};
+        for (const [name, cfg] of Object.entries(rawServers)) {
+          if (!isRecord(cfg)) continue;
+          servers[name] = expandTemplateDeep(cfg, pluginRoot);
+        }
+        configs.push(servers);
+      } catch {
+        continue;
+      }
+    }
+    if (isRecord(plugin.manifest)) {
+      const manifestRaw = plugin.manifest["mcpServers"];
+      if (isRecord(manifestRaw)) {
+        const maybeNested = manifestRaw["mcpServers"];
+        const rawServers = isRecord(maybeNested) ? maybeNested : manifestRaw;
+        if (isRecord(rawServers)) {
+          const servers = {};
+          for (const [name, cfg] of Object.entries(rawServers)) {
+            if (!isRecord(cfg)) continue;
+            servers[name] = expandTemplateDeep(
+              cfg,
+              pluginRoot
+            );
+          }
+          configs.push(servers);
+        }
+      }
+    }
+    const merged = Object.assign(
+      {},
+      ...configs
+    );
+    for (const [serverName, cfg] of Object.entries(merged)) {
+      const fullName = `plugin_${pluginName}_${serverName}`;
+      out[fullName] = cfg;
+    }
+  }
+  return out;
+}
+function getMcprcServerStatus(serverName) {
+  const config = getCurrentProjectConfig();
+  if (config.approvedMcprcServers?.includes(serverName)) {
+    return "approved";
+  }
+  if (config.rejectedMcprcServers?.includes(serverName)) {
+    return "rejected";
+  }
+  return "pending";
+}
+function addMcpServer(name, server, scope = "project") {
+  if (scope === "mcprc") {
+    if (process.env.NODE_ENV === "test") {
+      addMcprcServerForTesting(name, server);
+      return;
+    }
+    const mcprcPath = join(getCwd(), ".mcprc");
+    let mcprcConfig = {};
+    if (existsSync(mcprcPath)) {
+      try {
+        const mcprcContent = readFileSync(mcprcPath, "utf-8");
+        const existingConfig = safeParseJSON(mcprcContent);
+        if (isRecord(existingConfig)) {
+          mcprcConfig = existingConfig;
+        }
+      } catch {
+      }
+    }
+    mcprcConfig[name] = server;
+    try {
+      writeFileSync(mcprcPath, JSON.stringify(mcprcConfig, null, 2), "utf-8");
+    } catch (error) {
+      throw new Error(`Failed to write to .mcprc: ${error}`);
+    }
+    return;
+  }
+  if (scope === "mcpjson") {
+    const mcpJsonPath = join(getCwd(), ".mcp.json");
+    let config2 = { mcpServers: {} };
+    if (existsSync(mcpJsonPath)) {
+      try {
+        const content = readFileSync(mcpJsonPath, "utf-8");
+        const parsed = safeParseJSON(content);
+        if (isRecord(parsed)) config2 = parsed;
+      } catch {
+      }
+    }
+    const rawServers = config2["mcpServers"];
+    const servers = isRecord(rawServers) ? rawServers : {};
+    servers[name] = server;
+    config2["mcpServers"] = servers;
+    try {
+      writeFileSync(mcpJsonPath, JSON.stringify(config2, null, 2), "utf-8");
+    } catch (error) {
+      throw new Error(`Failed to write to .mcp.json: ${error}`);
+    }
+    return;
+  }
+  if (scope === "global") {
+    const config2 = getGlobalConfig();
+    if (!config2.mcpServers) config2.mcpServers = {};
+    config2.mcpServers[name] = server;
+    saveGlobalConfig(config2);
+    return;
+  }
+  const config = getCurrentProjectConfig();
+  if (!config.mcpServers) config.mcpServers = {};
+  config.mcpServers[name] = server;
+  saveCurrentProjectConfig(config);
+}
+function removeMcpServer(name, scope = "project") {
+  if (scope === "mcprc") {
+    if (process.env.NODE_ENV === "test") {
+      removeMcprcServerForTesting(name);
+      return;
+    }
+    const mcprcPath = join(getCwd(), ".mcprc");
+    if (!existsSync(mcprcPath)) {
+      throw new Error("No .mcprc file found in this directory");
+    }
+    const mcprcContent = readFileSync(mcprcPath, "utf-8");
+    const parsed = safeParseJSON(mcprcContent);
+    if (!isRecord(parsed) || !(name in parsed)) {
+      throw new Error(`No MCP server found with name: ${name} in .mcprc`);
+    }
+    delete parsed[name];
+    writeFileSync(mcprcPath, JSON.stringify(parsed, null, 2), "utf-8");
+    return;
+  }
+  if (scope === "mcpjson") {
+    const mcpJsonPath = join(getCwd(), ".mcp.json");
+    if (!existsSync(mcpJsonPath)) {
+      throw new Error("No .mcp.json file found in this directory");
+    }
+    const content = readFileSync(mcpJsonPath, "utf-8");
+    const parsed = safeParseJSON(content);
+    if (!isRecord(parsed)) {
+      throw new Error("Invalid .mcp.json format");
+    }
+    const rawServers = parsed["mcpServers"];
+    if (!isRecord(rawServers) || !(name in rawServers)) {
+      throw new Error(`No MCP server found with name: ${name} in .mcp.json`);
+    }
+    delete rawServers[name];
+    parsed["mcpServers"] = rawServers;
+    writeFileSync(mcpJsonPath, JSON.stringify(parsed, null, 2), "utf-8");
+    return;
+  }
+  if (scope === "global") {
+    const config2 = getGlobalConfig();
+    if (!config2.mcpServers?.[name]) {
+      throw new Error(`No MCP server found with name: ${name} in global config`);
+    }
+    delete config2.mcpServers[name];
+    saveGlobalConfig(config2);
+    return;
+  }
+  const config = getCurrentProjectConfig();
+  if (!config.mcpServers?.[name]) {
+    throw new Error(`No MCP server found with name: ${name} in project config`);
+  }
+  delete config.mcpServers[name];
+  saveCurrentProjectConfig(config);
+}
+function listMCPServers() {
+  const pluginServers = listPluginMCPServers();
+  const globalConfig = getGlobalConfig();
+  const projectFileConfig = getProjectMcpServerDefinitions().servers;
+  const projectConfig = getCurrentProjectConfig();
+  return {
+    ...pluginServers ?? {},
+    ...globalConfig.mcpServers ?? {},
+    ...projectFileConfig ?? {},
+    ...projectConfig.mcpServers ?? {}
+  };
+}
+function getMcpServer(name) {
+  const projectConfig = getCurrentProjectConfig();
+  const projectFileDefinitions = getProjectMcpServerDefinitions();
+  const projectFileConfig = projectFileDefinitions.servers;
+  const globalConfig = getGlobalConfig();
+  if (projectConfig.mcpServers?.[name]) {
+    return { ...projectConfig.mcpServers[name], scope: "project" };
+  }
+  if (projectFileConfig?.[name]) {
+    const source = projectFileDefinitions.sources[name];
+    const scope = source === ".mcp.json" ? "mcpjson" : "mcprc";
+    return { ...projectFileConfig[name], scope };
+  }
+  if (globalConfig.mcpServers?.[name]) {
+    return { ...globalConfig.mcpServers[name], scope: "global" };
+  }
+  return void 0;
+}
+function parseMcpServersFromCliConfigEntries(options) {
+  const out = {};
+  for (const rawEntry of options.entries) {
+    const entry = String(rawEntry ?? "").trim();
+    if (!entry) continue;
+    const resolvedPath = resolve(options.projectDir, entry);
+    const payload = existsSync(resolvedPath) ? readFileSync(resolvedPath, "utf8") : existsSync(entry) ? readFileSync(entry, "utf8") : entry;
+    const parsed = parseJsonOrJsonc(payload);
+    if (!isRecord(parsed)) continue;
+    const maybeNested = parsed["mcpServers"];
+    const rawServers = isRecord(maybeNested) ? maybeNested : parsed;
+    if (!isRecord(rawServers)) continue;
+    for (const [name, cfg] of Object.entries(rawServers)) {
+      if (!isRecord(cfg)) continue;
+      out[name] = cfg;
+    }
+  }
+  return out;
+}
+
+// packages/core/src/mcp/client/clients.ts
+import { memoize, pickBy } from "lodash-es";
+
+// packages/core/src/mcp/client/connection.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";
+async function ensureWebSocketGlobal() {
+  const global = globalThis;
+  if (typeof global.WebSocket === "function") return;
+  try {
+    const undiciModule = await import("undici");
+    const maybeWs = undiciModule.WebSocket;
+    if (typeof maybeWs === "function") {
+      global.WebSocket = maybeWs;
+    }
+  } catch {
+  }
+}
+function buildStdioEnv(extra) {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string") env[key] = value;
+  }
+  if (extra) Object.assign(env, extra);
+  return env;
+}
+async function connectToServer(name, serverRef) {
+  const candidates = await (async () => {
+    switch (serverRef.type) {
+      case "sse": {
+        const ref = serverRef;
+        return [
+          {
+            kind: "sse",
+            transport: new SSEClientTransport(new URL(ref.url), {
+              ...ref.headers ? { requestInit: { headers: ref.headers } } : {}
+            })
+          },
+          {
+            kind: "http",
+            transport: new StreamableHTTPClientTransport(new URL(ref.url), {
+              ...ref.headers ? { requestInit: { headers: ref.headers } } : {}
+            })
+          }
+        ];
+      }
+      case "sse-ide": {
+        const ref = serverRef;
+        return [
+          {
+            kind: "sse",
+            transport: new SSEClientTransport(new URL(ref.url), {
+              ...ref.headers ? { requestInit: { headers: ref.headers } } : {}
+            })
+          }
+        ];
+      }
+      case "http": {
+        const ref = serverRef;
+        return [
+          {
+            kind: "http",
+            transport: new StreamableHTTPClientTransport(new URL(ref.url), {
+              ...ref.headers ? { requestInit: { headers: ref.headers } } : {}
+            })
+          },
+          {
+            kind: "sse",
+            transport: new SSEClientTransport(new URL(ref.url), {
+              ...ref.headers ? { requestInit: { headers: ref.headers } } : {}
+            })
+          }
+        ];
+      }
+      case "ws": {
+        const ref = serverRef;
+        await ensureWebSocketGlobal();
+        return [
+          {
+            kind: "ws",
+            transport: new WebSocketClientTransport(new URL(ref.url))
+          }
+        ];
+      }
+      case "ws-ide": {
+        const ref = serverRef;
+        let url = ref.url;
+        if (ref.authToken) {
+          try {
+            const parsed = new URL(url);
+            if (!parsed.searchParams.has("authToken")) {
+              parsed.searchParams.set("authToken", ref.authToken);
+              url = parsed.toString();
+            }
+          } catch {
+          }
+        }
+        await ensureWebSocketGlobal();
+        return [
+          {
+            kind: "ws",
+            transport: new WebSocketClientTransport(new URL(url))
+          }
+        ];
+      }
+      case "stdio":
+      default: {
+        const ref = serverRef;
+        return [
+          {
+            kind: "stdio",
+            transport: new StdioClientTransport({
+              command: ref.command,
+              args: ref.args,
+              env: buildStdioEnv(ref.env),
+              stderr: "pipe"
+            })
+          }
+        ];
+      }
+    }
+  })();
+  const rawTimeout = process.env.MCP_CONNECTION_TIMEOUT_MS;
+  const parsedTimeout = rawTimeout ? Number.parseInt(rawTimeout, 10) : NaN;
+  const connectionTimeoutMs = Number.isFinite(parsedTimeout) ? parsedTimeout : 3e4;
+  let lastError;
+  for (const candidate of candidates) {
+    const client = new Client(
+      { name: PRODUCT_COMMAND, version: "0.1.0" },
+      { capabilities: {} }
+    );
+    try {
+      const connectPromise = client.connect(candidate.transport);
+      if (connectionTimeoutMs > 0) {
+        const timeoutPromise = new Promise((_, reject) => {
+          const timeoutId = setTimeout(() => {
+            reject(
+              new Error(
+                `Connection to MCP server "${name}" timed out after ${connectionTimeoutMs}ms`
+              )
+            );
+          }, connectionTimeoutMs);
+          connectPromise.finally(() => clearTimeout(timeoutId));
+        });
+        await Promise.race([connectPromise, timeoutPromise]);
+      } else {
+        await connectPromise;
+      }
+      if (candidate.kind === "stdio") {
+        candidate.transport.stderr?.on("data", (data) => {
+          const errorText = data.toString().trim();
+          if (errorText) logMCPError(name, `Server stderr: ${errorText}`);
+        });
+      }
+      if (candidates.length > 1 && candidate !== candidates[0]) {
+        logMCPError(
+          name,
+          `Connected using fallback transport "${candidate.kind}". Consider setting the server type explicitly in your MCP config.`
+        );
+      }
+      return client;
+    } catch (error) {
+      lastError = error;
+      try {
+        await client.close();
+      } catch {
+      }
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(`Failed to connect to MCP server "${name}"`);
+}
+
+// packages/core/src/mcp/client/settings.ts
+function sanitizeMcpIdentifierPart(value) {
+  return value.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function getMcpServerConnectionBatchSize() {
+  const raw = process.env.MCP_SERVER_CONNECTION_BATCH_SIZE;
+  const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
+  if (Number.isFinite(parsed) && parsed > 0 && parsed <= 50) return parsed;
+  return 3;
+}
+function getMcpToolTimeoutMs() {
+  const raw = process.env.MCP_TOOL_TIMEOUT;
+  const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
+  if (!Number.isFinite(parsed) || parsed <= 0) return null;
+  return parsed;
+}
+var IDE_MCP_TOOL_ALLOWLIST = /* @__PURE__ */ new Set([
+  "mcp__ide__executeCode",
+  "mcp__ide__getDiagnostics"
+]);
+
+// packages/core/src/mcp/client/clients.ts
+var getClients = memoize(async () => {
+  if (process.env.CI && process.env.NODE_ENV !== "test") {
+    return [];
+  }
+  const pluginServers = listPluginMCPServers();
+  const globalServers = getGlobalConfig().mcpServers ?? {};
+  const projectFileServers = getProjectMcpServerDefinitions().servers;
+  const projectServers = getCurrentProjectConfig().mcpServers ?? {};
+  const approvedProjectFileServers = pickBy(
+    projectFileServers,
+    (_, name) => getMcprcServerStatus(name) === "approved"
+  );
+  const allServers = {
+    ...pluginServers,
+    ...globalServers,
+    ...approvedProjectFileServers,
+    ...projectServers
+  };
+  const batchSize = getMcpServerConnectionBatchSize();
+  const entries = Object.entries(allServers);
+  const results = [];
+  for (let i = 0; i < entries.length; i += batchSize) {
+    const batch = entries.slice(i, i + batchSize);
+    const batchResults = await Promise.all(
+      batch.map(async ([name, serverRef]) => {
+        try {
+          const client = await connectToServer(name, serverRef);
+          let capabilities = null;
+          try {
+            capabilities = client.getServerCapabilities() ?? null;
+          } catch {
+            capabilities = null;
+          }
+          return { name, client, capabilities, type: "connected" };
+        } catch (error) {
+          logMCPError(
+            name,
+            `Connection failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+          return { name, type: "failed" };
+        }
+      })
+    );
+    results.push(...batchResults);
+  }
+  return results;
+});
+async function getClientsForCliMcpConfig(options) {
+  const projectDir = options.projectDir ?? getCwd();
+  const entries = Array.isArray(options.mcpConfig) && options.mcpConfig.length > 0 ? options.mcpConfig : [];
+  const strict = options.strictMcpConfig === true;
+  if (entries.length === 0 && !strict) {
+    return getClients();
+  }
+  const cliServers = parseMcpServersFromCliConfigEntries({
+    entries,
+    projectDir
+  });
+  const pluginServers = strict ? {} : listPluginMCPServers();
+  const globalServers = strict ? {} : getGlobalConfig().mcpServers ?? {};
+  const projectFileServers = strict ? {} : getProjectMcpServerDefinitions().servers;
+  const projectServers = strict ? {} : getCurrentProjectConfig().mcpServers ?? {};
+  const approvedProjectFileServers = strict ? {} : pickBy(
+    projectFileServers,
+    (_, name) => getMcprcServerStatus(name) === "approved"
+  );
+  const allServers = {
+    ...pluginServers ?? {},
+    ...globalServers ?? {},
+    ...approvedProjectFileServers ?? {},
+    ...projectServers ?? {},
+    ...cliServers ?? {}
+  };
+  const batchSize = getMcpServerConnectionBatchSize();
+  const entriesToConnect = Object.entries(allServers);
+  const results = [];
+  for (let i = 0; i < entriesToConnect.length; i += batchSize) {
+    const batch = entriesToConnect.slice(i, i + batchSize);
+    const batchResults = await Promise.all(
+      batch.map(async ([name, serverRef]) => {
+        try {
+          const client = await connectToServer(name, serverRef);
+          let capabilities = null;
+          try {
+            capabilities = client.getServerCapabilities() ?? null;
+          } catch {
+            capabilities = null;
+          }
+          return { name, client, capabilities, type: "connected" };
+        } catch (error) {
+          logMCPError(
+            name,
+            `Connection failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+          return { name, type: "failed" };
+        }
+      })
+    );
+    results.push(...batchResults);
+  }
+  return results;
+}
+
+// packages/core/src/mcp/client/tools.ts
+import {
+  CallToolResultSchema,
+  ListToolsResultSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { memoize as memoize2 } from "lodash-es";
+import { z } from "zod";
+
+// packages/core/src/mcp/client/timeouts.ts
+function createTimeoutSignal(timeoutMs) {
+  if (typeof AbortSignal.timeout === "function") {
+    return { signal: AbortSignal.timeout(timeoutMs), cleanup: () => {
+    } };
+  }
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), timeoutMs);
+  return { signal: controller.signal, cleanup: () => clearTimeout(id) };
+}
+function mergeAbortSignals(signals) {
+  const active = signals.filter((s) => !!s);
+  if (active.length === 0) return null;
+  if (active.length === 1) return { signal: active[0], cleanup: () => {
+  } };
+  const controller = new AbortController();
+  const unsubscribers = [];
+  const abort = () => {
+    try {
+      controller.abort();
+    } catch {
+    }
+  };
+  for (const signal of active) {
+    if (signal.aborted) {
+      abort();
+      return { signal: controller.signal, cleanup: () => {
+      } };
+    }
+    signal.addEventListener("abort", abort, { once: true });
+    unsubscribers.push(() => {
+      try {
+        signal.removeEventListener("abort", abort);
+      } catch {
+      }
+    });
+  }
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      for (const unsubscribe of unsubscribers) unsubscribe();
+    }
+  };
+}
+
+// packages/core/src/mcp/client/request.ts
+async function requestAll(req, resultSchema, requiredCapability) {
+  const timeoutMs = getMcpToolTimeoutMs();
+  const clients = await getClients();
+  const results = await Promise.allSettled(
+    clients.map(async (client) => {
+      if (client.type === "failed") return null;
+      let timeoutSignal = null;
+      let mergedSignal = null;
+      try {
+        let capabilities = client.capabilities ?? null;
+        if (!capabilities) {
+          try {
+            capabilities = client.client.getServerCapabilities() ?? null;
+          } catch {
+            capabilities = null;
+          }
+          client.capabilities = capabilities;
+        }
+        if (!capabilities?.[requiredCapability]) {
+          return null;
+        }
+        timeoutSignal = timeoutMs ? createTimeoutSignal(timeoutMs) : null;
+        mergedSignal = mergeAbortSignals([timeoutSignal?.signal]);
+        const options = mergedSignal?.signal ? { signal: mergedSignal.signal } : void 0;
+        return {
+          client,
+          result: await client.client.request(
+            req,
+            resultSchema,
+            options
+          )
+        };
+      } catch (error) {
+        logMCPError(
+          client.name,
+          `Failed to request '${req.method}': ${error instanceof Error ? error.message : String(error)}`
+        );
+        return null;
+      } finally {
+        mergedSignal?.cleanup();
+        timeoutSignal?.cleanup();
+      }
+    })
+  );
+  return results.filter(
+    (result) => result.status === "fulfilled"
+  ).map((result) => result.value).filter(
+    (result) => result !== null
+  );
+}
+
+// packages/core/src/mcp/client/tools.ts
+function isTextBlock(value) {
+  return isRecord(value) && value.type === "text" && typeof value.text === "string";
+}
+function isImageBlock(value) {
+  return isRecord(value) && value.type === "image";
+}
+function renderToolUseMessage(input) {
+  if (!isRecord(input)) return String(input ?? "");
+  return Object.entries(input).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ");
+}
+function renderToolResultMessage(output) {
+  if (Array.isArray(output)) {
+    return output.map((item) => {
+      if (!item || typeof item !== "object") return String(item ?? "");
+      if (isImageBlock(item)) return "[Image]";
+      if (isTextBlock(item)) return item.text;
+      return JSON.stringify(item);
+    }).join("\n");
+  }
+  if (!output) return "(No content)";
+  return typeof output === "string" ? output : JSON.stringify(output);
+}
+function renderResultForAssistant(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return content;
+  if (!content) return "";
+  try {
+    return JSON.stringify(content);
+  } catch {
+    return String(content);
+  }
+}
+var getMCPTools = memoize2(async () => {
+  const toolsList = await requestAll({ method: "tools/list" }, ListToolsResultSchema, "tools");
+  const inputSchema = z.object({}).passthrough();
+  return toolsList.flatMap(({ client, result: { tools } }) => {
+    const serverPart = sanitizeMcpIdentifierPart(client.name);
+    return tools.map((tool) => {
+      const toolPart = sanitizeMcpIdentifierPart(tool.name);
+      const name = `mcp__${serverPart}__${toolPart}`;
+      if (name.startsWith("mcp__ide__") && !IDE_MCP_TOOL_ALLOWLIST.has(name)) {
+        return null;
+      }
+      return {
+        name,
+        cachedDescription: tool.description ?? "",
+        async isEnabled() {
+          return true;
+        },
+        isConcurrencySafe() {
+          return tool.annotations?.readOnlyHint ?? false;
+        },
+        isReadOnly() {
+          return tool.annotations?.readOnlyHint ?? false;
+        },
+        async description() {
+          return tool.description ?? "";
+        },
+        async prompt() {
+          return tool.description ?? "";
+        },
+        inputSchema,
+        inputJSONSchema: tool.inputSchema,
+        needsPermissions() {
+          return true;
+        },
+        async validateInput() {
+          return { result: true };
+        },
+        renderToolUseMessage,
+        renderToolUseRejectedMessage() {
+          return null;
+        },
+        renderToolResultMessage,
+        renderResultForAssistant,
+        async *call(args, context) {
+          const data = await callMcpTool({
+            client,
+            tool: tool.name,
+            args,
+            toolUseId: context.toolUseId,
+            signal: context.abortController.signal
+          });
+          yield {
+            type: "result",
+            data,
+            resultForAssistant: data
+          };
+        },
+        userFacingName() {
+          const title = tool.annotations?.title || tool.name;
+          return `${client.name} - ${title} (MCP)`;
+        }
+      };
+    }).filter((tool) => tool !== null);
+  });
+});
+async function callMcpTool({
+  client: { client, name },
+  tool,
+  args,
+  toolUseId,
+  signal
+}) {
+  const timeoutMs = getMcpToolTimeoutMs();
+  const timeoutSignal = timeoutMs ? createTimeoutSignal(timeoutMs) : null;
+  const merged = mergeAbortSignals([signal, timeoutSignal?.signal]);
+  const meta = toolUseId && toolUseId.trim() ? { "claudecode/toolUseId": toolUseId } : void 0;
+  try {
+    const options = merged?.signal ? { signal: merged.signal } : void 0;
+    const rawResult = await client.callTool(
+      {
+        name: tool,
+        arguments: args,
+        ...meta ? { _meta: meta } : {}
+      },
+      CallToolResultSchema,
+      options
+    );
+    const result = CallToolResultSchema.parse(rawResult);
+    if (result.isError) {
+      const contentText = result.content.find((item) => item.type === "text");
+      const extraError = isRecord(rawResult) && typeof rawResult.error === "string" ? rawResult.error : isRecord(result) && typeof result.error === "string" ? result.error : "";
+      const message = contentText?.text?.trim() || extraError || `Error calling tool ${tool}`;
+      logMCPError(name, `Error calling tool ${tool}: ${message}`);
+      throw new Error(message);
+    }
+    const toolResult = isRecord(rawResult) && rawResult.toolResult !== void 0 ? rawResult.toolResult : isRecord(result) && result.toolResult !== void 0 ? result.toolResult : void 0;
+    if (toolResult !== void 0) return String(toolResult);
+    if (result.structuredContent !== void 0) {
+      return JSON.stringify(result.structuredContent);
+    }
+    const blocks = [];
+    for (const item of result.content) {
+      switch (item.type) {
+        case "text":
+          blocks.push({ type: "text", text: item.text });
+          break;
+        case "image":
+          blocks.push({
+            type: "image",
+            source: {
+              type: "base64",
+              data: item.data,
+              media_type: item.mimeType
+            }
+          });
+          break;
+        default: {
+          let text = "";
+          try {
+            text = JSON.stringify(item);
+          } catch {
+            text = String(item);
+          }
+          blocks.push({ type: "text", text });
+          break;
+        }
+      }
+    }
+    return blocks.length > 0 ? blocks : "(No content)";
+  } finally {
+    merged?.cleanup();
+    timeoutSignal?.cleanup();
+  }
+}
+
+// packages/core/src/mcp/client/commands.ts
+import { memoize as memoize3, zipObject } from "lodash-es";
+import { ListPromptsResultSchema } from "@modelcontextprotocol/sdk/types.js";
+var getMCPCommands = memoize3(async () => {
+  const results = await requestAll({ method: "prompts/list" }, ListPromptsResultSchema, "prompts");
+  return results.flatMap(
+    ({ client, result }) => result.prompts?.map((prompt) => {
+      const serverPart = sanitizeMcpIdentifierPart(client.name);
+      const argNames = (prompt.arguments ?? []).map((arg) => arg.name);
+      return {
+        type: "prompt",
+        name: `mcp__${serverPart}__${prompt.name}`,
+        description: prompt.description ?? "",
+        isEnabled: true,
+        isHidden: false,
+        progressMessage: "running",
+        userFacingName() {
+          const title = prompt.title?.trim() || prompt.name;
+          return `${client.name}:${title} (MCP)`;
+        },
+        argNames,
+        async getPromptForCommand(args) {
+          const argsArray = args.split(" ");
+          return await runCommand(
+            { name: prompt.name, client },
+            zipObject(argNames, argsArray)
+          );
+        }
+      };
+    })
+  );
+});
+async function runCommand({ name, client }, args) {
+  try {
+    const result = await client.client.getPrompt({ name, arguments: args });
+    return result.messages.map((message) => {
+      const content = message.content;
+      switch (content.type) {
+        case "text":
+          return {
+            role: message.role,
+            content: [{ type: "text", text: content.text }]
+          };
+        case "image":
+          return {
+            role: message.role,
+            content: [
+              {
+                type: "image",
+                source: {
+                  type: "base64",
+                  data: content.data,
+                  media_type: content.mimeType
+                }
+              }
+            ]
+          };
+        default:
+          return {
+            role: message.role,
+            content: [
+              {
+                type: "text",
+                text: `Unsupported MCP content type ${content.type}`
+              }
+            ]
+          };
+      }
+    });
+  } catch (error) {
+    logMCPError(
+      client.name,
+      `Error running command '${name}': ${error instanceof Error ? error.message : String(error)}`
+    );
+    throw error;
+  }
+}
+
+export {
+  safeParseJSON,
+  parseEnvVars,
+  ensureConfigScope,
+  listPluginMCPServers,
+  getMcprcServerStatus,
+  addMcpServer,
+  removeMcpServer,
+  listMCPServers,
+  getMcpServer,
+  parseMcpServersFromCliConfigEntries,
+  getClients,
+  getClientsForCliMcpConfig,
+  getMCPTools,
+  getMCPCommands,
+  runCommand
+};