add-mcp 0.5.0 → 0.6.0

package/README.md

@@ -7,7 +7,7 @@ Supports **OpenCode**, **Claude Code**, **Codex**, **Cursor**, and [5 more](#sup
 ## Install an MCP Server
 
 ```bash
-npx add-mcp https://mcp.example.com/sse
+npx add-mcp https://mcp.example.com/mcp
 ```
 
 ### Usage Examples
@@ -100,8 +100,8 @@ The CLI automatically detects agents based on your environment:
 
 **No agents detected:**
 
-- Interactive mode: Shows error with guidance to use `--global` or run in a project
-- With `--yes`: Installs to all project-capable agents
+- Interactive mode: Shows an agent selector (all available, last selection, or pick specific)
+- With `--yes`: Installs to all project-capable agents (project mode) or all global-capable agents (global mode)
 
 ## Transport Types
 

package/dist/index.js

@@ -2,9 +2,9 @@
 
 // src/index.ts
 import { program } from "commander";
-import * as p from "@clack/prompts";
+import * as p2 from "@clack/prompts";
 import chalk from "chalk";
-import { homedir as homedir2 } from "os";
+import { homedir as homedir3 } from "os";
 
 // src/types.ts
 var agentAliases = {
@@ -12,45 +12,107 @@ var agentAliases = {
 };
 
 // src/agents.ts
-import { homedir } from "os";
-import { join } from "path";
+import * as p from "@clack/prompts";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
 import { existsSync } from "fs";
-var home = homedir();
+
+// src/mcp-lock.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { dirname, join } from "path";
+import { homedir } from "os";
+var AGENTS_DIR = ".agents";
+var LOCK_FILE = ".mcp-lock.json";
+var CURRENT_VERSION = 1;
+function getMcpLockPath() {
+  return join(homedir(), AGENTS_DIR, LOCK_FILE);
+}
+async function readMcpLock() {
+  const lockPath = getMcpLockPath();
+  try {
+    const content = await readFile(lockPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed.version !== "number") {
+      return createEmptyLockFile();
+    }
+    if (parsed.version < CURRENT_VERSION) {
+      return createEmptyLockFile();
+    }
+    return parsed;
+  } catch {
+    return createEmptyLockFile();
+  }
+}
+async function writeMcpLock(lock) {
+  const lockPath = getMcpLockPath();
+  await mkdir(dirname(lockPath), { recursive: true });
+  const content = JSON.stringify(lock, null, 2);
+  await writeFile(lockPath, content, "utf-8");
+}
+async function getLastSelectedAgents() {
+  const lock = await readMcpLock();
+  return lock.lastSelectedAgents;
+}
+async function saveSelectedAgents(agents2) {
+  const lock = await readMcpLock();
+  lock.lastSelectedAgents = agents2;
+  await writeMcpLock(lock);
+}
+function createEmptyLockFile() {
+  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 || join(home, "AppData", "Roaming");
+    const appData = process.env.APPDATA || join2(home, "AppData", "Roaming");
     return {
       appSupport: appData,
-      vscodePath: join(appData, "Code", "User")
+      vscodePath: join2(appData, "Code", "User"),
+      gooseConfigPath: join2(appData, "Block", "goose", "config", "config.yaml")
     };
   } else if (platform === "darwin") {
     return {
-      appSupport: join(home, "Library", "Application Support"),
-      vscodePath: join(home, "Library", "Application Support", "Code", "User")
+      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 || join(home, ".config");
+    const configDir = process.env.XDG_CONFIG_HOME || join2(home, ".config");
     return {
       appSupport: configDir,
-      vscodePath: join(configDir, "Code", "User")
+      vscodePath: join2(configDir, "Code", "User"),
+      gooseConfigPath: join2(configDir, "goose", "config.yaml")
     };
   }
 }
-var { appSupport, vscodePath } = getPlatformPaths();
+var { appSupport, vscodePath, gooseConfigPath } = getPlatformPaths();
 function transformGooseConfig(serverName, config) {
   if (config.url) {
     const gooseType = config.type === "sse" ? "sse" : "streamable_http";
     return {
       name: serverName,
+      description: "",
       type: gooseType,
-      url: config.url,
+      uri: config.url,
+      headers: config.headers || {},
       enabled: true,
       timeout: 300
     };
   }
   return {
     name: serverName,
+    description: "",
     cmd: config.command,
     args: config.args || [],
     enabled: true,
@@ -110,7 +172,7 @@ var agents = {
   "claude-code": {
     name: "claude-code",
     displayName: "Claude Code",
-    configPath: join(home, ".claude.json"),
+    configPath: join2(home, ".claude.json"),
     localConfigPath: ".mcp.json",
     projectDetectPaths: [".mcp.json", ".claude"],
     configKey: "mcpServers",
@@ -118,13 +180,13 @@ var agents = {
     supportedTransports: ["stdio", "http", "sse"],
     supportsHeaders: true,
     detectGlobalInstall: async () => {
-      return existsSync(join(home, ".claude"));
+      return existsSync(join2(home, ".claude"));
     }
   },
   "claude-desktop": {
     name: "claude-desktop",
     displayName: "Claude Desktop",
-    configPath: join(appSupport, "Claude", "claude_desktop_config.json"),
+    configPath: join2(appSupport, "Claude", "claude_desktop_config.json"),
     projectDetectPaths: [],
     // Global only - no project support
     configKey: "mcpServers",
@@ -132,14 +194,14 @@ var agents = {
     supportedTransports: ["stdio", "http", "sse"],
     supportsHeaders: true,
     detectGlobalInstall: async () => {
-      return existsSync(join(appSupport, "Claude"));
+      return existsSync(join2(appSupport, "Claude"));
     }
   },
   codex: {
     name: "codex",
     displayName: "Codex",
-    configPath: join(
-      process.env.CODEX_HOME || join(home, ".codex"),
+    configPath: join2(
+      process.env.CODEX_HOME || join2(home, ".codex"),
       "config.toml"
     ),
     localConfigPath: ".codex/config.toml",
@@ -149,14 +211,14 @@ var agents = {
     supportedTransports: ["stdio", "http", "sse"],
     supportsHeaders: true,
     detectGlobalInstall: async () => {
-      return existsSync(join(home, ".codex"));
+      return existsSync(join2(home, ".codex"));
     },
     transformConfig: transformCodexConfig
   },
   cursor: {
     name: "cursor",
     displayName: "Cursor",
-    configPath: join(home, ".cursor", "mcp.json"),
+    configPath: join2(home, ".cursor", "mcp.json"),
     localConfigPath: ".cursor/mcp.json",
     projectDetectPaths: [".cursor"],
     configKey: "mcpServers",
@@ -164,13 +226,13 @@ var agents = {
     supportedTransports: ["stdio", "http", "sse"],
     supportsHeaders: true,
     detectGlobalInstall: async () => {
-      return existsSync(join(home, ".cursor"));
+      return existsSync(join2(home, ".cursor"));
     }
   },
   "gemini-cli": {
     name: "gemini-cli",
     displayName: "Gemini CLI",
-    configPath: join(home, ".gemini", "settings.json"),
+    configPath: join2(home, ".gemini", "settings.json"),
     localConfigPath: ".gemini/settings.json",
     projectDetectPaths: [".gemini"],
     configKey: "mcpServers",
@@ -178,28 +240,28 @@ var agents = {
     supportedTransports: ["stdio", "http", "sse"],
     supportsHeaders: true,
     detectGlobalInstall: async () => {
-      return existsSync(join(home, ".gemini"));
+      return existsSync(join2(home, ".gemini"));
     }
   },
   goose: {
     name: "goose",
     displayName: "Goose",
-    configPath: join(home, ".config", "goose", "config.yaml"),
-    localConfigPath: ".goose/config.yaml",
-    projectDetectPaths: [".goose"],
+    configPath: gooseConfigPath,
+    projectDetectPaths: [],
+    // Global only - no project support
     configKey: "extensions",
     format: "yaml",
     supportedTransports: ["stdio", "http", "sse"],
-    supportsHeaders: false,
+    supportsHeaders: true,
     detectGlobalInstall: async () => {
-      return existsSync(join(home, ".config", "goose"));
+      return existsSync(gooseConfigPath);
     },
     transformConfig: transformGooseConfig
   },
   opencode: {
     name: "opencode",
     displayName: "OpenCode",
-    configPath: join(home, ".config", "opencode", "opencode.json"),
+    configPath: join2(home, ".config", "opencode", "opencode.json"),
     localConfigPath: ".opencode.json",
     projectDetectPaths: [".opencode.json", ".opencode"],
     configKey: "mcp",
@@ -207,14 +269,14 @@ var agents = {
     supportedTransports: ["stdio", "http", "sse"],
     supportsHeaders: true,
     detectGlobalInstall: async () => {
-      return existsSync(join(home, ".config", "opencode"));
+      return existsSync(join2(home, ".config", "opencode"));
     },
     transformConfig: transformOpenCodeConfig
   },
   vscode: {
     name: "vscode",
     displayName: "VS Code",
-    configPath: join(vscodePath, "mcp.json"),
+    configPath: join2(vscodePath, "mcp.json"),
     localConfigPath: ".vscode/mcp.json",
     projectDetectPaths: [".vscode"],
     configKey: "servers",
@@ -228,7 +290,7 @@ var agents = {
   zed: {
     name: "zed",
     displayName: "Zed",
-    configPath: process.platform === "darwin" || process.platform === "win32" ? join(appSupport, "Zed", "settings.json") : join(appSupport, "zed", "settings.json"),
+    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",
@@ -236,7 +298,7 @@ var agents = {
     supportedTransports: ["stdio", "http", "sse"],
     supportsHeaders: true,
     detectGlobalInstall: async () => {
-      const configDir = process.platform === "darwin" || process.platform === "win32" ? join(appSupport, "Zed") : join(appSupport, "zed");
+      const configDir = process.platform === "darwin" || process.platform === "win32" ? join2(appSupport, "Zed") : join2(appSupport, "zed");
       return existsSync(configDir);
     },
     transformConfig: transformZedConfig
@@ -259,7 +321,7 @@ function detectProjectAgents(cwd) {
   for (const [type, config] of Object.entries(agents)) {
     if (!config.localConfigPath) continue;
     for (const detectPath of config.projectDetectPaths) {
-      if (existsSync(join(dir, detectPath))) {
+      if (existsSync(join2(dir, detectPath))) {
         detected.push(type);
         break;
       }
@@ -279,6 +341,91 @@ async function detectAllGlobalAgents() {
 function isTransportSupported(agentType, transport) {
   return agents[agentType].supportedTransports.includes(transport);
 }
+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 (Recommended)",
+      hint: agentNames
+    });
+  }
+  selectOptions.push({
+    value: "all",
+    label: hasPrevious ? "All available agents" : "All available agents (Recommended)",
+    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) {
@@ -410,11 +557,11 @@ function isRemoteSource(parsed) {
 
 // src/installer.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync4 } from "fs";
-import { join as join2, dirname as dirname4 } from "path";
+import { join as join3, dirname as dirname5 } from "path";
 
 // src/formats/json.ts
 import { readFileSync, writeFileSync, existsSync as existsSync2, mkdirSync } from "fs";
-import { dirname } from "path";
+import { dirname as dirname2 } from "path";
 import * as jsonc from "jsonc-parser";
 
 // src/formats/utils.ts
@@ -465,7 +612,7 @@ function detectIndent(text) {
   return result || { tabSize: 2, insertSpaces: true };
 }
 function writeJsonConfig(filePath, config, configKey) {
-  const dir = dirname(filePath);
+  const dir = dirname2(filePath);
   if (!existsSync2(dir)) {
     mkdirSync(dir, { recursive: true });
   }
@@ -507,7 +654,7 @@ function setNestedValue(obj, path, value) {
 
 // src/formats/yaml.ts
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
 import yaml from "js-yaml";
 function readYamlConfig(filePath) {
   if (!existsSync3(filePath)) {
@@ -518,7 +665,7 @@ function readYamlConfig(filePath) {
   return parsed || {};
 }
 function writeYamlConfig(filePath, config) {
-  const dir = dirname2(filePath);
+  const dir = dirname3(filePath);
   if (!existsSync3(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
@@ -537,7 +684,7 @@ function writeYamlConfig(filePath, config) {
 
 // src/formats/toml.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname3 } from "path";
+import { dirname as dirname4 } from "path";
 import * as TOML from "@iarna/toml";
 function readTomlConfig(filePath) {
   if (!existsSync4(filePath)) {
@@ -548,7 +695,7 @@ function readTomlConfig(filePath) {
   return parsed;
 }
 function writeTomlConfig(filePath, config) {
-  const dir = dirname3(filePath);
+  const dir = dirname4(filePath);
   if (!existsSync4(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
@@ -614,7 +761,7 @@ function buildServerConfig(parsed, options = {}) {
 function getConfigPath(agent, options = {}) {
   if (options.local && agent.localConfigPath) {
     const cwd = options.cwd || process.cwd();
-    return join2(cwd, agent.localConfigPath);
+    return join3(cwd, agent.localConfigPath);
   }
   return agent.configPath;
 }
@@ -622,7 +769,7 @@ function installServerForAgent(serverName, serverConfig, agentType, options = {}
   const agent = agents[agentType];
   const configPath = getConfigPath(agent, options);
   try {
-    const dir = dirname4(configPath);
+    const dir = dirname5(configPath);
     if (!existsSync5(dir)) {
       mkdirSync4(dir, { recursive: true });
     }
@@ -667,7 +814,7 @@ function installServer(serverName, serverConfig, agentTypes, options = {}) {
 // package.json
 var package_default = {
   name: "add-mcp",
-  version: "0.5.0",
+  version: "0.6.0",
   description: "Add MCP servers to your favorite coding agents with a single command.",
   author: "Andre Landgraf <andre@neon.tech>",
   license: "Apache-2.0",
@@ -683,8 +830,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/installer.test.ts && tsx tests/e2e/install.test.ts",
-    "test:unit": "tsx tests/source-parser.test.ts && tsx tests/agents.test.ts && tsx tests/installer.test.ts",
+    test: "tsx tests/source-parser.test.ts && tsx tests/agents.test.ts && tsx tests/mcp-lock.test.ts && tsx tests/installer.test.ts && tsx tests/e2e/install.test.ts",
+    "test:unit": "tsx tests/source-parser.test.ts && tsx tests/agents.test.ts && tsx tests/mcp-lock.test.ts && tsx tests/installer.test.ts",
     "test:e2e": "tsx tests/e2e/install.test.ts",
     typecheck: "tsc --noEmit",
     prepublishOnly: "npm run build"
@@ -760,8 +907,8 @@ function showLogo() {
     console.log(`${GRAYS[i]}${line}${RESET}`);
   });
 }
-function shortenPath(fullPath) {
-  const home2 = homedir2();
+function shortenPath2(fullPath) {
+  const home2 = homedir3();
   if (fullPath.startsWith(home2)) {
     return fullPath.replace(home2, "~");
   }
@@ -868,7 +1015,7 @@ async function main(target, options) {
     process.exit(0);
   }
   console.log();
-  const spinner2 = p.spinner();
+  const spinner2 = p2.spinner();
   spinner2.start("Parsing source...");
   const parsed = parseSource(target);
   const isRemote = isRemoteSource(parsed);
@@ -877,7 +1024,7 @@ async function main(target, options) {
   const headerValues = options.header ?? [];
   const headerResult = parseHeaders(headerValues);
   if (headerResult.invalid.length > 0) {
-    p.log.error(
+    p2.log.error(
       `Invalid --header value(s): ${headerResult.invalid.join(", ")}. Use "Key: Value" format.`
     );
     process.exit(1);
@@ -885,23 +1032,23 @@ async function main(target, options) {
   const headerKeys = Object.keys(headerResult.headers);
   const hasHeaderValues = headerKeys.length > 0;
   if (hasHeaderValues && !isRemote) {
-    p.log.warn("--header is only used for remote URLs, ignoring");
+    p2.log.warn("--header is only used for remote URLs, ignoring");
   }
   const serverName = options.name || parsed.inferredName;
-  p.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)) {
-      p.log.error(
+      p2.log.error(
         `Invalid transport: ${transportValue}. Valid options: ${validTransports.join(", ")}`
       );
       process.exit(1);
     }
     resolvedTransport = transportValue;
     if (!isRemoteSource(parsed)) {
-      p.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, {
@@ -925,14 +1072,14 @@ async function main(target, options) {
       }
     }
     if (invalid.length > 0) {
-      p.log.error(`Invalid agents: ${invalid.join(", ")}`);
-      p.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;
-    p.log.info(`Installing to all ${targetAgents.length} agents`);
+    p2.log.info(`Installing to all ${targetAgents.length} agents`);
   } else {
     spinner2.start("Detecting agents...");
     let detectedAgents;
@@ -953,61 +1100,63 @@ async function main(target, options) {
     );
     if (detectedAgents.length === 0) {
       if (options.yes) {
-        targetAgents = getProjectCapableAgents();
-        for (const agent of targetAgents) {
-          agentRouting.set(agent, "local");
-        }
-        p.log.info(
-          `Installing to ${targetAgents.length} project-capable agents (none detected)`
-        );
-      } else {
-        if (!options.global) {
-          p.log.error(
-            "No agents detected in this project. Use --global to install globally, or run in a project with agent config files."
+        if (options.global) {
+          targetAgents = allAgentTypes;
+          for (const agent of targetAgents) {
+            agentRouting.set(agent, "global");
+          }
+          p2.log.info(
+            `Installing to ${targetAgents.length} agents globally (none detected)`
+          );
+        } else {
+          targetAgents = getProjectCapableAgents();
+          for (const agent of targetAgents) {
+            agentRouting.set(agent, "local");
+          }
+          p2.log.info(
+            `Installing to ${targetAgents.length} project-capable agents (none detected)`
           );
-          process.exit(1);
         }
-        p.log.warn(
-          "No coding agents detected. You can still install MCP servers."
+      } else {
+        const availableAgents = options.global ? allAgentTypes : getProjectCapableAgents();
+        p2.log.warn(
+          options.global ? "No coding agents detected. You can still install MCP servers." : "No agents detected in this project. You can still install MCP servers."
         );
-        const allAgentChoices = allAgentTypes.map((type) => ({
-          value: type,
-          label: agents[type].displayName
-        }));
-        const selected = await p.multiselect({
-          message: "Select agents to install to",
-          options: allAgentChoices,
-          required: true
+        const selected = await selectAgentsInteractive(availableAgents, {
+          global: options.global
         });
-        if (p.isCancel(selected)) {
-          p.cancel("Installation cancelled");
+        if (p2.isCancel(selected)) {
+          p2.cancel("Installation cancelled");
           process.exit(0);
         }
         selectedViaPrompt = true;
         targetAgents = selected;
+        for (const agent of targetAgents) {
+          agentRouting.set(agent, options.global ? "global" : "local");
+        }
       }
     } else if (detectedAgents.length === 1 || options.yes) {
       targetAgents = detectedAgents;
       const agentNames = detectedAgents.map((a) => chalk.cyan(agents[a].displayName)).join(", ");
-      p.log.info(`Installing to: ${agentNames}`);
+      p2.log.info(`Installing to: ${agentNames}`);
     } else {
       const agentChoices = detectedAgents.map((a) => {
         const routing = agentRouting.get(a);
-        const hint = routing === "local" ? "project" : routing === "global" ? "global" : shortenPath(agents[a].configPath);
+        const hint = routing === "local" ? "project" : routing === "global" ? "global" : shortenPath2(agents[a].configPath);
         return {
           value: a,
           label: agents[a].displayName,
           hint
         };
       });
-      const selected = await p.multiselect({
+      const selected = await p2.multiselect({
         message: "Select agents to install to",
         options: agentChoices,
         required: true,
         initialValues: detectedAgents
       });
-      if (p.isCancel(selected)) {
-        p.cancel("Installation cancelled");
+      if (p2.isCancel(selected)) {
+        p2.cancel("Installation cancelled");
         process.exit(0);
       }
       selectedViaPrompt = true;
@@ -1021,18 +1170,18 @@ async function main(target, options) {
   if (unsupportedAgents.length > 0) {
     const unsupportedNames = unsupportedAgents.map((a) => agents[a].displayName).join(", ");
     if (options.all) {
-      p.log.warn(
+      p2.log.warn(
         `Skipping agents that don't support ${requiredTransport} transport: ${unsupportedNames}`
       );
       targetAgents = targetAgents.filter(
         (a) => isTransportSupported(a, requiredTransport)
       );
       if (targetAgents.length === 0) {
-        p.log.error("No agents support this transport type");
+        p2.log.error("No agents support this transport type");
         process.exit(1);
       }
     } else {
-      p.log.error(
+      p2.log.error(
         `The following agents don't support ${requiredTransport} transport: ${unsupportedNames}`
       );
       process.exit(1);
@@ -1047,7 +1196,7 @@ async function main(target, options) {
       const unsupportedNames = unsupportedHeaderAgents.map((a) => agents[a].displayName).join(", ");
       const hasExplicitAgentSelection = hasExplicitAgentFlags || selectedViaPrompt;
       if (hasExplicitAgentSelection) {
-        p.log.error(
+        p2.log.error(
           `The following agents don't support HTTP headers: ${unsupportedNames}`
         );
         process.exit(1);
@@ -1056,10 +1205,10 @@ async function main(target, options) {
         (a) => agents[a].supportsHeaders
       );
       if (supportedAgents.length === 0) {
-        p.log.error("No selected agents support HTTP headers");
+        p2.log.error("No selected agents support HTTP headers");
         process.exit(1);
       }
-      p.log.warn(
+      p2.log.warn(
         `Skipping agents that don't support HTTP headers: ${unsupportedNames}`
       );
       targetAgents = supportedAgents;
@@ -1083,7 +1232,7 @@ async function main(target, options) {
     if (selectedWithLocal.length > 0) {
       let installLocally = true;
       if (!options.yes) {
-        const scope = await p.select({
+        const scope = await p2.select({
           message: "Installation scope",
           options: [
             {
@@ -1098,8 +1247,8 @@ async function main(target, options) {
             }
           ]
         });
-        if (p.isCancel(scope)) {
-          p.cancel("Installation cancelled");
+        if (p2.isCancel(scope)) {
+          p2.cancel("Installation cancelled");
           process.exit(0);
         }
         installLocally = scope;
@@ -1108,7 +1257,7 @@ async function main(target, options) {
         agentRouting.set(agent, installLocally ? "local" : "global");
       }
     } else {
-      p.log.info("Selected agents only support global installation");
+      p2.log.info("Selected agents only support global installation");
     }
   }
   const summaryLines = [];
@@ -1140,13 +1289,13 @@ async function main(target, options) {
     );
   }
   console.log();
-  p.note(summaryLines.join("\n"), "Installation Summary");
+  p2.note(summaryLines.join("\n"), "Installation Summary");
   if (!options.yes) {
-    const confirmed = await p.confirm({
+    const confirmed = await p2.confirm({
       message: "Proceed with installation?"
     });
-    if (p.isCancel(confirmed) || !confirmed) {
-      p.cancel("Installation cancelled");
+    if (p2.isCancel(confirmed) || !confirmed) {
+      p2.cancel("Installation cancelled");
       process.exit(0);
     }
   }
@@ -1162,12 +1311,12 @@ async function main(target, options) {
     const resultLines = [];
     for (const [agentType, result] of successful) {
       const agent = agents[agentType];
-      const shortPath = shortenPath(result.path);
+      const shortPath = shortenPath2(result.path);
       resultLines.push(
         `${chalk.green("\u2713")} ${agent.displayName}: ${chalk.dim(shortPath)}`
       );
     }
-    p.note(
+    p2.note(
       resultLines.join("\n"),
       chalk.green(
         `Installed to ${successful.length} agent${successful.length !== 1 ? "s" : ""}`
@@ -1176,18 +1325,18 @@ async function main(target, options) {
   }
   if (failed.length > 0) {
     console.log();
-    p.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];
-      p.log.message(
+      p2.log.message(
         `  ${chalk.red("\u2717")} ${agent.displayName}: ${chalk.dim(result.error)}`
       );
     }
   }
   console.log();
-  p.outro(chalk.green("Done!"));
+  p2.outro(chalk.green("Done!"));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "add-mcp",
-  "version": "0.5.0",
+  "version": "0.6.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/installer.test.ts && tsx tests/e2e/install.test.ts",
-    "test:unit": "tsx tests/source-parser.test.ts && tsx tests/agents.test.ts && tsx tests/installer.test.ts",
+    "test": "tsx tests/source-parser.test.ts && tsx tests/agents.test.ts && tsx tests/mcp-lock.test.ts && tsx tests/installer.test.ts && tsx tests/e2e/install.test.ts",
+    "test:unit": "tsx tests/source-parser.test.ts && tsx tests/agents.test.ts && tsx tests/mcp-lock.test.ts && tsx tests/installer.test.ts",
     "test:e2e": "tsx tests/e2e/install.test.ts",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build"