add-mcp 1.7.0 → 1.8.0

package/README.md

@@ -89,6 +89,10 @@ Besides the implicit add command, `add-mcp` also supports the following commands
 | ------------- | ------------------------------------------------------------ |
 | `find`        | Search MCP registry servers and install a selected match     |
 | `search`      | Alias for `find`                                             |
+| `list`        | List installed MCP servers across detected agents            |
+| `remove`      | Remove an MCP server from agent configurations               |
+| `sync`        | Synchronize server names and installations across agents     |
+| `unify`       | Alias for `sync`                                             |
 | `list-agents` | List all supported coding agents with scope (project/global) |
 
 ## Add Command
@@ -219,7 +223,7 @@ If you run with `-y` before this one-time registry setup is completed, the CLI e
 
 | Registry                        | Base URL                                                | Description                                                                                                                                                                                                                        |
 | ------------------------------- | ------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **add-mcp curated registry**    | `https://mcp.agent-tooling.dev/api/v1/servers` | A curated list of first-party, verified MCP servers from popular developer tools and SaaS services. Designed to surface high-quality, officially maintained servers instead of a long tail of unmaintained or third-party entries. |
+| **add-mcp curated registry**    | `https://mcp.agent-tooling.dev/api/v1/servers`          | A curated list of first-party, verified MCP servers from popular developer tools and SaaS services. Designed to surface high-quality, officially maintained servers instead of a long tail of unmaintained or third-party entries. |
 | **Official Anthropic registry** | `https://registry.modelcontextprotocol.io/v0.1/servers` | The community-driven MCP server registry maintained by Anthropic. Contains the broadest catalog of MCP servers.                                                                                                                    |
 
 ### Missing A Server in add-mcp Curated Registry?
@@ -289,6 +293,72 @@ To add your own registry, append an entry to `findRegistries` in `~/.config/add-
 }
 ```
 
+## List Command
+
+List installed MCP servers across detected agents:
+
+```bash
+# List servers for all detected agents in the project
+npx add-mcp list
+
+# List global server configs
+npx add-mcp list -g
+
+# List servers for a specific agent (shown even if not detected)
+npx add-mcp list -a cursor
+```
+
+| Option                | Description                            |
+| --------------------- | -------------------------------------- |
+| `-g, --global`        | List global configs instead of project |
+| `-a, --agent <agent>` | Filter to specific agent(s)            |
+
+## Remove Command
+
+Remove an MCP server from agent configurations by server name, URL, or package name:
+
+```bash
+# Remove by server name (interactive selection by default)
+npx add-mcp remove neon
+
+# Remove all matches without prompting
+npx add-mcp remove neon -y
+
+# Remove by URL
+npx add-mcp remove https://mcp.neon.tech/mcp -y
+
+# Remove from global configs for a specific agent
+npx add-mcp remove neon -g -a cursor -y
+```
+
+| Option                | Description                          |
+| --------------------- | ------------------------------------ |
+| `-g, --global`        | Remove from global configs           |
+| `-a, --agent <agent>` | Filter to specific agent(s)          |
+| `-y, --yes`           | Remove all matches without prompting |
+
+## Sync Command
+
+Synchronize server names and installations across all detected agents. Servers are grouped by URL or package name, and each group is unified to the shortest server name. Servers with conflicting headers, env, or args across agents are skipped with a warning.
+
+```bash
+# Sync project-level configs (interactive confirmation)
+npx add-mcp sync
+
+# Sync without prompting
+npx add-mcp sync -y
+
+# Sync global configs
+npx add-mcp sync -g -y
+```
+
+| Option         | Description                            |
+| -------------- | -------------------------------------- |
+| `-g, --global` | Sync global configs instead of project |
+| `-y, --yes`    | Skip confirmation prompts              |
+
+`unify` is an alias for `sync`.
+
 ## Troubleshooting
 
 ### Server not loading

package/dist/index.js

