@wuyax/mcps 0.1.0-beta.2 → 0.1.0

package/dist/index.cjs

@@ -32,73 +32,47 @@ var src_exports = {};
 __export(src_exports, {
   AgentConfigStore: () => AgentConfigStore,
   DEFAULT_REMOTE_TRANSPORT: () => DEFAULT_REMOTE_TRANSPORT,
-  NPX_COMMAND: () => NPX_COMMAND,
-  NPX_DASH_Y: () => NPX_DASH_Y,
-  add: () => installMcpServer,
+  SECRET_HEADER_PATTERN: () => SECRET_HEADER_PATTERN,
+  SECRET_KEY_PATTERN: () => SECRET_KEY_PATTERN,
   agentConfigStore: () => agentConfigStore,
+  applyServerConfigDelta: () => applyServerConfigDelta,
   buildMcpServerConfig: () => buildMcpServerConfig,
   createAgentTransform: () => createAgentTransform,
   detectGloballyInstalledMcpAgents: () => detectGloballyInstalledMcpAgents,
   detectProjectInstalledMcpAgents: () => detectProjectInstalledMcpAgents,
-  displayServerDetails: () => displayServerDetails,
+  detectUpdateTransition: () => detectUpdateTransition,
   extractPackageName: () => extractPackageName,
-  formatArgsString: () => formatArgsString,
-  formatEnvText: () => formatEnvText,
-  formatHeadersText: () => formatHeadersText,
+  getCandidateAgentsForScope: () => getCandidateAgentsForScope,
+  getCoHostedAgents: () => getCoHostedAgents,
   getMcpAgentConfig: () => getMcpAgentConfig,
   getMcpAgentTypes: () => getMcpAgentTypes,
   getMcpAgentsSupportingProjectScope: () => getMcpAgentsSupportingProjectScope,
-  groupInstalledServersByName: () => groupInstalledServersByName,
-  install: () => installMcpServer,
   installMcpServer: () => installMcpServer,
   installMcpServerForAgent: () => installMcpServerForAgent,
   installMcpServerForAgents: () => installMcpServerForAgents,
+  installToCompatibleAgents: () => installToCompatibleAgents,
   isMcpAgentType: () => isMcpAgentType,
   isMcpTransportSupported: () => isMcpTransportSupported,
   isRemoteMcpSource: () => isRemoteMcpSource,
   isRemoteServerConfig: () => isRemoteServerConfig,
   isStdioServerConfig: () => isStdioServerConfig,
-  list: () => listInstalledMcpServers,
   listInstalledMcpServers: () => listInstalledMcpServers,
-  listServersInConfigFile: () => listServersInConfigFile,
-  mainMenu: () => mainMenu,
   maskSecretHeader: () => maskSecretHeader,
   maskSecretValue: () => maskSecretValue,
-  mcpAgentAliases: () => mcpAgentAliases,
-  mcpAgents: () => mcpAgents,
-  mcpManageCommand: () => mcpManageCommand,
-  normalizeServerConfig: () => normalizeServerConfig,
-  parseArgsString: () => parseArgsString,
-  parseEnvText: () => parseEnvText,
-  parseHeadersText: () => parseHeadersText,
   parseMcpSource: () => parseMcpSource,
   parseServerConfig: () => parseServerConfig,
-  parseSource: () => parseMcpSource,
-  promptArgsConfig: () => promptArgsConfig,
-  promptEditArgs: () => promptEditArgs,
-  promptEditEnvConfig: () => promptEditEnvConfig,
-  promptEditHeadersConfig: () => promptEditHeadersConfig,
-  promptEditKeyValueConfig: () => promptEditKeyValueConfig,
-  promptEnvConfig: () => promptEnvConfig,
-  promptHeadersConfig: () => promptHeadersConfig,
-  promptScope: () => promptScope,
-  promptScopeAndAgents: () => promptScopeAndAgents,
-  readConfigFile: () => readConfigFile,
-  remove: () => removeMcpServer,
+  queryGroupedInstalledServers: () => queryGroupedInstalledServers,
   removeMcpServer: () => removeMcpServer,
-  removeMcpServerFromAgent: () => removeMcpServerFromAgent,
-  removeServerFromConfigFile: () => removeServerFromConfigFile,
+  resolveConfigClusters: () => resolveConfigClusters,
   resolveMcpAgentAlias: () => resolveMcpAgentAlias,
   resolveMcpConfigTarget: () => resolveMcpConfigTarget,
   resolveTargetAgents: () => resolveTargetAgents,
-  transformServerConfig: () => transformServerConfig,
+  sanitizeUpdatedServerConfig: () => sanitizeUpdatedServerConfig,
+  sortAgentsByClusters: () => sortAgentsByClusters,
+  toRemoteServerConfig: () => toRemoteServerConfig,
+  toStdioServerConfig: () => toStdioServerConfig,
   transformServerConfigForAgent: () => transformServerConfigForAgent,
-  updateMcpServerForAgent: () => installMcpServerForAgent,
-  updateMcpServerForAgents: () => installMcpServerForAgents,
-  wizardAdd: () => wizardAdd,
-  wizardManage: () => wizardManage,
-  wizardRemove: () => wizardRemove,
-  writeServerToConfigFile: () => writeServerToConfigFile
+  updateMcpServer: () => updateMcpServer
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -556,9 +530,9 @@ var mcpAgentAliases = {
 var getMcpAgentConfig = (agentType) => mcpAgents[agentType];
 var getMcpAgentTypes = () => Object.values(mcpAgents).map((config) => config.name);
 var isMcpAgentType = (value) => value in mcpAgents;
-var resolveMcpAgentAlias = (input7) => {
-  if (isMcpAgentType(input7)) return input7;
-  return mcpAgentAliases[input7] ?? null;
+var resolveMcpAgentAlias = (input) => {
+  if (isMcpAgentType(input)) return input;
+  return mcpAgentAliases[input] ?? null;
 };
 var isMcpTransportSupported = (agent, transport) => agent.supportedTransports.includes(transport);
 var detectProjectInstalledMcpAgents = (cwd) => getMcpAgentTypes().filter(
@@ -610,7 +584,9 @@ var KNOWN_COMMAND_RUNNERS = /* @__PURE__ */ new Set([
 ]);
 var SCRIPT_EXTENSION_REGEX = /\.(?:js|ts|mjs|cjs|py|sh|rb|go)$/i;
 
-// src/build-server-config.ts
+// src/server-config.ts
+var isRemoteServerConfig = (config) => typeof config.url === "string" && config.url.length > 0;
+var isStdioServerConfig = (config) => typeof config.command === "string" && config.command.length > 0;
 var buildMcpServerConfig = (parsed, options = {}) => {
   if (parsed.type === "remote") {
     const config2 = {
@@ -648,10 +624,6 @@ var buildMcpServerConfig = (parsed, options = {}) => {
   }
   return config;
 };
-
-// src/parse-server-config.ts
-var isRemoteServerConfig = (config) => typeof config.url === "string" && config.url.length > 0;
-var isStdioServerConfig = (config) => typeof config.command === "string" && config.command.length > 0;
 var parseServerConfig = (raw) => {
   if (!raw || typeof raw !== "object") return {};
   const data = raw;
@@ -678,6 +650,237 @@ var parseServerConfig = (raw) => {
   }
   return {};
 };
+var toRemoteServerConfig = (config, defaultTransport = "http") => {
+  const {
+    command: _droppedCommand,
+    args: _droppedArgs,
+    env: _droppedEnv,
+    ...remoteConfig
+  } = config;
+  return {
+    ...remoteConfig,
+    type: remoteConfig.type ?? defaultTransport
+  };
+};
+var toStdioServerConfig = (config) => {
+  const {
+    url: _droppedUrl,
+    type: _droppedType,
+    headers: _droppedHeaders,
+    ...stdioConfig
+  } = config;
+  return stdioConfig;
+};
+var detectUpdateTransition = (incoming, previous) => {
+  if (!previous) {
+    return incoming.url ? "switch-to-remote" : "switch-to-stdio";
+  }
+  const previousIsRemote = Boolean(previous.url && previous.url.length > 0);
+  if (previousIsRemote) {
+    if (incoming.command && !incoming.url) {
+      return "switch-to-stdio";
+    }
+    return "merge-remote";
+  }
+  if (incoming.url && !incoming.command) {
+    return "switch-to-remote";
+  }
+  return "merge-stdio";
+};
+var sanitizeUpdatedServerConfig = (incoming, previous) => {
+  const transition = detectUpdateTransition(incoming, previous);
+  const targetTransport = incoming.type ?? previous?.type ?? "http";
+  switch (transition) {
+    case "switch-to-remote": {
+      const cleanBase = previous ? toRemoteServerConfig(previous, targetTransport) : {};
+      return toRemoteServerConfig({ ...cleanBase, ...incoming }, targetTransport);
+    }
+    case "switch-to-stdio": {
+      const cleanBase = previous ? toStdioServerConfig(previous) : {};
+      return toStdioServerConfig({ ...cleanBase, ...incoming });
+    }
+    case "merge-remote": {
+      return toRemoteServerConfig({ ...previous, ...incoming }, targetTransport);
+    }
+    case "merge-stdio":
+    default: {
+      return toStdioServerConfig({ ...previous, ...incoming });
+    }
+  }
+};
+var applyServerConfigDelta = (previousConfig, options) => {
+  if (options.url !== void 0 && options.command !== void 0) {
+    throw new Error('Cannot specify both "--url" (remote) and "--command" (stdio) simultaneously.');
+  }
+  const isCurrentRemote = Boolean(previousConfig?.url && previousConfig.url.length > 0);
+  const willBeRemote = options.url !== void 0 ? true : options.command !== void 0 ? false : isCurrentRemote;
+  const protocol = willBeRemote ? "remote" : "stdio";
+  const ignoredFlags = [];
+  if (willBeRemote) {
+    if (options.env !== void 0) ignoredFlags.push("--env");
+    if (options.clearEnv) ignoredFlags.push("--clear-env");
+    if (options.args !== void 0) ignoredFlags.push("--args");
+    if (options.clearArgs) ignoredFlags.push("--clear-args");
+  } else {
+    if (options.headers !== void 0) ignoredFlags.push("--header");
+    if (options.clearHeaders) ignoredFlags.push("--clear-headers");
+    if (options.transport !== void 0) ignoredFlags.push("--transport");
+  }
+  const incomingDelta = {};
+  if (options.command !== void 0) {
+    incomingDelta.command = options.command;
+  }
+  if (options.clearArgs) {
+    incomingDelta.args = void 0;
+  }
+  if (options.args !== void 0) {
+    incomingDelta.args = options.args;
+  }
+  if (options.url !== void 0) {
+    incomingDelta.url = options.url;
+  }
+  if (options.transport !== void 0) {
+    incomingDelta.type = options.transport;
+  }
+  if (options.clearEnv) {
+    incomingDelta.env = void 0;
+  }
+  if (options.env !== void 0) {
+    const baseEnv = options.clearEnv ? {} : previousConfig?.env ?? {};
+    incomingDelta.env = { ...baseEnv, ...options.env };
+  }
+  if (options.clearHeaders) {
+    incomingDelta.headers = void 0;
+  }
+  if (options.headers !== void 0) {
+    const baseHeaders = options.clearHeaders ? {} : previousConfig?.headers ?? {};
+    incomingDelta.headers = { ...baseHeaders, ...options.headers };
+  }
+  const transition = detectUpdateTransition(incomingDelta, previousConfig);
+  const cleanConfig = sanitizeUpdatedServerConfig(incomingDelta, previousConfig);
+  return {
+    config: cleanConfig,
+    transition,
+    protocol,
+    ignoredFlags
+  };
+};
+
+// src/source-parser.ts
+var REMOTE_URL_REGEX = /^https?:\/\//i;
+var HAS_WHITESPACE_REGEX = /\s/;
+var PACKAGE_NAME_REGEX = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*(?:@[^\s]+)?$/;
+var PATH_SEPARATOR_REGEX = /[/\\]/;
+var stripVersionSuffix = (input) => {
+  if (input.startsWith("@")) {
+    const secondAtIndex = input.indexOf("@", 1);
+    if (secondAtIndex > 0) return input.slice(0, secondAtIndex);
+    return input;
+  }
+  const atIndex = input.lastIndexOf("@");
+  if (atIndex > 0) return input.slice(0, atIndex);
+  return input;
+};
+var stripScopePrefix = (input) => {
+  if (!input.startsWith("@") || !input.includes("/")) return input;
+  const parts = input.split("/");
+  return parts[1] || input;
+};
+var stripPathPrefix = (input) => {
+  if (!PATH_SEPARATOR_REGEX.test(input)) return input;
+  const segments = input.split(PATH_SEPARATOR_REGEX);
+  const basename = segments[segments.length - 1];
+  return basename || input;
+};
+var extractPackageName = (input) => {
+  let name = stripVersionSuffix(input);
+  name = stripScopePrefix(name);
+  name = stripPathPrefix(name);
+  name = name.replace(SCRIPT_EXTENSION_REGEX, "");
+  for (const prefix of PACKAGE_NAME_PREFIX_STRIP) {
+    if (name.startsWith(prefix)) {
+      name = name.slice(prefix.length);
+      break;
+    }
+  }
+  for (const suffix of PACKAGE_NAME_SUFFIX_STRIP) {
+    if (name.endsWith(suffix)) {
+      name = name.slice(0, -suffix.length);
+      break;
+    }
+  }
+  return name || MCP_DEFAULT_SERVER_NAME;
+};
+var inferNameFromUrl = (input) => {
+  try {
+    const url = new URL(input);
+    const host = url.hostname;
+    const labels = host.split(".").filter((segment) => segment.length > 0);
+    if (labels.length === 0) return MCP_DEFAULT_SERVER_NAME;
+    const meaningfulLabels = labels.filter((label) => {
+      const lower = label.toLowerCase();
+      if (COMMON_TLD_LABELS.has(lower)) return false;
+      if (GENERIC_HOST_PREFIXES.has(lower)) return false;
+      return true;
+    });
+    if (meaningfulLabels.length > 0) return meaningfulLabels[0];
+    if (labels.length >= 2) return labels[labels.length - 2];
+    return labels[labels.length - 1] || MCP_DEFAULT_SERVER_NAME;
+  } catch {
+    return MCP_DEFAULT_SERVER_NAME;
+  }
+};
+var inferNameFromCommand = (command) => {
+  const tokens = command.trim().split(/\s+/);
+  const runnerBase = tokens[0]?.split(PATH_SEPARATOR_REGEX).pop() ?? "";
+  const startIndex = KNOWN_COMMAND_RUNNERS.has(runnerBase) ? 1 : 0;
+  for (let tokenIndex = startIndex; tokenIndex < tokens.length; tokenIndex += 1) {
+    const token = tokens[tokenIndex];
+    if (!token || token.startsWith("-")) continue;
+    return extractPackageName(token);
+  }
+  const firstNonFlag = tokens.find((token) => !token.startsWith("-"));
+  return firstNonFlag ? extractPackageName(firstNonFlag) : MCP_DEFAULT_SERVER_NAME;
+};
+var parseMcpSource = (input) => {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) {
+    throw new Error(
+      "Invalid MCP source: input is empty. Expected a remote URL, an npm package, or a command line."
+    );
+  }
+  if (REMOTE_URL_REGEX.test(trimmed)) {
+    return {
+      type: "remote",
+      value: trimmed,
+      inferredName: inferNameFromUrl(trimmed)
+    };
+  }
+  if (HAS_WHITESPACE_REGEX.test(trimmed)) {
+    return {
+      type: "command",
+      value: trimmed,
+      inferredName: inferNameFromCommand(trimmed)
+    };
+  }
+  if (PACKAGE_NAME_REGEX.test(trimmed)) {
+    return {
+      type: "package",
+      value: trimmed,
+      inferredName: extractPackageName(trimmed)
+    };
+  }
+  return {
+    type: "command",
+    value: trimmed,
+    inferredName: inferNameFromCommand(trimmed)
+  };
+};
+var isRemoteMcpSource = (parsed) => parsed.type === "remote";
+
+// src/config-store.ts
+var import_node_fs6 = require("fs");
+var import_node_path3 = require("path");
 
 // src/utils/is-plain-object.ts
 var isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
@@ -962,113 +1165,6 @@ var listServersInConfigFile = (filePath, format, dottedKey) => {
   return isPlainObject(entries) ? entries : {};
 };
 
-// src/config-store.ts
-var import_node_fs6 = require("fs");
-
-// src/resolve-config-target.ts
-var import_node_path3 = require("path");
-var resolveMcpConfigTarget = (agent, options = {}) => {
-  const isGlobal = options.global ?? false;
-  const cwd = options.cwd ?? process.cwd();
-  const configPath = agent.resolveConfigPath ? agent.resolveConfigPath({ global: isGlobal, cwd }) : !isGlobal && agent.projectConfigPath ? (0, import_node_path3.join)(cwd, agent.projectConfigPath) : agent.globalConfigPath;
-  const configKey = !isGlobal && agent.projectConfigKey ? agent.projectConfigKey : agent.configKey;
-  return { configPath, configKey };
-};
-
-// src/config-store.ts
-var FsConfigStoreAdapter = class {
-  exists(filePath) {
-    return (0, import_node_fs6.existsSync)(filePath);
-  }
-  read(target) {
-    return readConfigFile(target.filePath, target.format);
-  }
-  writeServer(target, serverName, serverConfig) {
-    if (!target.dottedKey) {
-      throw new Error(`Cannot write server: missing dottedKey for ${target.filePath}`);
-    }
-    writeServerToConfigFile(
-      target.filePath,
-      target.format,
-      target.dottedKey,
-      serverName,
-      serverConfig
-    );
-  }
-  removeServer(target, serverName) {
-    if (!target.dottedKey) return false;
-    return removeServerFromConfigFile(
-      target.filePath,
-      target.format,
-      target.dottedKey,
-      serverName
-    );
-  }
-  listServers(target) {
-    if (!target.dottedKey) return {};
-    return listServersInConfigFile(target.filePath, target.format, target.dottedKey);
-  }
-};
-var AgentConfigStore = class {
-  constructor(adapter = new FsConfigStoreAdapter()) {
-    this.adapter = adapter;
-  }
-  adapter;
-  getAdapter() {
-    return this.adapter;
-  }
-  resolveTarget(agent, options = {}) {
-    const agentConfig = typeof agent === "string" ? getMcpAgentConfig(agent) : agent;
-    const target = resolveMcpConfigTarget(agentConfig, options);
-    return { agent: agentConfig, target };
-  }
-  resolveDescriptor(agent, options = {}) {
-    const { agent: agentConfig, target } = this.resolveTarget(agent, options);
-    return {
-      filePath: target.configPath,
-      format: agentConfig.format,
-      dottedKey: target.configKey
-    };
-  }
-  writeServer(agent, serverName, serverConfig, options = {}) {
-    const descriptor = this.resolveDescriptor(agent, options);
-    this.adapter.writeServer(descriptor, serverName, serverConfig);
-    return { path: descriptor.filePath };
-  }
-  removeServer(agent, serverName, options = {}) {
-    const descriptor = this.resolveDescriptor(agent, options);
-    if (!this.adapter.exists(descriptor.filePath)) {
-      return { path: descriptor.filePath, removed: false };
-    }
-    const removed = this.adapter.removeServer(descriptor, serverName);
-    return { path: descriptor.filePath, removed };
-  }
-  listServers(agent, options = {}) {
-    const descriptor = this.resolveDescriptor(agent, options);
-    if (!this.adapter.exists(descriptor.filePath)) {
-      return { path: descriptor.filePath, exists: false, servers: {} };
-    }
-    const servers = this.adapter.listServers(descriptor);
-    return { path: descriptor.filePath, exists: true, servers };
-  }
-  read(agent, options = {}) {
-    const descriptor = this.resolveDescriptor(agent, options);
-    if (!this.adapter.exists(descriptor.filePath)) {
-      return {};
-    }
-    return this.adapter.read(descriptor);
-  }
-  readServer(agent, serverName, options = {}) {
-    const { exists, servers } = this.listServers(agent, options);
-    if (!exists) return void 0;
-    return servers[serverName];
-  }
-};
-var agentConfigStore = new AgentConfigStore();
-
-// src/utils/to-error-message.ts
-var toErrorMessage = (error, fallback = "Unknown error") => error instanceof Error ? error.message : fallback;
-
 // src/transforms/index.ts
 var DIALECT_PRESETS = {
   vscode: {
@@ -1279,47 +1375,314 @@ var transformServerConfigForAgent = (agent, serverName, config, context = { glob
   return config;
 };
 
-// src/installer.ts
-var installMcpServerForAgent = (serverName, serverConfig, agentType, options = {}) => {
-  const agent = getMcpAgentConfig(agentType);
+// src/utils/to-error-message.ts
+var toErrorMessage = (error, fallback = "Unknown error") => error instanceof Error ? error.message : fallback;
+
+// src/config-store.ts
+var resolveMcpConfigTarget = (agent, options = {}) => {
   const isGlobal = options.global ?? false;
-  const { target } = agentConfigStore.resolveTarget(agent, options);
-  try {
-    const transformed = transformServerConfigForAgent(agent, serverName, serverConfig, {
-      global: isGlobal
-    });
-    agentConfigStore.writeServer(agent, serverName, transformed, options);
-    return { agent: agentType, success: true, path: target.configPath };
-  } catch (error) {
-    return {
-      agent: agentType,
-      success: false,
-      path: target.configPath,
-      error: toErrorMessage(error)
-    };
-  }
+  const cwd = options.cwd ?? process.cwd();
+  const configPath = agent.resolveConfigPath ? agent.resolveConfigPath({ global: isGlobal, cwd }) : !isGlobal && agent.projectConfigPath ? (0, import_node_path3.join)(cwd, agent.projectConfigPath) : agent.globalConfigPath;
+  const configKey = !isGlobal && agent.projectConfigKey ? agent.projectConfigKey : agent.configKey;
+  return { configPath, configKey };
 };
-var installMcpServerForAgents = (serverName, serverConfig, agentTypes, options = {}) => agentTypes.map(
-  (agentType) => installMcpServerForAgent(serverName, serverConfig, agentType, options)
-);
-
-// src/utils/parse-mcp-agent-list.ts
-var parseMcpAgentList = (input7) => {
-  if (!input7 || input7.length === 0) return void 0;
-  if (input7.includes("*")) return getMcpAgentTypes();
-  const resolved = [];
-  for (const value of input7) {
-    const agentType = resolveMcpAgentAlias(value);
-    if (!agentType) throw new Error(`Unknown MCP agent "${value}"`);
-    resolved.push(agentType);
-  }
-  return resolved;
+var getCandidateAgentsForScope = (options = {}) => {
+  return options.global ? getMcpAgentTypes() : getMcpAgentsSupportingProjectScope();
 };
-
-// src/resolve-target-agents.ts
-var normalizeRequestedAgents = (input7) => {
-  if (!input7 || input7.length === 0) return void 0;
-  const rawList = [...input7];
+var FsConfigStoreAdapter = class {
+  exists(filePath) {
+    return (0, import_node_fs6.existsSync)(filePath);
+  }
+  read(target) {
+    return readConfigFile(target.filePath, target.format);
+  }
+  writeServer(target, serverName, serverConfig) {
+    if (!target.dottedKey) {
+      throw new Error(`Cannot write server: missing dottedKey for ${target.filePath}`);
+    }
+    writeServerToConfigFile(
+      target.filePath,
+      target.format,
+      target.dottedKey,
+      serverName,
+      serverConfig
+    );
+  }
+  removeServer(target, serverName) {
+    if (!target.dottedKey) return false;
+    return removeServerFromConfigFile(
+      target.filePath,
+      target.format,
+      target.dottedKey,
+      serverName
+    );
+  }
+  listServers(target) {
+    if (!target.dottedKey) return {};
+    return listServersInConfigFile(target.filePath, target.format, target.dottedKey);
+  }
+};
+var AgentConfigStore = class {
+  constructor(adapter = new FsConfigStoreAdapter()) {
+    this.adapter = adapter;
+  }
+  adapter;
+  getAdapter() {
+    return this.adapter;
+  }
+  // ---- Single-agent primitives ----
+  resolveTarget(agent, options = {}) {
+    const agentConfig = typeof agent === "string" ? getMcpAgentConfig(agent) : agent;
+    const target = resolveMcpConfigTarget(agentConfig, options);
+    return { agent: agentConfig, target };
+  }
+  resolveDescriptor(agent, options = {}) {
+    const { agent: agentConfig, target } = this.resolveTarget(agent, options);
+    return {
+      filePath: target.configPath,
+      format: agentConfig.format,
+      dottedKey: target.configKey
+    };
+  }
+  writeServer(agent, serverName, serverConfig, options = {}) {
+    const descriptor = this.resolveDescriptor(agent, options);
+    this.adapter.writeServer(descriptor, serverName, serverConfig);
+    return { path: descriptor.filePath };
+  }
+  removeServer(agent, serverName, options = {}) {
+    const descriptor = this.resolveDescriptor(agent, options);
+    if (!this.adapter.exists(descriptor.filePath)) {
+      return { path: descriptor.filePath, removed: false };
+    }
+    const removed = this.adapter.removeServer(descriptor, serverName);
+    return { path: descriptor.filePath, removed };
+  }
+  listServers(agent, options = {}) {
+    const descriptor = this.resolveDescriptor(agent, options);
+    if (!this.adapter.exists(descriptor.filePath)) {
+      return { path: descriptor.filePath, exists: false, servers: {} };
+    }
+    const servers = this.adapter.listServers(descriptor);
+    return { path: descriptor.filePath, exists: true, servers };
+  }
+  /**
+   * Batch lists servers for multiple agents, caching adapter reads for co-hosted
+   * agents that share the exact same physical configuration file and dotted key.
+   */
+  listServersForAgents(agents, options = {}) {
+    const readCache = /* @__PURE__ */ new Map();
+    return agents.map((agentType) => {
+      const descriptor = this.resolveDescriptor(agentType, options);
+      const cacheKey = `${descriptor.filePath}::${descriptor.dottedKey ?? ""}`;
+      let cached = readCache.get(cacheKey);
+      if (!cached) {
+        cached = this.listServers(agentType, options);
+        readCache.set(cacheKey, cached);
+      }
+      return {
+        agent: agentType,
+        path: cached.path,
+        exists: cached.exists,
+        servers: cached.servers
+      };
+    });
+  }
+  read(agent, options = {}) {
+    const descriptor = this.resolveDescriptor(agent, options);
+    if (!this.adapter.exists(descriptor.filePath)) {
+      return {};
+    }
+    return this.adapter.read(descriptor);
+  }
+  readServer(agent, serverName, options = {}) {
+    const { exists, servers } = this.listServers(agent, options);
+    if (!exists) return void 0;
+    return servers[serverName];
+  }
+  // ---- Cluster & co-hosted awareness ----
+  /**
+   * Returns all other agents sharing the exact same physical configuration target
+   * (same configPath and configKey) for the given scope.
+   */
+  getCoHostedAgents(agentType, options = {}) {
+    const currentAgent = getMcpAgentConfig(agentType);
+    const currentTarget = resolveMcpConfigTarget(currentAgent, options);
+    const candidates = getCandidateAgentsForScope(options);
+    const coHosted = [];
+    for (const candidateType of candidates) {
+      if (candidateType === agentType) continue;
+      const candidateConfig = getMcpAgentConfig(candidateType);
+      const candidateTarget = resolveMcpConfigTarget(candidateConfig, options);
+      if (candidateTarget.configPath === currentTarget.configPath && candidateTarget.configKey === currentTarget.configKey) {
+        coHosted.push(candidateType);
+      }
+    }
+    return coHosted;
+  }
+  /**
+   * Resolves configuration clusters for a given list of requested agents.
+   * Groups requested agents sharing the same physical config path, and tracks
+   * any remaining co-hosted agents sharing the same target that were not in the request.
+   */
+  resolveConfigClusters(agentTypes, options = {}) {
+    const clustersByPath = /* @__PURE__ */ new Map();
+    for (const agentType of agentTypes) {
+      const agentConfig = getMcpAgentConfig(agentType);
+      const target = resolveMcpConfigTarget(agentConfig, options);
+      let keyMap = clustersByPath.get(target.configPath);
+      if (!keyMap) {
+        keyMap = /* @__PURE__ */ new Map();
+        clustersByPath.set(target.configPath, keyMap);
+      }
+      let cluster = keyMap.get(target.configKey);
+      if (!cluster) {
+        const allCoHosted = this.getCoHostedAgents(agentType, options);
+        cluster = {
+          configPath: target.configPath,
+          configKey: target.configKey,
+          targetAgents: [],
+          coHostedAgents: allCoHosted
+        };
+        keyMap.set(target.configKey, cluster);
+      }
+      if (!cluster.targetAgents.includes(agentType)) {
+        cluster.targetAgents.push(agentType);
+      }
+    }
+    const clusters = [];
+    for (const keyMap of clustersByPath.values()) {
+      for (const cluster of keyMap.values()) {
+        cluster.coHostedAgents = cluster.coHostedAgents.filter(
+          (co) => !cluster.targetAgents.includes(co)
+        );
+        clusters.push(cluster);
+      }
+    }
+    return clusters;
+  }
+  /**
+   * Sorts agent types so that agents sharing the same physical config target
+   * appear adjacent to each other in the returned array.
+   */
+  sortAgentsByClusters(agentTypes, options = {}) {
+    const clusters = this.resolveConfigClusters(agentTypes, options);
+    const sorted = [];
+    for (const cluster of clusters) {
+      for (const agent of cluster.targetAgents) {
+        if (!sorted.includes(agent)) {
+          sorted.push(agent);
+        }
+      }
+    }
+    return sorted;
+  }
+  /**
+   * Alias for sortAgentsByClusters for backward compatibility.
+   */
+  sortAgentsWithClusters(agentTypes, options = {}) {
+    return this.sortAgentsByClusters(agentTypes, options);
+  }
+  // ---- Batch operations with automatic clustering & dialect transforms ----
+  /**
+   * Batch write: transforms and writes a server config to multiple agents,
+   * with automatic cluster deduplication, dialect transform, and co-hosted awareness.
+   * Callers pass standard McpServerConfig; the Store applies per-Agent dialect transforms
+   * internally before persisting.
+   */
+  writeServers(agents, serverName, serverConfig, options = {}) {
+    const clusters = this.resolveConfigClusters(agents, options);
+    const resultsByAgent = /* @__PURE__ */ new Map();
+    const isGlobal = options.global ?? false;
+    for (const cluster of clusters) {
+      const primaryAgentType = cluster.targetAgents[0];
+      const primaryAgent = getMcpAgentConfig(primaryAgentType);
+      try {
+        const transformed = transformServerConfigForAgent(primaryAgent, serverName, serverConfig, {
+          global: isGlobal
+        });
+        const descriptor = this.resolveDescriptor(primaryAgent, options);
+        this.adapter.writeServer(descriptor, serverName, transformed);
+        for (const agentType of cluster.targetAgents) {
+          resultsByAgent.set(agentType, {
+            agent: agentType,
+            success: true,
+            path: cluster.configPath,
+            coConfiguredAgents: cluster.coHostedAgents.length > 0 ? cluster.coHostedAgents : void 0
+          });
+        }
+      } catch (error) {
+        const errorMsg = toErrorMessage(error);
+        for (const agentType of cluster.targetAgents) {
+          resultsByAgent.set(agentType, {
+            agent: agentType,
+            success: false,
+            path: cluster.configPath,
+            error: errorMsg
+          });
+        }
+      }
+    }
+    return agents.map((agentType) => resultsByAgent.get(agentType));
+  }
+  /**
+   * Batch remove: removes a server from multiple agents' configs,
+   * with automatic cluster deduplication and co-hosted awareness.
+   */
+  removeServers(agents, serverName, options = {}) {
+    const clusters = this.resolveConfigClusters(agents, options);
+    const resultsByAgent = /* @__PURE__ */ new Map();
+    for (const cluster of clusters) {
+      const primaryAgentType = cluster.targetAgents[0];
+      const primaryAgent = getMcpAgentConfig(primaryAgentType);
+      try {
+        const { removed } = this.removeServer(primaryAgent, serverName, options);
+        for (const agentType of cluster.targetAgents) {
+          resultsByAgent.set(agentType, {
+            agent: agentType,
+            path: cluster.configPath,
+            removed,
+            coAffectedAgents: removed && cluster.coHostedAgents.length > 0 ? cluster.coHostedAgents : void 0
+          });
+        }
+      } catch (error) {
+        const errorMsg = toErrorMessage(error);
+        for (const agentType of cluster.targetAgents) {
+          resultsByAgent.set(agentType, {
+            agent: agentType,
+            path: cluster.configPath,
+            removed: false,
+            error: errorMsg
+          });
+        }
+      }
+    }
+    return agents.map((agentType) => resultsByAgent.get(agentType));
+  }
+};
+var agentConfigStore = new AgentConfigStore();
+
+// src/resolve-config-clusters.ts
+var getCoHostedAgents = (agentType, options = {}) => agentConfigStore.getCoHostedAgents(agentType, options);
+var resolveConfigClusters = (agentTypes, options = {}) => agentConfigStore.resolveConfigClusters(agentTypes, options);
+var sortAgentsByClusters = (agentTypes, options = {}) => agentConfigStore.sortAgentsByClusters(agentTypes, options);
+
+// src/utils/parse-mcp-agent-list.ts
+var parseMcpAgentList = (input) => {
+  if (!input || input.length === 0) return void 0;
+  if (input.includes("*")) return getMcpAgentTypes();
+  const resolved = [];
+  for (const value of input) {
+    const agentType = resolveMcpAgentAlias(value);
+    if (!agentType) throw new Error(`Unknown MCP agent "${value}"`);
+    resolved.push(agentType);
+  }
+  return resolved;
+};
+
+// src/resolve-target-agents.ts
+var normalizeRequestedAgents = (input) => {
+  if (!input || input.length === 0) return void 0;
+  const rawList = [...input];
   if (rawList.every((item) => isMcpAgentType(item))) {
     return rawList;
   }
@@ -1374,117 +1737,41 @@ var resolveTargetAgents = (query = {}) => {
   };
 };
 
-// src/source-parser.ts
-var REMOTE_URL_REGEX = /^https?:\/\//i;
-var HAS_WHITESPACE_REGEX = /\s/;
-var PACKAGE_NAME_REGEX = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*(?:@[^\s]+)?$/;
-var PATH_SEPARATOR_REGEX = /[/\\]/;
-var stripVersionSuffix = (input7) => {
-  if (input7.startsWith("@")) {
-    const secondAtIndex = input7.indexOf("@", 1);
-    if (secondAtIndex > 0) return input7.slice(0, secondAtIndex);
-    return input7;
-  }
-  const atIndex = input7.lastIndexOf("@");
-  if (atIndex > 0) return input7.slice(0, atIndex);
-  return input7;
-};
-var stripScopePrefix = (input7) => {
-  if (!input7.startsWith("@") || !input7.includes("/")) return input7;
-  const parts = input7.split("/");
-  return parts[1] || input7;
-};
-var stripPathPrefix = (input7) => {
-  if (!PATH_SEPARATOR_REGEX.test(input7)) return input7;
-  const segments = input7.split(PATH_SEPARATOR_REGEX);
-  const basename = segments[segments.length - 1];
-  return basename || input7;
+// src/install-compat.ts
+var installMcpServerForAgent = (serverName, serverConfig, agentType, options = {}) => {
+  const results = agentConfigStore.writeServers([agentType], serverName, serverConfig, options);
+  return results[0];
 };
-var extractPackageName = (input7) => {
-  let name = stripVersionSuffix(input7);
-  name = stripScopePrefix(name);
-  name = stripPathPrefix(name);
-  name = name.replace(SCRIPT_EXTENSION_REGEX, "");
-  for (const prefix of PACKAGE_NAME_PREFIX_STRIP) {
-    if (name.startsWith(prefix)) {
-      name = name.slice(prefix.length);
-      break;
+var installMcpServerForAgents = (serverName, serverConfig, agentTypes, options = {}) => {
+  return agentConfigStore.writeServers(agentTypes, serverName, serverConfig, options);
+};
+var installToCompatibleAgents = (serverName, serverConfig, options) => {
+  const { allAgents, incompatible = [], global: isGlobal, cwd } = options;
+  const incompatibleMap = new Map(incompatible.map((item) => [item.agent, item.reason]));
+  const compatibleAgents = allAgents.filter((a) => !incompatibleMap.has(a));
+  const installedResults = agentConfigStore.writeServers(
+    compatibleAgents,
+    serverName,
+    serverConfig,
+    {
+      global: isGlobal,
+      cwd
     }
-  }
-  for (const suffix of PACKAGE_NAME_SUFFIX_STRIP) {
-    if (name.endsWith(suffix)) {
-      name = name.slice(0, -suffix.length);
-      break;
+  );
+  const installedMap = new Map(installedResults.map((r) => [r.agent, r]));
+  return allAgents.map((agentType) => {
+    const incompatibleReason = incompatibleMap.get(agentType);
+    if (incompatibleReason) {
+      return {
+        agent: agentType,
+        success: false,
+        path: "",
+        error: incompatibleReason
+      };
     }
-  }
-  return name || MCP_DEFAULT_SERVER_NAME;
-};
-var inferNameFromUrl = (input7) => {
-  try {
-    const url = new URL(input7);
-    const host = url.hostname;
-    const labels = host.split(".").filter((segment) => segment.length > 0);
-    if (labels.length === 0) return MCP_DEFAULT_SERVER_NAME;
-    const meaningfulLabels = labels.filter((label) => {
-      const lower = label.toLowerCase();
-      if (COMMON_TLD_LABELS.has(lower)) return false;
-      if (GENERIC_HOST_PREFIXES.has(lower)) return false;
-      return true;
-    });
-    if (meaningfulLabels.length > 0) return meaningfulLabels[0];
-    if (labels.length >= 2) return labels[labels.length - 2];
-    return labels[labels.length - 1] || MCP_DEFAULT_SERVER_NAME;
-  } catch {
-    return MCP_DEFAULT_SERVER_NAME;
-  }
-};
-var inferNameFromCommand = (command) => {
-  const tokens = command.trim().split(/\s+/);
-  const runnerBase = tokens[0]?.split(PATH_SEPARATOR_REGEX).pop() ?? "";
-  const startIndex = KNOWN_COMMAND_RUNNERS.has(runnerBase) ? 1 : 0;
-  for (let tokenIndex = startIndex; tokenIndex < tokens.length; tokenIndex += 1) {
-    const token = tokens[tokenIndex];
-    if (!token || token.startsWith("-")) continue;
-    return extractPackageName(token);
-  }
-  const firstNonFlag = tokens.find((token) => !token.startsWith("-"));
-  return firstNonFlag ? extractPackageName(firstNonFlag) : MCP_DEFAULT_SERVER_NAME;
-};
-var parseMcpSource = (input7) => {
-  const trimmed = input7.trim();
-  if (trimmed.length === 0) {
-    throw new Error(
-      "Invalid MCP source: input is empty. Expected a remote URL, an npm package, or a command line."
-    );
-  }
-  if (REMOTE_URL_REGEX.test(trimmed)) {
-    return {
-      type: "remote",
-      value: trimmed,
-      inferredName: inferNameFromUrl(trimmed)
-    };
-  }
-  if (HAS_WHITESPACE_REGEX.test(trimmed)) {
-    return {
-      type: "command",
-      value: trimmed,
-      inferredName: inferNameFromCommand(trimmed)
-    };
-  }
-  if (PACKAGE_NAME_REGEX.test(trimmed)) {
-    return {
-      type: "package",
-      value: trimmed,
-      inferredName: extractPackageName(trimmed)
-    };
-  }
-  return {
-    type: "command",
-    value: trimmed,
-    inferredName: inferNameFromCommand(trimmed)
-  };
+    return installedMap.get(agentType);
+  });
 };
-var isRemoteMcpSource = (parsed) => parsed.type === "remote";
 
 // src/install-mcp-server.ts
 var installMcpServer = (options) => {
@@ -1505,18 +1792,11 @@ var installMcpServer = (options) => {
     cwd,
     transport: requestedTransport
   });
-  const incompatibleMap = new Map(incompatible.map((item) => [item.agent, item.reason]));
-  const results = allAgents.map((agentType) => {
-    const incompatibleReason = incompatibleMap.get(agentType);
-    if (incompatibleReason) {
-      return {
-        agent: agentType,
-        success: false,
-        path: "",
-        error: incompatibleReason
-      };
-    }
-    return installMcpServerForAgent(serverName, serverConfig, agentType, { global: isGlobal, cwd });
+  const results = installToCompatibleAgents(serverName, serverConfig, {
+    allAgents,
+    incompatible,
+    global: isGlobal,
+    cwd
   });
   return { serverName, config: serverConfig, results };
 };
@@ -1525,15 +1805,14 @@ var installMcpServer = (options) => {
 var listInstalledMcpServers = (options = {}) => {
   const agentTypes = options.agents ?? getMcpAgentTypes();
   const collected = [];
-  for (const agentType of agentTypes) {
-    const agent = getMcpAgentConfig(agentType);
-    const { path, exists, servers } = agentConfigStore.listServers(agent, options);
-    if (!exists) continue;
-    for (const [serverName, rawConfig] of Object.entries(servers)) {
+  const results = agentConfigStore.listServersForAgents(agentTypes, options);
+  for (const item of results) {
+    if (!item.exists) continue;
+    for (const [serverName, rawConfig] of Object.entries(item.servers)) {
       collected.push({
         serverName,
-        agent: agentType,
-        path,
+        agent: item.agent,
+        path: item.path,
         config: rawConfig,
         serverConfig: parseServerConfig(rawConfig)
       });
@@ -1541,828 +1820,24 @@ var listInstalledMcpServers = (options = {}) => {
   }
   return collected;
 };
-
-// src/remove.ts
-var removeMcpServerFromAgent = (serverName, agentType, options = {}) => {
-  const agent = getMcpAgentConfig(agentType);
-  const { target } = agentConfigStore.resolveTarget(agent, options);
-  try {
-    const { removed } = agentConfigStore.removeServer(agent, serverName, options);
-    return { agent: agentType, path: target.configPath, removed };
-  } catch (error) {
-    return {
-      agent: agentType,
-      path: target.configPath,
-      removed: false,
-      error: toErrorMessage(error)
-    };
-  }
-};
-var removeMcpServer = (options) => {
-  const { allAgents } = resolveTargetAgents({
-    requested: options.agents,
-    all: !options.agents,
-    global: options.global,
-    cwd: options.cwd
-  });
-  const results = [];
-  for (const agentType of allAgents) {
-    const result = removeMcpServerFromAgent(options.name, agentType, {
-      global: options.global,
-      cwd: options.cwd
-    });
-    if (result.removed || result.error) results.push(result);
-  }
-  return results;
-};
-
-// src/interactive/main-menu.ts
-var import_prompts11 = require("@inquirer/prompts");
-var import_picocolors11 = __toESM(require("picocolors"), 1);
-
-// src/interactive/wizard-add.ts
-var import_prompts8 = require("@inquirer/prompts");
-var import_picocolors8 = __toESM(require("picocolors"), 1);
-
-// src/utils/logger.ts
-var import_picocolors = __toESM(require("picocolors"), 1);
-var logger = {
-  info: (message) => {
-    console.log(import_picocolors.default.cyan("i"), message);
-  },
-  success: (message) => {
-    console.log(import_picocolors.default.green("\u221A"), message);
-  },
-  warn: (message) => {
-    console.log(import_picocolors.default.yellow("!"), message);
-  },
-  error: (message) => {
-    console.error(import_picocolors.default.red("x"), message);
-  }
-};
-
-// src/interactive/prompts/agents.ts
-var import_prompts2 = require("@inquirer/prompts");
-var import_picocolors3 = __toESM(require("picocolors"), 1);
-
-// src/interactive/prompts/scope.ts
-var import_prompts = require("@inquirer/prompts");
-var import_picocolors2 = __toESM(require("picocolors"), 1);
-var promptScope = async (options = {}) => {
-  const initialGlobal = options.defaultGlobal ?? options.global;
-  if (initialGlobal !== void 0) {
-    return initialGlobal;
-  }
-  const cwd = options.cwd ?? process.cwd();
-  return (0, import_prompts.select)({
-    message: options.message ?? "Select MCP scope:",
-    choices: [
-      {
-        name: `Current Project - ${import_picocolors2.default.dim(cwd)}`,
-        value: false
-      },
-      {
-        name: `Global User Config - ${import_picocolors2.default.dim("applies across all projects")}`,
-        value: true
-      }
-    ]
-  });
-};
-
-// src/interactive/prompts/agents.ts
-var promptScopeAndAgents = async (options = {}) => {
-  const cwd = options.cwd ?? process.cwd();
-  const isGlobal = await promptScope({
-    cwd,
-    defaultGlobal: options.defaultGlobal,
-    message: "Select MCP installation scope:"
-  });
-  const resolution = resolveTargetAgents({
-    global: isGlobal,
-    cwd
-  });
-  const detected = resolution.detected;
-  const availableAgentTypes = isGlobal ? getMcpAgentTypes() : getMcpAgentsSupportingProjectScope();
-  if (detected.length > 0) {
-    logger.info(
-      `Detected configured agents: ${import_picocolors3.default.cyan(detected.map((a) => getMcpAgentConfig(a).displayName).join(", "))}`
-    );
-  } else {
-    logger.warn(`No active ${isGlobal ? "global" : "project"} agents detected`);
-  }
-  const defaultChecked = options.defaultAgents && options.defaultAgents.length > 0 ? options.defaultAgents : detected;
-  const choices = availableAgentTypes.map((agentType) => {
-    const config = getMcpAgentConfig(agentType);
-    const isDetected = detected.includes(agentType);
-    const label = `${config.displayName} ${import_picocolors3.default.dim(`(${agentType})`)}${isDetected ? import_picocolors3.default.green(" [detected]") : ""}`;
-    return {
-      name: label,
-      value: agentType,
-      checked: defaultChecked.includes(agentType)
-    };
-  });
-  const selectedAgents = await (0, import_prompts2.checkbox)({
-    message: "Select target agents (Space to select, Enter to confirm):",
-    choices,
-    validate: (chosen) => {
-      if (chosen.length === 0) {
-        return "Please select at least one agent";
-      }
-      return true;
-    }
-  });
-  return {
-    global: isGlobal,
-    agents: selectedAgents
-  };
-};
-
-// src/interactive/prompts/args.ts
-var import_prompts3 = require("@inquirer/prompts");
-var parseArgsString = (rawText) => {
-  const matches = rawText.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g);
-  if (!matches) return [];
-  return matches.map((arg) => {
-    if (arg.startsWith('"') && arg.endsWith('"') || arg.startsWith("'") && arg.endsWith("'")) {
-      return arg.slice(1, -1);
-    }
-    return arg;
-  });
-};
-var promptArgsConfig = async (initialArgs = []) => {
-  if (initialArgs.length > 0) {
-    return initialArgs;
-  }
-  const needArgs = await (0, import_prompts3.confirm)({
-    message: "Configure command arguments (e.g. file paths, connection strings)?",
-    default: false
-  });
-  if (!needArgs) {
-    return [];
-  }
-  const raw = await (0, import_prompts3.input)({
-    message: "Enter command arguments (space-separated, wrap paths with spaces in quotes):",
-    validate: (val) => val.trim() ? true : "Arguments cannot be empty"
-  });
-  return parseArgsString(raw.trim());
-};
-var formatArgsString = (args) => {
-  return args.map((arg) => arg.includes(" ") || arg.includes('"') ? `"${arg.replace(/"/g, '\\"')}"` : arg).join(" ");
-};
-var promptEditArgs = async (currentArgs = []) => {
-  const defaultStr = formatArgsString(currentArgs);
-  const raw = await (0, import_prompts3.input)({
-    message: "Edit command arguments (space-separated, wrap paths with spaces in quotes, leave empty to clear):",
-    default: defaultStr
-  });
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return [];
-  }
-  return parseArgsString(trimmed);
-};
-
-// src/interactive/prompts/env.ts
-var import_prompts6 = require("@inquirer/prompts");
-var import_picocolors6 = __toESM(require("picocolors"), 1);
-
-// src/interactive/prompts/multiline.ts
-var import_node_readline = require("readline");
-var import_prompts4 = require("@inquirer/prompts");
-var import_picocolors4 = __toESM(require("picocolors"), 1);
-var readMultilineTextFromTerminal = async (message, endHint = "When done pasting, enter END on a new line or press Enter twice to finish") => {
-  console.log(import_picocolors4.default.cyan(`
-${message}`));
-  console.log(import_picocolors4.default.dim(`  (Hint: ${endHint})
-`));
-  return new Promise((resolve) => {
-    const rl = (0, import_node_readline.createInterface)({
-      input: process.stdin,
-      output: process.stdout
-    });
-    const lines = [];
-    let consecutiveEmpty = 0;
-    const cleanup = () => {
-      rl.removeAllListeners();
-      rl.close();
-    };
-    rl.on("line", (line) => {
-      const trimmed = line.trim();
-      if (trimmed === "END") {
-        cleanup();
-        resolve(lines.join("\n"));
-        return;
-      }
-      if (line === "") {
-        consecutiveEmpty++;
-        if (lines.length > 0) {
-          cleanup();
-          resolve(lines.join("\n"));
-          return;
-        }
-        if (consecutiveEmpty >= 2) {
-          cleanup();
-          resolve("");
-          return;
-        }
-      } else {
-        consecutiveEmpty = 0;
-        lines.push(line);
-      }
-    });
-    rl.on("close", () => {
-      resolve(lines.join("\n"));
-    });
-  });
-};
-var promptEditorText = async (options) => {
-  try {
-    return await (0, import_prompts4.editor)({
-      message: options.message,
-      default: options.defaultText ?? "",
-      postfix: options.postfix
-    });
-  } catch {
-    return readMultilineTextFromTerminal(options.message);
-  }
-};
-
-// src/interactive/prompts/kv.ts
-var import_prompts5 = require("@inquirer/prompts");
-var import_picocolors5 = __toESM(require("picocolors"), 1);
-var promptEditKeyValueConfig = async (currentItems = {}, options) => {
-  let items = { ...currentItems };
-  while (true) {
-    const keys = Object.keys(items);
-    console.log();
-    if (keys.length === 0) {
-      console.log(import_picocolors5.default.dim(`  No ${options.itemsNoun} configured.`));
-    } else {
-      console.log(import_picocolors5.default.cyan(import_picocolors5.default.bold(`  Configured ${options.title} (${keys.length}):`)));
-      for (const [k, v] of Object.entries(items)) {
-        const sep = options.separator === "=" ? "=" : ": ";
-        console.log(`    ${import_picocolors5.default.bold(k)}${sep}${import_picocolors5.default.dim(options.maskValue(k, v))}`);
-      }
-    }
-    console.log();
-    const choice = await (0, import_prompts5.select)({
-      message: `Manage ${options.itemsNoun}:`,
-      choices: [
-        {
-          name: "Open in system default editor ($EDITOR)",
-          value: "editor"
-        },
-        {
-          name: `Add or modify a ${options.itemNoun}`,
-          value: "upsert"
-        },
-        ...keys.length > 0 ? [
-          {
-            name: `Delete a ${options.itemNoun}`,
-            value: "delete"
-          }
-        ] : [],
-        {
-          name: `Paste multiline ${options.itemsNoun} into terminal`,
-          value: "paste"
-        },
-        ...keys.length > 0 ? [
-          {
-            name: `Clear all ${options.itemsNoun}`,
-            value: "clear"
-          }
-        ] : [],
-        {
-          name: `Done (finish editing ${options.itemsNoun})`,
-          value: "done"
-        }
-      ]
-    });
-    if (choice === "done") {
-      return items;
-    }
-    if (choice === "editor") {
-      const defaultText = options.formatText(items);
-      const text = await promptEditorText({
-        message: options.editorMessage,
-        postfix: options.editorPostfix,
-        defaultText
-      });
-      const parsed = options.parseText(text);
-      items = parsed;
-      logger.success(`${options.title} updated (${Object.keys(items).length} total)`);
-    } else if (choice === "upsert") {
-      const key = await (0, import_prompts5.input)({
-        message: options.keyPromptMessage,
-        validate: (val) => {
-          const trimmed = val.trim();
-          if (!trimmed) return `${options.itemNoun} name cannot be empty`;
-          if (/\s/.test(trimmed)) return `${options.itemNoun} name cannot contain spaces`;
-          return true;
-        }
-      });
-      const trimmedKey = key.trim();
-      const existingVal = items[trimmedKey];
-      const isSecret = options.isSecretKey(trimmedKey);
-      let newVal;
-      if (isSecret) {
-        newVal = await (0, import_prompts5.password)({
-          message: existingVal !== void 0 ? `New value for (${trimmedKey}) [leave empty to keep current]:` : `${options.valuePromptMessage} for (${trimmedKey}) [sensitive content masked]:`,
-          mask: "*"
-        });
-        if (existingVal !== void 0 && newVal === "") {
-          newVal = existingVal;
-        }
-      } else {
-        newVal = await (0, import_prompts5.input)({
-          message: `${options.valuePromptMessage} for (${trimmedKey}):`,
-          default: existingVal
-        });
-      }
-      items[trimmedKey] = newVal;
-      logger.success(`${existingVal !== void 0 ? "Updated" : "Added"}: ${import_picocolors5.default.cyan(trimmedKey)}`);
-    } else if (choice === "delete") {
-      const toDelete = await (0, import_prompts5.select)({
-        message: `Select ${options.itemNoun} to delete:`,
-        choices: [
-          ...keys.map((k) => ({ name: k, value: k })),
-          { name: "Cancel", value: "__cancel__" }
-        ]
-      });
-      if (toDelete !== "__cancel__") {
-        delete items[toDelete];
-        logger.success(`Deleted: ${import_picocolors5.default.cyan(toDelete)}`);
-      }
-    } else if (choice === "paste") {
-      const pasted = await readMultilineTextFromTerminal(options.pasteMessage);
-      const parsed = options.parseText(pasted);
-      const count = Object.keys(parsed).length;
-      if (count === 0) {
-        logger.warn(`No valid ${options.itemsNoun} recognized`);
-      } else {
-        if (keys.length > 0) {
-          const pasteMode = await (0, import_prompts5.select)({
-            message: `How to apply pasted ${options.itemsNoun}?`,
-            choices: [
-              { name: `Merge with existing ${options.itemsNoun}`, value: "merge" },
-              { name: `Replace all existing ${options.itemsNoun}`, value: "replace" }
-            ]
-          });
-          if (pasteMode === "replace") {
-            items = parsed;
-          } else {
-            Object.assign(items, parsed);
-          }
-        } else {
-          items = parsed;
-        }
-        logger.success(`Successfully applied ${import_picocolors5.default.cyan(String(count))} ${options.itemsNoun}`);
-      }
-    } else if (choice === "clear") {
-      const confirmClear = await (0, import_prompts5.confirm)({
-        message: `Are you sure you want to clear all ${options.itemsNoun}?`,
-        default: false
-      });
-      if (confirmClear) {
-        items = {};
-        logger.success(`Cleared all ${options.itemsNoun}`);
-      }
-    }
-  }
-};
-
-// src/interactive/prompts/env.ts
-var SECRET_KEY_PATTERN = /(token|key|secret|password|passwd|auth|credential)/i;
-var maskSecretValue = (key, value) => {
-  if (!SECRET_KEY_PATTERN.test(key) || value.length <= 4) {
-    return value;
-  }
-  return `${value.slice(0, 2)}***${value.slice(-2)}`;
-};
-var formatEnvText = (env) => {
-  return Object.entries(env).map(([key, value]) => {
-    if (/[\s"']/.test(value)) {
-      return `${key}="${value.replace(/"/g, '\\"')}"`;
-    }
-    return `${key}=${value}`;
-  }).join("\n");
-};
-var parseEnvText = (rawText) => {
-  const result = {};
-  const lines = rawText.split(/\r?\n/);
-  for (const rawLine of lines) {
-    let line = rawLine.trim();
-    if (!line || line.startsWith("#")) continue;
-    if (line.startsWith("export ")) {
-      line = line.slice(7).trim();
-    }
-    const eqIndex = line.indexOf("=");
-    if (eqIndex === -1) continue;
-    const key = line.slice(0, eqIndex).trim();
-    let value = line.slice(eqIndex + 1).trim();
-    if (!key) continue;
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
-    }
-    result[key] = value;
-  }
-  return result;
-};
-var promptEnvConfig = async (initialEnv = {}) => {
-  const env = { ...initialEnv };
-  const initialCount = Object.keys(env).length;
-  if (initialCount > 0) {
-    logger.info(`Includes ${import_picocolors6.default.cyan(String(initialCount))} preset environment variables`);
-  }
-  const mode = await (0, import_prompts6.select)({
-    message: "Configure environment variables?",
-    choices: [
-      {
-        name: "Skip / None",
-        value: "skip"
-      },
-      {
-        name: "Paste multiline .env text into terminal",
-        value: "paste"
-      },
-      {
-        name: "Open in system default editor ($EDITOR)",
-        value: "editor"
-      },
-      {
-        name: "Enter key-value pairs one by one",
-        value: "manual"
-      }
-    ]
-  });
-  if (mode === "skip") {
-    return env;
-  }
-  if (mode === "paste" || mode === "editor") {
-    const pasted = mode === "editor" ? await promptEditorText({
-      message: "Paste or edit environment variables in editor, then save and exit:",
-      postfix: ".env",
-      defaultText: formatEnvText(env)
-    }) : await readMultilineTextFromTerminal("Paste .env formatted content (multiline supported):");
-    const parsed = parseEnvText(pasted);
-    const count = Object.keys(parsed).length;
-    if (count === 0) {
-      logger.warn("No valid KEY=VALUE pairs recognized");
-    } else {
-      Object.assign(env, parsed);
-      logger.success(`Successfully parsed ${import_picocolors6.default.cyan(String(count))} environment variables:`);
-      for (const [k, v] of Object.entries(parsed)) {
-        console.log(`  ${import_picocolors6.default.bold(k)}=${import_picocolors6.default.dim(maskSecretValue(k, v))}`);
-      }
-    }
-    return env;
-  }
-  logger.info("Entering environment variables (leave key empty and press enter to finish):");
-  while (true) {
-    const key = await (0, import_prompts6.input)({
-      message: "Variable name (Key, leave empty to finish):",
-      validate: (val2) => {
-        const trimmed = val2.trim();
-        if (!trimmed) return true;
-        if (/\s/.test(trimmed)) return "Variable name cannot contain spaces";
-        return true;
-      }
-    });
-    const trimmedKey = key.trim();
-    if (!trimmedKey) break;
-    const isSecret = SECRET_KEY_PATTERN.test(trimmedKey);
-    let val;
-    if (isSecret) {
-      val = await (0, import_prompts6.password)({
-        message: `Value for (${trimmedKey}) [secret masked]:`,
-        mask: "*"
-      });
-    } else {
-      val = await (0, import_prompts6.input)({
-        message: `Value for (${trimmedKey}):`
-      });
-    }
-    env[trimmedKey] = val;
-    logger.success(`Added: ${import_picocolors6.default.cyan(trimmedKey)}`);
-  }
-  return env;
-};
-var promptEditEnvConfig = async (currentEnv = {}) => promptEditKeyValueConfig(currentEnv, {
-  title: "Environment Variables",
-  itemNoun: "variable",
-  itemsNoun: "environment variables",
-  separator: "=",
-  editorPostfix: ".env",
-  editorMessage: "Edit environment variables in editor, then save and exit:",
-  pasteMessage: "Paste .env formatted content (multiline supported):",
-  keyPromptMessage: "Variable name (Key):",
-  valuePromptMessage: "Value",
-  isSecretKey: (k) => SECRET_KEY_PATTERN.test(k),
-  maskValue: maskSecretValue,
-  formatText: formatEnvText,
-  parseText: parseEnvText
-});
-
-// src/interactive/prompts/headers.ts
-var import_prompts7 = require("@inquirer/prompts");
-var import_picocolors7 = __toESM(require("picocolors"), 1);
-var SECRET_HEADER_PATTERN = /(authorization|token|key|secret|auth)/i;
-var maskSecretHeader = (key, value) => {
-  if (!SECRET_HEADER_PATTERN.test(key) || value.length <= 8) {
-    return value;
-  }
-  return `${value.slice(0, 4)}***${value.slice(-3)}`;
-};
-var formatHeadersText = (headers) => {
-  return Object.entries(headers).map(([key, value]) => `${key}: ${value}`).join("\n");
-};
-var parseHeadersText = (rawText) => {
-  const result = {};
-  const lines = rawText.split(/\r?\n/);
-  for (const rawLine of lines) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("#")) continue;
-    const colonIndex = line.indexOf(":");
-    const equalIndex = line.indexOf("=");
-    let splitIndex = -1;
-    if (colonIndex !== -1 && equalIndex !== -1) {
-      splitIndex = Math.min(colonIndex, equalIndex);
-    } else if (colonIndex !== -1) {
-      splitIndex = colonIndex;
-    } else {
-      splitIndex = equalIndex;
-    }
-    if (splitIndex === -1) continue;
-    const key = line.slice(0, splitIndex).trim();
-    let value = line.slice(splitIndex + 1).trim();
-    if (!key) continue;
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
-    }
-    result[key] = value;
-  }
-  return result;
-};
-var promptHeadersConfig = async (initialHeaders = {}) => {
-  const headers = { ...initialHeaders };
-  const mode = await (0, import_prompts7.select)({
-    message: "Select HTTP headers configuration method:",
-    choices: [
-      {
-        name: "Paste multiline headers into terminal (Key: Value format)",
-        value: "paste"
-      },
-      {
-        name: "Open in system default editor ($EDITOR)",
-        value: "editor"
-      },
-      {
-        name: "Enter headers one by one (e.g. Authorization: Bearer ...)",
-        value: "manual"
-      },
-      {
-        name: "Skip / None",
-        value: "skip"
-      }
-    ]
-  });
-  if (mode === "skip") {
-    return headers;
-  }
-  if (mode === "paste" || mode === "editor") {
-    const pasted = mode === "editor" ? await promptEditorText({
-      message: "Paste or edit HTTP headers in editor, then save and exit:",
-      defaultText: formatHeadersText(headers)
-    }) : await readMultilineTextFromTerminal(
-      "Paste HTTP headers content (multiline supported, e.g. Authorization: Bearer ...):"
-    );
-    const parsed = parseHeadersText(pasted);
-    const count = Object.keys(parsed).length;
-    if (count === 0) {
-      logger.warn("No valid Key: Value pairs recognized");
-    } else {
-      Object.assign(headers, parsed);
-      logger.success(`Successfully parsed ${import_picocolors7.default.cyan(String(count))} headers:`);
-      for (const [k, v] of Object.entries(parsed)) {
-        console.log(`  ${import_picocolors7.default.bold(k)}: ${import_picocolors7.default.dim(maskSecretHeader(k, v))}`);
-      }
-    }
-    return headers;
-  }
-  logger.info("Entering HTTP headers (leave header name empty and press enter to finish):");
-  while (true) {
-    const name = await (0, import_prompts7.input)({
-      message: "Header name (e.g. Authorization, leave empty to finish):",
-      validate: (val2) => {
-        const trimmed = val2.trim();
-        if (!trimmed) return true;
-        if (/\s/.test(trimmed)) return "Header name cannot contain spaces";
-        return true;
-      }
-    });
-    const trimmedName = name.trim();
-    if (!trimmedName) break;
-    const isSecret = SECRET_HEADER_PATTERN.test(trimmedName);
-    let val;
-    if (isSecret) {
-      val = await (0, import_prompts7.password)({
-        message: `Header value for (${trimmedName}) [sensitive content masked]:`,
-        mask: "*"
-      });
-    } else {
-      val = await (0, import_prompts7.input)({
-        message: `Header value for (${trimmedName}):`
-      });
-    }
-    headers[trimmedName] = val;
-    logger.success(`Added: ${import_picocolors7.default.cyan(trimmedName)}`);
-  }
-  return headers;
-};
-var promptEditHeadersConfig = async (currentHeaders = {}) => promptEditKeyValueConfig(currentHeaders, {
-  title: "HTTP Headers",
-  itemNoun: "header",
-  itemsNoun: "HTTP headers",
-  separator: ":",
-  editorMessage: "Edit HTTP headers in editor, then save and exit:",
-  pasteMessage: "Paste HTTP headers content (multiline supported, e.g. Authorization: Bearer ...):",
-  keyPromptMessage: "Header name (e.g. Authorization):",
-  valuePromptMessage: "Header value",
-  isSecretKey: (k) => SECRET_HEADER_PATTERN.test(k),
-  maskValue: maskSecretHeader,
-  formatText: formatHeadersText,
-  parseText: parseHeadersText
-});
-
-// src/interactive/wizard-add.ts
-var wizardAdd = async (initial = {}) => {
-  const cwd = initial.cwd ?? process.cwd();
-  logger.info(import_picocolors8.default.bold("Welcome to the MCP interactive add wizard"));
-  let source = initial.source;
-  if (!source) {
-    const sourceType = await (0, import_prompts8.select)({
-      message: "Select MCP server type:",
-      choices: [
-        {
-          name: "npm package (run via npx)",
-          value: "npm"
-        },
-        {
-          name: "Remote MCP server (via HTTP / SSE URL)",
-          value: "remote"
-        },
-        {
-          name: "Local command / script / Docker (stdio)",
-          value: "command"
-        }
-      ]
-    });
-    if (sourceType === "npm") {
-      source = await (0, import_prompts8.input)({
-        message: "Enter npm package name (e.g. @modelcontextprotocol/server-postgres):",
-        validate: (val) => val.trim() ? true : "Package name cannot be empty"
-      });
-    } else if (sourceType === "remote") {
-      source = await (0, import_prompts8.input)({
-        message: "Enter remote server URL (e.g. https://mcp.example.com/sse):",
-        validate: (val) => {
-          const trimmed = val.trim();
-          if (!trimmed) return "URL cannot be empty";
-          if (!/^https?:\/\//i.test(trimmed)) return "Please enter a valid URL starting with http:// or https://";
-          return true;
-        }
-      });
-    } else {
-      source = await (0, import_prompts8.input)({
-        message: "Enter command and arguments (e.g. python -m my_mcp_server or docker run ...):",
-        validate: (val) => val.trim() ? true : "Command cannot be empty"
-      });
-    }
-  }
-  source = source.trim();
-  const parsed = parseMcpSource(source);
-  let serverName = initial.name;
-  if (!serverName) {
-    serverName = await (0, import_prompts8.input)({
-      message: "MCP server name:",
-      default: parsed.inferredName,
-      validate: (val) => val.trim() ? true : "Server name cannot be empty"
-    });
-  }
-  serverName = serverName.trim();
-  let transport = initial.transport;
-  let headers = initial.headers ?? {};
-  if (parsed.type === "remote") {
-    if (!transport) {
-      const isSseUrl = /\/sse\b/i.test(parsed.value);
-      transport = await (0, import_prompts8.select)({
-        message: "Select remote transport protocol:",
-        choices: [
-          { name: "HTTP", value: "http" },
-          { name: "SSE (Server-Sent Events)", value: "sse" }
-        ],
-        default: isSseUrl ? "sse" : "http"
-      });
-    }
-    if (Object.keys(headers).length === 0) {
-      const needHeader = await (0, import_prompts8.confirm)({
-        message: "Configure HTTP headers (e.g. Authorization Bearer token)?",
-        default: false
-      });
-      if (needHeader) {
-        headers = await promptHeadersConfig();
-      }
-    }
-  }
-  const { global: isGlobal, agents: selectedAgents } = await promptScopeAndAgents({
-    cwd,
-    defaultGlobal: initial.global,
-    defaultAgents: initial.agents
-  });
-  let args = initial.args ?? [];
-  if (parsed.type !== "remote") {
-    args = await promptArgsConfig(args);
-  }
-  let env = initial.env ?? {};
-  if (parsed.type !== "remote") {
-    env = await promptEnvConfig(env);
-  }
-  console.log("\n" + import_picocolors8.default.cyan(import_picocolors8.default.bold("Configuration Preview:")));
-  console.log(`  ${import_picocolors8.default.bold("Server Name:")} ${import_picocolors8.default.green(serverName)}`);
-  console.log(`  ${import_picocolors8.default.bold("Server Type:")} ${import_picocolors8.default.magenta(parsed.type)}`);
-  console.log(`  ${import_picocolors8.default.bold("Source/Command:")} ${import_picocolors8.default.dim(source)}`);
-  console.log(`  ${import_picocolors8.default.bold("Scope:")} ${isGlobal ? import_picocolors8.default.yellow("Global") : import_picocolors8.default.blue("Project")}`);
-  console.log(`  ${import_picocolors8.default.bold("Target Agents:")} ${import_picocolors8.default.cyan(selectedAgents.join(", "))}`);
-  if (args.length > 0) {
-    console.log(`  ${import_picocolors8.default.bold("Arguments:")} ${import_picocolors8.default.dim(args.join(" "))}`);
-  }
-  if (transport) {
-    console.log(`  ${import_picocolors8.default.bold("Transport:")} ${import_picocolors8.default.magenta(transport)}`);
-  }
-  const envKeys = Object.keys(env);
-  if (envKeys.length > 0) {
-    console.log(`  ${import_picocolors8.default.bold("Environment Variables:")} ${import_picocolors8.default.dim(envKeys.join(", "))} (${envKeys.length})`);
-  }
-  const headerKeys = Object.keys(headers);
-  if (headerKeys.length > 0) {
-    console.log(`  ${import_picocolors8.default.bold("Headers:")} ${import_picocolors8.default.dim(headerKeys.join(", "))} (${headerKeys.length})`);
-  }
-  console.log();
-  const proceed = await (0, import_prompts8.confirm)({
-    message: "Confirm installation with this configuration?",
-    default: true
-  });
-  if (!proceed) {
-    logger.warn("Operation cancelled");
-    return false;
-  }
-  const result = installMcpServer({
-    source,
-    name: serverName,
-    agents: selectedAgents,
-    args,
-    global: isGlobal,
-    cwd,
-    transport,
-    headers,
-    env
-  });
-  logger.info(
-    `Writing ${import_picocolors8.default.bold(result.serverName)} to ${import_picocolors8.default.cyan(String(result.results.length))} agent config files...`
-  );
-  let allSuccess = true;
-  for (const record of result.results) {
-    if (record.success) {
-      logger.success(`${import_picocolors8.default.cyan(record.agent)}: Successfully written to ${import_picocolors8.default.dim(record.path)}`);
-    } else {
-      allSuccess = false;
-      logger.error(`${import_picocolors8.default.cyan(record.agent)}: Failed to write - ${record.error}`);
-    }
-  }
-  if (allSuccess) {
-    logger.success(import_picocolors8.default.bold(`MCP server "${serverName}" configured successfully!`));
-  }
-  return allSuccess;
-};
-
-// src/interactive/wizard-manage.ts
-var import_prompts9 = require("@inquirer/prompts");
-var import_picocolors9 = __toESM(require("picocolors"), 1);
-
-// src/interactive/utils/group-installed-servers.ts
-var normalizeServerConfig = parseServerConfig;
 var groupInstalledServersByName = (installed) => {
   const grouped = /* @__PURE__ */ new Map();
   for (const item of installed) {
+    const itemConfig = item.serverConfig ?? parseServerConfig(item.config);
     let entry = grouped.get(item.serverName);
     if (!entry) {
       entry = {
         serverName: item.serverName,
         agents: [],
         paths: [],
-        config: normalizeServerConfig(item.config)
+        config: itemConfig,
+        hasDivergence: false
       };
       grouped.set(item.serverName, entry);
+    } else if (!entry.hasDivergence) {
+      if (JSON.stringify(entry.config) !== JSON.stringify(itemConfig)) {
+        entry.hasDivergence = true;
+      }
     }
     if (!entry.agents.includes(item.agent)) {
       entry.agents.push(item.agent);
@@ -2373,679 +1848,127 @@ var groupInstalledServersByName = (installed) => {
   }
   return grouped;
 };
-
-// src/interactive/wizard-manage.ts
-var displayServerDetails = ({
-  serverName,
-  config,
-  agents,
-  isGlobal,
-  titlePrefix = "MCP Server Details"
-}) => {
-  console.log("\n" + import_picocolors9.default.cyan(import_picocolors9.default.bold(`${titlePrefix}: [${serverName}]`)));
-  if (isGlobal !== void 0) {
-    console.log(`  ${import_picocolors9.default.bold("Scope:")} ${isGlobal ? "Global" : "Project"}`);
-  }
-  if (agents && agents.length > 0) {
-    console.log(
-      `  ${import_picocolors9.default.bold("Configured Agents:")} ${import_picocolors9.default.green(agents.map((a) => getMcpAgentConfig(a).displayName).join(", "))}`
-    );
-  }
-  const isRemote = Boolean(config.url && config.url.length > 0);
-  if (isRemote) {
-    console.log(`  ${import_picocolors9.default.bold("Transport:")} ${import_picocolors9.default.magenta(config.type ?? "http")}`);
-    console.log(`  ${import_picocolors9.default.bold("URL:")} ${import_picocolors9.default.dim(config.url ?? "")}`);
-    const headerKeys = Object.keys(config.headers ?? {});
-    if (headerKeys.length > 0) {
-      console.log(`  ${import_picocolors9.default.bold("Headers:")} ${import_picocolors9.default.cyan(String(headerKeys.length))}`);
-      for (const [k, v] of Object.entries(config.headers ?? {})) {
-        console.log(`    ${import_picocolors9.default.bold(k)}: ${import_picocolors9.default.dim(maskSecretHeader(k, v))}`);
-      }
-    } else {
-      console.log(`  ${import_picocolors9.default.bold("Headers:")} ${import_picocolors9.default.dim("(none)")}`);
-    }
-  } else {
-    console.log(`  ${import_picocolors9.default.bold("Command:")} ${import_picocolors9.default.magenta(config.command ?? "")}`);
-    const argsStr = config.args && config.args.length > 0 ? config.args.join(" ") : "(none)";
-    console.log(`  ${import_picocolors9.default.bold("Arguments:")} ${import_picocolors9.default.dim(argsStr)}`);
-    const envKeys = Object.keys(config.env ?? {});
-    if (envKeys.length > 0) {
-      console.log(`  ${import_picocolors9.default.bold("Environment Variables:")} ${import_picocolors9.default.cyan(String(envKeys.length))}`);
-      for (const [k, v] of Object.entries(config.env ?? {})) {
-        console.log(`    ${import_picocolors9.default.bold(k)}=${import_picocolors9.default.dim(maskSecretValue(k, v))}`);
-      }
-    } else {
-      console.log(`  ${import_picocolors9.default.bold("Environment Variables:")} ${import_picocolors9.default.dim("(none)")}`);
-    }
-  }
-  console.log();
-};
-var handleEditServerConfig = async ({
-  targetGroup,
-  isGlobal,
-  cwd
-}) => {
-  const serverName = targetGroup.serverName;
-  let workingConfig = {
-    ...targetGroup.config,
-    args: targetGroup.config.args ? [...targetGroup.config.args] : void 0,
-    env: targetGroup.config.env ? { ...targetGroup.config.env } : void 0,
-    headers: targetGroup.config.headers ? { ...targetGroup.config.headers } : void 0
-  };
-  while (true) {
-    const isRemote = Boolean(workingConfig.url && workingConfig.url.length > 0);
-    displayServerDetails({
-      serverName,
-      config: workingConfig,
-      titlePrefix: "Edit Server Configuration"
-    });
-    const editChoices = isRemote ? [
-      { name: "Edit HTTP Headers (headers)", value: "headers" },
-      { name: "Edit Remote URL (url)", value: "url" },
-      { name: "Edit Transport Protocol (type)", value: "transport" },
-      { name: "Reset changes to original", value: "reset" },
-      { name: "Save and apply changes", value: "save" },
-      { name: "Cancel (discard changes)", value: "cancel" }
-    ] : [
-      { name: "Edit Environment Variables (env)", value: "env" },
-      { name: "Edit Command Arguments (args)", value: "args" },
-      { name: "Edit Executable Command (command)", value: "command" },
-      { name: "Reset changes to original", value: "reset" },
-      { name: "Save and apply changes", value: "save" },
-      { name: "Cancel (discard changes)", value: "cancel" }
-    ];
-    const editAction = await (0, import_prompts9.select)({
-      message: `What would you like to modify in [${serverName}]?`,
-      choices: editChoices
-    });
-    if (editAction === "cancel") {
-      logger.info("Modification cancelled; changes discarded");
-      return;
-    }
-    if (editAction === "reset") {
-      workingConfig = {
-        ...targetGroup.config,
-        args: targetGroup.config.args ? [...targetGroup.config.args] : void 0,
-        env: targetGroup.config.env ? { ...targetGroup.config.env } : void 0,
-        headers: targetGroup.config.headers ? { ...targetGroup.config.headers } : void 0
-      };
-      logger.info("Configuration reset to original");
-      continue;
-    }
-    if (editAction === "env") {
-      workingConfig.env = await promptEditEnvConfig(workingConfig.env ?? {});
-    } else if (editAction === "args") {
-      workingConfig.args = await promptEditArgs(workingConfig.args ?? []);
-    } else if (editAction === "command") {
-      const newCmd = await (0, import_prompts9.input)({
-        message: "Executable command:",
-        default: workingConfig.command,
-        validate: (val) => val.trim() ? true : "Command cannot be empty"
-      });
-      workingConfig.command = newCmd.trim();
-    } else if (editAction === "headers") {
-      workingConfig.headers = await promptEditHeadersConfig(workingConfig.headers ?? {});
-    } else if (editAction === "url") {
-      const newUrl = await (0, import_prompts9.input)({
-        message: "Remote server URL:",
-        default: workingConfig.url,
-        validate: (val) => {
-          const trimmed = val.trim();
-          if (!trimmed) return "URL cannot be empty";
-          if (!/^https?:\/\//i.test(trimmed)) {
-            return "Please enter a valid URL starting with http:// or https://";
-          }
-          return true;
-        }
-      });
-      workingConfig.url = newUrl.trim();
-    } else if (editAction === "transport") {
-      workingConfig.type = await (0, import_prompts9.select)({
-        message: "Select remote transport protocol:",
-        choices: [
-          { name: "HTTP", value: "http" },
-          { name: "SSE (Server-Sent Events)", value: "sse" }
-        ],
-        default: workingConfig.type === "sse" ? "sse" : "http"
-      });
-    } else if (editAction === "save") {
-      let targetAgents = targetGroup.agents;
-      if (targetGroup.agents.length > 1) {
-        targetAgents = await (0, import_prompts9.checkbox)({
-          message: "Select agents to update configuration (Space to toggle):",
-          choices: targetGroup.agents.map((a) => ({
-            name: `${getMcpAgentConfig(a).displayName} (${a})`,
-            value: a,
-            checked: true
-          })),
-          loop: false,
-          validate: (ans) => ans.length === 0 ? "Please select at least one agent" : true
-        });
-      }
-      const requestedTransport = workingConfig.url ? workingConfig.type ?? "http" : "stdio";
-      const compatibleAgents = [];
-      const incompatibleAgents = [];
-      for (const agent of targetAgents) {
-        const agentConfig = getMcpAgentConfig(agent);
-        if (isMcpTransportSupported(agentConfig, requestedTransport)) {
-          compatibleAgents.push(agent);
-        } else {
-          const reason = agentConfig.unsupportedTransportMessage ?? `Agent does not support ${requestedTransport} transport`;
-          incompatibleAgents.push({ agent, reason });
-        }
-      }
-      if (incompatibleAgents.length > 0) {
-        for (const item of incompatibleAgents) {
-          logger.warn(`Skipping ${import_picocolors9.default.cyan(item.agent)}: ${item.reason}`);
-        }
-      }
-      if (compatibleAgents.length === 0) {
-        logger.error(
-          `None of the selected agents support ${requestedTransport} transport. Cannot update.`
-        );
-        continue;
-      }
-      const agentNames = compatibleAgents.map((a) => getMcpAgentConfig(a).displayName).join(", ");
-      const confirmed = await (0, import_prompts9.confirm)({
-        message: `Confirm updating configuration for [${serverName}] across: ${agentNames}?`,
-        default: true
-      });
-      if (!confirmed) {
-        logger.warn("Update cancelled");
-        continue;
-      }
-      for (const targetAgent of compatibleAgents) {
-        const res = installMcpServerForAgent(serverName, workingConfig, targetAgent, {
-          global: isGlobal,
-          cwd
-        });
-        if (res.success) {
-          logger.success(
-            `${import_picocolors9.default.cyan(targetAgent)}: Successfully updated configuration in ${import_picocolors9.default.dim(res.path)}`
-          );
-        } else {
-          logger.error(`${import_picocolors9.default.cyan(targetAgent)}: Update failed - ${res.error}`);
-        }
-      }
-      targetGroup.config = workingConfig;
-      logger.success(`Configuration for [${serverName}] updated successfully!`);
-      return;
-    }
-  }
-};
-var wizardManage = async (options = {}) => {
-  const cwd = options.cwd ?? process.cwd();
-  const isGlobal = await promptScope({
-    cwd,
-    defaultGlobal: options.global,
-    message: "Select MCP scope to inspect and manage:"
-  });
-  const installed = listInstalledMcpServers({ global: isGlobal, cwd });
-  if (installed.length === 0) {
-    logger.warn(`No configured MCP servers found in ${isGlobal ? "global" : "project"} scope`);
-    return;
-  }
-  const grouped = groupInstalledServersByName(installed);
-  let pendingServerName = options.serverName;
-  while (true) {
-    let chosenServerName;
-    if (pendingServerName && grouped.has(pendingServerName)) {
-      chosenServerName = pendingServerName;
-      pendingServerName = void 0;
-    } else {
-      pendingServerName = void 0;
-      const choices = Array.from(grouped.values()).map((g) => {
-        const agentNames = g.agents.map((a) => getMcpAgentConfig(a).displayName).join(", ");
-        return {
-          name: `${import_picocolors9.default.bold(g.serverName)} ${import_picocolors9.default.dim(`(configured in: ${agentNames})`)}`,
-          value: g.serverName
-        };
-      });
-      choices.push({
-        name: `Back`,
-        value: "__back__"
-      });
-      chosenServerName = await (0, import_prompts9.select)({
-        message: "Select MCP server to manage or sync:",
-        choices
-      });
-      if (chosenServerName === "__back__") {
-        return;
-      }
-    }
-    const targetGroup = grouped.get(chosenServerName);
-    if (!targetGroup) continue;
-    displayServerDetails({
-      serverName: chosenServerName,
-      config: targetGroup.config,
-      agents: targetGroup.agents,
-      isGlobal
-    });
-    const action = await (0, import_prompts9.select)({
-      message: `What would you like to do with [${chosenServerName}]?`,
-      choices: [
-        {
-          name: "Edit server configuration",
-          value: "edit"
-        },
-        {
-          name: "Sync / clone to other agents",
-          value: "sync"
-        },
-        {
-          name: "Back to list",
-          value: "back"
-        }
-      ]
-    });
-    if (action === "back") continue;
-    if (action === "edit") {
-      await handleEditServerConfig({
-        targetGroup,
-        isGlobal,
-        cwd
-      });
-      continue;
-    }
-    if (action === "sync") {
-      const allAllowedAgents = isGlobal ? getMcpAgentTypes() : getMcpAgentsSupportingProjectScope();
-      const candidateAgents = allAllowedAgents.filter((a) => !targetGroup.agents.includes(a));
-      if (candidateAgents.length === 0) {
-        logger.info(
-          "All supported agents in this scope already have this MCP server configured; no sync needed"
-        );
-        continue;
-      }
-      const selectedToSync = await (0, import_prompts9.checkbox)({
-        message: "Select target agents to sync to (Space to select):",
-        choices: candidateAgents.map((a) => ({
-          name: `${getMcpAgentConfig(a).displayName} (${a})`,
-          value: a,
-          checked: false
-        })),
-        loop: false,
-        validate: (ans) => ans.length === 0 ? "Please select at least one agent" : true
-      });
-      const confirmed = await (0, import_prompts9.confirm)({
-        message: `Confirm syncing configuration of [${chosenServerName}] to: ${selectedToSync.join(", ")}?`,
-        default: true
-      });
-      if (!confirmed) {
-        logger.warn("Sync cancelled");
-        continue;
-      }
-      for (const targetAgent of selectedToSync) {
-        const res = installMcpServerForAgent(chosenServerName, targetGroup.config, targetAgent, {
-          global: isGlobal,
-          cwd
-        });
-        if (res.success) {
-          logger.success(`${import_picocolors9.default.cyan(targetAgent)}: Successfully synced to ${import_picocolors9.default.dim(res.path)}`);
-          targetGroup.agents.push(targetAgent);
-        } else {
-          logger.error(`${import_picocolors9.default.cyan(targetAgent)}: Sync failed - ${res.error}`);
-        }
-      }
-    }
-  }
+var queryGroupedInstalledServers = (options = {}) => {
+  const installed = listInstalledMcpServers(options);
+  return groupInstalledServersByName(installed);
 };
 
-// src/interactive/wizard-remove.ts
-var import_prompts10 = require("@inquirer/prompts");
-var import_picocolors10 = __toESM(require("picocolors"), 1);
-var wizardRemove = async (options = {}) => {
+// src/update-mcp-server.ts
+var updateMcpServer = (options) => {
+  const isGlobal = options.global ?? false;
   const cwd = options.cwd ?? process.cwd();
-  const isGlobal = await promptScope({
-    cwd,
-    defaultGlobal: options.global,
-    message: "Select scope to remove MCP server from:"
-  });
-  const installed = listInstalledMcpServers({ global: isGlobal, cwd });
-  if (installed.length === 0) {
-    logger.warn(`No installed MCP servers found in ${isGlobal ? "global" : "project"} scope`);
-    return false;
-  }
-  const serverMap = groupInstalledServersByName(installed);
-  let serverName = options.name;
-  if (!serverName) {
-    const choices = Array.from(serverMap.values()).map((g) => ({
-      name: `${import_picocolors10.default.bold(g.serverName)} ${import_picocolors10.default.dim(`(installed in: ${g.agents.map((a) => getMcpAgentConfig(a).displayName).join(", ")})`)}`,
-      value: g.serverName
-    }));
-    serverName = await (0, import_prompts10.select)({
-      message: "Select MCP server to remove:",
-      choices
+  let previousConfig = options.previousConfig;
+  if (!previousConfig) {
+    const existing = listInstalledMcpServers({
+      global: isGlobal,
+      cwd,
+      agents: options.agents
     });
+    const found = existing.find((s) => s.serverName === options.serverName && s.serverConfig);
+    if (found) {
+      previousConfig = found.serverConfig;
+    }
   }
-  const installedAgents = serverMap.get(serverName)?.agents || [];
-  if (installedAgents.length === 0) {
-    logger.warn(`No agents found with [${serverName}] installed`);
-    return false;
-  }
+  const serverConfig = sanitizeUpdatedServerConfig(options.config, previousConfig);
   let targetAgents = options.agents;
   if (!targetAgents || targetAgents.length === 0) {
-    targetAgents = await (0, import_prompts10.checkbox)({
-      message: `Select agents to remove [${serverName}] from:`,
-      choices: installedAgents.map((agent) => ({
-        name: `${getMcpAgentConfig(agent)?.displayName ?? agent} (${agent})`,
-        value: agent,
-        checked: true
-      })),
-      loop: false,
-      validate: (ans) => ans.length === 0 ? "Please select at least one agent" : true
-    });
-  } else {
-    const validAgents = targetAgents.filter((agent) => installedAgents.includes(agent));
-    if (validAgents.length === 0) {
-      logger.warn(`None of the specified agents (${targetAgents.join(", ")}) have [${serverName}] installed`);
-      return false;
-    }
-    targetAgents = validAgents;
+    const existing = listInstalledMcpServers({ global: isGlobal, cwd });
+    targetAgents = existing.filter((s) => s.serverName === options.serverName).map((s) => s.agent);
   }
-  const confirmed = await (0, import_prompts10.confirm)({
-    message: `Confirm removing MCP server [${serverName}] from ${targetAgents.join(", ")}?`,
-    default: true
+  const requestedTransport = serverConfig.url ? serverConfig.type ?? "http" : "stdio";
+  const { allAgents, incompatible } = resolveTargetAgents({
+    requested: targetAgents,
+    global: isGlobal,
+    cwd,
+    transport: requestedTransport
   });
-  if (!confirmed) {
-    logger.warn("Operation cancelled");
-    return false;
-  }
-  const results = removeMcpServer({
-    name: serverName,
-    agents: targetAgents,
+  const results = installToCompatibleAgents(options.serverName, serverConfig, {
+    allAgents,
+    incompatible,
     global: isGlobal,
     cwd
   });
-  let removedCount = 0;
-  for (const res of results) {
-    if (res.removed) {
-      logger.success(`${import_picocolors10.default.cyan(res.agent)}: Successfully removed from ${import_picocolors10.default.dim(res.path)}`);
-      removedCount++;
-    } else if (res.error) {
-      logger.error(`${import_picocolors10.default.cyan(res.agent)}: Failed to remove - ${res.error}`);
-    }
-  }
-  if (removedCount > 0) {
-    logger.success(`Successfully removed [${serverName}] from ${removedCount} agent(s)`);
-    return true;
-  }
-  logger.warn(`Failed to remove [${serverName}] from specified agents`);
-  return false;
+  return {
+    serverName: options.serverName,
+    config: serverConfig,
+    results,
+    incompatible
+  };
 };
 
-// src/interactive/main-menu.ts
-var mainMenu = async () => {
-  console.log();
-  console.log(import_picocolors11.default.bold(import_picocolors11.default.cyan("mcps - Cross-Platform MCP Manager for AI Coding Agents")));
-  console.log(import_picocolors11.default.dim("Cross-platform MCP server configuration & synchronization tool"));
-  console.log();
-  while (true) {
-    try {
-      const action = await (0, import_prompts11.select)({
-        message: "Select an action:",
-        choices: [
-          {
-            name: "Add MCP Server",
-            value: "add"
-          },
-          {
-            name: "Manage & Sync Installed MCP Servers",
-            value: "manage"
-          },
-          {
-            name: "Remove MCP Server",
-            value: "remove"
-          },
-          {
-            name: "Exit",
-            value: "exit"
-          }
-        ]
-      });
-      if (action === "exit") {
-        console.log(import_picocolors11.default.dim("Goodbye!"));
-        break;
-      }
-      if (action === "add") {
-        await wizardAdd();
-      } else if (action === "manage") {
-        await wizardManage();
-      } else if (action === "remove") {
-        await wizardRemove();
-      }
-      console.log();
-    } catch (error) {
-      if (error?.name === "ExitPromptError") {
-        console.log("\n" + import_picocolors11.default.dim("Exited."));
-        break;
-      }
-      throw error;
-    }
-  }
+// src/remove.ts
+var removeMcpServer = (options) => {
+  const { allAgents } = resolveTargetAgents({
+    requested: options.agents,
+    all: !options.agents,
+    global: options.global,
+    cwd: options.cwd
+  });
+  const storeResults = agentConfigStore.removeServers(allAgents, options.name, {
+    global: options.global,
+    cwd: options.cwd
+  });
+  return storeResults.filter((r) => r.removed || Boolean(r.error));
 };
 
-// src/cli/manage.ts
-var import_commander = require("commander");
-var import_picocolors12 = __toESM(require("picocolors"), 1);
-
-// src/utils/parse-key-value-list.ts
-var parseKeyValueList = (entries, separator) => {
-  if (!entries || entries.length === 0) return {};
-  const result = {};
-  for (const entry of entries) {
-    const splitIndex = entry.indexOf(separator);
-    if (splitIndex === -1) {
-      throw new Error(`Invalid entry "${entry}": expected "${separator}" separator`);
-    }
-    const key = entry.slice(0, splitIndex).trim();
-    const value = entry.slice(splitIndex + separator.length).trim();
-    if (!key) throw new Error(`Invalid entry "${entry}": empty key`);
-    result[key] = value;
+// src/utils/mask-secret.ts
+var SECRET_KEY_PATTERN = /(token|key|secret|password|passwd|auth|credential)/i;
+var maskSecretValue = (key, value) => {
+  if (!SECRET_KEY_PATTERN.test(key) || value.length <= 4) {
+    return value;
   }
-  return result;
-};
-
-// src/cli/manage.ts
-var resolveTransport = (input7) => {
-  if (!input7) return void 0;
-  if (input7 === "http" || input7 === "sse") return input7;
-  throw new Error(`Unsupported transport "${input7}" (expected: http, sse)`);
+  return `${value.slice(0, 2)}***${value.slice(-2)}`;
 };
-var mcpManageCommand = new import_commander.Command("manage").description("Inspect, modify, and sync installed MCP servers across coding agents").argument("[server-name]", "Optional server name to inspect or manage").option("-a, --agent <agents...>", "Target specific agents for update").option("-g, --global", "Manage global scope servers instead of project").option("-t, --transport <type>", "Transport type for remote servers (http or sse)").option("--header <header...>", "HTTP header (Header: Value), repeatable").option("--env <env...>", "Env var for stdio servers (KEY=VALUE), repeatable").option("--args <args...>", "CLI arguments for stdio/package servers").option("--command <command>", "Executable command for stdio servers").option("--url <url>", "Remote endpoint URL").option("-y, --yes", "Skip interactive prompts").action(async (serverName, options) => {
-  try {
-    const cwd = process.cwd();
-    const isGlobal = Boolean(options.global);
-    const hasModifications = options.command !== void 0 || options.args !== void 0 || options.env !== void 0 || options.header !== void 0 || options.url !== void 0 || options.transport !== void 0;
-    const isInteractive = Boolean(process.stdin.isTTY && !options.yes);
-    if (hasModifications) {
-      if (!serverName) {
-        logger.error('Missing required argument: "server-name" when passing modification flags.');
-        process.exitCode = 1;
-        return;
-      }
-      const installed = listInstalledMcpServers({ global: isGlobal, cwd });
-      const grouped = groupInstalledServersByName(installed);
-      const targetGroup = grouped.get(serverName);
-      if (!targetGroup) {
-        logger.error(
-          `MCP server "${serverName}" is not configured in ${isGlobal ? "global" : "project"} scope.`
-        );
-        process.exitCode = 1;
-        return;
-      }
-      const updatedConfig = {
-        ...targetGroup.config,
-        args: targetGroup.config.args ? [...targetGroup.config.args] : void 0,
-        env: targetGroup.config.env ? { ...targetGroup.config.env } : void 0,
-        headers: targetGroup.config.headers ? { ...targetGroup.config.headers } : void 0
-      };
-      if (options.command !== void 0) {
-        updatedConfig.command = options.command;
-      }
-      if (options.args !== void 0) {
-        updatedConfig.args = options.args;
-      }
-      if (options.url !== void 0) {
-        updatedConfig.url = options.url;
-      }
-      if (options.transport !== void 0) {
-        updatedConfig.type = resolveTransport(options.transport);
-      }
-      if (options.env !== void 0) {
-        const parsedEnv = parseKeyValueList(options.env, "=");
-        updatedConfig.env = { ...updatedConfig.env ?? {}, ...parsedEnv };
-      }
-      if (options.header !== void 0) {
-        const parsedHeaders = parseKeyValueList(options.header, ":");
-        updatedConfig.headers = { ...updatedConfig.headers ?? {}, ...parsedHeaders };
-      }
-      const targetAgents = options.agent ? parseMcpAgentList(options.agent) ?? targetGroup.agents : targetGroup.agents;
-      const requestedTransport = updatedConfig.url ? updatedConfig.type ?? "http" : "stdio";
-      const compatibleAgents = [];
-      for (const agent of targetAgents) {
-        const agentConfig = getMcpAgentConfig(agent);
-        if (isMcpTransportSupported(agentConfig, requestedTransport)) {
-          compatibleAgents.push(agent);
-        } else {
-          const reason = agentConfig.unsupportedTransportMessage ?? `Agent does not support ${requestedTransport} transport`;
-          logger.warn(`Skipping ${import_picocolors12.default.cyan(agent)}: ${reason}`);
-        }
-      }
-      if (compatibleAgents.length === 0) {
-        logger.error(
-          `None of the target agents support ${requestedTransport} transport. Update aborted.`
-        );
-        process.exitCode = 1;
-        return;
-      }
-      logger.info(
-        `Updating ${import_picocolors12.default.bold(serverName)} across ${import_picocolors12.default.cyan(String(compatibleAgents.length))} agent(s)...`
-      );
-      let allSuccess = true;
-      for (const agent of compatibleAgents) {
-        const res = installMcpServerForAgent(serverName, updatedConfig, agent, {
-          global: isGlobal,
-          cwd
-        });
-        if (res.success) {
-          logger.success(`${import_picocolors12.default.cyan(agent)}: Successfully updated in ${import_picocolors12.default.dim(res.path)}`);
-        } else {
-          allSuccess = false;
-          logger.error(`${import_picocolors12.default.cyan(agent)}: Update failed - ${res.error}`);
-        }
-      }
-      if (!allSuccess) {
-        process.exitCode = 1;
-      }
-      return;
-    }
-    if (!isInteractive) {
-      if (!serverName) {
-        logger.error(
-          'Missing required argument: "server-name" for non-interactive manage command. Specify a server name or use interactive terminal.'
-        );
-        process.exitCode = 1;
-        return;
-      }
-      const installed = listInstalledMcpServers({ global: isGlobal, cwd });
-      const grouped = groupInstalledServersByName(installed);
-      const targetGroup = grouped.get(serverName);
-      if (!targetGroup) {
-        logger.error(
-          `MCP server "${serverName}" is not configured in ${isGlobal ? "global" : "project"} scope.`
-        );
-        process.exitCode = 1;
-        return;
-      }
-      displayServerDetails({
-        serverName,
-        config: targetGroup.config,
-        agents: targetGroup.agents,
-        isGlobal
-      });
-      return;
-    }
-    await wizardManage({
-      global: options.global,
-      serverName
-    });
-  } catch (error) {
-    if (error && typeof error === "object" && "name" in error && error.name === "ExitPromptError") {
-      process.exit(0);
-    }
-    logger.error(toErrorMessage(error));
-    process.exitCode = 1;
+var SECRET_HEADER_PATTERN = /(authorization|token|key|secret|auth)/i;
+var maskSecretHeader = (key, value) => {
+  if (!SECRET_HEADER_PATTERN.test(key) || value.length <= 8) {
+    return value;
   }
-});
+  return `${value.slice(0, 4)}***${value.slice(-3)}`;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentConfigStore,
   DEFAULT_REMOTE_TRANSPORT,
-  NPX_COMMAND,
-  NPX_DASH_Y,
-  add,
+  SECRET_HEADER_PATTERN,
+  SECRET_KEY_PATTERN,
   agentConfigStore,
+  applyServerConfigDelta,
   buildMcpServerConfig,
   createAgentTransform,
   detectGloballyInstalledMcpAgents,
   detectProjectInstalledMcpAgents,
-  displayServerDetails,
+  detectUpdateTransition,
   extractPackageName,
-  formatArgsString,
-  formatEnvText,
-  formatHeadersText,
+  getCandidateAgentsForScope,
+  getCoHostedAgents,
   getMcpAgentConfig,
   getMcpAgentTypes,
   getMcpAgentsSupportingProjectScope,
-  groupInstalledServersByName,
-  install,
   installMcpServer,
   installMcpServerForAgent,
   installMcpServerForAgents,
+  installToCompatibleAgents,
   isMcpAgentType,
   isMcpTransportSupported,
   isRemoteMcpSource,
   isRemoteServerConfig,
   isStdioServerConfig,
-  list,
   listInstalledMcpServers,
-  listServersInConfigFile,
-  mainMenu,
   maskSecretHeader,
   maskSecretValue,
-  mcpAgentAliases,
-  mcpAgents,
-  mcpManageCommand,
-  normalizeServerConfig,
-  parseArgsString,
-  parseEnvText,
-  parseHeadersText,
   parseMcpSource,
   parseServerConfig,
-  parseSource,
-  promptArgsConfig,
-  promptEditArgs,
-  promptEditEnvConfig,
-  promptEditHeadersConfig,
-  promptEditKeyValueConfig,
-  promptEnvConfig,
-  promptHeadersConfig,
-  promptScope,
-  promptScopeAndAgents,
-  readConfigFile,
-  remove,
+  queryGroupedInstalledServers,
   removeMcpServer,
-  removeMcpServerFromAgent,
-  removeServerFromConfigFile,
+  resolveConfigClusters,
   resolveMcpAgentAlias,
   resolveMcpConfigTarget,
   resolveTargetAgents,
-  transformServerConfig,
+  sanitizeUpdatedServerConfig,
+  sortAgentsByClusters,
+  toRemoteServerConfig,
+  toStdioServerConfig,
   transformServerConfigForAgent,
-  updateMcpServerForAgent,
-  updateMcpServerForAgents,
-  wizardAdd,
-  wizardManage,
-  wizardRemove,
-  writeServerToConfigFile
+  updateMcpServer
 });