add-mcp 1.9.0 → 1.10.0

package/dist/chunk-56AZIA6W.js

@@ -0,0 +1,1221 @@
+// src/config.ts
+import { readFile, writeFile, mkdir, rm } from "fs/promises";
+import { dirname, join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = "add-mcp";
+var CONFIG_FILE = "config.json";
+var CURRENT_VERSION = 1;
+var LEGACY_AGENTS_DIR = ".agents";
+var LEGACY_LOCK_FILE = ".mcp-lock.json";
+function getXdgConfigHome() {
+  return process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+}
+function getConfigPath() {
+  return join(getXdgConfigHome(), CONFIG_DIR, CONFIG_FILE);
+}
+function getLegacyConfigPath() {
+  return join(homedir(), LEGACY_AGENTS_DIR, LEGACY_LOCK_FILE);
+}
+async function readConfig() {
+  const configPath = getConfigPath();
+  try {
+    const content = await readFile(configPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed.version !== "number") {
+      return createEmptyConfig();
+    }
+    if (parsed.version < CURRENT_VERSION) {
+      return createEmptyConfig();
+    }
+    return parsed;
+  } catch {
+  }
+  const legacyPath = getLegacyConfigPath();
+  try {
+    const content = await readFile(legacyPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed.version !== "number" || parsed.version < CURRENT_VERSION) {
+      return createEmptyConfig();
+    }
+    await writeConfig(parsed);
+    await cleanupLegacyConfig();
+    return parsed;
+  } catch {
+    return createEmptyConfig();
+  }
+}
+async function writeConfig(config) {
+  const configPath = getConfigPath();
+  await mkdir(dirname(configPath), { recursive: true });
+  const content = JSON.stringify(config, null, 2);
+  await writeFile(configPath, content, "utf-8");
+}
+async function cleanupLegacyConfig() {
+  const legacyPath = getLegacyConfigPath();
+  try {
+    await rm(legacyPath, { force: true });
+  } catch {
+  }
+}
+async function getLastSelectedAgents() {
+  const config = await readConfig();
+  return config.lastSelectedAgents;
+}
+async function saveSelectedAgents(agents2) {
+  const config = await readConfig();
+  config.lastSelectedAgents = agents2;
+  await writeConfig(config);
+}
+async function getFindRegistries() {
+  const config = await readConfig();
+  if (!config.findRegistries) return [];
+  return config.findRegistries.map(normalizeFindRegistryEntry);
+}
+function normalizeFindRegistryEntry(raw) {
+  const legacy = raw;
+  const url = legacy.url ?? legacy.serversUrl;
+  if (!url || typeof url !== "string") {
+    throw new Error("Registry entry missing url");
+  }
+  return {
+    url,
+    ...legacy.label ? { label: legacy.label } : {}
+  };
+}
+async function saveFindRegistries(registries) {
+  const config = await readConfig();
+  config.findRegistries = registries;
+  await writeConfig(config);
+}
+function createEmptyConfig() {
+  return {
+    version: CURRENT_VERSION
+  };
+}
+
+// src/agents.ts
+import * as p from "@clack/prompts";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join2 } from "path";
+import { existsSync } from "fs";
+var home = homedir2();
+function shortenPath(fullPath) {
+  if (fullPath.startsWith(home)) {
+    return fullPath.replace(home, "~");
+  }
+  return fullPath;
+}
+function getPlatformPaths() {
+  const platform = process.platform;
+  if (platform === "win32") {
+    const appData = process.env.APPDATA || join2(home, "AppData", "Roaming");
+    return {
+      appSupport: appData,
+      vscodePath: join2(appData, "Code", "User"),
+      gooseConfigPath: join2(appData, "Block", "goose", "config", "config.yaml")
+    };
+  } else if (platform === "darwin") {
+    return {
+      appSupport: join2(home, "Library", "Application Support"),
+      vscodePath: join2(home, "Library", "Application Support", "Code", "User"),
+      gooseConfigPath: join2(home, ".config", "goose", "config.yaml")
+    };
+  } else {
+    const configDir = process.env.XDG_CONFIG_HOME || join2(home, ".config");
+    return {
+      appSupport: configDir,
+      vscodePath: join2(configDir, "Code", "User"),
+      gooseConfigPath: join2(configDir, "goose", "config.yaml")
+    };
+  }
+}
+var { appSupport, vscodePath, gooseConfigPath } = getPlatformPaths();
+var antigravityConfigPath = join2(
+  home,
+  ".gemini",
+  "antigravity",
+  "mcp_config.json"
+);
+var clineCliConfigPath = join2(
+  process.env.CLINE_DIR || join2(home, ".cline"),
+  "data",
+  "settings",
+  "cline_mcp_settings.json"
+);
+var clineExtensionConfigPath = join2(
+  vscodePath,
+  "globalStorage",
+  "saoudrizwan.claude-dev",
+  "settings",
+  "cline_mcp_settings.json"
+);
+var copilotConfigPath = join2(
+  process.env.XDG_CONFIG_HOME || join2(home, ".copilot"),
+  "mcp-config.json"
+);
+function transformGooseConfig(serverName, config) {
+  if (config.url) {
+    const gooseType = config.type === "sse" ? "sse" : "streamable_http";
+    return {
+      name: serverName,
+      description: "",
+      type: gooseType,
+      uri: config.url,
+      headers: config.headers || {},
+      enabled: true,
+      timeout: 300
+    };
+  }
+  return {
+    name: serverName,
+    description: "",
+    cmd: config.command,
+    args: config.args || [],
+    enabled: true,
+    envs: config.env || {},
+    type: "stdio",
+    timeout: 300
+  };
+}
+function transformZedConfig(_serverName, config) {
+  if (config.url) {
+    return {
+      source: "custom",
+      type: config.type || "http",
+      url: config.url,
+      headers: config.headers || {}
+    };
+  }
+  return {
+    source: "custom",
+    command: config.command,
+    args: config.args || [],
+    env: config.env || {}
+  };
+}
+function transformOpenCodeConfig(_serverName, config) {
+  if (config.url) {
+    return {
+      type: "remote",
+      url: config.url,
+      enabled: true,
+      headers: config.headers
+    };
+  }
+  return {
+    type: "local",
+    command: [config.command, ...config.args || []],
+    enabled: true,
+    environment: config.env || {}
+  };
+}
+function transformCodexConfig(_serverName, config) {
+  if (config.url) {
+    const remoteConfig = {
+      type: config.type || "http",
+      url: config.url
+    };
+    if (config.headers && Object.keys(config.headers).length > 0) {
+      remoteConfig.http_headers = config.headers;
+    }
+    return remoteConfig;
+  }
+  return {
+    command: config.command,
+    args: config.args || [],
+    env: config.env
+  };
+}
+function transformCursorConfig(_serverName, config) {
+  if (config.url) {
+    const remoteConfig = {
+      url: config.url
+    };
+    if (config.headers && Object.keys(config.headers).length > 0) {
+      remoteConfig.headers = config.headers;
+    }
+    return remoteConfig;
+  }
+  return config;
+}
+function transformClineConfig(_serverName, config) {
+  if (config.url) {
+    const remoteConfig = {
+      url: config.url,
+      type: config.type === "sse" ? "sse" : "streamableHttp",
+      disabled: false
+    };
+    if (config.headers && Object.keys(config.headers).length > 0) {
+      remoteConfig.headers = config.headers;
+    }
+    return remoteConfig;
+  }
+  const localConfig = {
+    command: config.command,
+    args: config.args || [],
+    disabled: false
+  };
+  if (config.env && Object.keys(config.env).length > 0) {
+    localConfig.env = config.env;
+  }
+  return localConfig;
+}
+function transformAntigravityConfig(_serverName, config) {
+  if (config.url) {
+    const remoteConfig = {
+      serverUrl: config.url
+    };
+    if (config.headers && Object.keys(config.headers).length > 0) {
+      remoteConfig.headers = config.headers;
+    }
+    return remoteConfig;
+  }
+  const localConfig = {
+    command: config.command,
+    args: config.args || []
+  };
+  if (config.env && Object.keys(config.env).length > 0) {
+    localConfig.env = config.env;
+  }
+  return localConfig;
+}
+function transformGitHubCopilotCliConfig(_serverName, config, context) {
+  if (context?.local) {
+    return config;
+  }
+  if (config.url) {
+    const remoteConfig = {
+      type: config.type || "http",
+      url: config.url,
+      tools: ["*"]
+    };
+    if (config.headers && Object.keys(config.headers).length > 0) {
+      remoteConfig.headers = config.headers;
+    }
+    return remoteConfig;
+  }
+  const localConfig = {
+    type: "stdio",
+    command: config.command,
+    args: config.args || [],
+    tools: ["*"]
+  };
+  if (config.env && Object.keys(config.env).length > 0) {
+    localConfig.env = config.env;
+  }
+  return localConfig;
+}
+function resolveMcporterConfigPath(agent, options) {
+  if (options.local && agent.localConfigPath) {
+    return join2(options.cwd, agent.localConfigPath);
+  }
+  const globalJsonPath = agent.configPath;
+  const globalJsoncPath = join2(dirname2(globalJsonPath), "mcporter.jsonc");
+  if (existsSync(globalJsonPath)) {
+    return globalJsonPath;
+  }
+  if (existsSync(globalJsoncPath)) {
+    return globalJsoncPath;
+  }
+  return globalJsonPath;
+}
+var agents = {
+  antigravity: {
+    name: "antigravity",
+    displayName: "Antigravity",
+    configPath: antigravityConfigPath,
+    projectDetectPaths: [],
+    // Global only - no project support
+    configKey: "mcpServers",
+    format: "json",
+    supportedTransports: ["stdio", "http", "sse"],
+    detectGlobalInstall: async () => {
+      return existsSync(join2(home, ".gemini"));
+    },
+    transformConfig: transformAntigravityConfig
+  },
+  cline: {
+    name: "cline",
+    displayName: "Cline VSCode Extension",
+    configPath: clineExtensionConfigPath,
+    projectDetectPaths: [],
+    // Global only - no project support
+    configKey: "mcpServers",
+    format: "json",
+    supportedTransports: ["stdio", "http", "sse"],
+    detectGlobalInstall: async () => {
+      return existsSync(dirname2(clineExtensionConfigPath));
+    },
+    transformConfig: transformClineConfig
+  },
+  "cline-cli": {
+    name: "cline-cli",
+    displayName: "Cline CLI",
+    configPath: clineCliConfigPath,
+    projectDetectPaths: [],
+    // Global only - no project support
+    configKey: "mcpServers",
+    format: "json",
+    supportedTransports: ["stdio", "http", "sse"],
+    detectGlobalInstall: async () => {
+      return existsSync(dirname2(clineCliConfigPath));
+    },
+    transformConfig: transformClineConfig
+  },
+  "claude-code": {
+    name: "claude-code",
+    displayName: "Claude Code",
+    configPath: join2(home, ".claude.json"),
+    localConfigPath: ".mcp.json",
+    projectDetectPaths: [".mcp.json", ".claude"],
+    configKey: "mcpServers",
+    format: "json",
+    supportedTransports: ["stdio", "http", "sse"],
+    detectGlobalInstall: async () => {
+      return existsSync(join2(home, ".claude"));
+    }
+  },
+  "claude-desktop": {
+    name: "claude-desktop",
+    displayName: "Claude Desktop",
+    configPath: join2(appSupport, "Claude", "claude_desktop_config.json"),
+    projectDetectPaths: [],
+    // Global only - no project support
+    configKey: "mcpServers",
+    format: "json",
+    supportedTransports: ["stdio"],
+    unsupportedTransportMessage: "Claude Desktop only supports local (stdio) servers via its config file. Add remote servers through Settings \u2192 Connectors in the app instead.",
+    detectGlobalInstall: async () => {
+      return existsSync(join2(appSupport, "Claude"));
+    }
+  },
+  codex: {
+    name: "codex",
+    displayName: "Codex",
+    configPath: join2(
+      process.env.CODEX_HOME || join2(home, ".codex"),
+      "config.toml"
+    ),
+    localConfigPath: ".codex/config.toml",
+    projectDetectPaths: [".codex"],
+    configKey: "mcp_servers",
+    format: "toml",
+    supportedTransports: ["stdio", "http", "sse"],
+    detectGlobalInstall: async () => {
+      return existsSync(join2(home, ".codex"));
+    },
+    transformConfig: transformCodexConfig
+  },
+  cursor: {
+    name: "cursor",
+    displayName: "Cursor",
+    configPath: join2(home, ".cursor", "mcp.json"),
+    localConfigPath: ".cursor/mcp.json",
+    projectDetectPaths: [".cursor"],
+    configKey: "mcpServers",
+    format: "json",
+    supportedTransports: ["stdio", "http", "sse"],
+    detectGlobalInstall: async () => {
+      return existsSync(join2(home, ".cursor"));
+    },
+    transformConfig: transformCursorConfig
+  },
+  "gemini-cli": {
+    name: "gemini-cli",
+    displayName: "Gemini CLI",
+    configPath: join2(home, ".gemini", "settings.json"),
+    localConfigPath: ".gemini/settings.json",
+    projectDetectPaths: [".gemini"],
+    configKey: "mcpServers",
+    format: "json",
+    supportedTransports: ["stdio", "http", "sse"],
+    detectGlobalInstall: async () => {
+      return existsSync(join2(home, ".gemini"));
+    }
+  },
+  goose: {
+    name: "goose",
+    displayName: "Goose",
+    configPath: gooseConfigPath,
+    projectDetectPaths: [],
+    // Global only - no project support
+    configKey: "extensions",
+    format: "yaml",
+    supportedTransports: ["stdio", "http", "sse"],
+    detectGlobalInstall: async () => {
+      return existsSync(gooseConfigPath);
+    },
+    transformConfig: transformGooseConfig
+  },
+  "github-copilot-cli": {
+    name: "github-copilot-cli",
+    displayName: "GitHub Copilot CLI",
+    configPath: copilotConfigPath,
+    localConfigPath: ".vscode/mcp.json",
+    projectDetectPaths: [".vscode"],
+    configKey: "mcpServers",
+    localConfigKey: "servers",
+    format: "json",
+    supportedTransports: ["stdio", "http", "sse"],
+    detectGlobalInstall: async () => {
+      return existsSync(dirname2(copilotConfigPath));
+    },
+    transformConfig: transformGitHubCopilotCliConfig
+  },
+  mcporter: {
+    name: "mcporter",
+    displayName: "MCPorter",
+    configPath: join2(home, ".mcporter", "mcporter.json"),
+    localConfigPath: "config/mcporter.json",
+    projectDetectPaths: ["config/mcporter.json"],
+    configKey: "mcpServers",
+    format: "json",
+    supportedTransports: ["stdio", "http", "sse"],
+    detectGlobalInstall: async () => {
+      return existsSync(join2(home, ".mcporter"));
+    },
+    resolveConfigPath: resolveMcporterConfigPath
+  },
+  opencode: {
+    name: "opencode",
+    displayName: "OpenCode",
+    configPath: join2(home, ".config", "opencode", "opencode.json"),
+    localConfigPath: "opencode.json",
+    projectDetectPaths: ["opencode.json", ".opencode"],
+    configKey: "mcp",
+    format: "json",
+    supportedTransports: ["stdio", "http", "sse"],
+    detectGlobalInstall: async () => {
+      return existsSync(join2(home, ".config", "opencode"));
+    },
+    transformConfig: transformOpenCodeConfig
+  },
+  vscode: {
+    name: "vscode",
+    displayName: "VS Code",
+    configPath: join2(vscodePath, "mcp.json"),
+    localConfigPath: ".vscode/mcp.json",
+    projectDetectPaths: [".vscode"],
+    configKey: "servers",
+    format: "json",
+    supportedTransports: ["stdio", "http", "sse"],
+    detectGlobalInstall: async () => {
+      return existsSync(vscodePath);
+    }
+  },
+  zed: {
+    name: "zed",
+    displayName: "Zed",
+    configPath: process.platform === "darwin" || process.platform === "win32" ? join2(appSupport, "Zed", "settings.json") : join2(appSupport, "zed", "settings.json"),
+    localConfigPath: ".zed/settings.json",
+    projectDetectPaths: [".zed"],
+    configKey: "context_servers",
+    format: "json",
+    supportedTransports: ["stdio", "http", "sse"],
+    detectGlobalInstall: async () => {
+      const configDir = process.platform === "darwin" || process.platform === "win32" ? join2(appSupport, "Zed") : join2(appSupport, "zed");
+      return existsSync(configDir);
+    },
+    transformConfig: transformZedConfig
+  }
+};
+function getAgentTypes() {
+  return Object.keys(agents);
+}
+function supportsProjectConfig(agentType) {
+  return agents[agentType].localConfigPath !== void 0;
+}
+function getProjectCapableAgents() {
+  return Object.keys(agents).filter(
+    (type) => supportsProjectConfig(type)
+  );
+}
+function detectProjectAgents(cwd) {
+  const dir = cwd || process.cwd();
+  const detected = [];
+  for (const [type, config] of Object.entries(agents)) {
+    if (!config.localConfigPath) continue;
+    for (const detectPath of config.projectDetectPaths) {
+      if (existsSync(join2(dir, detectPath))) {
+        detected.push(type);
+        break;
+      }
+    }
+  }
+  return detected;
+}
+async function detectGlobalAgents() {
+  const detected = [];
+  for (const [type, config] of Object.entries(agents)) {
+    if (await config.detectGlobalInstall()) {
+      detected.push(type);
+    }
+  }
+  return detected;
+}
+function isTransportSupported(agentType, transport) {
+  return agents[agentType].supportedTransports.includes(transport);
+}
+function buildAgentSelectionChoices(options) {
+  const { availableAgents, detectedAgents, agentRouting, lastSelected } = options;
+  const detectedSet = new Set(detectedAgents);
+  const validLastSelected = lastSelected?.filter(
+    (agent) => availableAgents.includes(agent) && !detectedSet.has(agent)
+  ) ?? [];
+  const remainingAgents = availableAgents.filter(
+    (agent) => !detectedSet.has(agent) && !validLastSelected.includes(agent)
+  );
+  const orderedAgents = [
+    ...detectedAgents,
+    ...validLastSelected,
+    ...remainingAgents
+  ];
+  const choices = orderedAgents.map((agentType) => {
+    const routing = agentRouting.get(agentType);
+    const baseHint = routing === "local" ? "project" : routing === "global" ? "global" : shortenPath(agents[agentType].configPath);
+    const lastSelectedHint = validLastSelected.includes(agentType) ? "selected last time" : "";
+    const hint = lastSelectedHint ? `${baseHint} \xB7 ${lastSelectedHint}` : baseHint;
+    return {
+      value: agentType,
+      label: agents[agentType].displayName,
+      hint
+    };
+  });
+  return { choices, initialValues: detectedAgents };
+}
+async function promptForAgents(message, choices, defaultToAll = false) {
+  let lastSelected;
+  try {
+    lastSelected = await getLastSelectedAgents();
+  } catch {
+  }
+  const validAgents = choices.map((c) => c.value);
+  let initialValues;
+  if (lastSelected && lastSelected.length > 0) {
+    initialValues = lastSelected.filter(
+      (a) => validAgents.includes(a)
+    );
+    if (initialValues.length === 0 && defaultToAll) {
+      initialValues = validAgents;
+    }
+  } else {
+    initialValues = defaultToAll ? validAgents : [];
+  }
+  const selected = await p.multiselect({
+    message,
+    options: choices,
+    required: true,
+    initialValues
+  });
+  if (!p.isCancel(selected)) {
+    try {
+      await saveSelectedAgents(selected);
+    } catch {
+    }
+  }
+  return selected;
+}
+async function selectAgentsInteractive(availableAgents, options) {
+  let lastSelected;
+  try {
+    lastSelected = await getLastSelectedAgents();
+  } catch {
+  }
+  const validLastSelected = lastSelected?.filter(
+    (a) => availableAgents.includes(a)
+  );
+  const selectOptions = [];
+  const hasPrevious = validLastSelected && validLastSelected.length > 0;
+  if (hasPrevious) {
+    const agentNames = validLastSelected.map((a) => agents[a].displayName).join(", ");
+    selectOptions.push({
+      value: "previous",
+      label: "Same as last time",
+      hint: agentNames
+    });
+  }
+  selectOptions.push({
+    value: "all",
+    label: hasPrevious ? "All available agents" : "All available agents",
+    hint: `Install to all ${availableAgents.length} available agents`
+  });
+  selectOptions.push({
+    value: "select",
+    label: "Select specific agents",
+    hint: "Choose which agents to install to"
+  });
+  const installChoice = await p.select({
+    message: "Install to",
+    options: selectOptions
+  });
+  if (p.isCancel(installChoice)) {
+    return installChoice;
+  }
+  if (installChoice === "all") {
+    return availableAgents;
+  }
+  if (installChoice === "previous" && validLastSelected) {
+    return validLastSelected;
+  }
+  const agentChoices = availableAgents.map((agentType) => {
+    const localPath = agents[agentType].localConfigPath;
+    const hint = options.global ? shortenPath(agents[agentType].configPath) : localPath ?? shortenPath(agents[agentType].configPath);
+    return {
+      value: agentType,
+      label: agents[agentType].displayName,
+      hint
+    };
+  });
+  return promptForAgents("Select agents to install to", agentChoices, false);
+}
+
+// src/formats/utils.ts
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (sourceValue && typeof sourceValue === "object" && !Array.isArray(sourceValue)) {
+      result[key] = deepMerge(
+        targetValue && typeof targetValue === "object" ? targetValue : {},
+        sourceValue
+      );
+    } else {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function getNestedValue(obj, path) {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current && typeof current === "object" && key in current) {
+      current = current[key];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+
+// src/formats/json.ts
+import { readFileSync, writeFileSync, existsSync as existsSync2, mkdirSync } from "fs";
+import { dirname as dirname3 } from "path";
+import * as jsonc from "jsonc-parser";
+function detectIndent(text) {
+  let result = null;
+  jsonc.visit(text, {
+    onObjectProperty: (_property, offset, _length, startLine, startCharacter) => {
+      if (result === null && startLine > 0 && startCharacter > 0) {
+        const lineStart = text.lastIndexOf("\n", offset - 1) + 1;
+        const whitespace = text.slice(lineStart, offset);
+        result = {
+          tabSize: startCharacter,
+          insertSpaces: !whitespace.includes("	")
+        };
+      }
+    }
+  });
+  return result || { tabSize: 2, insertSpaces: true };
+}
+function readJsonConfig(filePath) {
+  if (!existsSync2(filePath)) {
+    return {};
+  }
+  const content = readFileSync(filePath, "utf-8");
+  const parsed = jsonc.parse(content);
+  return parsed;
+}
+function writeJsonConfig(filePath, config, configKey) {
+  const dir = dirname3(filePath);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  let originalContent = "";
+  let existingConfig = {};
+  if (existsSync2(filePath)) {
+    originalContent = readFileSync(filePath, "utf-8");
+    existingConfig = jsonc.parse(originalContent);
+  }
+  const mergedConfig = deepMerge(existingConfig, config);
+  if (originalContent) {
+    try {
+      const configKeyPath = configKey.split(".");
+      const newValue = getNestedValue(mergedConfig, configKey);
+      const edits = jsonc.modify(originalContent, configKeyPath, newValue, {
+        formattingOptions: detectIndent(originalContent)
+      });
+      const updatedContent = jsonc.applyEdits(originalContent, edits);
+      writeFileSync(filePath, updatedContent);
+      return;
+    } catch {
+    }
+  }
+  writeFileSync(filePath, JSON.stringify(mergedConfig, null, 2));
+}
+function removeJsonConfigKey(filePath, configKey, serverName) {
+  if (!existsSync2(filePath)) {
+    return;
+  }
+  const originalContent = readFileSync(filePath, "utf-8");
+  const configKeyPath = configKey.split(".");
+  try {
+    const edits = jsonc.modify(
+      originalContent,
+      [...configKeyPath, serverName],
+      void 0,
+      { formattingOptions: detectIndent(originalContent) }
+    );
+    const updatedContent = jsonc.applyEdits(originalContent, edits);
+    writeFileSync(filePath, updatedContent);
+    return;
+  } catch {
+  }
+  const parsed = jsonc.parse(originalContent);
+  const servers = getNestedValue(parsed, configKey);
+  if (servers && typeof servers === "object" && serverName in servers) {
+    delete servers[serverName];
+  }
+  writeFileSync(filePath, JSON.stringify(parsed, null, 2));
+}
+function setNestedValue(obj, path, value) {
+  const keys = path.split(".");
+  const lastKey = keys.pop();
+  if (!lastKey) return;
+  let current = obj;
+  for (const key of keys) {
+    if (!current[key] || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[lastKey] = value;
+}
+
+// src/formats/yaml.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname4 } from "path";
+import yaml from "js-yaml";
+function readYamlConfig(filePath) {
+  if (!existsSync3(filePath)) {
+    return {};
+  }
+  const content = readFileSync2(filePath, "utf-8");
+  const parsed = yaml.load(content);
+  return parsed || {};
+}
+function removeYamlConfigKey(filePath, configKey, serverName) {
+  if (!existsSync3(filePath)) {
+    return;
+  }
+  const existing = readYamlConfig(filePath);
+  const keys = configKey.split(".");
+  let current = existing;
+  for (const key of keys) {
+    if (current && typeof current === "object" && key in current) {
+      current = current[key];
+    } else {
+      return;
+    }
+  }
+  if (current && typeof current === "object" && serverName in current) {
+    delete current[serverName];
+  }
+  const content = yaml.dump(existing, {
+    indent: 2,
+    lineWidth: -1,
+    noRefs: true
+  });
+  writeFileSync2(filePath, content);
+}
+function writeYamlConfig(filePath, config) {
+  const dir = dirname4(filePath);
+  if (!existsSync3(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  let existingConfig = {};
+  if (existsSync3(filePath)) {
+    existingConfig = readYamlConfig(filePath);
+  }
+  const mergedConfig = deepMerge(existingConfig, config);
+  const content = yaml.dump(mergedConfig, {
+    indent: 2,
+    lineWidth: -1,
+    noRefs: true
+  });
+  writeFileSync2(filePath, content);
+}
+
+// src/formats/toml.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname5 } from "path";
+import * as TOML from "@iarna/toml";
+function readTomlConfig(filePath) {
+  if (!existsSync4(filePath)) {
+    return {};
+  }
+  const content = readFileSync3(filePath, "utf-8");
+  const parsed = TOML.parse(content);
+  return parsed;
+}
+function removeTomlConfigKey(filePath, configKey, serverName) {
+  if (!existsSync4(filePath)) {
+    return;
+  }
+  const existing = readTomlConfig(filePath);
+  const keys = configKey.split(".");
+  let current = existing;
+  for (const key of keys) {
+    if (current && typeof current === "object" && key in current) {
+      current = current[key];
+    } else {
+      return;
+    }
+  }
+  if (current && typeof current === "object" && serverName in current) {
+    delete current[serverName];
+  }
+  const content = TOML.stringify(existing);
+  writeFileSync3(filePath, content);
+}
+function writeTomlConfig(filePath, config) {
+  const dir = dirname5(filePath);
+  if (!existsSync4(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  let existingConfig = {};
+  if (existsSync4(filePath)) {
+    existingConfig = readTomlConfig(filePath);
+  }
+  const mergedConfig = deepMerge(existingConfig, config);
+  const content = TOML.stringify(mergedConfig);
+  writeFileSync3(filePath, content);
+}
+
+// src/formats/index.ts
+function readConfig2(filePath, format) {
+  switch (format) {
+    case "json":
+      return readJsonConfig(filePath);
+    case "yaml":
+      return readYamlConfig(filePath);
+    case "toml":
+      return readTomlConfig(filePath);
+    default:
+      throw new Error(`Unsupported config format: ${format}`);
+  }
+}
+function removeServerFromConfig(filePath, format, configKey, serverName) {
+  switch (format) {
+    case "json":
+      removeJsonConfigKey(filePath, configKey, serverName);
+      break;
+    case "yaml":
+      removeYamlConfigKey(filePath, configKey, serverName);
+      break;
+    case "toml":
+      removeTomlConfigKey(filePath, configKey, serverName);
+      break;
+    default:
+      throw new Error(`Unsupported config format: ${format}`);
+  }
+}
+function writeConfig2(filePath, config, format, configKey) {
+  switch (format) {
+    case "json":
+      writeJsonConfig(filePath, config, configKey);
+      break;
+    case "yaml":
+      writeYamlConfig(filePath, config);
+      break;
+    case "toml":
+      writeTomlConfig(filePath, config);
+      break;
+    default:
+      throw new Error(`Unsupported config format: ${format}`);
+  }
+}
+function buildConfigWithKey(configKey, serverName, serverConfig) {
+  const config = {};
+  const servers = {};
+  servers[serverName] = serverConfig;
+  setNestedValue(config, configKey, servers);
+  return config;
+}
+
+// src/installer.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join3, dirname as dirname6, isAbsolute, relative, sep } from "path";
+function buildServerConfig(parsed, options = {}) {
+  if (parsed.type === "remote") {
+    const config2 = {
+      type: options.transport ?? "http",
+      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(" ");
+    const command = parts[0];
+    const args = [...parts.slice(1), ...options.args ?? []];
+    const config2 = {
+      command,
+      args
+    };
+    if (options.env && Object.keys(options.env).length > 0) {
+      config2.env = options.env;
+    }
+    return config2;
+  }
+  const config = {
+    command: "npx",
+    args: ["-y", parsed.value, ...options.args ?? []]
+  };
+  if (options.env && Object.keys(options.env).length > 0) {
+    config.env = options.env;
+  }
+  return config;
+}
+function updateGitignoreWithPaths(paths, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const gitignorePath = join3(cwd, ".gitignore");
+  const existingContent = existsSync5(gitignorePath) ? readFileSync4(gitignorePath, "utf-8") : "";
+  const existingEntries = new Set(
+    existingContent.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0)
+  );
+  const entriesToAdd = [];
+  for (const filePath of paths) {
+    const relativePath = isAbsolute(filePath) ? relative(cwd, filePath) : filePath;
+    if (!relativePath || relativePath.startsWith("..") || isAbsolute(relativePath)) {
+      continue;
+    }
+    const normalizedPath = relativePath.split(sep).join("/");
+    const cleanPath = normalizedPath.startsWith("./") ? normalizedPath.slice(2) : normalizedPath;
+    if (!cleanPath || cleanPath === ".gitignore" || existingEntries.has(cleanPath)) {
+      continue;
+    }
+    existingEntries.add(cleanPath);
+    entriesToAdd.push(cleanPath);
+  }
+  if (entriesToAdd.length > 0) {
+    let nextContent = existingContent;
+    if (nextContent.length > 0 && !nextContent.endsWith("\n")) {
+      nextContent += "\n";
+    }
+    nextContent += `${entriesToAdd.join("\n")}
+`;
+    writeFileSync4(gitignorePath, nextContent, "utf-8");
+  }
+  return {
+    path: gitignorePath,
+    added: entriesToAdd
+  };
+}
+function getConfigPath2(agent, options = {}) {
+  const local = Boolean(options.local);
+  const cwd = options.cwd || process.cwd();
+  if (agent.resolveConfigPath) {
+    return agent.resolveConfigPath(agent, { local, cwd });
+  }
+  if (local && agent.localConfigPath) {
+    return join3(cwd, agent.localConfigPath);
+  }
+  return agent.configPath;
+}
+function getConfigKey(agent, options = {}) {
+  if (options.local && agent.localConfigKey) {
+    return agent.localConfigKey;
+  }
+  return agent.configKey;
+}
+function installServerForAgent(serverName, serverConfig, agentType, options = {}) {
+  const agent = agents[agentType];
+  const configPath = getConfigPath2(agent, options);
+  try {
+    const dir = dirname6(configPath);
+    if (!existsSync5(dir)) {
+      mkdirSync4(dir, { recursive: true });
+    }
+    const transformedConfig = agent.transformConfig ? agent.transformConfig(serverName, serverConfig, {
+      local: Boolean(options.local)
+    }) : serverConfig;
+    const configKey = getConfigKey(agent, options);
+    const config = buildConfigWithKey(configKey, serverName, transformedConfig);
+    writeConfig2(configPath, config, agent.format, configKey);
+    return {
+      success: true,
+      path: configPath
+    };
+  } catch (error) {
+    return {
+      success: false,
+      path: configPath,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+function installServer(serverName, serverConfig, agentTypes, options = {}) {
+  const results = /* @__PURE__ */ new Map();
+  for (const agentType of agentTypes) {
+    const routing = options.routing?.get(agentType);
+    const installOptions = {
+      local: routing === "local",
+      cwd: options.cwd
+    };
+    const result = installServerForAgent(
+      serverName,
+      serverConfig,
+      agentType,
+      installOptions
+    );
+    results.set(agentType, result);
+  }
+  return results;
+}
+
+// src/reader.ts
+function extractServerIdentity(serverConfig) {
+  for (const key of ["url", "uri", "serverUrl"]) {
+    const value = serverConfig[key];
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+  const command = typeof serverConfig.command === "string" ? serverConfig.command : typeof serverConfig.cmd === "string" ? serverConfig.cmd : void 0;
+  if (!command) {
+    return "";
+  }
+  const rawArgs = Array.isArray(serverConfig.args) ? serverConfig.args.filter((a) => typeof a === "string") : Array.isArray(serverConfig.command) ? serverConfig.command.slice(1).filter((a) => typeof a === "string") : [];
+  if (command === "npx" || command === "bunx") {
+    const yIndex = rawArgs.indexOf("-y");
+    const pkgIndex = yIndex >= 0 ? yIndex + 1 : 0;
+    const pkg = rawArgs[pkgIndex];
+    if (pkg && !pkg.startsWith("-")) {
+      return pkg;
+    }
+  }
+  if (Array.isArray(serverConfig.command)) {
+    return serverConfig.command.join(" ");
+  }
+  if (rawArgs.length > 0) {
+    return `${command} ${rawArgs.join(" ")}`;
+  }
+  return command;
+}
+function readServersForAgent(agentType, options) {
+  const agent = agents[agentType];
+  const installOptions = {
+    local: options.scope === "local",
+    cwd: options.cwd
+  };
+  const configPath = getConfigPath2(agent, installOptions);
+  const configKey = getConfigKey(agent, installOptions);
+  const fullConfig = readConfig2(configPath, agent.format);
+  const serversObj = getNestedValue(fullConfig, configKey);
+  const servers = [];
+  if (serversObj && typeof serversObj === "object" && !Array.isArray(serversObj)) {
+    for (const [serverName, serverConfig] of Object.entries(serversObj)) {
+      if (serverConfig && typeof serverConfig === "object") {
+        const config = serverConfig;
+        servers.push({
+          serverName,
+          config,
+          identity: extractServerIdentity(config),
+          agentType,
+          scope: options.scope,
+          configPath
+        });
+      }
+    }
+  }
+  return {
+    agentType,
+    displayName: agent.displayName,
+    detected: true,
+    scope: options.scope,
+    configPath,
+    servers
+  };
+}
+async function listInstalledServers(options) {
+  const scope = options.global ? "global" : "local";
+  const results = [];
+  if (options.agents && options.agents.length > 0) {
+    const detectedSet = new Set(
+      options.global ? await detectGlobalAgents() : detectProjectAgents(options.cwd)
+    );
+    for (const agentType of options.agents) {
+      const detected = detectedSet.has(agentType);
+      if (detected) {
+        results.push(
+          readServersForAgent(agentType, { scope, cwd: options.cwd })
+        );
+      } else {
+        const agent = agents[agentType];
+        const installOptions = {
+          local: scope === "local",
+          cwd: options.cwd
+        };
+        results.push({
+          agentType,
+          displayName: agent.displayName,
+          detected: false,
+          scope,
+          configPath: getConfigPath2(agent, installOptions),
+          servers: []
+        });
+      }
+    }
+  } else {
+    const detected = options.global ? await detectGlobalAgents() : detectProjectAgents(options.cwd);
+    for (const agentType of detected) {
+      results.push(readServersForAgent(agentType, { scope, cwd: options.cwd }));
+    }
+  }
+  return results;
+}
+function findMatchingServers(agentServersList, query) {
+  const lowerQuery = query.toLowerCase();
+  const matches = [];
+  for (const agentServers of agentServersList) {
+    for (const server of agentServers.servers) {
+      const nameMatch = server.serverName.toLowerCase().includes(lowerQuery);
+      const identityMatch = server.identity === query;
+      if (nameMatch || identityMatch) {
+        matches.push(server);
+      }
+    }
+  }
+  return matches;
+}
+
+export {
+  getConfigPath,
+  getLastSelectedAgents,
+  getFindRegistries,
+  saveFindRegistries,
+  agents,
+  getAgentTypes,
+  supportsProjectConfig,
+  getProjectCapableAgents,
+  detectProjectAgents,
+  detectGlobalAgents,
+  isTransportSupported,
+  buildAgentSelectionChoices,
+  selectAgentsInteractive,
+  getNestedValue,
+  readConfig2 as readConfig,
+  removeServerFromConfig,
+  buildServerConfig,
+  updateGitignoreWithPaths,
+  getConfigPath2,
+  getConfigKey,
+  installServerForAgent,
+  installServer,
+  listInstalledServers,
+  findMatchingServers
+};