@wuyax/mcps 0.1.0-beta.2 → 0.1.0

package/dist/chunk-O3BRJFEC.js

@@ -0,0 +1,1898 @@
+// src/agents.ts
+import { existsSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+var home = homedir();
+var getPlatformPaths = () => {
+  const currentPlatform = platform();
+  if (currentPlatform === "win32") {
+    const appData = process.env.APPDATA || join(home, "AppData", "Roaming");
+    return {
+      appSupport: appData,
+      vscodePath: join(appData, "Code", "User"),
+      traePath: join(appData, "Trae", "User"),
+      gooseConfigPath: join(appData, "Block", "goose", "config", "config.yaml"),
+      zedConfigPath: join(appData, "Zed", "settings.json")
+    };
+  }
+  if (currentPlatform === "darwin") {
+    return {
+      appSupport: join(home, "Library", "Application Support"),
+      vscodePath: join(home, "Library", "Application Support", "Code", "User"),
+      traePath: join(home, "Library", "Application Support", "Trae", "User"),
+      gooseConfigPath: join(home, ".config", "goose", "config.yaml"),
+      zedConfigPath: join(home, ".config", "zed", "settings.json")
+    };
+  }
+  const configDir = process.env.XDG_CONFIG_HOME || join(home, ".config");
+  return {
+    appSupport: configDir,
+    vscodePath: join(configDir, "Code", "User"),
+    traePath: join(configDir, "Trae", "User"),
+    gooseConfigPath: join(configDir, "goose", "config.yaml"),
+    zedConfigPath: join(configDir, "zed", "settings.json")
+  };
+};
+var { appSupport, vscodePath, traePath, gooseConfigPath, zedConfigPath } = getPlatformPaths();
+var ampConfigDir = process.env.AMP_HOME?.trim() || join(process.env.XDG_CONFIG_HOME || join(home, ".config"), "amp");
+var ampGlobalConfigPath = existsSync(join(ampConfigDir, "settings.jsonc")) ? join(ampConfigDir, "settings.jsonc") : join(ampConfigDir, "settings.json");
+var antigravityMcpConfigPath = join(home, ".gemini", "config", "mcp_config.json");
+var augmentConfigDir = process.env.AUGMENT_HOME?.trim() || join(home, ".augment");
+var augmentGlobalConfigPath = existsSync(join(augmentConfigDir, "settings.jsonc")) ? join(augmentConfigDir, "settings.jsonc") : join(augmentConfigDir, "settings.json");
+var clineDir = process.env.CLINE_DIR || join(home, ".cline");
+var clineCliConfigPath = join(clineDir, "mcp.json");
+var clineExtensionConfigPath = join(
+  vscodePath,
+  "globalStorage",
+  "saoudrizwan.claude-dev",
+  "settings",
+  "cline_mcp_settings.json"
+);
+var copilotConfigPath = join(
+  process.env.COPILOT_HOME?.trim() || join(home, ".copilot"),
+  "mcp-config.json"
+);
+var grokConfigPath = join(
+  process.env.GROK_HOME?.trim() || join(home, ".grok"),
+  "config.toml"
+);
+var kimiCodeConfigPath = join(
+  process.env.KIMI_CODE_HOME?.trim() || join(home, ".kimi-code"),
+  "mcp.json"
+);
+var kiroConfigPath = join(
+  process.env.KIRO_HOME?.trim() || join(home, ".kiro"),
+  "settings",
+  "mcp.json"
+);
+var qoderConfigPath = join(
+  process.env.QODER_HOME?.trim() || join(home, ".qoder"),
+  "settings.json"
+);
+var qwenCodeConfigPath = join(
+  process.env.QWEN_CODE_HOME?.trim() || process.env.QWEN_HOME?.trim() || join(home, ".qwen"),
+  "settings.json"
+);
+var traeConfigPath = existsSync(join(home, ".trae", "mcp.json")) ? join(home, ".trae", "mcp.json") : join(traePath, "mcp.json");
+var ALL_TRANSPORTS = ["stdio", "http", "sse"];
+var mcpAgents = {
+  // https://ampcode.com/docs/markdown/customize/mcp
+  amp: {
+    name: "amp",
+    displayName: "Amp",
+    globalConfigPath: ampGlobalConfigPath,
+    projectConfigPath: ".amp/settings.json",
+    configKey: "amp.mcpServers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(ampConfigDir) || existsSync(join(home, ".amp")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".amp", "settings.json")) || existsSync(join(cwd, ".amp", "settings.jsonc")) || existsSync(join(cwd, ".amp")),
+    resolveConfigPath: ({ global: isGlobal, cwd }) => {
+      if (isGlobal) {
+        if (existsSync(join(ampConfigDir, "settings.jsonc"))) {
+          return join(ampConfigDir, "settings.jsonc");
+        }
+        return ampGlobalConfigPath;
+      }
+      if (existsSync(join(cwd, ".amp", "settings.jsonc"))) {
+        return join(cwd, ".amp", "settings.jsonc");
+      }
+      return join(cwd, ".amp", "settings.json");
+    },
+    transformDialect: "amp"
+  },
+  antigravity: {
+    name: "antigravity",
+    displayName: "Antigravity",
+    globalConfigPath: antigravityMcpConfigPath,
+    projectConfigPath: ".agents/mcp_config.json",
+    configKey: "mcpServers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(join(home, ".gemini", "antigravity")) || existsSync(join(home, ".gemini", "config")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".agents", "mcp_config.json")) || existsSync(join(cwd, ".agents"))
+  },
+  // https://antigravity.google/docs/cli/mcp/
+  "antigravity-cli": {
+    name: "antigravity-cli",
+    displayName: "Antigravity CLI",
+    globalConfigPath: antigravityMcpConfigPath,
+    projectConfigPath: ".agents/mcp_config.json",
+    configKey: "mcpServers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(join(home, ".gemini", "antigravity-cli")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".agents", "mcp_config.json")) || existsSync(join(cwd, ".agents"))
+  },
+  // https://docs.augmentcode.com/cli/integrations.md
+  augment: {
+    name: "augment",
+    displayName: "Augment",
+    globalConfigPath: augmentGlobalConfigPath,
+    projectConfigPath: ".augment/settings.json",
+    configKey: "mcpServers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(augmentConfigDir) || existsSync(join(home, ".augment")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".augment", "settings.json")) || existsSync(join(cwd, ".augment", "settings.jsonc")) || existsSync(join(cwd, ".augment")),
+    resolveConfigPath: ({ global: isGlobal, cwd }) => {
+      if (isGlobal) {
+        if (existsSync(join(augmentConfigDir, "settings.jsonc"))) {
+          return join(augmentConfigDir, "settings.jsonc");
+        }
+        return augmentGlobalConfigPath;
+      }
+      if (existsSync(join(cwd, ".augment", "settings.jsonc"))) {
+        return join(cwd, ".augment", "settings.jsonc");
+      }
+      return join(cwd, ".augment", "settings.json");
+    },
+    transformDialect: "augment"
+  },
+  cline: {
+    name: "cline",
+    displayName: "Cline (VSCode extension)",
+    globalConfigPath: clineExtensionConfigPath,
+    projectConfigPath: ".cline/mcp.json",
+    configKey: "mcpServers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(clineExtensionConfigPath),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".cline", "mcp.json")) || existsSync(join(cwd, ".cline")),
+    resolveConfigPath: ({ global: isGlobal, cwd }) => {
+      if (isGlobal) {
+        return clineExtensionConfigPath;
+      }
+      return join(cwd, ".cline", "mcp.json");
+    },
+    transformDialect: "cline"
+  },
+  // https://docs.cline.bot/mcp/mcp-overview.md
+  "cline-cli": {
+    name: "cline-cli",
+    displayName: "Cline CLI",
+    globalConfigPath: clineCliConfigPath,
+    projectConfigPath: ".cline/mcp.json",
+    configKey: "mcpServers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(clineDir),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".cline", "mcp.json")) || existsSync(join(cwd, ".cline")),
+    resolveConfigPath: ({ global: isGlobal, cwd }) => {
+      if (isGlobal) {
+        return clineCliConfigPath;
+      }
+      return join(cwd, ".cline", "mcp.json");
+    },
+    transformDialect: "cline"
+  },
+  // https://code.claude.com/docs/en/mcp-quickstart#edit-mcp-json-directly
+  "claude-code": {
+    name: "claude-code",
+    displayName: "Claude Code",
+    globalConfigPath: join(home, ".claude.json"),
+    projectConfigPath: ".mcp.json",
+    configKey: "mcpServers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(join(home, ".claude.json")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".mcp.json"))
+  },
+  "claude-desktop": {
+    name: "claude-desktop",
+    displayName: "Claude Desktop",
+    globalConfigPath: join(appSupport, "Claude", "claude_desktop_config.json"),
+    configKey: "mcpServers",
+    format: "jsonc",
+    supportedTransports: ["stdio"],
+    unsupportedTransportMessage: "Claude Desktop currently supports only stdio MCP servers. Use a package name or command instead of a URL.",
+    detectGlobalInstall: () => existsSync(join(appSupport, "Claude", "claude_desktop_config.json"))
+  },
+  // https://learn.chatgpt.com/docs/extend/mcp?surface=app
+  codex: {
+    name: "codex",
+    displayName: "Codex",
+    globalConfigPath: join(process.env.CODEX_HOME?.trim() || join(home, ".codex"), "config.toml"),
+    projectConfigPath: ".codex/config.toml",
+    configKey: "mcp_servers",
+    format: "toml",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(process.env.CODEX_HOME?.trim() || join(home, ".codex")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".codex", "config.toml")),
+    transformDialect: "augment"
+  },
+  // https://cursor.com/help/customization/mcp
+  cursor: {
+    name: "cursor",
+    displayName: "Cursor",
+    globalConfigPath: join(home, ".cursor", "mcp.json"),
+    projectConfigPath: ".cursor/mcp.json",
+    configKey: "mcpServers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(join(home, ".cursor")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".cursor", "mcp.json"))
+  },
+  "gemini-cli": {
+    name: "gemini-cli",
+    displayName: "Gemini CLI",
+    globalConfigPath: join(home, ".gemini", "settings.json"),
+    projectConfigPath: ".gemini/settings.json",
+    configKey: "mcpServers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(join(home, ".gemini")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".gemini", "settings.json"))
+  },
+  // https://docs.x.ai/build/features/mcp-servers.md
+  grok: {
+    name: "grok",
+    displayName: "Grok",
+    globalConfigPath: grokConfigPath,
+    projectConfigPath: ".grok/config.toml",
+    configKey: "mcp_servers",
+    format: "toml",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(grokConfigPath) || existsSync(process.env.GROK_HOME?.trim() || join(home, ".grok")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".grok", "config.toml")) || existsSync(join(cwd, ".grok")),
+    transformDialect: "grok"
+  },
+  // https://goose-docs.ai/docs/guides/config-files/
+  goose: {
+    name: "goose",
+    displayName: "Goose",
+    globalConfigPath: gooseConfigPath,
+    projectConfigPath: ".goose/config.yaml",
+    configKey: "extensions",
+    format: "yaml",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(gooseConfigPath),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".goose", "config.yaml")),
+    transformDialect: "goose"
+  },
+  "github-copilot-cli": {
+    name: "github-copilot-cli",
+    displayName: "GitHub Copilot CLI",
+    globalConfigPath: copilotConfigPath,
+    projectConfigPath: ".mcp.json",
+    configKey: "mcpServers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(copilotConfigPath) || existsSync(process.env.COPILOT_HOME?.trim() || join(home, ".copilot")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".mcp.json")) || existsSync(join(cwd, ".github", "mcp.json")),
+    transformDialect: "vscode"
+  },
+  // https://www.kimi.com/code/docs/en/kimi-code-cli/customization/mcp.html
+  "kimi-code-cli": {
+    name: "kimi-code-cli",
+    displayName: "Kimi Code CLI",
+    globalConfigPath: kimiCodeConfigPath,
+    projectConfigPath: ".kimi-code/mcp.json",
+    configKey: "mcpServers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(kimiCodeConfigPath) || existsSync(process.env.KIMI_CODE_HOME?.trim() || join(home, ".kimi-code")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".kimi-code", "mcp.json")) || existsSync(join(cwd, ".kimi-code")),
+    transformDialect: "kimi-code"
+  },
+  // https://kiro.dev/docs/mcp/configuration.md
+  kiro: {
+    name: "kiro",
+    displayName: "Kiro",
+    globalConfigPath: kiroConfigPath,
+    projectConfigPath: ".kiro/settings/mcp.json",
+    configKey: "mcpServers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(kiroConfigPath) || existsSync(process.env.KIRO_HOME?.trim() || join(home, ".kiro")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".kiro", "settings", "mcp.json")) || existsSync(join(cwd, ".kiro")),
+    transformDialect: "kiro"
+  },
+  // https://opencode.ai/docs/config/
+  opencode: {
+    name: "opencode",
+    displayName: "OpenCode",
+    globalConfigPath: join(
+      process.env.XDG_CONFIG_HOME || join(home, ".config"),
+      "opencode",
+      "opencode.json"
+    ),
+    projectConfigPath: "opencode.json",
+    configKey: "mcp",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(join(process.env.XDG_CONFIG_HOME || join(home, ".config"), "opencode")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, "opencode.json")),
+    transformDialect: "opencode"
+  },
+  // https://pi.dev/packages/pi-mcp-extension
+  pi: {
+    name: "pi",
+    displayName: "Pi",
+    globalConfigPath: join(home, ".pi", "agent", "mcp.json"),
+    projectConfigPath: ".pi/mcp.json",
+    configKey: "mcpServers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(join(home, ".pi")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".pi", "mcp.json")) || existsSync(join(cwd, ".pi")),
+    transformDialect: "pi"
+  },
+  // https://docs.qoder.com/zh/cli/mcp-servers.md
+  qoder: {
+    name: "qoder",
+    displayName: "Qoder",
+    globalConfigPath: qoderConfigPath,
+    projectConfigPath: ".mcp.json",
+    configKey: "mcpServers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(qoderConfigPath) || existsSync(process.env.QODER_HOME?.trim() || join(home, ".qoder")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".mcp.json")) || existsSync(join(cwd, ".qoder", "settings.json")) || existsSync(join(cwd, ".qoder")),
+    resolveConfigPath: ({ global: isGlobal, cwd }) => {
+      if (isGlobal) return qoderConfigPath;
+      if (existsSync(join(cwd, ".qoder", "settings.json"))) {
+        return join(cwd, ".qoder", "settings.json");
+      }
+      return join(cwd, ".mcp.json");
+    }
+  },
+  // https://qwenlm.github.io/qwen-code-docs/en/users/features/mcp/
+  "qwen-code": {
+    name: "qwen-code",
+    displayName: "Qwen Code",
+    globalConfigPath: qwenCodeConfigPath,
+    projectConfigPath: ".qwen/settings.json",
+    configKey: "mcpServers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(qwenCodeConfigPath) || existsSync(
+      process.env.QWEN_CODE_HOME?.trim() || process.env.QWEN_HOME?.trim() || join(home, ".qwen")
+    ),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".qwen", "settings.json")) || existsSync(join(cwd, ".qwen")),
+    transformDialect: "qwen-code"
+  },
+  // https://docs.trae.ai/ide/add-mcp-servers?_lang=en
+  trae: {
+    name: "trae",
+    displayName: "Trae",
+    globalConfigPath: traeConfigPath,
+    projectConfigPath: ".trae/mcp.json",
+    configKey: "mcpServers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(traeConfigPath) || existsSync(join(home, ".trae", "mcp.json")) || existsSync(join(home, ".trae")) || existsSync(traePath) || existsSync(join(appSupport, "Trae")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".trae", "mcp.json")) || existsSync(join(cwd, ".trae")),
+    resolveConfigPath: ({ global: isGlobal, cwd }) => {
+      if (isGlobal) {
+        if (existsSync(join(home, ".trae", "mcp.json"))) {
+          return join(home, ".trae", "mcp.json");
+        }
+        return traeConfigPath;
+      }
+      return join(cwd, ".trae", "mcp.json");
+    },
+    transformDialect: "trae"
+  },
+  // https://code.visualstudio.com/raw/docs/agents/reference/mcp-configuration.md
+  vscode: {
+    name: "vscode",
+    displayName: "VS Code",
+    globalConfigPath: join(vscodePath, "mcp.json"),
+    projectConfigPath: ".vscode/mcp.json",
+    configKey: "servers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(join(vscodePath, "mcp.json")) || existsSync(vscodePath),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".vscode", "mcp.json")),
+    transformDialect: "vscode"
+  },
+  // https://zed.dev/docs/ai/mcp.md
+  zed: {
+    name: "zed",
+    displayName: "Zed",
+    globalConfigPath: zedConfigPath,
+    projectConfigPath: ".zed/settings.json",
+    configKey: "context_servers",
+    format: "jsonc",
+    supportedTransports: ALL_TRANSPORTS,
+    detectGlobalInstall: () => existsSync(zedConfigPath) || existsSync(join(process.env.XDG_CONFIG_HOME || join(home, ".config"), "zed")) || existsSync(join(appSupport, "Zed")),
+    detectProjectInstall: (cwd) => existsSync(join(cwd, ".zed", "settings.json")),
+    transformDialect: "zed"
+  }
+};
+var mcpAgentAliases = {
+  agy: "antigravity-cli",
+  "amp-cli": "amp",
+  "amp-code": "amp",
+  ampcode: "amp",
+  auggie: "augment",
+  "augment-code": "augment",
+  augmentcode: "augment",
+  "cline-vscode": "cline",
+  gemini: "gemini-cli",
+  "github-copilot": "vscode",
+  "grok-cli": "grok",
+  kimi: "kimi-code-cli",
+  "kimi-cli": "kimi-code-cli",
+  "kimi-code": "kimi-code-cli",
+  "kiro-cli": "kiro",
+  "kiro-ide": "kiro",
+  "pi-agent": "pi",
+  "qoder-cli": "qoder",
+  qwen: "qwen-code",
+  "qwen-cli": "qwen-code",
+  qwencode: "qwen-code",
+  "trae-code": "trae",
+  traecode: "trae",
+  "trae-ide": "trae",
+  xai: "grok",
+  "xai-grok": "grok"
+};
+var getMcpAgentConfig = (agentType) => mcpAgents[agentType];
+var getMcpAgentTypes = () => Object.values(mcpAgents).map((config) => config.name);
+var isMcpAgentType = (value) => value in mcpAgents;
+var resolveMcpAgentAlias = (input) => {
+  if (isMcpAgentType(input)) return input;
+  return mcpAgentAliases[input] ?? null;
+};
+var isMcpTransportSupported = (agent, transport) => agent.supportedTransports.includes(transport);
+var detectProjectInstalledMcpAgents = (cwd) => getMcpAgentTypes().filter(
+  (type) => mcpAgents[type].detectProjectInstall ? mcpAgents[type].detectProjectInstall(cwd) : false
+);
+var detectGloballyInstalledMcpAgents = () => getMcpAgentTypes().filter((type) => mcpAgents[type].detectGlobalInstall());
+var getMcpAgentsSupportingProjectScope = () => getMcpAgentTypes().filter((type) => Boolean(mcpAgents[type].projectConfigPath));
+
+// src/constants.ts
+var DEFAULT_REMOTE_TRANSPORT = "http";
+var NPX_COMMAND = "npx";
+var NPX_DASH_Y = "-y";
+var GOOSE_TIMEOUT_SECONDS = 300;
+var DEFAULT_JSON_INDENT_SPACES = 2;
+var MCP_DEFAULT_SERVER_NAME = "mcp-server";
+var GENERIC_HOST_PREFIXES = /* @__PURE__ */ new Set([
+  "mcp",
+  "api",
+  "app",
+  "www",
+  "server",
+  "servers",
+  "remote"
+]);
+var COMMON_TLD_LABELS = /* @__PURE__ */ new Set([
+  "com",
+  "org",
+  "net",
+  "io",
+  "dev",
+  "ai",
+  "tech",
+  "co",
+  "app",
+  "cloud",
+  "sh",
+  "run"
+]);
+var PACKAGE_NAME_PREFIX_STRIP = ["mcp-server-", "server-"];
+var PACKAGE_NAME_SUFFIX_STRIP = ["-mcp-server", "-mcp"];
+var KNOWN_COMMAND_RUNNERS = /* @__PURE__ */ new Set([
+  "npx",
+  "node",
+  "python",
+  "python3",
+  "uvx",
+  "bunx",
+  "deno"
+]);
+var SCRIPT_EXTENSION_REGEX = /\.(?:js|ts|mjs|cjs|py|sh|rb|go)$/i;
+
+// src/server-config.ts
+var isRemoteServerConfig = (config) => typeof config.url === "string" && config.url.length > 0;
+var isStdioServerConfig = (config) => typeof config.command === "string" && config.command.length > 0;
+var buildMcpServerConfig = (parsed, options = {}) => {
+  if (parsed.type === "remote") {
+    const config2 = {
+      type: options.transport ?? DEFAULT_REMOTE_TRANSPORT,
+      url: parsed.value
+    };
+    if (options.headers && Object.keys(options.headers).length > 0) {
+      config2.headers = options.headers;
+    }
+    return config2;
+  }
+  if (parsed.type === "command") {
+    const parts = parsed.value.split(/\s+/);
+    const command = parts[0] ?? "";
+    const args = parts.slice(1);
+    if (options.args && options.args.length > 0) {
+      args.push(...options.args);
+    }
+    const config2 = { command, args };
+    if (options.env && Object.keys(options.env).length > 0) {
+      config2.env = options.env;
+    }
+    return config2;
+  }
+  const packageArgs = [NPX_DASH_Y, parsed.value];
+  if (options.args && options.args.length > 0) {
+    packageArgs.push(...options.args);
+  }
+  const config = {
+    command: NPX_COMMAND,
+    args: packageArgs
+  };
+  if (options.env && Object.keys(options.env).length > 0) {
+    config.env = options.env;
+  }
+  return config;
+};
+var parseServerConfig = (raw) => {
+  if (!raw || typeof raw !== "object") return {};
+  const data = raw;
+  const rawUrl = typeof data.url === "string" && data.url.trim().length > 0 ? data.url.trim() : void 0;
+  const rawHttpUrl = typeof data.httpUrl === "string" && data.httpUrl.trim().length > 0 ? data.httpUrl.trim() : void 0;
+  const remoteUrl = rawHttpUrl ?? rawUrl;
+  if (remoteUrl) {
+    const transport = data.type === "sse" || data.transport === "sse" ? "sse" : "http";
+    const headers = data.headers && typeof data.headers === "object" ? data.headers : void 0;
+    return {
+      type: transport,
+      url: remoteUrl,
+      headers
+    };
+  }
+  if (typeof data.command === "string" && data.command.trim().length > 0) {
+    const args = Array.isArray(data.args) ? data.args.filter((item) => typeof item === "string") : void 0;
+    const env = data.env && typeof data.env === "object" ? data.env : void 0;
+    return {
+      command: data.command.trim(),
+      args,
+      env
+    };
+  }
+  return {};
+};
+var toRemoteServerConfig = (config, defaultTransport = "http") => {
+  const {
+    command: _droppedCommand,
+    args: _droppedArgs,
+    env: _droppedEnv,
+    ...remoteConfig
+  } = config;
+  return {
+    ...remoteConfig,
+    type: remoteConfig.type ?? defaultTransport
+  };
+};
+var toStdioServerConfig = (config) => {
+  const {
+    url: _droppedUrl,
+    type: _droppedType,
+    headers: _droppedHeaders,
+    ...stdioConfig
+  } = config;
+  return stdioConfig;
+};
+var detectUpdateTransition = (incoming, previous) => {
+  if (!previous) {
+    return incoming.url ? "switch-to-remote" : "switch-to-stdio";
+  }
+  const previousIsRemote = Boolean(previous.url && previous.url.length > 0);
+  if (previousIsRemote) {
+    if (incoming.command && !incoming.url) {
+      return "switch-to-stdio";
+    }
+    return "merge-remote";
+  }
+  if (incoming.url && !incoming.command) {
+    return "switch-to-remote";
+  }
+  return "merge-stdio";
+};
+var sanitizeUpdatedServerConfig = (incoming, previous) => {
+  const transition = detectUpdateTransition(incoming, previous);
+  const targetTransport = incoming.type ?? previous?.type ?? "http";
+  switch (transition) {
+    case "switch-to-remote": {
+      const cleanBase = previous ? toRemoteServerConfig(previous, targetTransport) : {};
+      return toRemoteServerConfig({ ...cleanBase, ...incoming }, targetTransport);
+    }
+    case "switch-to-stdio": {
+      const cleanBase = previous ? toStdioServerConfig(previous) : {};
+      return toStdioServerConfig({ ...cleanBase, ...incoming });
+    }
+    case "merge-remote": {
+      return toRemoteServerConfig({ ...previous, ...incoming }, targetTransport);
+    }
+    case "merge-stdio":
+    default: {
+      return toStdioServerConfig({ ...previous, ...incoming });
+    }
+  }
+};
+var applyServerConfigDelta = (previousConfig, options) => {
+  if (options.url !== void 0 && options.command !== void 0) {
+    throw new Error('Cannot specify both "--url" (remote) and "--command" (stdio) simultaneously.');
+  }
+  const isCurrentRemote = Boolean(previousConfig?.url && previousConfig.url.length > 0);
+  const willBeRemote = options.url !== void 0 ? true : options.command !== void 0 ? false : isCurrentRemote;
+  const protocol = willBeRemote ? "remote" : "stdio";
+  const ignoredFlags = [];
+  if (willBeRemote) {
+    if (options.env !== void 0) ignoredFlags.push("--env");
+    if (options.clearEnv) ignoredFlags.push("--clear-env");
+    if (options.args !== void 0) ignoredFlags.push("--args");
+    if (options.clearArgs) ignoredFlags.push("--clear-args");
+  } else {
+    if (options.headers !== void 0) ignoredFlags.push("--header");
+    if (options.clearHeaders) ignoredFlags.push("--clear-headers");
+    if (options.transport !== void 0) ignoredFlags.push("--transport");
+  }
+  const incomingDelta = {};
+  if (options.command !== void 0) {
+    incomingDelta.command = options.command;
+  }
+  if (options.clearArgs) {
+    incomingDelta.args = void 0;
+  }
+  if (options.args !== void 0) {
+    incomingDelta.args = options.args;
+  }
+  if (options.url !== void 0) {
+    incomingDelta.url = options.url;
+  }
+  if (options.transport !== void 0) {
+    incomingDelta.type = options.transport;
+  }
+  if (options.clearEnv) {
+    incomingDelta.env = void 0;
+  }
+  if (options.env !== void 0) {
+    const baseEnv = options.clearEnv ? {} : previousConfig?.env ?? {};
+    incomingDelta.env = { ...baseEnv, ...options.env };
+  }
+  if (options.clearHeaders) {
+    incomingDelta.headers = void 0;
+  }
+  if (options.headers !== void 0) {
+    const baseHeaders = options.clearHeaders ? {} : previousConfig?.headers ?? {};
+    incomingDelta.headers = { ...baseHeaders, ...options.headers };
+  }
+  const transition = detectUpdateTransition(incomingDelta, previousConfig);
+  const cleanConfig = sanitizeUpdatedServerConfig(incomingDelta, previousConfig);
+  return {
+    config: cleanConfig,
+    transition,
+    protocol,
+    ignoredFlags
+  };
+};
+
+// src/source-parser.ts
+var REMOTE_URL_REGEX = /^https?:\/\//i;
+var HAS_WHITESPACE_REGEX = /\s/;
+var PACKAGE_NAME_REGEX = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*(?:@[^\s]+)?$/;
+var PATH_SEPARATOR_REGEX = /[/\\]/;
+var stripVersionSuffix = (input) => {
+  if (input.startsWith("@")) {
+    const secondAtIndex = input.indexOf("@", 1);
+    if (secondAtIndex > 0) return input.slice(0, secondAtIndex);
+    return input;
+  }
+  const atIndex = input.lastIndexOf("@");
+  if (atIndex > 0) return input.slice(0, atIndex);
+  return input;
+};
+var stripScopePrefix = (input) => {
+  if (!input.startsWith("@") || !input.includes("/")) return input;
+  const parts = input.split("/");
+  return parts[1] || input;
+};
+var stripPathPrefix = (input) => {
+  if (!PATH_SEPARATOR_REGEX.test(input)) return input;
+  const segments = input.split(PATH_SEPARATOR_REGEX);
+  const basename = segments[segments.length - 1];
+  return basename || input;
+};
+var extractPackageName = (input) => {
+  let name = stripVersionSuffix(input);
+  name = stripScopePrefix(name);
+  name = stripPathPrefix(name);
+  name = name.replace(SCRIPT_EXTENSION_REGEX, "");
+  for (const prefix of PACKAGE_NAME_PREFIX_STRIP) {
+    if (name.startsWith(prefix)) {
+      name = name.slice(prefix.length);
+      break;
+    }
+  }
+  for (const suffix of PACKAGE_NAME_SUFFIX_STRIP) {
+    if (name.endsWith(suffix)) {
+      name = name.slice(0, -suffix.length);
+      break;
+    }
+  }
+  return name || MCP_DEFAULT_SERVER_NAME;
+};
+var inferNameFromUrl = (input) => {
+  try {
+    const url = new URL(input);
+    const host = url.hostname;
+    const labels = host.split(".").filter((segment) => segment.length > 0);
+    if (labels.length === 0) return MCP_DEFAULT_SERVER_NAME;
+    const meaningfulLabels = labels.filter((label) => {
+      const lower = label.toLowerCase();
+      if (COMMON_TLD_LABELS.has(lower)) return false;
+      if (GENERIC_HOST_PREFIXES.has(lower)) return false;
+      return true;
+    });
+    if (meaningfulLabels.length > 0) return meaningfulLabels[0];
+    if (labels.length >= 2) return labels[labels.length - 2];
+    return labels[labels.length - 1] || MCP_DEFAULT_SERVER_NAME;
+  } catch {
+    return MCP_DEFAULT_SERVER_NAME;
+  }
+};
+var inferNameFromCommand = (command) => {
+  const tokens = command.trim().split(/\s+/);
+  const runnerBase = tokens[0]?.split(PATH_SEPARATOR_REGEX).pop() ?? "";
+  const startIndex = KNOWN_COMMAND_RUNNERS.has(runnerBase) ? 1 : 0;
+  for (let tokenIndex = startIndex; tokenIndex < tokens.length; tokenIndex += 1) {
+    const token = tokens[tokenIndex];
+    if (!token || token.startsWith("-")) continue;
+    return extractPackageName(token);
+  }
+  const firstNonFlag = tokens.find((token) => !token.startsWith("-"));
+  return firstNonFlag ? extractPackageName(firstNonFlag) : MCP_DEFAULT_SERVER_NAME;
+};
+var parseMcpSource = (input) => {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) {
+    throw new Error(
+      "Invalid MCP source: input is empty. Expected a remote URL, an npm package, or a command line."
+    );
+  }
+  if (REMOTE_URL_REGEX.test(trimmed)) {
+    return {
+      type: "remote",
+      value: trimmed,
+      inferredName: inferNameFromUrl(trimmed)
+    };
+  }
+  if (HAS_WHITESPACE_REGEX.test(trimmed)) {
+    return {
+      type: "command",
+      value: trimmed,
+      inferredName: inferNameFromCommand(trimmed)
+    };
+  }
+  if (PACKAGE_NAME_REGEX.test(trimmed)) {
+    return {
+      type: "package",
+      value: trimmed,
+      inferredName: extractPackageName(trimmed)
+    };
+  }
+  return {
+    type: "command",
+    value: trimmed,
+    inferredName: inferNameFromCommand(trimmed)
+  };
+};
+var isRemoteMcpSource = (parsed) => parsed.type === "remote";
+
+// src/config-store.ts
+import { existsSync as existsSync6 } from "fs";
+import { join as join2 } from "path";
+
+// src/utils/is-plain-object.ts
+var isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+
+// src/utils/get-nested-value.ts
+var getNestedValue = (source, dottedKey) => {
+  if (!source) return void 0;
+  if (dottedKey in source) return source[dottedKey];
+  const segments = dottedKey.split(".");
+  let cursor = source;
+  for (const segment of segments) {
+    if (!isPlainObject(cursor)) return void 0;
+    cursor = cursor[segment];
+  }
+  return cursor;
+};
+
+// src/formats/json.ts
+import { existsSync as existsSync3, readFileSync, writeFileSync } from "fs";
+import { applyEdits, modify, parse as parseJsonc } from "jsonc-parser";
+
+// src/utils/ensure-parent-dir.ts
+import { existsSync as existsSync2, mkdirSync } from "fs";
+import { dirname } from "path";
+var ensureParentDir = (filePath) => {
+  const parentDir = dirname(filePath);
+  if (!existsSync2(parentDir)) mkdirSync(parentDir, { recursive: true });
+};
+
+// src/utils/set-nested-value.ts
+var DANGEROUS_KEY_SEGMENTS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "prototype",
+  "constructor"
+]);
+var assertSafeSegment = (segment) => {
+  if (DANGEROUS_KEY_SEGMENTS.has(segment)) {
+    throw new Error(`Refusing to write to unsafe key segment "${segment}"`);
+  }
+};
+var setNestedValue = (target, dottedKey, value) => {
+  if (dottedKey in target) {
+    assertSafeSegment(dottedKey);
+    target[dottedKey] = value;
+    return;
+  }
+  const segments = dottedKey.split(".");
+  let cursor = target;
+  for (let segmentIndex = 0; segmentIndex < segments.length - 1; segmentIndex += 1) {
+    const segment = segments[segmentIndex];
+    assertSafeSegment(segment);
+    const existing = cursor[segment];
+    if (isPlainObject(existing)) {
+      cursor = existing;
+      continue;
+    }
+    const next = {};
+    cursor[segment] = next;
+    cursor = next;
+  }
+  const finalSegment = segments[segments.length - 1];
+  assertSafeSegment(finalSegment);
+  cursor[finalSegment] = value;
+};
+
+// src/utils/walk-nested-object.ts
+var walkNestedObject = (root, segments) => {
+  let cursor = root;
+  for (const segment of segments) {
+    if (!isPlainObject(cursor)) return void 0;
+    cursor = cursor[segment];
+  }
+  return isPlainObject(cursor) ? cursor : void 0;
+};
+
+// src/formats/json.ts
+var JSONC_FORMATTING = {
+  insertSpaces: true,
+  tabSize: DEFAULT_JSON_INDENT_SPACES,
+  eol: "\n"
+};
+var readFileOrEmpty = (filePath) => existsSync3(filePath) ? readFileSync(filePath, "utf-8") : "";
+var writeWithTrailingNewline = (filePath, contents) => {
+  writeFileSync(filePath, contents.endsWith("\n") ? contents : `${contents}
+`, "utf-8");
+};
+var readJsoncConfig = (filePath) => {
+  const raw = readFileOrEmpty(filePath);
+  if (!raw.trim()) return {};
+  const parsed = parseJsonc(raw);
+  return isPlainObject(parsed) ? parsed : {};
+};
+var resolvePathPrefix = (root, dottedKey) => {
+  if (dottedKey in root) return [dottedKey];
+  const segments = dottedKey.split(".");
+  if (segments.length > 1 && walkNestedObject(root, segments)) {
+    return segments;
+  }
+  return [dottedKey];
+};
+var setJsoncNestedValue = (filePath, dottedKey, serverName, serverConfig) => {
+  ensureParentDir(filePath);
+  const existingText = readFileOrEmpty(filePath);
+  const sourceText = existingText.trim() ? existingText : "{}";
+  const existing = readJsoncConfig(filePath);
+  const pathPrefix = resolvePathPrefix(existing, dottedKey);
+  const path = [...pathPrefix, serverName];
+  const edits = modify(sourceText, path, serverConfig, {
+    formattingOptions: JSONC_FORMATTING
+  });
+  writeWithTrailingNewline(filePath, applyEdits(sourceText, edits));
+};
+var writeJsonConfigAtKey = (filePath, dottedKey, serverName, serverConfig) => {
+  ensureParentDir(filePath);
+  const existing = readJsoncConfig(filePath);
+  const pathPrefix = resolvePathPrefix(existing, dottedKey);
+  const existingServers = walkNestedObject(existing, pathPrefix);
+  const servers = existingServers ? { ...existingServers } : {};
+  servers[serverName] = serverConfig;
+  if (pathPrefix.length === 1) {
+    existing[pathPrefix[0]] = servers;
+  } else {
+    setNestedValue(existing, dottedKey, servers);
+  }
+  writeFileSync(
+    filePath,
+    `${JSON.stringify(existing, null, DEFAULT_JSON_INDENT_SPACES)}
+`,
+    "utf-8"
+  );
+};
+var removeJsoncConfigKey = (filePath, dottedKey, serverName) => {
+  if (!existsSync3(filePath)) return false;
+  const sourceText = readFileSync(filePath, "utf-8");
+  if (!sourceText.trim()) return false;
+  const existing = readJsoncConfig(filePath);
+  const pathPrefix = resolvePathPrefix(existing, dottedKey);
+  const parentObject = walkNestedObject(existing, pathPrefix);
+  if (!parentObject || !(serverName in parentObject)) return false;
+  const path = [...pathPrefix, serverName];
+  const edits = modify(sourceText, path, void 0, {
+    formattingOptions: JSONC_FORMATTING
+  });
+  if (edits.length === 0) return false;
+  writeWithTrailingNewline(filePath, applyEdits(sourceText, edits));
+  return true;
+};
+
+// src/formats/toml.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import TOML from "@iarna/toml";
+
+// src/utils/delete-nested-value.ts
+var DANGEROUS_KEY_SEGMENTS2 = /* @__PURE__ */ new Set([
+  "__proto__",
+  "prototype",
+  "constructor"
+]);
+var deleteNestedValue = (target, dottedKey) => {
+  if (!target) return false;
+  if (dottedKey in target) {
+    if (DANGEROUS_KEY_SEGMENTS2.has(dottedKey)) return false;
+    delete target[dottedKey];
+    return true;
+  }
+  const segments = dottedKey.split(".");
+  if (segments.some((segment) => DANGEROUS_KEY_SEGMENTS2.has(segment))) return false;
+  let cursor = target;
+  for (let segmentIndex = 0; segmentIndex < segments.length - 1; segmentIndex += 1) {
+    const segment = segments[segmentIndex];
+    const existing = cursor[segment];
+    if (!isPlainObject(existing)) return false;
+    cursor = existing;
+  }
+  const lastSegment = segments[segments.length - 1];
+  if (!(lastSegment in cursor)) return false;
+  delete cursor[lastSegment];
+  return true;
+};
+
+// src/formats/toml.ts
+var toTomlJsonMap = (value) => JSON.parse(JSON.stringify(value));
+var readTomlConfig = (filePath) => {
+  if (!existsSync4(filePath)) return {};
+  const raw = readFileSync2(filePath, "utf-8");
+  if (!raw.trim()) return {};
+  const parsed = TOML.parse(raw);
+  return isPlainObject(parsed) ? parsed : {};
+};
+var writeTomlConfigAtKey = (filePath, dottedKey, serverName, serverConfig) => {
+  ensureParentDir(filePath);
+  const existing = readTomlConfig(filePath);
+  const existingServers = walkNestedObject(existing, dottedKey.split("."));
+  const servers = existingServers ? { ...existingServers } : {};
+  servers[serverName] = serverConfig;
+  setNestedValue(existing, dottedKey, servers);
+  writeFileSync2(filePath, TOML.stringify(toTomlJsonMap(existing)), "utf-8");
+};
+var removeTomlConfigKey = (filePath, dottedKey, serverName) => {
+  if (!existsSync4(filePath)) return false;
+  const existing = readTomlConfig(filePath);
+  const didRemove = deleteNestedValue(existing, `${dottedKey}.${serverName}`);
+  if (didRemove) writeFileSync2(filePath, TOML.stringify(toTomlJsonMap(existing)), "utf-8");
+  return didRemove;
+};
+
+// src/formats/yaml.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var readYamlConfig = (filePath) => {
+  if (!existsSync5(filePath)) return {};
+  const raw = readFileSync3(filePath, "utf-8");
+  if (!raw.trim()) return {};
+  const parsed = parseYaml(raw);
+  return isPlainObject(parsed) ? parsed : {};
+};
+var writeYamlConfigAtKey = (filePath, dottedKey, serverName, serverConfig) => {
+  ensureParentDir(filePath);
+  const existing = readYamlConfig(filePath);
+  const existingServers = walkNestedObject(existing, dottedKey.split("."));
+  const servers = existingServers ? { ...existingServers } : {};
+  servers[serverName] = serverConfig;
+  setNestedValue(existing, dottedKey, servers);
+  writeFileSync3(filePath, stringifyYaml(existing), "utf-8");
+};
+var removeYamlConfigKey = (filePath, dottedKey, serverName) => {
+  if (!existsSync5(filePath)) return false;
+  const existing = readYamlConfig(filePath);
+  const didRemove = deleteNestedValue(existing, `${dottedKey}.${serverName}`);
+  if (didRemove) writeFileSync3(filePath, stringifyYaml(existing), "utf-8");
+  return didRemove;
+};
+
+// src/formats/index.ts
+var readConfigFile = (filePath, format) => {
+  switch (format) {
+    case "json":
+    case "jsonc":
+      return readJsoncConfig(filePath);
+    case "yaml":
+      return readYamlConfig(filePath);
+    case "toml":
+      return readTomlConfig(filePath);
+    default:
+      throw new Error(`Unsupported config format: ${format}`);
+  }
+};
+var writeServerToConfigFile = (filePath, format, dottedKey, serverName, serverConfig) => {
+  switch (format) {
+    case "jsonc":
+      setJsoncNestedValue(filePath, dottedKey, serverName, serverConfig);
+      return;
+    case "json":
+      writeJsonConfigAtKey(filePath, dottedKey, serverName, serverConfig);
+      return;
+    case "yaml":
+      writeYamlConfigAtKey(filePath, dottedKey, serverName, serverConfig);
+      return;
+    case "toml":
+      writeTomlConfigAtKey(filePath, dottedKey, serverName, serverConfig);
+      return;
+    default:
+      throw new Error(`Unsupported config format: ${format}`);
+  }
+};
+var removeServerFromConfigFile = (filePath, format, dottedKey, serverName) => {
+  switch (format) {
+    case "json":
+    case "jsonc":
+      return removeJsoncConfigKey(filePath, dottedKey, serverName);
+    case "yaml":
+      return removeYamlConfigKey(filePath, dottedKey, serverName);
+    case "toml":
+      return removeTomlConfigKey(filePath, dottedKey, serverName);
+    default:
+      throw new Error(`Unsupported config format: ${format}`);
+  }
+};
+var listServersInConfigFile = (filePath, format, dottedKey) => {
+  const config = readConfigFile(filePath, format);
+  const entries = getNestedValue(config, dottedKey);
+  return isPlainObject(entries) ? entries : {};
+};
+
+// src/transforms/index.ts
+var DIALECT_PRESETS = {
+  vscode: {
+    stdioTransport: "type-stdio",
+    remoteTransport: "type-http-sse"
+  },
+  augment: {
+    stdioTransport: "none",
+    remoteTransport: "type-http-sse"
+  },
+  amp: {
+    stdioTransport: "none",
+    remoteTransport: "none"
+  },
+  trae: {
+    stdioTransport: "none",
+    remoteTransport: "sse-only-type"
+  },
+  grok: {
+    stdioTransport: "none",
+    remoteTransport: "sse-only-type"
+  },
+  cline: {
+    stdioTransport: "none",
+    remoteTransport: "streamableHttp"
+  },
+  goose: {
+    stdioTransport: "type-stdio",
+    remoteTransport: "streamable_http",
+    commandField: "cmd",
+    envField: "envs",
+    urlField: "uri",
+    defaultEnvEmpty: true,
+    defaultHeadersEmpty: true,
+    includeServerName: true,
+    timeoutSeconds: GOOSE_TIMEOUT_SECONDS,
+    extraFields: {
+      description: "",
+      enabled: true
+    }
+  },
+  "kimi-code": {
+    stdioTransport: "none",
+    remoteTransport: "sse-only-transport"
+  },
+  kiro: {
+    stdioTransport: "none",
+    remoteTransport: "none"
+  },
+  opencode: {
+    stdioTransport: "type-local",
+    remoteTransport: "remote-type",
+    commandArray: true,
+    envField: "environment",
+    defaultEnvEmpty: true,
+    extraFields: {
+      enabled: true
+    }
+  },
+  pi: {
+    stdioTransport: "transport-stdio",
+    remoteTransport: "streamable-http"
+  },
+  "qwen-code": {
+    stdioTransport: "none",
+    remoteTransport: "qwen"
+  },
+  zed: {
+    stdioTransport: "none",
+    remoteTransport: "none",
+    defaultEnvEmpty: true
+  }
+};
+var resolveDialectOptions = (dialect) => {
+  if (typeof dialect === "string") {
+    const preset = DIALECT_PRESETS[dialect];
+    if (!preset) {
+      throw new Error(`Unknown server config dialect: "${dialect}"`);
+    }
+    return preset;
+  }
+  return dialect;
+};
+var transformRemoteConfig = (serverName, config, options) => {
+  const result = {};
+  if (options.includeServerName) {
+    result.name = serverName;
+  }
+  if (options.extraFields) {
+    Object.assign(result, options.extraFields);
+  }
+  const remoteTransport = options.remoteTransport ?? "type-http-sse";
+  const urlField = options.urlField ?? "url";
+  switch (remoteTransport) {
+    case "type-http-sse":
+      result.type = config.type || "http";
+      result[urlField] = config.url;
+      break;
+    case "sse-only-type":
+      result[urlField] = config.url;
+      if (config.type === "sse") {
+        result.type = "sse";
+      }
+      break;
+    case "sse-only-transport":
+      result[urlField] = config.url;
+      if (config.type === "sse") {
+        result.transport = "sse";
+      }
+      break;
+    case "none":
+      result[urlField] = config.url;
+      break;
+    case "streamableHttp":
+      result.type = config.type === "sse" ? "sse" : "streamableHttp";
+      result[urlField] = config.url;
+      break;
+    case "streamable-http":
+      result.transport = config.type === "sse" ? "sse" : "streamable-http";
+      result[urlField] = config.url;
+      break;
+    case "streamable_http":
+      result.type = config.type === "sse" ? "sse" : "streamable_http";
+      result[urlField] = config.url;
+      break;
+    case "remote-type":
+      result.type = "remote";
+      result[urlField] = config.url;
+      break;
+    case "qwen":
+      if (config.type === "sse") {
+        result.url = config.url;
+      } else {
+        result.httpUrl = config.url;
+      }
+      break;
+  }
+  const hasHeaders = config.headers && Object.keys(config.headers).length > 0;
+  if (hasHeaders) {
+    result.headers = config.headers;
+  } else if (options.defaultHeadersEmpty) {
+    result.headers = {};
+  }
+  if (options.timeoutSeconds !== void 0) {
+    result.timeout = options.timeoutSeconds;
+  }
+  return result;
+};
+var transformStdioConfig = (serverName, config, options) => {
+  const result = {};
+  if (options.includeServerName) {
+    result.name = serverName;
+  }
+  if (options.extraFields) {
+    Object.assign(result, options.extraFields);
+  }
+  const stdioTransport = options.stdioTransport ?? "none";
+  const commandField = options.commandField ?? "command";
+  const argsField = options.argsField ?? "args";
+  const envField = options.envField ?? "env";
+  switch (stdioTransport) {
+    case "type-stdio":
+      result.type = "stdio";
+      break;
+    case "transport-stdio":
+      result.transport = "stdio";
+      break;
+    case "type-local":
+      result.type = "local";
+      break;
+    case "none":
+      break;
+  }
+  if (options.commandArray) {
+    result[commandField] = [config.command, ...config.args || []];
+  } else {
+    result[commandField] = config.command;
+    result[argsField] = config.args || [];
+  }
+  const hasEnv = config.env && Object.keys(config.env).length > 0;
+  if (hasEnv) {
+    result[envField] = config.env;
+  } else if (options.defaultEnvEmpty) {
+    result[envField] = {};
+  }
+  if (options.timeoutSeconds !== void 0) {
+    result.timeout = options.timeoutSeconds;
+  }
+  return result;
+};
+var transformServerConfig = (serverName, config, dialect, _context) => {
+  const options = resolveDialectOptions(dialect);
+  if (config.url) {
+    return transformRemoteConfig(serverName, config, options);
+  }
+  return transformStdioConfig(serverName, config, options);
+};
+var createAgentTransform = (dialect) => {
+  return (serverName, config, context) => transformServerConfig(serverName, config, dialect, context);
+};
+var transformServerConfigForAgent = (agent, serverName, config, context = { global: false }) => {
+  if (agent.transformConfig) {
+    return agent.transformConfig(serverName, config, context);
+  }
+  if (agent.transformDialect) {
+    return transformServerConfig(serverName, config, agent.transformDialect, context);
+  }
+  return config;
+};
+
+// src/utils/to-error-message.ts
+var toErrorMessage = (error, fallback = "Unknown error") => error instanceof Error ? error.message : fallback;
+
+// src/config-store.ts
+var resolveMcpConfigTarget = (agent, options = {}) => {
+  const isGlobal = options.global ?? false;
+  const cwd = options.cwd ?? process.cwd();
+  const configPath = agent.resolveConfigPath ? agent.resolveConfigPath({ global: isGlobal, cwd }) : !isGlobal && agent.projectConfigPath ? join2(cwd, agent.projectConfigPath) : agent.globalConfigPath;
+  const configKey = !isGlobal && agent.projectConfigKey ? agent.projectConfigKey : agent.configKey;
+  return { configPath, configKey };
+};
+var getCandidateAgentsForScope = (options = {}) => {
+  return options.global ? getMcpAgentTypes() : getMcpAgentsSupportingProjectScope();
+};
+var FsConfigStoreAdapter = class {
+  exists(filePath) {
+    return existsSync6(filePath);
+  }
+  read(target) {
+    return readConfigFile(target.filePath, target.format);
+  }
+  writeServer(target, serverName, serverConfig) {
+    if (!target.dottedKey) {
+      throw new Error(`Cannot write server: missing dottedKey for ${target.filePath}`);
+    }
+    writeServerToConfigFile(
+      target.filePath,
+      target.format,
+      target.dottedKey,
+      serverName,
+      serverConfig
+    );
+  }
+  removeServer(target, serverName) {
+    if (!target.dottedKey) return false;
+    return removeServerFromConfigFile(
+      target.filePath,
+      target.format,
+      target.dottedKey,
+      serverName
+    );
+  }
+  listServers(target) {
+    if (!target.dottedKey) return {};
+    return listServersInConfigFile(target.filePath, target.format, target.dottedKey);
+  }
+};
+var AgentConfigStore = class {
+  constructor(adapter = new FsConfigStoreAdapter()) {
+    this.adapter = adapter;
+  }
+  adapter;
+  getAdapter() {
+    return this.adapter;
+  }
+  // ---- Single-agent primitives ----
+  resolveTarget(agent, options = {}) {
+    const agentConfig = typeof agent === "string" ? getMcpAgentConfig(agent) : agent;
+    const target = resolveMcpConfigTarget(agentConfig, options);
+    return { agent: agentConfig, target };
+  }
+  resolveDescriptor(agent, options = {}) {
+    const { agent: agentConfig, target } = this.resolveTarget(agent, options);
+    return {
+      filePath: target.configPath,
+      format: agentConfig.format,
+      dottedKey: target.configKey
+    };
+  }
+  writeServer(agent, serverName, serverConfig, options = {}) {
+    const descriptor = this.resolveDescriptor(agent, options);
+    this.adapter.writeServer(descriptor, serverName, serverConfig);
+    return { path: descriptor.filePath };
+  }
+  removeServer(agent, serverName, options = {}) {
+    const descriptor = this.resolveDescriptor(agent, options);
+    if (!this.adapter.exists(descriptor.filePath)) {
+      return { path: descriptor.filePath, removed: false };
+    }
+    const removed = this.adapter.removeServer(descriptor, serverName);
+    return { path: descriptor.filePath, removed };
+  }
+  listServers(agent, options = {}) {
+    const descriptor = this.resolveDescriptor(agent, options);
+    if (!this.adapter.exists(descriptor.filePath)) {
+      return { path: descriptor.filePath, exists: false, servers: {} };
+    }
+    const servers = this.adapter.listServers(descriptor);
+    return { path: descriptor.filePath, exists: true, servers };
+  }
+  /**
+   * Batch lists servers for multiple agents, caching adapter reads for co-hosted
+   * agents that share the exact same physical configuration file and dotted key.
+   */
+  listServersForAgents(agents, options = {}) {
+    const readCache = /* @__PURE__ */ new Map();
+    return agents.map((agentType) => {
+      const descriptor = this.resolveDescriptor(agentType, options);
+      const cacheKey = `${descriptor.filePath}::${descriptor.dottedKey ?? ""}`;
+      let cached = readCache.get(cacheKey);
+      if (!cached) {
+        cached = this.listServers(agentType, options);
+        readCache.set(cacheKey, cached);
+      }
+      return {
+        agent: agentType,
+        path: cached.path,
+        exists: cached.exists,
+        servers: cached.servers
+      };
+    });
+  }
+  read(agent, options = {}) {
+    const descriptor = this.resolveDescriptor(agent, options);
+    if (!this.adapter.exists(descriptor.filePath)) {
+      return {};
+    }
+    return this.adapter.read(descriptor);
+  }
+  readServer(agent, serverName, options = {}) {
+    const { exists, servers } = this.listServers(agent, options);
+    if (!exists) return void 0;
+    return servers[serverName];
+  }
+  // ---- Cluster & co-hosted awareness ----
+  /**
+   * Returns all other agents sharing the exact same physical configuration target
+   * (same configPath and configKey) for the given scope.
+   */
+  getCoHostedAgents(agentType, options = {}) {
+    const currentAgent = getMcpAgentConfig(agentType);
+    const currentTarget = resolveMcpConfigTarget(currentAgent, options);
+    const candidates = getCandidateAgentsForScope(options);
+    const coHosted = [];
+    for (const candidateType of candidates) {
+      if (candidateType === agentType) continue;
+      const candidateConfig = getMcpAgentConfig(candidateType);
+      const candidateTarget = resolveMcpConfigTarget(candidateConfig, options);
+      if (candidateTarget.configPath === currentTarget.configPath && candidateTarget.configKey === currentTarget.configKey) {
+        coHosted.push(candidateType);
+      }
+    }
+    return coHosted;
+  }
+  /**
+   * Resolves configuration clusters for a given list of requested agents.
+   * Groups requested agents sharing the same physical config path, and tracks
+   * any remaining co-hosted agents sharing the same target that were not in the request.
+   */
+  resolveConfigClusters(agentTypes, options = {}) {
+    const clustersByPath = /* @__PURE__ */ new Map();
+    for (const agentType of agentTypes) {
+      const agentConfig = getMcpAgentConfig(agentType);
+      const target = resolveMcpConfigTarget(agentConfig, options);
+      let keyMap = clustersByPath.get(target.configPath);
+      if (!keyMap) {
+        keyMap = /* @__PURE__ */ new Map();
+        clustersByPath.set(target.configPath, keyMap);
+      }
+      let cluster = keyMap.get(target.configKey);
+      if (!cluster) {
+        const allCoHosted = this.getCoHostedAgents(agentType, options);
+        cluster = {
+          configPath: target.configPath,
+          configKey: target.configKey,
+          targetAgents: [],
+          coHostedAgents: allCoHosted
+        };
+        keyMap.set(target.configKey, cluster);
+      }
+      if (!cluster.targetAgents.includes(agentType)) {
+        cluster.targetAgents.push(agentType);
+      }
+    }
+    const clusters = [];
+    for (const keyMap of clustersByPath.values()) {
+      for (const cluster of keyMap.values()) {
+        cluster.coHostedAgents = cluster.coHostedAgents.filter(
+          (co) => !cluster.targetAgents.includes(co)
+        );
+        clusters.push(cluster);
+      }
+    }
+    return clusters;
+  }
+  /**
+   * Sorts agent types so that agents sharing the same physical config target
+   * appear adjacent to each other in the returned array.
+   */
+  sortAgentsByClusters(agentTypes, options = {}) {
+    const clusters = this.resolveConfigClusters(agentTypes, options);
+    const sorted = [];
+    for (const cluster of clusters) {
+      for (const agent of cluster.targetAgents) {
+        if (!sorted.includes(agent)) {
+          sorted.push(agent);
+        }
+      }
+    }
+    return sorted;
+  }
+  /**
+   * Alias for sortAgentsByClusters for backward compatibility.
+   */
+  sortAgentsWithClusters(agentTypes, options = {}) {
+    return this.sortAgentsByClusters(agentTypes, options);
+  }
+  // ---- Batch operations with automatic clustering & dialect transforms ----
+  /**
+   * Batch write: transforms and writes a server config to multiple agents,
+   * with automatic cluster deduplication, dialect transform, and co-hosted awareness.
+   * Callers pass standard McpServerConfig; the Store applies per-Agent dialect transforms
+   * internally before persisting.
+   */
+  writeServers(agents, serverName, serverConfig, options = {}) {
+    const clusters = this.resolveConfigClusters(agents, options);
+    const resultsByAgent = /* @__PURE__ */ new Map();
+    const isGlobal = options.global ?? false;
+    for (const cluster of clusters) {
+      const primaryAgentType = cluster.targetAgents[0];
+      const primaryAgent = getMcpAgentConfig(primaryAgentType);
+      try {
+        const transformed = transformServerConfigForAgent(primaryAgent, serverName, serverConfig, {
+          global: isGlobal
+        });
+        const descriptor = this.resolveDescriptor(primaryAgent, options);
+        this.adapter.writeServer(descriptor, serverName, transformed);
+        for (const agentType of cluster.targetAgents) {
+          resultsByAgent.set(agentType, {
+            agent: agentType,
+            success: true,
+            path: cluster.configPath,
+            coConfiguredAgents: cluster.coHostedAgents.length > 0 ? cluster.coHostedAgents : void 0
+          });
+        }
+      } catch (error) {
+        const errorMsg = toErrorMessage(error);
+        for (const agentType of cluster.targetAgents) {
+          resultsByAgent.set(agentType, {
+            agent: agentType,
+            success: false,
+            path: cluster.configPath,
+            error: errorMsg
+          });
+        }
+      }
+    }
+    return agents.map((agentType) => resultsByAgent.get(agentType));
+  }
+  /**
+   * Batch remove: removes a server from multiple agents' configs,
+   * with automatic cluster deduplication and co-hosted awareness.
+   */
+  removeServers(agents, serverName, options = {}) {
+    const clusters = this.resolveConfigClusters(agents, options);
+    const resultsByAgent = /* @__PURE__ */ new Map();
+    for (const cluster of clusters) {
+      const primaryAgentType = cluster.targetAgents[0];
+      const primaryAgent = getMcpAgentConfig(primaryAgentType);
+      try {
+        const { removed } = this.removeServer(primaryAgent, serverName, options);
+        for (const agentType of cluster.targetAgents) {
+          resultsByAgent.set(agentType, {
+            agent: agentType,
+            path: cluster.configPath,
+            removed,
+            coAffectedAgents: removed && cluster.coHostedAgents.length > 0 ? cluster.coHostedAgents : void 0
+          });
+        }
+      } catch (error) {
+        const errorMsg = toErrorMessage(error);
+        for (const agentType of cluster.targetAgents) {
+          resultsByAgent.set(agentType, {
+            agent: agentType,
+            path: cluster.configPath,
+            removed: false,
+            error: errorMsg
+          });
+        }
+      }
+    }
+    return agents.map((agentType) => resultsByAgent.get(agentType));
+  }
+};
+var agentConfigStore = new AgentConfigStore();
+
+// src/resolve-config-clusters.ts
+var getCoHostedAgents = (agentType, options = {}) => agentConfigStore.getCoHostedAgents(agentType, options);
+var resolveConfigClusters = (agentTypes, options = {}) => agentConfigStore.resolveConfigClusters(agentTypes, options);
+var sortAgentsByClusters = (agentTypes, options = {}) => agentConfigStore.sortAgentsByClusters(agentTypes, options);
+
+// src/utils/parse-mcp-agent-list.ts
+var parseMcpAgentList = (input) => {
+  if (!input || input.length === 0) return void 0;
+  if (input.includes("*")) return getMcpAgentTypes();
+  const resolved = [];
+  for (const value of input) {
+    const agentType = resolveMcpAgentAlias(value);
+    if (!agentType) throw new Error(`Unknown MCP agent "${value}"`);
+    resolved.push(agentType);
+  }
+  return resolved;
+};
+
+// src/resolve-target-agents.ts
+var normalizeRequestedAgents = (input) => {
+  if (!input || input.length === 0) return void 0;
+  const rawList = [...input];
+  if (rawList.every((item) => isMcpAgentType(item))) {
+    return rawList;
+  }
+  return parseMcpAgentList(rawList);
+};
+var resolveTargetAgents = (query = {}) => {
+  const cwd = query.cwd ?? process.cwd();
+  const isGlobal = query.global ?? false;
+  let explicitAgents = normalizeRequestedAgents(query.requested);
+  if (query.all) {
+    explicitAgents = getMcpAgentTypes();
+  }
+  const isDetected = !explicitAgents || explicitAgents.length === 0;
+  const detected = isGlobal ? detectGloballyInstalledMcpAgents() : detectProjectInstalledMcpAgents(cwd);
+  const candidateAgents = isDetected ? detected : explicitAgents ?? [];
+  const allAgents = candidateAgents.filter(
+    (type, index) => candidateAgents.indexOf(type) === index
+  );
+  const incompatible = [];
+  const compatibleAgents = [];
+  for (const agentType of allAgents) {
+    const config = getMcpAgentConfig(agentType);
+    if (query.transport && !isMcpTransportSupported(config, query.transport)) {
+      incompatible.push({
+        agent: agentType,
+        reason: config.unsupportedTransportMessage ?? `agent ${agentType} only supports ${config.supportedTransports.join(", ")} transport (attempted ${query.transport})`
+      });
+    } else {
+      compatibleAgents.push(agentType);
+    }
+  }
+  let diagnostic;
+  if (compatibleAgents.length === 0) {
+    if (isDetected) {
+      diagnostic = `No ${isGlobal ? "global" : "project"}-installed MCP agents detected. Pass -a <agent> (e.g. -a cursor) or --all to install.`;
+    } else if (allAgents.length > 0 && incompatible.length > 0 && query.transport) {
+      const list = incompatible.map((item) => `${item.agent} (${item.reason})`).join(", ");
+      diagnostic = `None of the selected agents support ${query.transport} transport: ${list}`;
+    } else {
+      diagnostic = "No valid target agents specified.";
+    }
+  }
+  return {
+    agents: compatibleAgents,
+    compatibleAgents,
+    allAgents,
+    candidateAgents: allAgents,
+    detected,
+    isDetected,
+    incompatible,
+    diagnostic
+  };
+};
+
+// src/install-compat.ts
+var installMcpServerForAgent = (serverName, serverConfig, agentType, options = {}) => {
+  const results = agentConfigStore.writeServers([agentType], serverName, serverConfig, options);
+  return results[0];
+};
+var installMcpServerForAgents = (serverName, serverConfig, agentTypes, options = {}) => {
+  return agentConfigStore.writeServers(agentTypes, serverName, serverConfig, options);
+};
+var installToCompatibleAgents = (serverName, serverConfig, options) => {
+  const { allAgents, incompatible = [], global: isGlobal, cwd } = options;
+  const incompatibleMap = new Map(incompatible.map((item) => [item.agent, item.reason]));
+  const compatibleAgents = allAgents.filter((a) => !incompatibleMap.has(a));
+  const installedResults = agentConfigStore.writeServers(
+    compatibleAgents,
+    serverName,
+    serverConfig,
+    {
+      global: isGlobal,
+      cwd
+    }
+  );
+  const installedMap = new Map(installedResults.map((r) => [r.agent, r]));
+  return allAgents.map((agentType) => {
+    const incompatibleReason = incompatibleMap.get(agentType);
+    if (incompatibleReason) {
+      return {
+        agent: agentType,
+        success: false,
+        path: "",
+        error: incompatibleReason
+      };
+    }
+    return installedMap.get(agentType);
+  });
+};
+
+// src/install-mcp-server.ts
+var installMcpServer = (options) => {
+  const parsed = parseMcpSource(options.source);
+  const isGlobal = options.global ?? false;
+  const cwd = options.cwd ?? process.cwd();
+  const serverName = options.name ?? parsed.inferredName;
+  const serverConfig = buildMcpServerConfig(parsed, {
+    transport: options.transport,
+    headers: options.headers,
+    env: options.env,
+    args: options.args
+  });
+  const requestedTransport = parsed.type === "remote" ? serverConfig.type ?? "http" : "stdio";
+  const { allAgents, incompatible } = resolveTargetAgents({
+    requested: options.agents,
+    global: isGlobal,
+    cwd,
+    transport: requestedTransport
+  });
+  const results = installToCompatibleAgents(serverName, serverConfig, {
+    allAgents,
+    incompatible,
+    global: isGlobal,
+    cwd
+  });
+  return { serverName, config: serverConfig, results };
+};
+
+// src/list.ts
+var listInstalledMcpServers = (options = {}) => {
+  const agentTypes = options.agents ?? getMcpAgentTypes();
+  const collected = [];
+  const results = agentConfigStore.listServersForAgents(agentTypes, options);
+  for (const item of results) {
+    if (!item.exists) continue;
+    for (const [serverName, rawConfig] of Object.entries(item.servers)) {
+      collected.push({
+        serverName,
+        agent: item.agent,
+        path: item.path,
+        config: rawConfig,
+        serverConfig: parseServerConfig(rawConfig)
+      });
+    }
+  }
+  return collected;
+};
+var groupInstalledServersByName = (installed) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const item of installed) {
+    const itemConfig = item.serverConfig ?? parseServerConfig(item.config);
+    let entry = grouped.get(item.serverName);
+    if (!entry) {
+      entry = {
+        serverName: item.serverName,
+        agents: [],
+        paths: [],
+        config: itemConfig,
+        hasDivergence: false
+      };
+      grouped.set(item.serverName, entry);
+    } else if (!entry.hasDivergence) {
+      if (JSON.stringify(entry.config) !== JSON.stringify(itemConfig)) {
+        entry.hasDivergence = true;
+      }
+    }
+    if (!entry.agents.includes(item.agent)) {
+      entry.agents.push(item.agent);
+    }
+    if (!entry.paths.includes(item.path)) {
+      entry.paths.push(item.path);
+    }
+  }
+  return grouped;
+};
+var queryGroupedInstalledServers = (options = {}) => {
+  const installed = listInstalledMcpServers(options);
+  return groupInstalledServersByName(installed);
+};
+
+// src/update-mcp-server.ts
+var updateMcpServer = (options) => {
+  const isGlobal = options.global ?? false;
+  const cwd = options.cwd ?? process.cwd();
+  let previousConfig = options.previousConfig;
+  if (!previousConfig) {
+    const existing = listInstalledMcpServers({
+      global: isGlobal,
+      cwd,
+      agents: options.agents
+    });
+    const found = existing.find((s) => s.serverName === options.serverName && s.serverConfig);
+    if (found) {
+      previousConfig = found.serverConfig;
+    }
+  }
+  const serverConfig = sanitizeUpdatedServerConfig(options.config, previousConfig);
+  let targetAgents = options.agents;
+  if (!targetAgents || targetAgents.length === 0) {
+    const existing = listInstalledMcpServers({ global: isGlobal, cwd });
+    targetAgents = existing.filter((s) => s.serverName === options.serverName).map((s) => s.agent);
+  }
+  const requestedTransport = serverConfig.url ? serverConfig.type ?? "http" : "stdio";
+  const { allAgents, incompatible } = resolveTargetAgents({
+    requested: targetAgents,
+    global: isGlobal,
+    cwd,
+    transport: requestedTransport
+  });
+  const results = installToCompatibleAgents(options.serverName, serverConfig, {
+    allAgents,
+    incompatible,
+    global: isGlobal,
+    cwd
+  });
+  return {
+    serverName: options.serverName,
+    config: serverConfig,
+    results,
+    incompatible
+  };
+};
+
+// src/remove.ts
+var removeMcpServer = (options) => {
+  const { allAgents } = resolveTargetAgents({
+    requested: options.agents,
+    all: !options.agents,
+    global: options.global,
+    cwd: options.cwd
+  });
+  const storeResults = agentConfigStore.removeServers(allAgents, options.name, {
+    global: options.global,
+    cwd: options.cwd
+  });
+  return storeResults.filter((r) => r.removed || Boolean(r.error));
+};
+
+// src/utils/mask-secret.ts
+var SECRET_KEY_PATTERN = /(token|key|secret|password|passwd|auth|credential)/i;
+var maskSecretValue = (key, value) => {
+  if (!SECRET_KEY_PATTERN.test(key) || value.length <= 4) {
+    return value;
+  }
+  return `${value.slice(0, 2)}***${value.slice(-2)}`;
+};
+var SECRET_HEADER_PATTERN = /(authorization|token|key|secret|auth)/i;
+var maskSecretHeader = (key, value) => {
+  if (!SECRET_HEADER_PATTERN.test(key) || value.length <= 8) {
+    return value;
+  }
+  return `${value.slice(0, 4)}***${value.slice(-3)}`;
+};
+
+export {
+  getMcpAgentConfig,
+  getMcpAgentTypes,
+  isMcpAgentType,
+  resolveMcpAgentAlias,
+  isMcpTransportSupported,
+  detectProjectInstalledMcpAgents,
+  detectGloballyInstalledMcpAgents,
+  getMcpAgentsSupportingProjectScope,
+  DEFAULT_REMOTE_TRANSPORT,
+  isRemoteServerConfig,
+  isStdioServerConfig,
+  buildMcpServerConfig,
+  parseServerConfig,
+  toRemoteServerConfig,
+  toStdioServerConfig,
+  detectUpdateTransition,
+  sanitizeUpdatedServerConfig,
+  applyServerConfigDelta,
+  extractPackageName,
+  parseMcpSource,
+  isRemoteMcpSource,
+  createAgentTransform,
+  transformServerConfigForAgent,
+  toErrorMessage,
+  resolveMcpConfigTarget,
+  getCandidateAgentsForScope,
+  AgentConfigStore,
+  agentConfigStore,
+  getCoHostedAgents,
+  resolveConfigClusters,
+  sortAgentsByClusters,
+  parseMcpAgentList,
+  resolveTargetAgents,
+  installMcpServerForAgent,
+  installMcpServerForAgents,
+  installToCompatibleAgents,
+  installMcpServer,
+  listInstalledMcpServers,
+  queryGroupedInstalledServers,
+  updateMcpServer,
+  removeMcpServer,
+  SECRET_KEY_PATTERN,
+  maskSecretValue,
+  SECRET_HEADER_PATTERN,
+  maskSecretHeader
+};