add-mcp 1.7.0 → 1.9.0

package/dist/index.js

@@ -816,6 +816,234 @@ function isRemoteSource(parsed) {
 
 // src/find.ts
 import * as p2 from "@clack/prompts";
+
+// src/template.ts
+var TEMPLATE_PATTERN = /\$\{([^}]+)\}/g;
+function findTemplateVars(value) {
+  const vars = [];
+  let match;
+  while ((match = TEMPLATE_PATTERN.exec(value)) !== null) {
+    vars.push(match[1]);
+  }
+  TEMPLATE_PATTERN.lastIndex = 0;
+  return vars;
+}
+function substituteTemplatePlaceholders(value, replacement) {
+  return value.replace(/\$\{([^}]+)\}/g, () => replacement);
+}
+async function resolveTemplates(value, ask) {
+  const vars = findTemplateVars(value);
+  if (vars.length === 0) return { resolved: value, cancelled: false };
+  let result = value;
+  for (const varName of vars) {
+    const answer = await ask(varName);
+    if (typeof answer === "symbol") return { resolved: value, cancelled: true };
+    const entered = typeof answer === "string" ? answer : "";
+    result = result.replace(`\${${varName}}`, entered);
+  }
+  return { resolved: result, cancelled: false };
+}
+async function resolveRecordTemplates(record, ask) {
+  const resolved = {};
+  for (const [key, value] of Object.entries(record)) {
+    const result = await resolveTemplates(value, ask);
+    if (result.cancelled) return { resolved: record, cancelled: true };
+    resolved[key] = result.resolved;
+  }
+  return { resolved, cancelled: false };
+}
+async function resolveArrayTemplates(values, ask) {
+  const resolved = [];
+  for (const value of values) {
+    const result = await resolveTemplates(value, ask);
+    if (result.cancelled) return { resolved: values, cancelled: true };
+    resolved.push(result.resolved);
+  }
+  return { resolved, cancelled: false };
+}
+function hasTemplateVars(values) {
+  const strings = Array.isArray(values) ? values : Object.values(values);
+  return strings.some((v) => findTemplateVars(v).length > 0);
+}
+
+// src/package-arguments.ts
+var ARG_PLACEHOLDER = "<your-variable-value-here>";
+function normalizeNamedFlag(name) {
+  const t = name.trim();
+  if (t.startsWith("-")) return t;
+  return `--${t}`;
+}
+function definitionsFromPackage(pkg) {
+  return pkg.packageArguments ?? [];
+}
+function isNamedArg(d) {
+  if (d.type === "positional") return false;
+  if (d.type === "named") return true;
+  return Boolean(d.name?.trim());
+}
+function labelForArg(d, index) {
+  if (isNamedArg(d)) {
+    return `Flag ${normalizeNamedFlag(d.name)}`;
+  }
+  return d.valueHint?.trim() || d.description?.trim() || `Positional argument #${index + 1}`;
+}
+function hasTemplates(s) {
+  return Boolean(s && findTemplateVars(s).length > 0);
+}
+function buildPackageArgumentsArgvNonInteractive(definitions, placeholder = ARG_PLACEHOLDER) {
+  const out = [];
+  for (let i = 0; i < definitions.length; i++) {
+    const d = definitions[i];
+    if (isNamedArg(d)) {
+      const flag = normalizeNamedFlag(d.name);
+      let val = d.value?.trim() ?? "";
+      if (hasTemplates(d.value)) {
+        val = substituteTemplatePlaceholders(d.value, placeholder);
+      } else if (!val && d.default?.trim()) {
+        val = d.default.trim();
+      }
+      if (!val) {
+        if (d.isRequired === true) {
+          out.push(flag, placeholder);
+        }
+        continue;
+      }
+      out.push(flag, val);
+    } else {
+      let val = d.value?.trim() ?? "";
+      if (hasTemplates(d.value)) {
+        val = substituteTemplatePlaceholders(d.value, placeholder);
+        pushPositionalSegments(out, d, val);
+        continue;
+      }
+      if (val) {
+        pushPositionalSegments(out, d, val);
+        continue;
+      }
+      if (d.default?.trim()) {
+        pushPositionalSegments(out, d, d.default.trim());
+        continue;
+      }
+      pushPositionalSegments(out, d, placeholder);
+    }
+  }
+  return out;
+}
+function pushPositionalSegments(out, d, raw) {
+  if (d.isRepeated === true) {
+    const parts = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    if (parts.length === 0) {
+      out.push(raw);
+      return;
+    }
+    for (const p4 of parts) {
+      out.push(p4);
+    }
+    return;
+  }
+  out.push(raw);
+}
+async function buildPackageArgumentsArgvInteractive(definitions, prompt) {
+  const out = [];
+  for (let i = 0; i < definitions.length; i++) {
+    const d = definitions[i];
+    const label = labelForArg(d, i);
+    if (isNamedArg(d)) {
+      const flag = normalizeNamedFlag(d.name);
+      let val2 = d.value ?? "";
+      if (hasTemplates(d.value)) {
+        const res = await resolveTemplates(d.value, async (varName) => {
+          const answer = await prompt({
+            label: `${label} (${varName})`,
+            isRequired: true,
+            placeholder: `<${varName}>`
+          });
+          return answer;
+        });
+        if (res.cancelled) return { cancelled: true };
+        val2 = res.resolved;
+        out.push(flag, val2);
+        continue;
+      }
+      if (val2.trim()) {
+        out.push(flag, val2.trim());
+        continue;
+      }
+      const defVal2 = d.default?.trim() ?? "";
+      const raw2 = await prompt({
+        label,
+        isRequired: d.isRequired === true,
+        placeholder: defVal2 || ARG_PLACEHOLDER
+      });
+      if (typeof raw2 === "symbol") return { cancelled: true };
+      const trimmed2 = typeof raw2 === "string" ? raw2.trim() : "";
+      if (!trimmed2) {
+        if (d.isRequired === true) {
+          out.push(flag, defVal2 || ARG_PLACEHOLDER);
+        } else if (defVal2) {
+          out.push(flag, defVal2);
+        }
+        continue;
+      }
+      out.push(flag, trimmed2);
+      continue;
+    }
+    let val = d.value ?? "";
+    if (hasTemplates(d.value)) {
+      const res = await resolveTemplates(d.value, async (varName) => {
+        const answer = await prompt({
+          label: `${label} (${varName})`,
+          isRequired: true,
+          placeholder: `<${varName}>`
+        });
+        return answer;
+      });
+      if (res.cancelled) return { cancelled: true };
+      val = res.resolved;
+      pushPositionalSegments(out, d, val);
+      continue;
+    }
+    if (val.trim()) {
+      pushPositionalSegments(out, d, val.trim());
+      continue;
+    }
+    const defVal = d.default?.trim() ?? "";
+    if (defVal) {
+      pushPositionalSegments(out, d, defVal);
+      continue;
+    }
+    if (d.isRequired !== true) {
+      const raw2 = await prompt({
+        label,
+        isRequired: false,
+        placeholder: ARG_PLACEHOLDER
+      });
+      if (typeof raw2 === "symbol") return { cancelled: true };
+      const trimmed2 = typeof raw2 === "string" ? raw2.trim() : "";
+      if (!trimmed2) {
+        pushPositionalSegments(out, d, ARG_PLACEHOLDER);
+      } else {
+        pushPositionalSegments(out, d, trimmed2);
+      }
+      continue;
+    }
+    const raw = await prompt({
+      label,
+      isRequired: true,
+      placeholder: ARG_PLACEHOLDER
+    });
+    if (typeof raw === "symbol") return { cancelled: true };
+    const trimmed = typeof raw === "string" ? raw.trim() : "";
+    pushPositionalSegments(
+      out,
+      d,
+      trimmed.length > 0 ? trimmed : ARG_PLACEHOLDER
+    );
+  }
+  return { argv: out, cancelled: false };
+}
+
+// src/find.ts
 function buildPlaceholderValue(kind) {
   return kind === "header" ? "<your-header-value-here>" : "<your-variable-value-here>";
 }
