@wuyax/mcps 0.1.0-beta.1

package/dist/chunk-XW2KL6W3.js

@@ -0,0 +1,2360 @@
+// 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 = (input5) => {
+  if (isMcpAgentType(input5)) return input5;
+  return mcpAgentAliases[input5] ?? 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/build-server-config.ts
+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;
+};
+
+// src/parse-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 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 {};
+};
+
+// 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/config-store.ts
+import { existsSync as existsSync6 } from "fs";
+
+// src/resolve-config-target.ts
+import { join as join2 } from "path";
+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 };
+};
+
+// src/config-store.ts
+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;
+  }
+  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 };
+  }
+  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];
+  }
+};
+var agentConfigStore = new AgentConfigStore();
+
+// src/utils/to-error-message.ts
+var toErrorMessage = (error, fallback = "Unknown error") => error instanceof Error ? error.message : fallback;
+
+// 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/installer.ts
+var installMcpServerForAgent = (serverName, serverConfig, agentType, options = {}) => {
+  const agent = getMcpAgentConfig(agentType);
+  const isGlobal = options.global ?? false;
+  const { target } = agentConfigStore.resolveTarget(agent, options);
+  try {
+    const transformed = transformServerConfigForAgent(agent, serverName, serverConfig, {
+      global: isGlobal
+    });
+    agentConfigStore.writeServer(agent, serverName, transformed, options);
+    return { agent: agentType, success: true, path: target.configPath };
+  } catch (error) {
+    return {
+      agent: agentType,
+      success: false,
+      path: target.configPath,
+      error: toErrorMessage(error)
+    };
+  }
+};
+var installMcpServerForAgents = (serverName, serverConfig, agentTypes, options = {}) => agentTypes.map(
+  (agentType) => installMcpServerForAgent(serverName, serverConfig, agentType, options)
+);
+
+// src/utils/parse-mcp-agent-list.ts
+var parseMcpAgentList = (input5) => {
+  if (!input5 || input5.length === 0) return void 0;
+  if (input5.includes("*")) return getMcpAgentTypes();
+  const resolved = [];
+  for (const value of input5) {
+    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 = (input5) => {
+  if (!input5 || input5.length === 0) return void 0;
+  const rawList = [...input5];
+  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/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 = (input5) => {
+  if (input5.startsWith("@")) {
+    const secondAtIndex = input5.indexOf("@", 1);
+    if (secondAtIndex > 0) return input5.slice(0, secondAtIndex);
+    return input5;
+  }
+  const atIndex = input5.lastIndexOf("@");
+  if (atIndex > 0) return input5.slice(0, atIndex);
+  return input5;
+};
+var stripScopePrefix = (input5) => {
+  if (!input5.startsWith("@") || !input5.includes("/")) return input5;
+  const parts = input5.split("/");
+  return parts[1] || input5;
+};
+var stripPathPrefix = (input5) => {
+  if (!PATH_SEPARATOR_REGEX.test(input5)) return input5;
+  const segments = input5.split(PATH_SEPARATOR_REGEX);
+  const basename = segments[segments.length - 1];
+  return basename || input5;
+};
+var extractPackageName = (input5) => {
+  let name = stripVersionSuffix(input5);
+  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 = (input5) => {
+  try {
+    const url = new URL(input5);
+    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 = (input5) => {
+  const trimmed = input5.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/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 incompatibleMap = new Map(incompatible.map((item) => [item.agent, item.reason]));
+  const results = allAgents.map((agentType) => {
+    const incompatibleReason = incompatibleMap.get(agentType);
+    if (incompatibleReason) {
+      return {
+        agent: agentType,
+        success: false,
+        path: "",
+        error: incompatibleReason
+      };
+    }
+    return installMcpServerForAgent(serverName, serverConfig, agentType, { global: isGlobal, cwd });
+  });
+  return { serverName, config: serverConfig, results };
+};
+
+// src/list.ts
+var listInstalledMcpServers = (options = {}) => {
+  const agentTypes = options.agents ?? getMcpAgentTypes();
+  const collected = [];
+  for (const agentType of agentTypes) {
+    const agent = getMcpAgentConfig(agentType);
+    const { path, exists, servers } = agentConfigStore.listServers(agent, options);
+    if (!exists) continue;
+    for (const [serverName, rawConfig] of Object.entries(servers)) {
+      collected.push({
+        serverName,
+        agent: agentType,
+        path,
+        config: rawConfig,
+        serverConfig: parseServerConfig(rawConfig)
+      });
+    }
+  }
+  return collected;
+};
+
+// src/remove.ts
+var removeMcpServerFromAgent = (serverName, agentType, options = {}) => {
+  const agent = getMcpAgentConfig(agentType);
+  const { target } = agentConfigStore.resolveTarget(agent, options);
+  try {
+    const { removed } = agentConfigStore.removeServer(agent, serverName, options);
+    return { agent: agentType, path: target.configPath, removed };
+  } catch (error) {
+    return {
+      agent: agentType,
+      path: target.configPath,
+      removed: false,
+      error: toErrorMessage(error)
+    };
+  }
+};
+var removeMcpServer = (options) => {
+  const { allAgents } = resolveTargetAgents({
+    requested: options.agents,
+    all: !options.agents,
+    global: options.global,
+    cwd: options.cwd
+  });
+  const results = [];
+  for (const agentType of allAgents) {
+    const result = removeMcpServerFromAgent(options.name, agentType, {
+      global: options.global,
+      cwd: options.cwd
+    });
+    if (result.removed || result.error) results.push(result);
+  }
+  return results;
+};
+
+// src/interactive/main-menu.ts
+import { select as select8 } from "@inquirer/prompts";
+import pc10 from "picocolors";
+
+// src/interactive/wizard-add.ts
+import { confirm as confirm2, input as input4, select as select5 } from "@inquirer/prompts";
+import pc7 from "picocolors";
+
+// src/utils/logger.ts
+import pc from "picocolors";
+var logger = {
+  info: (message) => {
+    console.log(pc.cyan("i"), message);
+  },
+  success: (message) => {
+    console.log(pc.green("\u221A"), message);
+  },
+  warn: (message) => {
+    console.log(pc.yellow("!"), message);
+  },
+  error: (message) => {
+    console.error(pc.red("x"), message);
+  }
+};
+
+// src/interactive/prompts/agents.ts
+import { checkbox } from "@inquirer/prompts";
+import pc3 from "picocolors";
+
+// src/interactive/prompts/scope.ts
+import { select } from "@inquirer/prompts";
+import pc2 from "picocolors";
+var promptScope = async (options = {}) => {
+  const initialGlobal = options.defaultGlobal ?? options.global;
+  if (initialGlobal !== void 0) {
+    return initialGlobal;
+  }
+  const cwd = options.cwd ?? process.cwd();
+  return select({
+    message: options.message ?? "Select MCP scope:",
+    choices: [
+      {
+        name: `Current Project - ${pc2.dim(cwd)}`,
+        value: false
+      },
+      {
+        name: `Global User Config - ${pc2.dim("applies across all projects")}`,
+        value: true
+      }
+    ]
+  });
+};
+
+// src/interactive/prompts/agents.ts
+var promptScopeAndAgents = async (options = {}) => {
+  const cwd = options.cwd ?? process.cwd();
+  const isGlobal = await promptScope({
+    cwd,
+    defaultGlobal: options.defaultGlobal,
+    message: "Select MCP installation scope:"
+  });
+  const resolution = resolveTargetAgents({
+    global: isGlobal,
+    cwd
+  });
+  const detected = resolution.detected;
+  const availableAgentTypes = isGlobal ? getMcpAgentTypes() : getMcpAgentsSupportingProjectScope();
+  if (detected.length > 0) {
+    logger.info(
+      `Detected configured agents: ${pc3.cyan(detected.map((a) => getMcpAgentConfig(a).displayName).join(", "))}`
+    );
+  } else {
+    logger.warn(`No active ${isGlobal ? "global" : "project"} agents detected`);
+  }
+  const defaultChecked = options.defaultAgents && options.defaultAgents.length > 0 ? options.defaultAgents : detected;
+  const choices = availableAgentTypes.map((agentType) => {
+    const config = getMcpAgentConfig(agentType);
+    const isDetected = detected.includes(agentType);
+    const label = `${config.displayName} ${pc3.dim(`(${agentType})`)}${isDetected ? pc3.green(" [detected]") : ""}`;
+    return {
+      name: label,
+      value: agentType,
+      checked: defaultChecked.includes(agentType)
+    };
+  });
+  const selectedAgents = await checkbox({
+    message: "Select target agents (Space to select, Enter to confirm):",
+    choices,
+    validate: (chosen) => {
+      if (chosen.length === 0) {
+        return "Please select at least one agent";
+      }
+      return true;
+    }
+  });
+  return {
+    global: isGlobal,
+    agents: selectedAgents
+  };
+};
+
+// src/interactive/prompts/args.ts
+import { confirm, input } from "@inquirer/prompts";
+var parseArgsString = (rawText) => {
+  const matches = rawText.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g);
+  if (!matches) return [];
+  return matches.map((arg) => {
+    if (arg.startsWith('"') && arg.endsWith('"') || arg.startsWith("'") && arg.endsWith("'")) {
+      return arg.slice(1, -1);
+    }
+    return arg;
+  });
+};
+var promptArgsConfig = async (initialArgs = []) => {
+  if (initialArgs.length > 0) {
+    return initialArgs;
+  }
+  const needArgs = await confirm({
+    message: "Configure command arguments (e.g. file paths, connection strings)?",
+    default: false
+  });
+  if (!needArgs) {
+    return [];
+  }
+  const raw = await input({
+    message: "Enter command arguments (space-separated, wrap paths with spaces in quotes):",
+    validate: (val) => val.trim() ? true : "Arguments cannot be empty"
+  });
+  return parseArgsString(raw.trim());
+};
+
+// src/interactive/prompts/env.ts
+import { input as input2, password, select as select3 } from "@inquirer/prompts";
+import pc5 from "picocolors";
+
+// src/interactive/prompts/multiline.ts
+import { createInterface } from "readline";
+import { editor } from "@inquirer/prompts";
+import pc4 from "picocolors";
+var readMultilineTextFromTerminal = async (message, endHint = "When done pasting, enter END on a new line or press Enter twice to finish") => {
+  console.log(pc4.cyan(`
+${message}`));
+  console.log(pc4.dim(`  (Hint: ${endHint})
+`));
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const lines = [];
+    let consecutiveEmpty = 0;
+    const cleanup = () => {
+      rl.removeAllListeners();
+      rl.close();
+    };
+    rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (trimmed === "END") {
+        cleanup();
+        resolve(lines.join("\n"));
+        return;
+      }
+      if (line === "") {
+        consecutiveEmpty++;
+        if (lines.length > 0) {
+          cleanup();
+          resolve(lines.join("\n"));
+          return;
+        }
+        if (consecutiveEmpty >= 2) {
+          cleanup();
+          resolve("");
+          return;
+        }
+      } else {
+        consecutiveEmpty = 0;
+        lines.push(line);
+      }
+    });
+    rl.on("close", () => {
+      resolve(lines.join("\n"));
+    });
+  });
+};
+var promptEditorText = async (options) => {
+  try {
+    return await editor({
+      message: options.message,
+      default: options.defaultText ?? "",
+      postfix: options.postfix
+    });
+  } catch {
+    return readMultilineTextFromTerminal(options.message);
+  }
+};
+
+// src/interactive/prompts/env.ts
+var SECRET_KEY_PATTERN = /(token|key|secret|password|passwd|auth|credential)/i;
+var parseEnvText = (rawText) => {
+  const result = {};
+  const lines = rawText.split(/\r?\n/);
+  for (const rawLine of lines) {
+    let line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    if (line.startsWith("export ")) {
+      line = line.slice(7).trim();
+    }
+    const eqIndex = line.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = line.slice(0, eqIndex).trim();
+    let value = line.slice(eqIndex + 1).trim();
+    if (!key) continue;
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+};
+var promptEnvConfig = async (initialEnv = {}) => {
+  const env = { ...initialEnv };
+  const initialCount = Object.keys(env).length;
+  if (initialCount > 0) {
+    logger.info(`Includes ${pc5.cyan(String(initialCount))} preset environment variables`);
+  }
+  const mode = await select3({
+    message: "Configure environment variables?",
+    choices: [
+      {
+        name: "Skip / None",
+        value: "skip"
+      },
+      {
+        name: "Paste multiline .env text into terminal",
+        value: "paste"
+      },
+      {
+        name: "Open in system default editor ($EDITOR)",
+        value: "editor"
+      },
+      {
+        name: "Enter key-value pairs one by one",
+        value: "manual"
+      }
+    ]
+  });
+  if (mode === "skip") {
+    return env;
+  }
+  if (mode === "paste" || mode === "editor") {
+    const pasted = mode === "editor" ? await promptEditorText({
+      message: "Paste or edit environment variables in editor, then save and exit:",
+      postfix: ".env"
+    }) : await readMultilineTextFromTerminal("Paste .env formatted content (multiline supported):");
+    const parsed = parseEnvText(pasted);
+    const count = Object.keys(parsed).length;
+    if (count === 0) {
+      logger.warn("No valid KEY=VALUE pairs recognized");
+    } else {
+      Object.assign(env, parsed);
+      logger.success(`Successfully parsed ${pc5.cyan(String(count))} environment variables:`);
+      for (const [k, v] of Object.entries(parsed)) {
+        const masked = SECRET_KEY_PATTERN.test(k) && v.length > 4 ? `${v.slice(0, 2)}***${v.slice(-2)}` : v;
+        console.log(`  ${pc5.bold(k)}=${pc5.dim(masked)}`);
+      }
+    }
+    return env;
+  }
+  logger.info("Entering environment variables (leave key empty and press enter to finish):");
+  while (true) {
+    const key = await input2({
+      message: "Variable name (Key, leave empty to finish):",
+      validate: (val2) => {
+        const trimmed = val2.trim();
+        if (!trimmed) return true;
+        if (/\s/.test(trimmed)) return "Variable name cannot contain spaces";
+        return true;
+      }
+    });
+    const trimmedKey = key.trim();
+    if (!trimmedKey) break;
+    const isSecret = SECRET_KEY_PATTERN.test(trimmedKey);
+    let val;
+    if (isSecret) {
+      val = await password({
+        message: `Value for (${trimmedKey}) [secret masked]:`,
+        mask: "*"
+      });
+    } else {
+      val = await input2({
+        message: `Value for (${trimmedKey}):`
+      });
+    }
+    env[trimmedKey] = val;
+    logger.success(`Added: ${pc5.cyan(trimmedKey)}`);
+  }
+  return env;
+};
+
+// src/interactive/prompts/headers.ts
+import { input as input3, password as password2, select as select4 } from "@inquirer/prompts";
+import pc6 from "picocolors";
+var SECRET_HEADER_PATTERN = /(authorization|token|key|secret|auth)/i;
+var parseHeadersText = (rawText) => {
+  const result = {};
+  const lines = rawText.split(/\r?\n/);
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const colonIndex = line.indexOf(":");
+    const equalIndex = line.indexOf("=");
+    let splitIndex = -1;
+    if (colonIndex !== -1 && equalIndex !== -1) {
+      splitIndex = Math.min(colonIndex, equalIndex);
+    } else if (colonIndex !== -1) {
+      splitIndex = colonIndex;
+    } else {
+      splitIndex = equalIndex;
+    }
+    if (splitIndex === -1) continue;
+    const key = line.slice(0, splitIndex).trim();
+    let value = line.slice(splitIndex + 1).trim();
+    if (!key) continue;
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+};
+var promptHeadersConfig = async (initialHeaders = {}) => {
+  const headers = { ...initialHeaders };
+  const mode = await select4({
+    message: "Select HTTP headers configuration method:",
+    choices: [
+      {
+        name: "Paste multiline headers into terminal (Key: Value format)",
+        value: "paste"
+      },
+      {
+        name: "Open in system default editor ($EDITOR)",
+        value: "editor"
+      },
+      {
+        name: "Enter headers one by one (e.g. Authorization: Bearer ...)",
+        value: "manual"
+      },
+      {
+        name: "Skip / None",
+        value: "skip"
+      }
+    ]
+  });
+  if (mode === "skip") {
+    return headers;
+  }
+  if (mode === "paste" || mode === "editor") {
+    const pasted = mode === "editor" ? await promptEditorText({
+      message: "Paste or edit HTTP headers in editor, then save and exit:"
+    }) : await readMultilineTextFromTerminal(
+      "Paste HTTP headers content (multiline supported, e.g. Authorization: Bearer ...):"
+    );
+    const parsed = parseHeadersText(pasted);
+    const count = Object.keys(parsed).length;
+    if (count === 0) {
+      logger.warn("No valid Key: Value pairs recognized");
+    } else {
+      Object.assign(headers, parsed);
+      logger.success(`Successfully parsed ${pc6.cyan(String(count))} headers:`);
+      for (const [k, v] of Object.entries(parsed)) {
+        const masked = SECRET_HEADER_PATTERN.test(k) && v.length > 8 ? `${v.slice(0, 4)}***${v.slice(-3)}` : v;
+        console.log(`  ${pc6.bold(k)}: ${pc6.dim(masked)}`);
+      }
+    }
+    return headers;
+  }
+  logger.info("Entering HTTP headers (leave header name empty and press enter to finish):");
+  while (true) {
+    const name = await input3({
+      message: "Header name (e.g. Authorization, leave empty to finish):",
+      validate: (val2) => {
+        const trimmed = val2.trim();
+        if (!trimmed) return true;
+        if (/\s/.test(trimmed)) return "Header name cannot contain spaces";
+        return true;
+      }
+    });
+    const trimmedName = name.trim();
+    if (!trimmedName) break;
+    const isSecret = SECRET_HEADER_PATTERN.test(trimmedName);
+    let val;
+    if (isSecret) {
+      val = await password2({
+        message: `Header value for (${trimmedName}) [sensitive content masked]:`,
+        mask: "*"
+      });
+    } else {
+      val = await input3({
+        message: `Header value for (${trimmedName}):`
+      });
+    }
+    headers[trimmedName] = val;
+    logger.success(`Added: ${pc6.cyan(trimmedName)}`);
+  }
+  return headers;
+};
+
+// src/interactive/wizard-add.ts
+var wizardAdd = async (initial = {}) => {
+  const cwd = initial.cwd ?? process.cwd();
+  logger.info(pc7.bold("Welcome to the MCP interactive add wizard"));
+  let source = initial.source;
+  if (!source) {
+    const sourceType = await select5({
+      message: "Select MCP server type:",
+      choices: [
+        {
+          name: "npm package (run via npx)",
+          value: "npm"
+        },
+        {
+          name: "Remote MCP server (via HTTP / SSE URL)",
+          value: "remote"
+        },
+        {
+          name: "Local command / script / Docker (stdio)",
+          value: "command"
+        }
+      ]
+    });
+    if (sourceType === "npm") {
+      source = await input4({
+        message: "Enter npm package name (e.g. @modelcontextprotocol/server-postgres or mcp-server-git):",
+        validate: (val) => val.trim() ? true : "Package name cannot be empty"
+      });
+    } else if (sourceType === "remote") {
+      source = await input4({
+        message: "Enter remote server URL (e.g. https://mcp.example.com/sse):",
+        validate: (val) => {
+          const trimmed = val.trim();
+          if (!trimmed) return "URL cannot be empty";
+          if (!/^https?:\/\//i.test(trimmed)) return "Please enter a valid URL starting with http:// or https://";
+          return true;
+        }
+      });
+    } else {
+      source = await input4({
+        message: "Enter command and arguments (e.g. python -m my_mcp_server or docker run ...):",
+        validate: (val) => val.trim() ? true : "Command cannot be empty"
+      });
+    }
+  }
+  source = source.trim();
+  const parsed = parseMcpSource(source);
+  let serverName = initial.name;
+  if (!serverName) {
+    serverName = await input4({
+      message: "MCP server name:",
+      default: parsed.inferredName,
+      validate: (val) => val.trim() ? true : "Server name cannot be empty"
+    });
+  }
+  serverName = serverName.trim();
+  let transport = initial.transport;
+  let headers = initial.headers ?? {};
+  if (parsed.type === "remote") {
+    if (!transport) {
+      const isSseUrl = /\/sse\b/i.test(parsed.value);
+      transport = await select5({
+        message: "Select remote transport protocol:",
+        choices: [
+          { name: "HTTP", value: "http" },
+          { name: "SSE (Server-Sent Events)", value: "sse" }
+        ],
+        default: isSseUrl ? "sse" : "http"
+      });
+    }
+    if (Object.keys(headers).length === 0) {
+      const needHeader = await confirm2({
+        message: "Configure HTTP headers (e.g. Authorization Bearer token)?",
+        default: false
+      });
+      if (needHeader) {
+        headers = await promptHeadersConfig();
+      }
+    }
+  }
+  const { global: isGlobal, agents: selectedAgents } = await promptScopeAndAgents({
+    cwd,
+    defaultGlobal: initial.global,
+    defaultAgents: initial.agents
+  });
+  let args = initial.args ?? [];
+  if (parsed.type !== "remote") {
+    args = await promptArgsConfig(args);
+  }
+  let env = initial.env ?? {};
+  if (parsed.type !== "remote") {
+    env = await promptEnvConfig(env);
+  }
+  console.log("\n" + pc7.cyan(pc7.bold("Configuration Preview:")));
+  console.log(`  ${pc7.bold("Server Name:")} ${pc7.green(serverName)}`);
+  console.log(`  ${pc7.bold("Server Type:")} ${pc7.magenta(parsed.type)}`);
+  console.log(`  ${pc7.bold("Source/Command:")} ${pc7.dim(source)}`);
+  console.log(`  ${pc7.bold("Scope:")} ${isGlobal ? pc7.yellow("Global") : pc7.blue("Project")}`);
+  console.log(`  ${pc7.bold("Target Agents:")} ${pc7.cyan(selectedAgents.join(", "))}`);
+  if (args.length > 0) {
+    console.log(`  ${pc7.bold("Arguments:")} ${pc7.dim(args.join(" "))}`);
+  }
+  if (transport) {
+    console.log(`  ${pc7.bold("Transport:")} ${pc7.magenta(transport)}`);
+  }
+  const envKeys = Object.keys(env);
+  if (envKeys.length > 0) {
+    console.log(`  ${pc7.bold("Environment Variables:")} ${pc7.dim(envKeys.join(", "))} (${envKeys.length})`);
+  }
+  const headerKeys = Object.keys(headers);
+  if (headerKeys.length > 0) {
+    console.log(`  ${pc7.bold("Headers:")} ${pc7.dim(headerKeys.join(", "))} (${headerKeys.length})`);
+  }
+  console.log();
+  const proceed = await confirm2({
+    message: "Confirm installation with this configuration?",
+    default: true
+  });
+  if (!proceed) {
+    logger.warn("Operation cancelled");
+    return false;
+  }
+  const result = installMcpServer({
+    source,
+    name: serverName,
+    agents: selectedAgents,
+    args,
+    global: isGlobal,
+    cwd,
+    transport,
+    headers,
+    env
+  });
+  logger.info(
+    `Writing ${pc7.bold(result.serverName)} to ${pc7.cyan(String(result.results.length))} agent config files...`
+  );
+  let allSuccess = true;
+  for (const record of result.results) {
+    if (record.success) {
+      logger.success(`${pc7.cyan(record.agent)}: Successfully written to ${pc7.dim(record.path)}`);
+    } else {
+      allSuccess = false;
+      logger.error(`${pc7.cyan(record.agent)}: Failed to write - ${record.error}`);
+    }
+  }
+  if (allSuccess) {
+    logger.success(pc7.bold(`MCP server "${serverName}" configured successfully!`));
+  }
+  return allSuccess;
+};
+
+// src/interactive/wizard-manage.ts
+import { checkbox as checkbox2, confirm as confirm3, select as select6 } from "@inquirer/prompts";
+import pc8 from "picocolors";
+
+// src/interactive/utils/group-installed-servers.ts
+var normalizeServerConfig = parseServerConfig;
+var groupInstalledServersByName = (installed) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const item of installed) {
+    let entry = grouped.get(item.serverName);
+    if (!entry) {
+      entry = {
+        serverName: item.serverName,
+        agents: [],
+        paths: [],
+        config: normalizeServerConfig(item.config)
+      };
+      grouped.set(item.serverName, entry);
+    }
+    if (!entry.agents.includes(item.agent)) {
+      entry.agents.push(item.agent);
+    }
+    if (!entry.paths.includes(item.path)) {
+      entry.paths.push(item.path);
+    }
+  }
+  return grouped;
+};
+
+// src/interactive/wizard-manage.ts
+var wizardManage = async (options = {}) => {
+  const cwd = options.cwd ?? process.cwd();
+  const isGlobal = await promptScope({
+    cwd,
+    defaultGlobal: options.global,
+    message: "Select MCP scope to inspect and manage:"
+  });
+  const installed = listInstalledMcpServers({ global: isGlobal, cwd });
+  if (installed.length === 0) {
+    logger.warn(`No configured MCP servers found in ${isGlobal ? "global" : "project"} scope`);
+    return;
+  }
+  const grouped = groupInstalledServersByName(installed);
+  while (true) {
+    const choices = Array.from(grouped.values()).map((g) => {
+      const agentNames = g.agents.map((a) => getMcpAgentConfig(a).displayName).join(", ");
+      return {
+        name: `${pc8.bold(g.serverName)} ${pc8.dim(`(configured in: ${agentNames})`)}`,
+        value: g.serverName
+      };
+    });
+    choices.push({
+      name: `Back`,
+      value: "__back__"
+    });
+    const chosenServerName = await select6({
+      message: "Select MCP server to manage or sync:",
+      choices
+    });
+    if (chosenServerName === "__back__") {
+      return;
+    }
+    const targetGroup = grouped.get(chosenServerName);
+    if (!targetGroup) continue;
+    console.log("\n" + pc8.cyan(pc8.bold(`MCP Server Details: [${chosenServerName}]`)));
+    console.log(`  ${pc8.bold("Scope:")} ${isGlobal ? "Global" : "Project"}`);
+    console.log(
+      `  ${pc8.bold("Configured Agents:")} ${pc8.green(targetGroup.agents.map((a) => getMcpAgentConfig(a).displayName).join(", "))}`
+    );
+    const cfg = targetGroup.config;
+    if (isRemoteServerConfig(cfg)) {
+      console.log(`  ${pc8.bold("URL:")} ${pc8.dim(cfg.url)} (${cfg.type})`);
+      if (cfg.headers && Object.keys(cfg.headers).length > 0) {
+        console.log(`  ${pc8.bold("Headers:")} ${Object.keys(cfg.headers).join(", ")}`);
+      }
+    } else if (isStdioServerConfig(cfg)) {
+      console.log(`  ${pc8.bold("Command:")} ${pc8.magenta(cfg.command)}`);
+      if (cfg.args && cfg.args.length > 0) {
+        console.log(`  ${pc8.bold("Arguments:")} ${pc8.dim(cfg.args.join(" "))}`);
+      }
+      if (cfg.env && Object.keys(cfg.env).length > 0) {
+        console.log(`  ${pc8.bold("Environment Variables:")} ${pc8.dim(Object.keys(cfg.env).join(", "))}`);
+      }
+    }
+    console.log();
+    const action = await select6({
+      message: `What would you like to do with [${chosenServerName}]?`,
+      choices: [
+        {
+          name: "Sync / clone to other agents",
+          value: "sync"
+        },
+        {
+          name: "Back to list",
+          value: "back"
+        }
+      ]
+    });
+    if (action === "back") continue;
+    if (action === "sync") {
+      const allAllowedAgents = isGlobal ? getMcpAgentTypes() : getMcpAgentsSupportingProjectScope();
+      const candidateAgents = allAllowedAgents.filter((a) => !targetGroup.agents.includes(a));
+      if (candidateAgents.length === 0) {
+        logger.info("All supported agents in this scope already have this MCP server configured; no sync needed");
+        continue;
+      }
+      const selectedToSync = await checkbox2({
+        message: "Select target agents to sync to (Space to select):",
+        choices: candidateAgents.map((a) => ({
+          name: `${getMcpAgentConfig(a).displayName} (${a})`,
+          value: a,
+          checked: false
+        })),
+        validate: (ans) => ans.length === 0 ? "Please select at least one agent" : true
+      });
+      const confirmed = await confirm3({
+        message: `Confirm syncing configuration of [${chosenServerName}] to: ${selectedToSync.join(", ")}?`,
+        default: true
+      });
+      if (!confirmed) {
+        logger.warn("Sync cancelled");
+        continue;
+      }
+      for (const targetAgent of selectedToSync) {
+        const res = installMcpServerForAgent(chosenServerName, targetGroup.config, targetAgent, {
+          global: isGlobal,
+          cwd
+        });
+        if (res.success) {
+          logger.success(`${pc8.cyan(targetAgent)}: Successfully synced to ${pc8.dim(res.path)}`);
+          targetGroup.agents.push(targetAgent);
+        } else {
+          logger.error(`${pc8.cyan(targetAgent)}: Sync failed - ${res.error}`);
+        }
+      }
+    }
+  }
+};
+
+// src/interactive/wizard-remove.ts
+import { checkbox as checkbox3, confirm as confirm4, select as select7 } from "@inquirer/prompts";
+import pc9 from "picocolors";
+var wizardRemove = async (options = {}) => {
+  const cwd = options.cwd ?? process.cwd();
+  const isGlobal = await promptScope({
+    cwd,
+    defaultGlobal: options.global,
+    message: "Select scope to remove MCP server from:"
+  });
+  const installed = listInstalledMcpServers({ global: isGlobal, cwd });
+  if (installed.length === 0) {
+    logger.warn(`No installed MCP servers found in ${isGlobal ? "global" : "project"} scope`);
+    return false;
+  }
+  const serverMap = groupInstalledServersByName(installed);
+  let serverName = options.name;
+  if (!serverName) {
+    const choices = Array.from(serverMap.values()).map((g) => ({
+      name: `${pc9.bold(g.serverName)} ${pc9.dim(`(installed in: ${g.agents.map((a) => getMcpAgentConfig(a).displayName).join(", ")})`)}`,
+      value: g.serverName
+    }));
+    serverName = await select7({
+      message: "Select MCP server to remove:",
+      choices
+    });
+  }
+  const installedAgents = serverMap.get(serverName)?.agents || [];
+  if (installedAgents.length === 0) {
+    logger.warn(`No agents found with [${serverName}] installed`);
+    return false;
+  }
+  let targetAgents = options.agents;
+  if (!targetAgents || targetAgents.length === 0) {
+    targetAgents = await checkbox3({
+      message: `Select agents to remove [${serverName}] from:`,
+      choices: installedAgents.map((agent) => ({
+        name: `${getMcpAgentConfig(agent)?.displayName ?? agent} (${agent})`,
+        value: agent,
+        checked: true
+      })),
+      validate: (ans) => ans.length === 0 ? "Please select at least one agent" : true
+    });
+  } else {
+    const validAgents = targetAgents.filter((agent) => installedAgents.includes(agent));
+    if (validAgents.length === 0) {
+      logger.warn(`None of the specified agents (${targetAgents.join(", ")}) have [${serverName}] installed`);
+      return false;
+    }
+    targetAgents = validAgents;
+  }
+  const confirmed = await confirm4({
+    message: `Confirm removing MCP server [${serverName}] from ${targetAgents.join(", ")}?`,
+    default: true
+  });
+  if (!confirmed) {
+    logger.warn("Operation cancelled");
+    return false;
+  }
+  const results = removeMcpServer({
+    name: serverName,
+    agents: targetAgents,
+    global: isGlobal,
+    cwd
+  });
+  let removedCount = 0;
+  for (const res of results) {
+    if (res.removed) {
+      logger.success(`${pc9.cyan(res.agent)}: Successfully removed from ${pc9.dim(res.path)}`);
+      removedCount++;
+    } else if (res.error) {
+      logger.error(`${pc9.cyan(res.agent)}: Failed to remove - ${res.error}`);
+    }
+  }
+  if (removedCount > 0) {
+    logger.success(`Successfully removed [${serverName}] from ${removedCount} agent(s)`);
+    return true;
+  }
+  logger.warn(`Failed to remove [${serverName}] from specified agents`);
+  return false;
+};
+
+// src/interactive/main-menu.ts
+var mainMenu = async () => {
+  console.log();
+  console.log(pc10.bold(pc10.cyan("mcps - Cross-Platform MCP Manager for AI Coding Agents")));
+  console.log(pc10.dim("Cross-platform MCP server configuration & synchronization tool"));
+  console.log();
+  while (true) {
+    try {
+      const action = await select8({
+        message: "Select an action:",
+        choices: [
+          {
+            name: "Add MCP Server",
+            value: "add"
+          },
+          {
+            name: "Manage & Sync Installed MCP Servers",
+            value: "manage"
+          },
+          {
+            name: "Remove MCP Server",
+            value: "remove"
+          },
+          {
+            name: "Exit",
+            value: "exit"
+          }
+        ]
+      });
+      if (action === "exit") {
+        console.log(pc10.dim("Goodbye!"));
+        break;
+      }
+      if (action === "add") {
+        await wizardAdd();
+      } else if (action === "manage") {
+        await wizardManage();
+      } else if (action === "remove") {
+        await wizardRemove();
+      }
+      console.log();
+    } catch (error) {
+      if (error?.name === "ExitPromptError") {
+        console.log("\n" + pc10.dim("Exited."));
+        break;
+      }
+      throw error;
+    }
+  }
+};
+
+export {
+  mcpAgents,
+  mcpAgentAliases,
+  getMcpAgentConfig,
+  getMcpAgentTypes,
+  isMcpAgentType,
+  resolveMcpAgentAlias,
+  isMcpTransportSupported,
+  detectProjectInstalledMcpAgents,
+  detectGloballyInstalledMcpAgents,
+  getMcpAgentsSupportingProjectScope,
+  DEFAULT_REMOTE_TRANSPORT,
+  NPX_COMMAND,
+  NPX_DASH_Y,
+  buildMcpServerConfig,
+  isRemoteServerConfig,
+  isStdioServerConfig,
+  parseServerConfig,
+  readConfigFile,
+  writeServerToConfigFile,
+  removeServerFromConfigFile,
+  listServersInConfigFile,
+  resolveMcpConfigTarget,
+  AgentConfigStore,
+  agentConfigStore,
+  toErrorMessage,
+  transformServerConfig,
+  createAgentTransform,
+  transformServerConfigForAgent,
+  installMcpServerForAgent,
+  installMcpServerForAgents,
+  parseMcpAgentList,
+  resolveTargetAgents,
+  extractPackageName,
+  parseMcpSource,
+  isRemoteMcpSource,
+  installMcpServer,
+  listInstalledMcpServers,
+  removeMcpServerFromAgent,
+  removeMcpServer,
+  logger,
+  promptScope,
+  promptScopeAndAgents,
+  parseArgsString,
+  promptArgsConfig,
+  parseEnvText,
+  promptEnvConfig,
+  parseHeadersText,
+  promptHeadersConfig,
+  wizardAdd,
+  normalizeServerConfig,
+  groupInstalledServersByName,
+  wizardManage,
+  wizardRemove,
+  mainMenu
+};