@@ -1322,6 +1322,14 @@ function detectIndent(text2) {
   });
   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)) {
@@ -1349,6 +1357,31 @@ function writeJsonConfig(filePath, config, configKey) {
   }
   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();
@@ -1375,6 +1408,30 @@ function readYamlConfig(filePath) {
   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)) {
@@ -1405,6 +1462,26 @@ function readTomlConfig(filePath) {
   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)) {
@@ -1420,6 +1497,33 @@ function writeTomlConfig(filePath, config) {
 }
 
 // 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":
@@ -1574,10 +1678,126 @@ function installServer(serverName, serverConfig, agentTypes, options = {}) {
   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.7.0",
+  version: "1.8.0",
   description: "Add MCP servers to your favorite coding agents with a single command.",
   author: "Andre Landgraf <andre@neon.tech>",
   license: "Apache-2.0",
@@ -1593,8 +1813,8 @@ var package_default = {
     fmt: "prettier --write .",
     build: "tsup src/index.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/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",
+    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/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/reader.test.ts && tsx tests/formats-remove.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",
@@ -1734,7 +1954,7 @@ function extractOptions(raw) {
   }
   return raw;
 }
-function extractFindOptionsFromArgv() {
+function extractSubcommandOptionsFromArgv() {
   const argv = process.argv.slice(2);
   const result = {};
   for (let i = 0; i < argv.length; i++) {
@@ -1868,7 +2088,7 @@ program.command("list-agents").description("List all supported coding agents").a
 async function runFindCommand(keyword, rawOptions) {
   const options = {
     ...extractOptions(rawOptions),
-    ...extractFindOptionsFromArgv()
+    ...extractSubcommandOptionsFromArgv()
   };
   const query = (keyword ?? "").trim();
   const registries = await ensureFindRegistriesConfigured(options.yes);
@@ -1919,7 +2139,437 @@ program.command("search [keyword]").description("Alias for find").option(
     await runFindCommand(keyword, options);
   }
 );
+program.command("list").description("List installed MCP servers across detected agents").option("-g, --global", "List global configs instead of project-level").option("-a, --agent <agent>", "Filter to specific agent(s)", collect, []).action(async (rawOptions) => {
+  const options = {
+    ...extractOptions(rawOptions),
+    ...extractSubcommandOptionsFromArgv()
+  };
+  await runListCommand(options);
+});
+program.command("remove <query>").description("Remove an MCP server from agent configurations").option("-g, --global", "Remove from global configs instead of project-level").option("-a, --agent <agent>", "Filter to specific agent(s)", collect, []).option("-y, --yes", "Remove all matches without prompting").action(
+  async (query, rawOptions) => {
+    const options = {
+      ...extractOptions(rawOptions),
+      ...extractSubcommandOptionsFromArgv()
+    };
+    await runRemoveCommand(query, options);
+  }
+);
+program.command("sync").description(
+  "Synchronize server names and installations across all detected agents"
+).option("-g, --global", "Sync global configs instead of project-level").option("-y, --yes", "Skip confirmation prompts").action(async (rawOptions) => {
+  const options = {
+    ...extractOptions(rawOptions),
+    ...extractSubcommandOptionsFromArgv()
+  };
+  await runSyncCommand(options);
+});
+program.command("unify").description("Alias for sync").option("-g, --global", "Sync global configs instead of project-level").option("-y, --yes", "Skip confirmation prompts").action(async (rawOptions) => {
+  const options = {
+    ...extractOptions(rawOptions),
+    ...extractSubcommandOptionsFromArgv()
+  };
+  await runSyncCommand(options);
+});
 program.parse();
+async function runListCommand(options) {
+  showLogo();
+  console.log();
+  const explicitAgents = resolveAgentFlags(options.agent);
+  const agentServersList = await gatherInstalledServers({
+    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);
+    console.log();
+    return;
+  }
+  for (const agentServers of agentServersList) {
+    if (!agentServers.detected) {
+      console.log(
+        `${TEXT}${agentServers.displayName}:${RESET} ${DIM}not detected${RESET}`
+      );
+      continue;
+    }
+    if (agentServers.servers.length === 0) {
+      console.log(
+        `${TEXT}${agentServers.displayName}:${RESET} ${DIM}no servers configured${RESET}`
+      );
+      continue;
+    }
+    console.log(`${TEXT}${agentServers.displayName}:${RESET}`);
+    for (const server of agentServers.servers) {
+      const identityHint = server.identity ? ` ${DIM}(${server.identity})${RESET}` : "";
+      console.log(
+        `  ${DIM}-${RESET} ${TEXT}${server.serverName}${RESET}${identityHint}`
+      );
+    }
+  }
+  console.log();
+}
+async function runRemoveCommand(query, options) {
+  showLogo();
+  console.log();
+  const explicitAgents = resolveAgentFlags(options.agent);
+  const agentServersList = await gatherInstalledServers({
+    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}'`);
+    console.log();
+    return;
+  }
+  const matchOptions = matches.map((m, i) => ({
+    value: i,
+    label: `${m.serverName} (${agents[m.agentType].displayName})`,
+    hint: m.identity || m.configPath
+  }));
+  let selectedIndices;
+  if (options.yes) {
+    selectedIndices = matches.map((_, i) => i);
+    p3.log.info(
+      `Removing ${matches.length} server${matches.length !== 1 ? "s" : ""} matching '${query}'`
+    );
+  } else {
+    const selected = await p3.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");
+      console.log();
+      return;
+    }
+    selectedIndices = selected;
+    if (selectedIndices.length === 0) {
+      p3.log.info("No changes made");
+      console.log();
+      return;
+    }
+  }
+  let removedCount = 0;
+  const affectedAgents = /* @__PURE__ */ new Set();
+  for (const idx of selectedIndices) {
+    const server = matches[idx];
+    const agent = agents[server.agentType];
+    try {
+      removeServerFromConfig(
+        server.configPath,
+        agent.format,
+        getConfigKeyForServer(server),
+        server.serverName
+      );
+      removedCount++;
+      affectedAgents.add(agent.displayName);
+    } catch (error) {
+      p3.log.error(
+        `Failed to remove ${server.serverName} from ${agent.displayName}: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  if (removedCount > 0) {
+    p3.log.success(
+      `Removed ${removedCount} server${removedCount !== 1 ? "s" : ""} from ${affectedAgents.size} agent${affectedAgents.size !== 1 ? "s" : ""}`
+    );
+  }
+  console.log();
+}
+function getConfigKeyForServer(server) {
+  const agent = agents[server.agentType];
+  if (server.scope === "local" && agent.localConfigKey) {
+    return agent.localConfigKey;
+  }
+  return agent.configKey;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (a === void 0 || b === void 0) return a === b;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((val, i) => deepEqual(val, b[i]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj).sort();
+    const bKeys = Object.keys(bObj).sort();
+    if (!deepEqual(aKeys, bKeys)) return false;
+    return aKeys.every((key) => deepEqual(aObj[key], bObj[key]));
+  }
+  return false;
+}
+function pickCanonicalName(entries) {
+  const nameFreq = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    nameFreq.set(entry.serverName, (nameFreq.get(entry.serverName) ?? 0) + 1);
+  }
+  const names = [...nameFreq.entries()];
+  names.sort(([nameA, freqA], [nameB, freqB]) => {
+    if (nameA.length !== nameB.length) return nameA.length - nameB.length;
+    if (freqA !== freqB) return freqB - freqA;
+    return nameA.localeCompare(nameB);
+  });
+  return names[0][0];
+}
+function extractConflictFields(config) {
+  return {
+    headers: config.headers ?? config.http_headers ?? null,
+    env: config.env ?? config.envs ?? config.environment ?? null,
+    args: config.args ?? null
+  };
+}
+function buildSyncGroups(agentServersList) {
+  const byIdentity = /* @__PURE__ */ new Map();
+  for (const agentServers of agentServersList) {
+    for (const server of agentServers.servers) {
+      if (!server.identity) continue;
+      const existing = byIdentity.get(server.identity) ?? [];
+      existing.push(server);
+      byIdentity.set(server.identity, existing);
+    }
+  }
+  const groups = [];
+  for (const [identity, entries] of byIdentity) {
+    const fieldSets = entries.map((e) => extractConflictFields(e.config));
+    const reference = fieldSets[0];
+    let hasConflict = false;
+    let conflictReason;
+    for (let i = 1; i < fieldSets.length; i++) {
+      const other = fieldSets[i];
+      if (!deepEqual(reference.headers, other.headers)) {
+        hasConflict = true;
+        conflictReason = `headers differ between ${agents[entries[0].agentType].displayName} and ${agents[entries[i].agentType].displayName}`;
+        break;
+      }
+      if (!deepEqual(reference.env, other.env)) {
+        hasConflict = true;
+        conflictReason = `env differs between ${agents[entries[0].agentType].displayName} and ${agents[entries[i].agentType].displayName}`;
+        break;
+      }
+      if (!deepEqual(reference.args, other.args)) {
+        hasConflict = true;
+        conflictReason = `args differ between ${agents[entries[0].agentType].displayName} and ${agents[entries[i].agentType].displayName}`;
+        break;
+      }
+    }
+    groups.push({
+      identity,
+      entries,
+      canonicalName: pickCanonicalName(entries),
+      canonicalConfig: entries[0].config,
+      hasConflict,
+      conflictReason
+    });
+  }
+  return groups;
+}
+async function runSyncCommand(options) {
+  showLogo();
+  console.log();
+  const agentServersList = await gatherInstalledServers({
+    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");
+    console.log();
+    return;
+  }
+  const groups = buildSyncGroups(agentServersList);
+  const detectedAgentTypes = new Set(agentServersList.map((a) => a.agentType));
+  const renames = [];
+  const additions = [];
+  const skipped = [];
+  for (const group of groups) {
+    if (group.hasConflict) {
+      skipped.push(group);
+      continue;
+    }
+    const presentAgents = new Set(group.entries.map((e) => e.agentType));
+    for (const entry of group.entries) {
+      if (entry.serverName !== group.canonicalName) {
+        renames.push({
+          group,
+          agentType: entry.agentType,
+          oldName: entry.serverName
+        });
+      }
+    }
+    for (const agentType of detectedAgentTypes) {
+      if (!presentAgents.has(agentType)) {
+        additions.push({ group, agentType });
+      }
+    }
+  }
+  if (renames.length === 0 && additions.length === 0 && skipped.length === 0) {
+    p3.log.info("All servers are already in sync");
+    console.log();
+    return;
+  }
+  const planLines = [];
+  if (renames.length > 0) {
+    planLines.push(chalk.cyan("Renames:"));
+    for (const r of renames) {
+      planLines.push(
+        `  ${agents[r.agentType].displayName}: ${r.oldName} \u2192 ${r.group.canonicalName}`
+      );
+    }
+  }
+  if (additions.length > 0) {
+    planLines.push(chalk.cyan("Additions:"));
+    for (const a of additions) {
+      planLines.push(
+        `  ${agents[a.agentType].displayName}: + ${a.group.canonicalName} (${a.group.identity})`
+      );
+    }
+  }
+  if (skipped.length > 0) {
+    planLines.push(chalk.yellow("Skipped (conflicts):"));
+    for (const s of skipped) {
+      planLines.push(`  ${s.identity}: ${s.conflictReason}`);
+    }
+  }
+  if (renames.length === 0 && additions.length === 0) {
+    p3.note(planLines.join("\n"), "Sync Plan");
+    p3.log.info(
+      "All servers are already in sync (some skipped due to conflicts)"
+    );
+    console.log();
+    return;
+  }
+  p3.note(planLines.join("\n"), "Sync Plan");
+  if (!options.yes) {
+    const confirmed = await p3.confirm({
+      message: "Proceed with sync?"
+    });
+    if (p3.isCancel(confirmed) || !confirmed) {
+      p3.log.info("No changes made");
+      console.log();
+      return;
+    }
+  }
+  const scope = options.global ? "global" : "local";
+  let changeCount = 0;
+  for (const rename of renames) {
+    const { group, agentType } = rename;
+    const result = installServerForAgent(
+      group.canonicalName,
+      buildServerConfigFromStored(group.canonicalConfig),
+      agentType,
+      { local: scope === "local" }
+    );
+    if (result.success) {
+      changeCount++;
+    } else {
+      p3.log.error(
+        `Failed to write ${group.canonicalName} to ${agents[agentType].displayName}: ${result.error}`
+      );
+    }
+  }
+  for (const addition of additions) {
+    const { group, agentType } = addition;
+    const result = installServerForAgent(
+      group.canonicalName,
+      buildServerConfigFromStored(group.canonicalConfig),
+      agentType,
+      { local: scope === "local" }
+    );
+    if (result.success) {
+      changeCount++;
+    } else {
+      p3.log.error(
+        `Failed to add ${group.canonicalName} to ${agents[agentType].displayName}: ${result.error}`
+      );
+    }
+  }
+  for (const rename of renames) {
+    const { group, agentType, oldName } = rename;
+    const agentConfig = agents[agentType];
+    const entry = group.entries.find((e) => e.agentType === agentType);
+    if (!entry) continue;
+    try {
+      removeServerFromConfig(
+        entry.configPath,
+        agentConfig.format,
+        getConfigKeyForServer(entry),
+        oldName
+      );
+    } catch (error) {
+      p3.log.error(
+        `Failed to remove old alias ${oldName} from ${agentConfig.displayName}: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  p3.log.success(
+    `Synced ${changeCount} server${changeCount !== 1 ? "s" : ""} across ${detectedAgentTypes.size} agent${detectedAgentTypes.size !== 1 ? "s" : ""}`
+  );
+  console.log();
+}
+var TRANSPORT_ALIASES = {
+  http: "http",
+  sse: "sse",
+  streamable_http: "http",
+  streamableHttp: "http",
+  "streamable-http": "http",
+  remote: "http"
+};
+function normalizeTransportType(raw) {
+  if (typeof raw === "string" && raw in TRANSPORT_ALIASES) {
+    return TRANSPORT_ALIASES[raw];
+  }
+  return "http";
+}
+function buildServerConfigFromStored(config) {
+  const url = typeof config.url === "string" ? config.url : typeof config.uri === "string" ? config.uri : typeof config.serverUrl === "string" ? config.serverUrl : void 0;
+  if (url) {
+    const result2 = {
+      type: normalizeTransportType(config.type),
+      url
+    };
+    const headers = config.headers && typeof config.headers === "object" ? config.headers : config.http_headers && typeof config.http_headers === "object" ? config.http_headers : void 0;
+    if (headers && Object.keys(headers).length > 0) {
+      result2.headers = headers;
+    }
+    return result2;
+  }
+  const command = typeof config.command === "string" ? config.command : typeof config.cmd === "string" ? config.cmd : void 0;
+  const args = Array.isArray(config.args) ? config.args.filter((a) => typeof a === "string") : [];
+  const env = config.env && typeof config.env === "object" ? config.env : config.envs && typeof config.envs === "object" ? config.envs : config.environment && typeof config.environment === "object" ? config.environment : void 0;
+  const result = {};
+  if (command) result.command = command;
+  if (args.length > 0) result.args = args;
+  if (env && Object.keys(env).length > 0) result.env = env;
+  return result;
+}
+function resolveAgentFlags(agentFlags) {
+  if (!agentFlags || agentFlags.length === 0) return [];
+  const resolved = [];
+  const invalid = [];
+  for (const input of agentFlags) {
+    const agentType = resolveAgentType(input);
+    if (agentType) {
+      resolved.push(agentType);
+    } else {
+      invalid.push(input);
+    }
+  }
+  if (invalid.length > 0) {
+    p3.log.error(`Invalid agents: ${invalid.join(", ")}`);
+    p3.log.info(`Valid agents: ${getAgentTypes().join(", ")}`);
+    process.exit(1);
+  }
+  return resolved;
+}
 function listAgents() {
   showLogo();
   console.log();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "add-mcp",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Add MCP servers to your favorite coding agents with a single command.",
   "author": "Andre Landgraf <andre@neon.tech>",
   "license": "Apache-2.0",
@@ -16,8 +16,8 @@
     "fmt": "prettier --write .",
     "build": "tsup src/index.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/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",
+    "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/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/reader.test.ts && tsx tests/formats-remove.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",