@@ -1009,9 +1237,6 @@ function pickRemote(entry, preferredTransport) {
   return preferred ?? remotes[0] ?? null;
 }
 function formatPackageTarget(pkg) {
-  if (pkg.version) {
-    return `${pkg.identifier}@${pkg.version}`;
-  }
   return pkg.identifier;
 }
 function transportLabel(entry) {
@@ -1064,6 +1289,15 @@ function headerFields(headers) {
     placeholder: buildPlaceholderValue("header")
   }));
 }
+function packageVariableFields(variables) {
+  if (!variables) return [];
+  return variables.filter((variable) => variable.name && variable.name.trim().length > 0).map((variable) => ({
+    key: variable.name,
+    label: `Environment variable ${variable.name}`,
+    isRequired: variable.isRequired === true,
+    placeholder: buildPlaceholderValue("variable")
+  }));
+}
 function resolveNonInteractiveRemote(remote) {
   const variableValues = {};
   for (const [key, def] of Object.entries(remote.variables ?? {})) {
@@ -1098,6 +1332,55 @@ async function resolveInteractiveRemote(remote) {
     headers: Object.keys(headerResult.values).length > 0 ? headerResult.values : void 0
   };
 }
+function resolveNonInteractivePackage(pkg) {
+  const env = {};
+  for (const field of packageVariableFields(pkg.environmentVariables)) {
+    if (field.isRequired) {
+      env[field.key] = field.placeholder;
+    }
+  }
+  const headers = {};
+  for (const field of headerFields(pkg.headers)) {
+    if (field.isRequired) {
+      headers[field.key] = field.placeholder;
+    }
+  }
+  const argv = buildPackageArgumentsArgvNonInteractive(
+    definitionsFromPackage(pkg),
+    buildPlaceholderValue("variable")
+  );
+  return {
+    env: Object.keys(env).length > 0 ? env : void 0,
+    headers: Object.keys(headers).length > 0 ? headers : void 0,
+    args: argv.length > 0 ? argv : void 0
+  };
+}
+async function resolveInteractivePackage(pkg) {
+  const promptPackageArg = async (info) => p2.text({
+    message: `${info.label} ${info.isRequired ? "(required)" : "(optional)"}`,
+    placeholder: info.placeholder
+  });
+  const envResult = await collectPromptValues(
+    packageVariableFields(pkg.environmentVariables),
+    promptValue
+  );
+  if (envResult.cancelled) return null;
+  const headerResult = await collectPromptValues(
+    headerFields(pkg.headers),
+    promptValue
+  );
+  if (headerResult.cancelled) return null;
+  const argvResult = await buildPackageArgumentsArgvInteractive(
+    definitionsFromPackage(pkg),
+    promptPackageArg
+  );
+  if (argvResult.cancelled) return null;
+  return {
+    env: Object.keys(envResult.values).length > 0 ? envResult.values : void 0,
+    headers: Object.keys(headerResult.values).length > 0 ? headerResult.values : void 0,
+    args: argvResult.argv.length > 0 ? argvResult.argv : void 0
+  };
+}
 async function buildInstallPlanForEntry(entry, options) {
   const remote = pickRemote(entry, options.preferredTransport);
   const pkg = entry.package ?? null;
@@ -1130,9 +1413,14 @@ async function buildInstallPlanForEntry(entry, options) {
     mode = hasRemote ? "remote" : "package";
   }
   if (mode === "package" && pkg) {
+    const resolved2 = options.yes ? resolveNonInteractivePackage(pkg) : await resolveInteractivePackage(pkg);
+    if (!resolved2) return null;
     return {
       target: formatPackageTarget(pkg),
-      serverName: resolveServerName(entry)
+      serverName: resolveServerName(entry),
+      env: resolved2.env,
+      headers: resolved2.headers,
+      args: resolved2.args
     };
   }
   if (!remote) return null;
@@ -1306,13 +1594,13 @@ function getNestedValue(obj, path) {
 }
 
 // src/formats/json.ts
-function detectIndent(text2) {
+function detectIndent(text3) {
   let result = null;
-  jsonc.visit(text2, {
+  jsonc.visit(text3, {
     onObjectProperty: (_property, offset, _length, startLine, startCharacter) => {
       if (result === null && startLine > 0 && startCharacter > 0) {
-        const lineStart = text2.lastIndexOf("\n", offset - 1) + 1;
-        const whitespace = text2.slice(lineStart, offset);
+        const lineStart = text3.lastIndexOf("\n", offset - 1) + 1;
+        const whitespace = text3.slice(lineStart, offset);
         result = {
           tabSize: startCharacter,
           insertSpaces: !whitespace.includes("	")
@@ -1322,6 +1610,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 +1645,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 +1696,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 +1750,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 +1785,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":
@@ -1458,7 +1850,7 @@ function buildServerConfig(parsed, options = {}) {
   if (parsed.type === "command") {
     const parts = parsed.value.split(" ");
     const command = parts[0];
-    const args = parts.slice(1);
+    const args = [...parts.slice(1), ...options.args ?? []];
     const config2 = {
       command,
       args
@@ -1470,7 +1862,7 @@ function buildServerConfig(parsed, options = {}) {
   }
   const config = {
     command: "npx",
-    args: ["-y", parsed.value]
+    args: ["-y", parsed.value, ...options.args ?? []]
   };
   if (options.env && Object.keys(options.env).length > 0) {
     config.env = options.env;
@@ -1574,10 +1966,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.9.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,12 +2101,13 @@ 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/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",
     "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",
     typecheck: "tsc --noEmit",
+    fallow: "fallow",
     prepublishOnly: "npm run build"
   },
   keywords: [
@@ -1622,11 +2131,11 @@ var package_default = {
   ],
   repository: {
     type: "git",
-    url: "git+https://github.com/neondatabase/add-mcp.git"
+    url: "git+https://github.com/neon-solutions/add-mcp.git"
   },
-  homepage: "https://github.com/neondatabase/add-mcp#readme",
+  homepage: "https://github.com/neon-solutions/add-mcp#readme",
   bugs: {
-    url: "https://github.com/neondatabase/add-mcp/issues"
+    url: "https://github.com/neon-solutions/add-mcp/issues"
   },
   dependencies: {
     "@clack/prompts": "^0.9.1",
@@ -1639,6 +2148,7 @@ var package_default = {
   devDependencies: {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.10.0",
+    fallow: "^2.61.0",
     prettier: "^3.8.1",
     tsup: "^8.3.5",
     tsx: "^4.19.2",
@@ -1734,7 +2244,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++) {
@@ -1756,6 +2266,27 @@ function extractFindOptionsFromArgv() {
       result.gitignore = true;
       continue;
     }
+    if (arg === "--header" && argv[i + 1]) {
+      const headers = result.header ? [...result.header] : [];
+      headers.push(argv[i + 1]);
+      result.header = headers;
+      i += 1;
+      continue;
+    }
+    if (arg === "--env" && argv[i + 1]) {
+      const env = result.env ? [...result.env] : [];
+      env.push(argv[i + 1]);
+      result.env = env;
+      i += 1;
+      continue;
+    }
+    if (arg === "--args" && argv[i + 1]) {
+      const args = result.args ? [...result.args] : [];
+      args.push(argv[i + 1]);
+      result.args = args;
+      i += 1;
+      continue;
+    }
     if ((arg === "-n" || arg === "--name") && argv[i + 1]) {
       result.name = argv[i + 1];
       i += 1;
@@ -1838,6 +2369,13 @@ function parseEnv(values) {
   }
   return { env, invalid };
 }
+function omitEmptyStringValues(record) {
+  return Object.fromEntries(
+    Object.entries(record).filter(
+      ([, v]) => typeof v === "string" && v.trim().length > 0
+    )
+  );
+}
 program.name("add-mcp").description(
   "Install MCP servers for coding agents (Claude Code, Cursor, VS Code, OpenCode, Codex, and more \u2014 run list-agents for the full list)"
 ).version(version).argument("[target]", "MCP server URL (remote) or package name (local stdio)").option(
@@ -1851,12 +2389,17 @@ program.name("add-mcp").description(
   "Transport type for remote servers (http, sse)"
 ).option("--type <type>", "Alias for --transport").option(
   "--header <header>",
-  "HTTP header for remote servers (repeatable, 'Key: Value')",
+  "HTTP header for remote servers (repeatable, 'Key: Value'). Placeholders ${VAR} prompt interactively when not using --yes.",
   collect,
   []
 ).option(
   "--env <env>",
-  "Environment variable for local stdio servers (repeatable, 'KEY=VALUE')",
+  "Environment variable for local stdio servers (repeatable, 'KEY=VALUE'). Placeholders ${VAR} prompt interactively when not using --yes.",
+  collect,
+  []
+).option(
+  "--args <arg>",
+  "Argument for local stdio servers (repeatable). Placeholders ${VAR} prompt interactively when not using --yes.",
   collect,
   []
 ).option("-y, --yes", "Skip confirmation prompts").option("--all", "Install to all agents").option("--gitignore", "Add generated project config files to .gitignore").action(async (target, options) => {
@@ -1868,7 +2411,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);
@@ -1891,7 +2434,9 @@ async function runFindCommand(keyword, rawOptions) {
     transport: installPlan.transport,
     header: installPlan.headers ? Object.entries(installPlan.headers).map(
       ([key, value]) => `${key}: ${value}`
-    ) : options.header
+    ) : options.header,
+    env: installPlan.env ? Object.entries(installPlan.env).map(([key, value]) => `${key}=${value}`) : options.env,
+    args: installPlan.args ?? options.args
   };
   await main(installPlan.target, mergedOptions);
 }
@@ -1919,7 +2464,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();
@@ -2031,6 +3006,55 @@ async function main(target, options) {
       "--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(
+      "--args is only used for local/package/command installs, ignoring"
+    );
+  }
+  const promptTemplateVar = (varName) => p3.text({
+    message: `Enter value for ${varName}`,
+    placeholder: `<${varName}>`
+  });
+  let resolvedArgs = [...argsValues];
+  if (!options.yes && hasHeaderValues && hasTemplateVars(headerResult.headers)) {
+    const result = await resolveRecordTemplates(
+      headerResult.headers,
+      promptTemplateVar
+    );
+    if (result.cancelled) {
+      p3.cancel("Cancelled");
+      process.exit(0);
+    }
+    for (const [key, value] of Object.entries(result.resolved)) {
+      headerResult.headers[key] = value;
+    }
+  }
+  if (!options.yes && hasEnvValues && hasTemplateVars(envResult.env)) {
+    const result = await resolveRecordTemplates(
+      envResult.env,
+      promptTemplateVar
+    );
+    if (result.cancelled) {
+      p3.cancel("Cancelled");
+      process.exit(0);
+    }
+    for (const [key, value] of Object.entries(result.resolved)) {
+      envResult.env[key] = value;
+    }
+  }
+  if (!options.yes && hasArgsValues && hasTemplateVars(resolvedArgs)) {
+    const result = await resolveArrayTemplates(resolvedArgs, promptTemplateVar);
+    if (result.cancelled) {
+      p3.cancel("Cancelled");
+      process.exit(0);
+    }
+    resolvedArgs = result.resolved;
+  }
+  const headersForConfig = isRemote && hasHeaderValues ? omitEmptyStringValues(headerResult.headers) : void 0;
+  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)}`);
   const transportValue = options.transport || options.type;
@@ -2050,8 +3074,9 @@ async function main(target, options) {
   }
   const serverConfig = buildServerConfig(parsed, {
     transport: resolvedTransport,
-    headers: isRemote && hasHeaderValues ? headerResult.headers : void 0,
-    env: !isRemote && hasEnvValues ? envResult.env : void 0
+    headers: headersForConfig && Object.keys(headersForConfig).length > 0 ? headersForConfig : void 0,
+    env: envForConfig && Object.keys(envForConfig).length > 0 ? envForConfig : void 0,
+    args: argsForConfig && argsForConfig.length > 0 ? argsForConfig : void 0
   });
   let targetAgents;
   const allAgentTypes = getAgentTypes();