add-mcp 1.9.1 → 1.10.2

package/dist/index.js

@@ -1,10 +1,34 @@
 #!/usr/bin/env node
+import {
+  agents,
+  buildAgentSelectionChoices,
+  buildServerConfig,
+  detectGlobalAgents,
+  detectProjectAgents,
+  findMatchingServers,
+  getAgentTypes,
+  getConfigPath,
+  getFindRegistries,
+  getLastSelectedAgents,
+  getProjectCapableAgents,
+  installServer,
+  installServerForAgent,
+  isRemoteSource,
+  isTransportSupported,
+  listInstalledServers,
+  parseSource,
+  removeServerFromConfig,
+  saveFindRegistries,
+  selectAgentsInteractive,
+  supportsProjectConfig,
+  updateGitignoreWithPaths
+} from "./chunk-B27GVIBZ.js";
 
 // src/index.ts
 import { program } from "commander";
-import * as p3 from "@clack/prompts";
+import * as p2 from "@clack/prompts";
 import chalk from "chalk";
-import { homedir as homedir3 } from "os";
+import { homedir } from "os";
 
 // src/types.ts
 var agentAliases = {
@@ -13,809 +37,8 @@ var agentAliases = {
   "github-copilot": "vscode"
 };
 
-// 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";
-
-// 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
-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 detectAllGlobalAgents() {
-  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/source-parser.ts
-function isUrl(input) {
-  return input.startsWith("http://") || input.startsWith("https://");
-}
-function isCommand(input) {
-  if (input.includes(" ")) {
-    return true;
-  }
-  if (input.startsWith("npx ") || input.startsWith("node ") || input.startsWith("python ")) {
-    return true;
-  }
-  return false;
-}
-function isPackageName(input) {
-  if (input.startsWith("@") && input.includes("/")) {
-    return true;
-  }
-  if (/^[a-z0-9][\w.-]*(@[\w.-]+)?$/i.test(input)) {
-    return true;
-  }
-  return false;
-}
-var commonTlds = /* @__PURE__ */ new Set([
-  "com",
-  "org",
-  "net",
-  "io",
-  "dev",
-  "ai",
-  "tech",
-  "co",
-  "app",
-  "cloud",
-  "sh",
-  "run"
-]);
-function extractBrandFromHostname(hostname) {
-  const parts = hostname.split(".");
-  const meaningfulParts = parts.filter((part) => {
-    const lower = part.toLowerCase();
-    if (commonTlds.has(lower)) return false;
-    if (lower === "mcp" || lower === "api" || lower === "www") return false;
-    return true;
-  });
-  if (meaningfulParts.length > 0) {
-    return meaningfulParts[0];
-  }
-  if (parts.length >= 2) {
-    return parts[parts.length - 2];
-  }
-  return "mcp-server";
-}
-function inferName(input, type) {
-  if (type === "remote") {
-    try {
-      const url = new URL(input);
-      return extractBrandFromHostname(url.hostname);
-    } catch {
-      return "mcp-server";
-    }
-  }
-  if (type === "command") {
-    const parts = input.split(" ");
-    let startIndex = 0;
-    if (parts[0] === "npx" || parts[0] === "node" || parts[0] === "python") {
-      startIndex = 1;
-    }
-    for (let i = startIndex; i < parts.length; i++) {
-      const part = parts[i];
-      if (part && !part.startsWith("-")) {
-        return extractPackageName(part);
-      }
-    }
-    return "mcp-server";
-  }
-  return extractPackageName(input);
-}
-function extractPackageName(input) {
-  let name = input;
-  const atIndex = name.lastIndexOf("@");
-  if (atIndex > 0 && !name.startsWith("@")) {
-    name = name.slice(0, atIndex);
-  } else if (name.startsWith("@") && name.indexOf("@", 1) > 0) {
-    const secondAt = name.indexOf("@", 1);
-    name = name.slice(0, secondAt);
-  }
-  if (name.startsWith("@") && name.includes("/")) {
-    const parts = name.split("/");
-    name = parts[1] || name;
-  }
-  name = name.replace(/^mcp-server-/, "");
-  name = name.replace(/^server-/, "");
-  name = name.replace(/-mcp$/, "");
-  return name || "mcp-server";
-}
-function parseSource(input) {
-  const trimmed = input.trim();
-  if (isUrl(trimmed)) {
-    return {
-      type: "remote",
-      value: trimmed,
-      inferredName: inferName(trimmed, "remote")
-    };
-  }
-  if (isCommand(trimmed)) {
-    return {
-      type: "command",
-      value: trimmed,
-      inferredName: inferName(trimmed, "command")
-    };
-  }
-  if (isPackageName(trimmed)) {
-    return {
-      type: "package",
-      value: trimmed,
-      inferredName: inferName(trimmed, "package")
-    };
-  }
-  return {
-    type: "package",
-    value: trimmed,
-    inferredName: inferName(trimmed, "package")
-  };
-}
-function isRemoteSource(parsed) {
-  return parsed.type === "remote";
-}
-
 // src/find.ts
-import * as p2 from "@clack/prompts";
+import * as p from "@clack/prompts";
 
 // src/template.ts
 var TEMPLATE_PATTERN = /\$\{([^}]+)\}/g;
@@ -936,8 +159,8 @@ function pushPositionalSegments(out, d, raw) {
       out.push(raw);
       return;
     }
-    for (const p4 of parts) {
-      out.push(p4);
+    for (const p3 of parts) {
+      out.push(p3);
     }
     return;
   }
@@ -1250,7 +473,7 @@ function formatFindResultRow(entry) {
   return `${display} (${entry.name}) [${transportLabel(entry)}]`;
 }
 async function promptValue(field) {
-  return p2.text({
+  return p.text({
     message: `${field.label} ${field.isRequired ? "(required)" : "(optional)"}`,
     placeholder: field.placeholder
   });
@@ -1259,7 +482,7 @@ async function collectPromptValues(fields, ask) {
   const values = {};
   for (const field of fields) {
     const raw = await ask(field);
-    if (p2.isCancel(raw)) {
+    if (p.isCancel(raw)) {
       return { values, cancelled: true };
     }
     const value = raw != null && typeof raw === "string" ? raw.trim() : "";
@@ -1356,7 +579,7 @@ function resolveNonInteractivePackage(pkg) {
   };
 }
 async function resolveInteractivePackage(pkg) {
-  const promptPackageArg = async (info) => p2.text({
+  const promptPackageArg = async (info) => p.text({
     message: `${info.label} ${info.isRequired ? "(required)" : "(optional)"}`,
     placeholder: info.placeholder
   });
@@ -1394,7 +617,7 @@ async function buildInstallPlanForEntry(entry, options) {
     if (options.yes) {
       mode = "remote";
     } else {
-      const selected = await p2.select({
+      const selected = await p.select({
         message: `Install mode for ${entry.name}`,
         initialValue: "remote",
         options: [
@@ -1406,7 +629,7 @@ async function buildInstallPlanForEntry(entry, options) {
           }
         ]
       });
-      if (p2.isCancel(selected)) return null;
+      if (p.isCancel(selected)) return null;
       mode = selected;
     }
   } else {
@@ -1443,15 +666,15 @@ async function offerFallbackSearch(query, alreadyQueried) {
   let selectedRegistries;
   if (candidates.length === 1) {
     const candidate = candidates[0];
-    const confirmed = await p2.confirm({
+    const confirmed = await p.confirm({
       message: `Search "${candidate.label ?? candidate.url}" (${candidate.url}) instead?`
     });
-    if (p2.isCancel(confirmed) || !confirmed) {
+    if (p.isCancel(confirmed) || !confirmed) {
       return null;
     }
     selectedRegistries = [candidate];
   } else {
-    const selected = await p2.multiselect({
+    const selected = await p.multiselect({
       message: "Search other registries instead?",
       options: candidates.map((r) => ({
         value: r.url,
@@ -1459,7 +682,7 @@ async function offerFallbackSearch(query, alreadyQueried) {
       })),
       required: true
     });
-    if (p2.isCancel(selected)) {
+    if (p.isCancel(selected)) {
       return null;
     }
     selectedRegistries = candidates.filter(
@@ -1469,12 +692,12 @@ async function offerFallbackSearch(query, alreadyQueried) {
   const fallbackResult = await searchRegistry(query, selectedRegistries);
   if (fallbackResult.failedRegistries.length > 0) {
     for (const failure of fallbackResult.failedRegistries) {
-      p2.log.error(formatRegistryFailure(failure));
+      p.log.error(formatRegistryFailure(failure));
     }
   }
   if (fallbackResult.entries.length === 0) {
     if (fallbackResult.failedRegistries.length === 0) {
-      p2.log.warn(`No MCP servers found for "${query}"`);
+      p.log.warn(`No MCP servers found for "${query}"`);
     }
     return null;
   }
@@ -1500,8 +723,8 @@ async function selectEntryWithPagination(visibleEntries, message) {
         label: `\u25BC Show more results (${remaining} remaining)`
       });
     }
-    const selected = await p2.select({ message, options });
-    if (p2.isCancel(selected)) return null;
+    const selected = await p.select({ message, options });
+    if (p.isCancel(selected)) return null;
     if (selected === LOAD_MORE_SENTINEL) {
       page++;
       continue;
@@ -1522,12 +745,12 @@ async function runFind(query, options) {
   const { failedRegistries } = result;
   if (failedRegistries.length > 0 && entries.length > 0) {
     for (const failure of failedRegistries) {
-      p2.log.warn(formatRegistryFailure(failure));
+      p.log.warn(formatRegistryFailure(failure));
     }
   }
   if (entries.length === 0 && failedRegistries.length > 0) {
     for (const failure of failedRegistries) {
-      p2.log.error(formatRegistryFailure(failure));
+      p.log.error(formatRegistryFailure(failure));
     }
     if (!options.yes && !isBrowseMode) {
       const fallbackEntries = await offerFallbackSearch(query, registries);
@@ -1538,7 +761,7 @@ async function runFind(query, options) {
   }
   if (entries.length === 0) {
     if (failedRegistries.length === 0) {
-      p2.log.warn(
+      p.log.warn(
         isBrowseMode ? "No MCP servers found in the configured registries" : `No MCP servers found for "${query}"`
       );
     }
@@ -1554,542 +777,23 @@ async function runFind(query, options) {
   return buildInstallPlanForEntry(entry, options);
 }
 
-// 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";
-
-// 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";
-
-// 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
-function detectIndent(text3) {
-  let result = null;
-  jsonc.visit(text3, {
-    onObjectProperty: (_property, offset, _length, startLine, startCharacter) => {
-      if (result === null && startLine > 0 && startCharacter > 0) {
-        const lineStart = text3.lastIndexOf("\n", offset - 1) + 1;
-        const whitespace = text3.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
-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 gatherInstalledServers(options) {
-  const scope = options.global ? "global" : "local";
-  const results = [];
-  if (options.agents && options.agents.length > 0) {
-    const detectedSet = new Set(
-      options.global ? await detectAllGlobalAgents() : 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 detectAllGlobalAgents() : 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;
-}
-
 // package.json
 var package_default = {
   name: "add-mcp",
-  version: "1.9.1",
+  version: "1.10.2",
   description: "Add MCP servers to your favorite coding agents with a single command.",
   author: "Andre Landgraf <andre@neon.tech>",
   license: "Apache-2.0",
   type: "module",
+  main: "./dist/lib.js",
+  types: "./dist/lib.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/lib.d.ts",
+      import: "./dist/lib.js"
+    },
+    "./package.json": "./package.json"
+  },
   bin: {
     "add-mcp": "dist/index.js"
   },
@@ -2099,10 +803,10 @@ var package_default = {
   ],
   scripts: {
     fmt: "prettier --write .",
-    build: "tsup src/index.ts --format esm --dts --clean",
+    build: "tsup src/index.ts src/lib.ts --format esm --dts --clean",
     dev: "tsx src/index.ts",
-    test: "tsx tests/source-parser.test.ts && tsx tests/agents.test.ts && tsx tests/config.test.ts && tsx tests/installer.test.ts && tsx tests/find.test.ts && tsx tests/package-arguments.test.ts && tsx tests/template.test.ts && tsx tests/reader.test.ts && tsx tests/formats-remove.test.ts && tsx tests/e2e/install.test.ts && tsx tests/e2e/cli.test.ts",
-    "test:unit": "tsx tests/source-parser.test.ts && tsx tests/agents.test.ts && tsx tests/config.test.ts && tsx tests/installer.test.ts && tsx tests/find.test.ts && tsx tests/package-arguments.test.ts && tsx tests/template.test.ts && tsx tests/reader.test.ts && tsx tests/formats-remove.test.ts",
+    test: "tsx tests/source-parser.test.ts && tsx tests/agents.test.ts && tsx tests/config.test.ts && tsx tests/installer.test.ts && tsx tests/find.test.ts && tsx tests/package-arguments.test.ts && tsx tests/template.test.ts && tsx tests/reader.test.ts && tsx tests/formats-remove.test.ts && tsx tests/lib.test.ts && tsx tests/e2e/install.test.ts && tsx tests/e2e/cli.test.ts",
+    "test:unit": "tsx tests/source-parser.test.ts && tsx tests/agents.test.ts && tsx tests/config.test.ts && tsx tests/installer.test.ts && tsx tests/find.test.ts && tsx tests/package-arguments.test.ts && tsx tests/template.test.ts && tsx tests/reader.test.ts && tsx tests/formats-remove.test.ts && tsx tests/lib.test.ts",
     "registry:sort": "tsx scripts/sort-registry.ts",
     "registry:verify": "tsx scripts/verify-registry.ts",
     "test:e2e": "tsx tests/e2e/install.test.ts && tsx tests/e2e/cli.test.ts",
@@ -2187,10 +891,10 @@ function showLogo() {
     console.log(`${GRAYS[i]}${line}${RESET}`);
   });
 }
-function shortenPath2(fullPath) {
-  const home2 = homedir3();
-  if (fullPath.startsWith(home2)) {
-    return fullPath.replace(home2, "~");
+function shortenPath(fullPath) {
+  const home = homedir();
+  if (fullPath.startsWith(home)) {
+    return fullPath.replace(home, "~");
   }
   return fullPath;
 }
@@ -2209,13 +913,13 @@ async function ensureFindRegistriesConfigured(yes) {
   if (configured.length > 0) {
     return configured;
   }
-  p3.log.warn("Find requires configuring one or more registries");
+  p2.log.warn("Find requires configuring one or more registries");
   if (yes) {
-    p3.log.error("Re-run without --yes to configure registries for find/search");
+    p2.log.error("Re-run without --yes to configure registries for find/search");
     return null;
   }
   const defaults = getDefaultFindRegistries();
-  const selected = await p3.multiselect({
+  const selected = await p2.multiselect({
     message: "[One time] Please select what MCP registries you would like to configure globally for search",
     options: defaults.map((registry) => ({
       value: registry.url,
@@ -2223,15 +927,15 @@ async function ensureFindRegistriesConfigured(yes) {
     })),
     required: true
   });
-  if (p3.isCancel(selected)) {
+  if (p2.isCancel(selected)) {
     return null;
   }
   const selectedRegistries = defaults.filter(
     (registry) => selected.includes(registry.url)
   );
   await saveFindRegistries(selectedRegistries);
-  p3.log.info(
-    `Selection has been saved to ${shortenPath2(getConfigPath())} - you can remove or update it any time.`
+  p2.log.info(
+    `Selection has been saved to ${shortenPath(getConfigPath())} - you can remove or update it any time.`
   );
   return selectedRegistries;
 }
@@ -2426,7 +1130,7 @@ async function runFindCommand(keyword, rawOptions) {
   const query = (keyword ?? "").trim();
   const registries = await ensureFindRegistriesConfigured(options.yes);
   if (!registries) {
-    p3.cancel("Find cancelled");
+    p2.cancel("Find cancelled");
     process.exit(0);
   }
   const installPlan = await runFind(query, {
@@ -2435,7 +1139,7 @@ async function runFindCommand(keyword, rawOptions) {
     preferredTransport: inferFindPreferredTransport(options)
   });
   if (!installPlan) {
-    p3.cancel("Find cancelled");
+    p2.cancel("Find cancelled");
     process.exit(0);
   }
   const mergedOptions = {
@@ -2511,13 +1215,13 @@ async function runListCommand(options) {
   showLogo();
   console.log();
   const explicitAgents = resolveAgentFlags(options.agent);
-  const agentServersList = await gatherInstalledServers({
+  const agentServersList = await listInstalledServers({
     global: options.global,
     agents: explicitAgents.length > 0 ? explicitAgents : void 0
   });
   if (agentServersList.length === 0) {
     const hint = options.global ? "No agents detected globally. Use -a to target a specific agent." : "No agents detected in this project. Use -g for global or -a to target a specific agent.";
-    p3.log.info(hint);
+    p2.log.info(hint);
     console.log();
     return;
   }
@@ -2548,13 +1252,13 @@ async function runRemoveCommand(query, options) {
   showLogo();
   console.log();
   const explicitAgents = resolveAgentFlags(options.agent);
-  const agentServersList = await gatherInstalledServers({
+  const agentServersList = await listInstalledServers({
     global: options.global,
     agents: explicitAgents.length > 0 ? explicitAgents : void 0
   });
   const matches = findMatchingServers(agentServersList, query);
   if (matches.length === 0) {
-    p3.log.info(`No matching servers found for '${query}'`);
+    p2.log.info(`No matching servers found for '${query}'`);
     console.log();
     return;
   }
@@ -2566,24 +1270,24 @@ async function runRemoveCommand(query, options) {
   let selectedIndices;
   if (options.yes) {
     selectedIndices = matches.map((_, i) => i);
-    p3.log.info(
+    p2.log.info(
       `Removing ${matches.length} server${matches.length !== 1 ? "s" : ""} matching '${query}'`
     );
   } else {
-    const selected = await p3.multiselect({
+    const selected = await p2.multiselect({
       message: `Select servers to remove (${matches.length} match${matches.length !== 1 ? "es" : ""} found)`,
       options: matchOptions,
       required: false,
       initialValues: matches.map((_, i) => i)
     });
-    if (p3.isCancel(selected)) {
-      p3.log.info("No changes made");
+    if (p2.isCancel(selected)) {
+      p2.log.info("No changes made");
       console.log();
       return;
     }
     selectedIndices = selected;
     if (selectedIndices.length === 0) {
-      p3.log.info("No changes made");
+      p2.log.info("No changes made");
       console.log();
       return;
     }
@@ -2603,13 +1307,13 @@ async function runRemoveCommand(query, options) {
       removedCount++;
       affectedAgents.add(agent.displayName);
     } catch (error) {
-      p3.log.error(
+      p2.log.error(
         `Failed to remove ${server.serverName} from ${agent.displayName}: ${error instanceof Error ? error.message : "Unknown error"}`
       );
     }
   }
   if (removedCount > 0) {
-    p3.log.success(
+    p2.log.success(
       `Removed ${removedCount} server${removedCount !== 1 ? "s" : ""} from ${affectedAgents.size} agent${affectedAgents.size !== 1 ? "s" : ""}`
     );
   }
@@ -2709,14 +1413,14 @@ function buildSyncGroups(agentServersList) {
 async function runSyncCommand(options) {
   showLogo();
   console.log();
-  const agentServersList = await gatherInstalledServers({
+  const agentServersList = await listInstalledServers({
     global: options.global
   });
   const agentsWithServers = agentServersList.filter(
     (a) => a.servers.length > 0
   );
   if (agentServersList.length < 2) {
-    p3.log.info("Need at least 2 detected agents to sync");
+    p2.log.info("Need at least 2 detected agents to sync");
     console.log();
     return;
   }
@@ -2747,7 +1451,7 @@ async function runSyncCommand(options) {
     }
   }
   if (renames.length === 0 && additions.length === 0 && skipped.length === 0) {
-    p3.log.info("All servers are already in sync");
+    p2.log.info("All servers are already in sync");
     console.log();
     return;
   }
@@ -2775,20 +1479,20 @@ async function runSyncCommand(options) {
     }
   }
   if (renames.length === 0 && additions.length === 0) {
-    p3.note(planLines.join("\n"), "Sync Plan");
-    p3.log.info(
+    p2.note(planLines.join("\n"), "Sync Plan");
+    p2.log.info(
       "All servers are already in sync (some skipped due to conflicts)"
     );
     console.log();
     return;
   }
-  p3.note(planLines.join("\n"), "Sync Plan");
+  p2.note(planLines.join("\n"), "Sync Plan");
   if (!options.yes) {
-    const confirmed = await p3.confirm({
+    const confirmed = await p2.confirm({
       message: "Proceed with sync?"
     });
-    if (p3.isCancel(confirmed) || !confirmed) {
-      p3.log.info("No changes made");
+    if (p2.isCancel(confirmed) || !confirmed) {
+      p2.log.info("No changes made");
       console.log();
       return;
     }
@@ -2806,7 +1510,7 @@ async function runSyncCommand(options) {
     if (result.success) {
       changeCount++;
     } else {
-      p3.log.error(
+      p2.log.error(
         `Failed to write ${group.canonicalName} to ${agents[agentType].displayName}: ${result.error}`
       );
     }
@@ -2822,7 +1526,7 @@ async function runSyncCommand(options) {
     if (result.success) {
       changeCount++;
     } else {
-      p3.log.error(
+      p2.log.error(
         `Failed to add ${group.canonicalName} to ${agents[agentType].displayName}: ${result.error}`
       );
     }
@@ -2840,12 +1544,12 @@ async function runSyncCommand(options) {
         oldName
       );
     } catch (error) {
-      p3.log.error(
+      p2.log.error(
         `Failed to remove old alias ${oldName} from ${agentConfig.displayName}: ${error instanceof Error ? error.message : "Unknown error"}`
       );
     }
   }
-  p3.log.success(
+  p2.log.success(
     `Synced ${changeCount} server${changeCount !== 1 ? "s" : ""} across ${detectedAgentTypes.size} agent${detectedAgentTypes.size !== 1 ? "s" : ""}`
   );
   console.log();
@@ -2899,8 +1603,8 @@ function resolveAgentFlags(agentFlags) {
     }
   }
   if (invalid.length > 0) {
-    p3.log.error(`Invalid agents: ${invalid.join(", ")}`);
-    p3.log.info(`Valid agents: ${getAgentTypes().join(", ")}`);
+    p2.log.error(`Invalid agents: ${invalid.join(", ")}`);
+    p2.log.info(`Valid agents: ${getAgentTypes().join(", ")}`);
     process.exit(1);
   }
   return resolved;
@@ -2982,7 +1686,7 @@ async function main(target, options) {
     process.exit(0);
   }
   console.log();
-  const spinner2 = p3.spinner();
+  const spinner2 = p2.spinner();
   spinner2.start("Parsing source...");
   const parsed = parseSource(target);
   const isRemote = isRemoteSource(parsed);
@@ -2992,40 +1696,40 @@ async function main(target, options) {
   const headerResult = parseHeaders(headerValues);
   if (headerResult.invalid.length > 0) {
     const hint = looksLikeEatenShellVar(headerResult.invalid, ":") ? " (looks like your shell expanded a ${VAR} to an empty string; use single quotes: --header 'Key: ${VAR}' to pass the template literally)" : "";
-    p3.log.error(
-      `Invalid --header value(s): ${headerResult.invalid.join(", ")}. Use "Key: Value" format.${hint}`
+    p2.log.error(
+      `Invalid --header value(s): ${headerResult.invalid.join(", ")}. Use 'Key: Value' format.${hint}`
     );
     process.exit(1);
   }
   const headerKeys = Object.keys(headerResult.headers);
   const hasHeaderValues = headerKeys.length > 0;
   if (hasHeaderValues && !isRemote) {
-    p3.log.warn("--header is only used for remote URLs, ignoring");
+    p2.log.warn("--header is only used for remote URLs, ignoring");
   }
   const envValues = options.env ?? [];
   const envResult = parseEnv(envValues);
   if (envResult.invalid.length > 0) {
     const hint = looksLikeEatenShellVar(envResult.invalid, "=") ? " (looks like your shell expanded a ${VAR} to an empty string; use single quotes: --env 'KEY=${VAR}' to pass the template literally)" : "";
-    p3.log.error(
-      `Invalid --env value(s): ${envResult.invalid.join(", ")}. Use "KEY=VALUE" format.${hint}`
+    p2.log.error(
+      `Invalid --env value(s): ${envResult.invalid.join(", ")}. Use 'KEY=VALUE' format.${hint}`
     );
     process.exit(1);
   }
   const envKeys = Object.keys(envResult.env);
   const hasEnvValues = envKeys.length > 0;
   if (hasEnvValues && isRemote) {
-    p3.log.warn(
+    p2.log.warn(
       "--env is only used for local/package/command installs, ignoring"
     );
   }
   const argsValues = options.args ?? [];
   const hasArgsValues = argsValues.length > 0;
   if (hasArgsValues && isRemote) {
-    p3.log.warn(
+    p2.log.warn(
       "--args is only used for local/package/command installs, ignoring"
     );
   }
-  const promptTemplateVar = (varName) => p3.text({
+  const promptTemplateVar = (varName) => p2.text({
     message: `Enter value for ${varName}`,
     placeholder: `<${varName}>`
   });
@@ -3036,7 +1740,7 @@ async function main(target, options) {
       promptTemplateVar
     );
     if (result.cancelled) {
-      p3.cancel("Cancelled");
+      p2.cancel("Cancelled");
       process.exit(0);
     }
     for (const [key, value] of Object.entries(result.resolved)) {
@@ -3049,7 +1753,7 @@ async function main(target, options) {
       promptTemplateVar
     );
     if (result.cancelled) {
-      p3.cancel("Cancelled");
+      p2.cancel("Cancelled");
       process.exit(0);
     }
     for (const [key, value] of Object.entries(result.resolved)) {
@@ -3059,7 +1763,7 @@ async function main(target, options) {
   if (!options.yes && hasArgsValues && hasTemplateVars(resolvedArgs)) {
     const result = await resolveArrayTemplates(resolvedArgs, promptTemplateVar);
     if (result.cancelled) {
-      p3.cancel("Cancelled");
+      p2.cancel("Cancelled");
       process.exit(0);
     }
     resolvedArgs = result.resolved;
@@ -3068,20 +1772,20 @@ async function main(target, options) {
   const envForConfig = !isRemote && hasEnvValues ? omitEmptyStringValues(envResult.env) : void 0;
   const argsForConfig = !isRemote && hasArgsValues ? resolvedArgs.filter((a) => a.trim().length > 0) : void 0;
   const serverName = options.name || parsed.inferredName;
-  p3.log.info(`Server name: ${chalk.cyan(serverName)}`);
+  p2.log.info(`Server name: ${chalk.cyan(serverName)}`);
   const transportValue = options.transport || options.type;
   let resolvedTransport;
   if (transportValue) {
     const validTransports = ["http", "sse"];
     if (!validTransports.includes(transportValue)) {
-      p3.log.error(
+      p2.log.error(
         `Invalid transport: ${transportValue}. Valid options: ${validTransports.join(", ")}`
       );
       process.exit(1);
     }
     resolvedTransport = transportValue;
     if (!isRemoteSource(parsed)) {
-      p3.log.warn("--transport is only used for remote URLs, ignoring");
+      p2.log.warn("--transport is only used for remote URLs, ignoring");
     }
   }
   const serverConfig = buildServerConfig(parsed, {
@@ -3107,19 +1811,19 @@ async function main(target, options) {
       }
     }
     if (invalid.length > 0) {
-      p3.log.error(`Invalid agents: ${invalid.join(", ")}`);
-      p3.log.info(`Valid agents: ${allAgentTypes.join(", ")}`);
+      p2.log.error(`Invalid agents: ${invalid.join(", ")}`);
+      p2.log.info(`Valid agents: ${allAgentTypes.join(", ")}`);
       process.exit(1);
     }
     targetAgents = resolved;
   } else if (options.all) {
     targetAgents = allAgentTypes;
-    p3.log.info(`Installing to all ${targetAgents.length} agents`);
+    p2.log.info(`Installing to all ${targetAgents.length} agents`);
   } else {
     spinner2.start("Detecting agents...");
     let detectedAgents;
     if (options.global) {
-      detectedAgents = await detectAllGlobalAgents();
+      detectedAgents = await detectGlobalAgents();
       for (const agent of detectedAgents) {
         agentRouting.set(agent, "global");
       }
@@ -3140,7 +1844,7 @@ async function main(target, options) {
           for (const agent of targetAgents) {
             agentRouting.set(agent, "global");
           }
-          p3.log.info(
+          p2.log.info(
             `Installing to ${targetAgents.length} agents globally (none detected)`
           );
         } else {
@@ -3148,20 +1852,20 @@ async function main(target, options) {
           for (const agent of targetAgents) {
             agentRouting.set(agent, "local");
           }
-          p3.log.info(
+          p2.log.info(
             `Installing to ${targetAgents.length} project-capable agents (none detected)`
           );
         }
       } else {
         const availableAgents = options.global ? allAgentTypes : getProjectCapableAgents();
-        p3.log.warn(
+        p2.log.warn(
           options.global ? "No coding agents detected." : "No agents detected in this project."
         );
         const selected = await selectAgentsInteractive(availableAgents, {
           global: options.global
         });
-        if (p3.isCancel(selected)) {
-          p3.cancel("Installation cancelled");
+        if (p2.isCancel(selected)) {
+          p2.cancel("Installation cancelled");
           process.exit(0);
         }
         selectedViaPrompt = true;
@@ -3173,7 +1877,7 @@ async function main(target, options) {
     } else if (options.yes) {
       targetAgents = detectedAgents;
       const agentNames = detectedAgents.map((a) => chalk.cyan(agents[a].displayName)).join(", ");
-      p3.log.info(`Installing to: ${agentNames}`);
+      p2.log.info(`Installing to: ${agentNames}`);
     } else {
       const availableAgents = options.global ? allAgentTypes : getProjectCapableAgents();
       let lastSelected;
@@ -3187,14 +1891,14 @@ async function main(target, options) {
         agentRouting,
         lastSelected
       });
-      const selected = await p3.multiselect({
+      const selected = await p2.multiselect({
         message: "Select agents to install to",
         options: agentChoices,
         required: true,
         initialValues
       });
-      if (p3.isCancel(selected)) {
-        p3.cancel("Installation cancelled");
+      if (p2.isCancel(selected)) {
+        p2.cancel("Installation cancelled");
         process.exit(0);
       }
       selectedViaPrompt = true;
@@ -3212,25 +1916,25 @@ async function main(target, options) {
     const unsupportedNames = unsupportedAgents.map((a) => agents[a].displayName).join(", ");
     const hints = unsupportedAgents.map((a) => agents[a].unsupportedTransportMessage).filter(Boolean);
     if (options.all) {
-      p3.log.warn(
+      p2.log.warn(
         `Skipping agents that don't support ${requiredTransport} transport: ${unsupportedNames}`
       );
       for (const hint of hints) {
-        p3.log.info(hint);
+        p2.log.info(hint);
       }
       targetAgents = targetAgents.filter(
         (a) => isTransportSupported(a, requiredTransport)
       );
       if (targetAgents.length === 0) {
-        p3.log.error("No agents support this transport type");
+        p2.log.error("No agents support this transport type");
         process.exit(1);
       }
     } else {
-      p3.log.error(
+      p2.log.error(
         `The following agents don't support ${requiredTransport} transport: ${unsupportedNames}`
       );
       for (const hint of hints) {
-        p3.log.info(hint);
+        p2.log.info(hint);
       }
       process.exit(1);
     }
@@ -3253,7 +1957,7 @@ async function main(target, options) {
     if (selectedWithLocal.length > 0) {
       let installLocally = true;
       if (!options.yes) {
-        const scope = await p3.select({
+        const scope = await p2.select({
           message: "Installation scope",
           options: [
             {
@@ -3268,8 +1972,8 @@ async function main(target, options) {
             }
           ]
         });
-        if (p3.isCancel(scope)) {
-          p3.cancel("Installation cancelled");
+        if (p2.isCancel(scope)) {
+          p2.cancel("Installation cancelled");
           process.exit(0);
         }
         installLocally = scope;
@@ -3278,7 +1982,7 @@ async function main(target, options) {
         agentRouting.set(agent, installLocally ? "local" : "global");
       }
     } else {
-      p3.log.info("Selected agents only support global installation");
+      p2.log.info("Selected agents only support global installation");
     }
   }
   const summaryLines = [];
@@ -3310,13 +2014,13 @@ async function main(target, options) {
     );
   }
   console.log();
-  p3.note(summaryLines.join("\n"), "Installation Summary");
+  p2.note(summaryLines.join("\n"), "Installation Summary");
   if (!options.yes) {
-    const confirmed = await p3.confirm({
+    const confirmed = await p2.confirm({
       message: "Proceed with installation?"
     });
-    if (p3.isCancel(confirmed) || !confirmed) {
-      p3.cancel("Installation cancelled");
+    if (p2.isCancel(confirmed) || !confirmed) {
+      p2.cancel("Installation cancelled");
       process.exit(0);
     }
   }
@@ -3332,12 +2036,12 @@ async function main(target, options) {
     const resultLines = [];
     for (const [agentType, result] of successful) {
       const agent = agents[agentType];
-      const shortPath = shortenPath2(result.path);
+      const shortPath = shortenPath(result.path);
       resultLines.push(
         `${chalk.green("\u2713")} ${agent.displayName}: ${chalk.dim(shortPath)}`
       );
     }
-    p3.note(
+    p2.note(
       resultLines.join("\n"),
       chalk.green(
         `Installed to ${successful.length} agent${successful.length !== 1 ? "s" : ""}`
@@ -3346,33 +2050,33 @@ async function main(target, options) {
   }
   if (failed.length > 0) {
     console.log();
-    p3.log.error(
+    p2.log.error(
       chalk.red(
         `Failed to install to ${failed.length} agent${failed.length !== 1 ? "s" : ""}`
       )
     );
     for (const [agentType, result] of failed) {
       const agent = agents[agentType];
-      p3.log.message(
+      p2.log.message(
         `  ${chalk.red("\u2717")} ${agent.displayName}: ${chalk.dim(result.error)}`
       );
     }
   }
   if (options.gitignore && options.global) {
-    p3.log.warn(
+    p2.log.warn(
       "--gitignore is only supported for project-scoped installations; ignoring."
     );
   } else if (options.gitignore) {
     const successfulPaths = successful.map(([_, result]) => result.path);
     const gitignoreUpdate = updateGitignoreWithPaths(successfulPaths);
     if (gitignoreUpdate.added.length > 0) {
-      p3.log.info(
+      p2.log.info(
         `Added ${gitignoreUpdate.added.length} entr${gitignoreUpdate.added.length === 1 ? "y" : "ies"} to .gitignore`
       );
     } else {
-      p3.log.info("No new local config paths to add to .gitignore");
+      p2.log.info("No new local config paths to add to .gitignore");
     }
   }
   console.log();
-  p3.outro(chalk.green("Done!"));
+  p2.outro(chalk.green("Done!"));
 }