@wuyax/mcps 0.1.0-beta.3 → 0.1.0

package/dist/cli.cjs

@@ -26,8 +26,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var import_commander5 = require("commander");
 
 // src/cli/add.ts
-var import_commander2 = require("commander");
-var import_picocolors17 = __toESM(require("picocolors"), 1);
+var import_commander = require("commander");
+var import_picocolors12 = __toESM(require("picocolors"), 1);
 
 // src/agents.ts
 var import_node_fs = require("fs");
@@ -537,7 +537,7 @@ 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 buildMcpServerConfig = (parsed, options = {}) => {
   if (parsed.type === "remote") {
     const config2 = {
@@ -575,8 +575,6 @@ var buildMcpServerConfig = (parsed, options = {}) => {
   }
   return config;
 };
-
-// src/parse-server-config.ts
 var parseServerConfig = (raw) => {
   if (!raw || typeof raw !== "object") return {};
   const data = raw;
@@ -603,6 +601,236 @@ 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 = (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;
+};
+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;
+    }
+  }
+  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 = (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)
+  };
+};
+
+// 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);
@@ -887,220 +1115,45 @@ 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/resolve-config-clusters.ts
-var getCandidateAgentsForScope = (options = {}) => {
-  return options.global ? getMcpAgentTypes() : getMcpAgentsSupportingProjectScope();
-};
-var 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;
-};
-var 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 = 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;
-};
-var sortAgentsWithClusters = (agentTypes, options = {}) => {
-  const clusters = 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;
-};
-
-// src/transforms/index.ts
-var DIALECT_PRESETS = {
-  vscode: {
-    stdioTransport: "type-stdio",
-    remoteTransport: "type-http-sse"
-  },
-  augment: {
-    stdioTransport: "none",
-    remoteTransport: "type-http-sse"
-  },
-  amp: {
-    stdioTransport: "none",
-    remoteTransport: "none"
-  },
-  trae: {
-    stdioTransport: "none",
-    remoteTransport: "sse-only-type"
-  },
-  grok: {
-    stdioTransport: "none",
-    remoteTransport: "sse-only-type"
-  },
-  cline: {
-    stdioTransport: "none",
-    remoteTransport: "streamableHttp"
-  },
-  goose: {
-    stdioTransport: "type-stdio",
-    remoteTransport: "streamable_http",
-    commandField: "cmd",
-    envField: "envs",
-    urlField: "uri",
-    defaultEnvEmpty: true,
-    defaultHeadersEmpty: true,
-    includeServerName: true,
-    timeoutSeconds: GOOSE_TIMEOUT_SECONDS,
-    extraFields: {
-      description: "",
-      enabled: true
+// src/transforms/index.ts
+var DIALECT_PRESETS = {
+  vscode: {
+    stdioTransport: "type-stdio",
+    remoteTransport: "type-http-sse"
+  },
+  augment: {
+    stdioTransport: "none",
+    remoteTransport: "type-http-sse"
+  },
+  amp: {
+    stdioTransport: "none",
+    remoteTransport: "none"
+  },
+  trae: {
+    stdioTransport: "none",
+    remoteTransport: "sse-only-type"
+  },
+  grok: {
+    stdioTransport: "none",
+    remoteTransport: "sse-only-type"
+  },
+  cline: {
+    stdioTransport: "none",
+    remoteTransport: "streamableHttp"
+  },
+  goose: {
+    stdioTransport: "type-stdio",
+    remoteTransport: "streamable_http",
+    commandField: "cmd",
+    envField: "envs",
+    urlField: "uri",
+    defaultEnvEmpty: true,
+    defaultHeadersEmpty: true,
+    includeServerName: true,
+    timeoutSeconds: GOOSE_TIMEOUT_SECONDS,
+    extraFields: {
+      description: "",
+      enabled: true
     }
   },
   "kimi-code": {
@@ -1269,246 +1322,392 @@ var transformServerConfigForAgent = (agent, serverName, config, context = { glob
   return config;
 };
 
-// src/installer.ts
-var installMcpServerForAgents = (serverName, serverConfig, agentTypes, options = {}) => {
-  const clusters = resolveConfigClusters(agentTypes, options);
-  const resultsByAgent = /* @__PURE__ */ new Map();
+// 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;
-  for (const cluster of clusters) {
-    const primaryAgentType = cluster.targetAgents[0];
-    const primaryAgent = getMcpAgentConfig(primaryAgentType);
-    try {
-      const transformed = transformServerConfigForAgent(primaryAgent, serverName, serverConfig, {
-        global: isGlobal
-      });
-      agentConfigStore.writeServer(primaryAgent, serverName, transformed, options);
-      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 agentTypes.map((agentType) => resultsByAgent.get(agentType));
-};
-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 = installMcpServerForAgents(serverName, serverConfig, compatibleAgents, {
-    global: isGlobal,
-    cwd
-  });
-  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 installedMap.get(agentType);
-  });
+  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/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];
-  if (rawList.every((item) => isMcpAgentType(item))) {
-    return rawList;
+var FsConfigStoreAdapter = class {
+  exists(filePath) {
+    return (0, import_node_fs6.existsSync)(filePath);
   }
-  return parseMcpAgentList(rawList);
-};
-var resolveTargetAgents = (query = {}) => {
-  const cwd = query.cwd ?? process.cwd();
-  const isGlobal = query.global ?? false;
-  let explicitAgents = normalizeRequestedAgents(query.requested);
-  if (query.all) {
-    explicitAgents = getMcpAgentTypes();
+  read(target) {
+    return readConfigFile(target.filePath, target.format);
   }
-  const isDetected = !explicitAgents || explicitAgents.length === 0;
-  const detected = isGlobal ? detectGloballyInstalledMcpAgents() : detectProjectInstalledMcpAgents(cwd);
-  const candidateAgents = isDetected ? detected : explicitAgents ?? [];
-  const allAgents = candidateAgents.filter(
-    (type, index) => candidateAgents.indexOf(type) === index
-  );
-  const incompatible = [];
-  const compatibleAgents = [];
-  for (const agentType of allAgents) {
-    const config = getMcpAgentConfig(agentType);
-    if (query.transport && !isMcpTransportSupported(config, query.transport)) {
-      incompatible.push({
-        agent: agentType,
-        reason: config.unsupportedTransportMessage ?? `agent ${agentType} only supports ${config.supportedTransports.join(", ")} transport (attempted ${query.transport})`
-      });
-    } else {
-      compatibleAgents.push(agentType);
+  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
+    );
   }
-  let diagnostic;
-  if (compatibleAgents.length === 0) {
-    if (isDetected) {
-      diagnostic = `No ${isGlobal ? "global" : "project"}-installed MCP agents detected. Pass -a <agent> (e.g. -a cursor) or --all to install.`;
-    } else if (allAgents.length > 0 && incompatible.length > 0 && query.transport) {
-      const list = incompatible.map((item) => `${item.agent} (${item.reason})`).join(", ");
-      diagnostic = `None of the selected agents support ${query.transport} transport: ${list}`;
-    } else {
-      diagnostic = "No valid target agents specified.";
-    }
+  removeServer(target, serverName) {
+    if (!target.dottedKey) return false;
+    return removeServerFromConfigFile(
+      target.filePath,
+      target.format,
+      target.dottedKey,
+      serverName
+    );
   }
-  return {
-    agents: compatibleAgents,
-    compatibleAgents,
-    allAgents,
-    candidateAgents: allAgents,
-    detected,
-    isDetected,
-    incompatible,
-    diagnostic
-  };
-};
-
-// 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;
+  listServers(target) {
+    if (!target.dottedKey) return {};
+    return listServersInConfigFile(target.filePath, target.format, target.dottedKey);
   }
-  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;
-};
-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 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 };
   }
-  for (const suffix of PACKAGE_NAME_SUFFIX_STRIP) {
-    if (name.endsWith(suffix)) {
-      name = name.slice(0, -suffix.length);
-      break;
+  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 };
   }
-  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;
+  /**
+   * 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
+      };
     });
-    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;
+  }
+  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 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);
+var agentConfigStore = new AgentConfigStore();
+
+// 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);
   }
-  const firstNonFlag = tokens.find((token) => !token.startsWith("-"));
-  return firstNonFlag ? extractPackageName(firstNonFlag) : MCP_DEFAULT_SERVER_NAME;
+  return resolved;
 };
-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."
-    );
+
+// src/resolve-target-agents.ts
+var normalizeRequestedAgents = (input7) => {
+  if (!input7 || input7.length === 0) return void 0;
+  const rawList = [...input7];
+  if (rawList.every((item) => isMcpAgentType(item))) {
+    return rawList;
   }
-  if (REMOTE_URL_REGEX.test(trimmed)) {
-    return {
-      type: "remote",
-      value: trimmed,
-      inferredName: inferNameFromUrl(trimmed)
-    };
+  return parseMcpAgentList(rawList);
+};
+var resolveTargetAgents = (query = {}) => {
+  const cwd = query.cwd ?? process.cwd();
+  const isGlobal = query.global ?? false;
+  let explicitAgents = normalizeRequestedAgents(query.requested);
+  if (query.all) {
+    explicitAgents = getMcpAgentTypes();
   }
-  if (HAS_WHITESPACE_REGEX.test(trimmed)) {
-    return {
-      type: "command",
-      value: trimmed,
-      inferredName: inferNameFromCommand(trimmed)
-    };
+  const isDetected = !explicitAgents || explicitAgents.length === 0;
+  const detected = isGlobal ? detectGloballyInstalledMcpAgents() : detectProjectInstalledMcpAgents(cwd);
+  const candidateAgents = isDetected ? detected : explicitAgents ?? [];
+  const allAgents = candidateAgents.filter(
+    (type, index) => candidateAgents.indexOf(type) === index
+  );
+  const incompatible = [];
+  const compatibleAgents = [];
+  for (const agentType of allAgents) {
+    const config = getMcpAgentConfig(agentType);
+    if (query.transport && !isMcpTransportSupported(config, query.transport)) {
+      incompatible.push({
+        agent: agentType,
+        reason: config.unsupportedTransportMessage ?? `agent ${agentType} only supports ${config.supportedTransports.join(", ")} transport (attempted ${query.transport})`
+      });
+    } else {
+      compatibleAgents.push(agentType);
+    }
   }
-  if (PACKAGE_NAME_REGEX.test(trimmed)) {
-    return {
-      type: "package",
-      value: trimmed,
-      inferredName: extractPackageName(trimmed)
-    };
+  let diagnostic;
+  if (compatibleAgents.length === 0) {
+    if (isDetected) {
+      diagnostic = `No ${isGlobal ? "global" : "project"}-installed MCP agents detected. Pass -a <agent> (e.g. -a cursor) or --all to install.`;
+    } else if (allAgents.length > 0 && incompatible.length > 0 && query.transport) {
+      const list = incompatible.map((item) => `${item.agent} (${item.reason})`).join(", ");
+      diagnostic = `None of the selected agents support ${query.transport} transport: ${list}`;
+    } else {
+      diagnostic = "No valid target agents specified.";
+    }
   }
   return {
-    type: "command",
-    value: trimmed,
-    inferredName: inferNameFromCommand(trimmed)
+    agents: compatibleAgents,
+    compatibleAgents,
+    allAgents,
+    candidateAgents: allAgents,
+    detected,
+    isDetected,
+    incompatible,
+    diagnostic
   };
 };
 
+// src/install-compat.ts
+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
+    }
+  );
+  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 installedMap.get(agentType);
+  });
+};
+
 // src/install-mcp-server.ts
 var installMcpServer = (options) => {
   const parsed = parseMcpSource(options.source);
@@ -1541,15 +1740,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)
       });
@@ -1557,110 +1755,40 @@ var listInstalledMcpServers = (options = {}) => {
   }
   return collected;
 };
-
-// src/remove.ts
-var removeMcpServer = (options) => {
-  const { allAgents } = resolveTargetAgents({
-    requested: options.agents,
-    all: !options.agents,
-    global: options.global,
-    cwd: options.cwd
-  });
-  const clusters = resolveConfigClusters(allAgents, {
-    global: options.global,
-    cwd: options.cwd
-  });
-  const results = [];
-  for (const cluster of clusters) {
-    const primaryAgentType = cluster.targetAgents[0];
-    const primaryAgent = getMcpAgentConfig(primaryAgentType);
-    try {
-      const { removed } = agentConfigStore.removeServer(primaryAgent, options.name, {
-        global: options.global,
-        cwd: options.cwd
-      });
-      if (removed) {
-        for (const agentType of cluster.targetAgents) {
-          results.push({
-            agent: agentType,
-            path: cluster.configPath,
-            removed: true,
-            coAffectedAgents: cluster.coHostedAgents.length > 0 ? cluster.coHostedAgents : void 0
-          });
-        }
-      }
-    } catch (error) {
-      const errorMsg = toErrorMessage(error);
-      for (const agentType of cluster.targetAgents) {
-        results.push({
-          agent: agentType,
-          path: cluster.configPath,
-          removed: false,
-          error: errorMsg
-        });
+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: itemConfig,
+        hasDivergence: false
+      };
+      grouped.set(item.serverName, entry);
+    } else if (!entry.hasDivergence) {
+      if (JSON.stringify(entry.config) !== JSON.stringify(itemConfig)) {
+        entry.hasDivergence = true;
       }
     }
-  }
-  return results;
-};
-
-// src/update-mcp-server.ts
-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";
-  }
-  if (incoming.url && !incoming.command) {
-    return "switch-to-remote";
-  }
-  if (incoming.command && !incoming.url) {
-    return "switch-to-stdio";
-  }
-  if (incoming.url || !incoming.command && previous.url) {
-    return "merge-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);
+    if (!entry.agents.includes(item.agent)) {
+      entry.agents.push(item.agent);
     }
-    case "merge-stdio": {
-      return toStdioServerConfig({ ...previous, ...incoming });
+    if (!entry.paths.includes(item.path)) {
+      entry.paths.push(item.path);
     }
   }
+  return grouped;
 };
+var queryGroupedInstalledServers = (options = {}) => {
+  const installed = listInstalledMcpServers(options);
+  return groupInstalledServersByName(installed);
+};
+
+// src/update-mcp-server.ts
 var updateMcpServer = (options) => {
   const isGlobal = options.global ?? false;
   const cwd = options.cwd ?? process.cwd();
@@ -1703,9 +1831,36 @@ var updateMcpServer = (options) => {
   };
 };
 
-// src/interactive/main-menu.ts
-var import_prompts10 = require("@inquirer/prompts");
-var import_picocolors15 = __toESM(require("picocolors"), 1);
+// 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/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 `${value.slice(0, 2)}***${value.slice(-2)}`;
+};
+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)}`;
+};
 
 // src/interactive/wizard-add.ts
 var import_prompts7 = require("@inquirer/prompts");
@@ -1754,7 +1909,7 @@ var buildLinkedAgentChoices = (options) => {
   const { agents, checkedAgents, detectedAgents = [], scopeOptions = {} } = options;
   const alignedCheckedSet = new Set(checkedAgents);
   for (const agent of checkedAgents) {
-    const coHosted = getCoHostedAgents(agent, scopeOptions);
+    const coHosted = agentConfigStore.getCoHostedAgents(agent, scopeOptions);
     for (const co of coHosted) {
       if (agents.includes(co)) {
         alignedCheckedSet.add(co);
@@ -1765,7 +1920,7 @@ var buildLinkedAgentChoices = (options) => {
     const config = getMcpAgentConfig(agent);
     const displayName = config?.displayName ?? agent;
     const isDetected = detectedAgents.includes(agent);
-    const coHosted = getCoHostedAgents(agent, scopeOptions).filter(
+    const coHosted = agentConfigStore.getCoHostedAgents(agent, scopeOptions).filter(
       (co) => agents.includes(co)
     );
     const detectedBadge = isDetected ? import_picocolors3.default.green(" [detected]") : "";
@@ -2029,7 +2184,10 @@ var promptScopeAndAgents = async (options = {}) => {
   });
   const detected = resolution.detected;
   const rawAvailable = isGlobal ? getMcpAgentTypes() : getMcpAgentsSupportingProjectScope();
-  const availableAgentTypes = sortAgentsWithClusters(rawAvailable, { global: isGlobal, cwd });
+  const availableAgentTypes = agentConfigStore.sortAgentsByClusters(rawAvailable, {
+    global: isGlobal,
+    cwd
+  });
   if (detected.length > 0) {
     logger.info(
       `Detected configured agents: ${import_picocolors6.default.cyan(detected.map((a) => getMcpAgentConfig(a).displayName).join(", "))}`
@@ -2109,22 +2267,6 @@ var promptEditArgs = async (currentArgs = []) => {
 var import_prompts5 = require("@inquirer/prompts");
 var import_picocolors9 = __toESM(require("picocolors"), 1);
 
-// 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 `${value.slice(0, 2)}***${value.slice(-2)}`;
-};
-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)}`;
-};
-
 // src/interactive/prompts/kv.ts
 var import_prompts4 = require("@inquirer/prompts");
 var import_picocolors8 = __toESM(require("picocolors"), 1);
@@ -2728,18 +2870,166 @@ var wizardAdd = async (initial = {}) => {
       logger.error(`${import_picocolors11.default.cyan(record.agent)}: Failed to write - ${record.error}`);
     }
   }
-  if (allSuccess) {
-    logger.success(import_picocolors11.default.bold(`MCP server "${serverName}" configured successfully!`));
+  if (allSuccess) {
+    logger.success(import_picocolors11.default.bold(`MCP server "${serverName}" configured successfully!`));
+  }
+  return allSuccess;
+};
+
+// src/utils/format-agent-list.ts
+var formatAgentList = (agentList, emptyLabel = "(none)") => agentList.length === 0 ? emptyLabel : agentList.join(", ");
+
+// 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;
+  }
+  return result;
+};
+
+// src/utils/resolve-transport.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)`);
+};
+
+// src/cli/add.ts
+var mcpAddCommand = new import_commander.Command("add").description("Add an MCP server to coding agents").argument("[source]", "Remote URL, npm package, or command line").option("-a, --agent <agents...>", "Target specific agents (use '*' for all)").option("-g, --global", "Install to user-level config instead of project").option("-t, --transport <type>", "Transport type for remote servers (http or sse)").option("--header <header...>", "HTTP header (Key: Value), repeatable").option("--env <env...>", "Env var for stdio servers (KEY=VALUE), repeatable").option("--args <args...>", "CLI arguments for stdio/package servers").option("-n, --name <name>", "Server name override").option("-y, --yes", "Skip all prompts").option("--all", "Install to all supported agents").action(async (source, options) => {
+  try {
+    const isInteractive = Boolean(process.stdin.isTTY && !options.yes);
+    if (!source) {
+      if (isInteractive) {
+        const success = await wizardAdd({
+          name: options.name,
+          global: options.global,
+          args: options.args,
+          transport: resolveTransport(options.transport),
+          headers: parseKeyValueList(options.header, ":"),
+          env: parseKeyValueList(options.env, "="),
+          agents: options.all ? getMcpAgentTypes() : parseMcpAgentList(options.agent)
+        });
+        if (!success) process.exitCode = 1;
+        return;
+      }
+      logger.error('Missing required argument: "source" (e.g. mcps add @modelcontextprotocol/server-filesystem)');
+      process.exitCode = 1;
+      return;
+    }
+    const parsed = parseMcpSource(source);
+    const cwd = process.cwd();
+    const isGlobal = Boolean(options.global);
+    const explicitTransport = resolveTransport(options.transport);
+    const transport = explicitTransport ?? (parsed.type === "remote" ? "http" : "stdio");
+    const resolvedTargets = resolveTargetAgents({
+      requested: options.agent,
+      all: options.all,
+      global: isGlobal,
+      cwd,
+      transport
+    });
+    if (resolvedTargets.agents.length === 0) {
+      const message = resolvedTargets.diagnostic ?? `No ${isGlobal ? "global" : "project"}-installed MCP agents detected. Pass ${import_picocolors12.default.cyan("-a <agent>")} (e.g. ${import_picocolors12.default.cyan("-a cursor")}) or ${import_picocolors12.default.cyan("--all")} to install.`;
+      logger.warn(message);
+      process.exitCode = 1;
+      return;
+    }
+    if (resolvedTargets.isDetected) {
+      logger.info(
+        `Detected ${isGlobal ? "global" : "project"} agents: ${import_picocolors12.default.cyan(formatAgentList(resolvedTargets.detected, "(none detected)"))}`
+      );
+      if (resolvedTargets.incompatible.length > 0) {
+        const skippedList = resolvedTargets.incompatible.map((item) => `${item.agent} (${item.reason})`).join(", ");
+        logger.info(
+          `Skipping detected agents incompatible with ${transport}: ${import_picocolors12.default.yellow(skippedList)}`
+        );
+      }
+    }
+    const targetAgents = resolvedTargets.isDetected ? resolvedTargets.agents : resolvedTargets.allAgents;
+    const result = installMcpServer({
+      source,
+      name: options.name,
+      agents: targetAgents,
+      args: options.args,
+      global: isGlobal,
+      cwd,
+      transport: explicitTransport,
+      headers: parseKeyValueList(options.header, ":"),
+      env: parseKeyValueList(options.env, "=")
+    });
+    logger.info(
+      `Installing ${import_picocolors12.default.bold(result.serverName)} (${import_picocolors12.default.cyan(parsed.type)}) to ${import_picocolors12.default.cyan(String(result.results.length))} agent(s)`
+    );
+    for (const record of result.results) {
+      if (record.success) {
+        logger.success(`${import_picocolors12.default.cyan(record.agent)} ${import_picocolors12.default.dim(record.path)}`);
+        logCoHostedNotice("configured", record.coConfiguredAgents);
+      } else {
+        logger.error(`${import_picocolors12.default.cyan(record.agent)}: ${record.error}`);
+      }
+    }
+    if (result.results.some((record) => !record.success)) process.exitCode = 1;
+  } catch (error) {
+    logger.error(toErrorMessage(error));
+    process.exitCode = 1;
+  }
+});
+
+// src/cli/list.ts
+var import_commander2 = require("commander");
+var import_picocolors13 = __toESM(require("picocolors"), 1);
+var mcpListCommand = new import_commander2.Command("list").alias("ls").description("List installed MCP servers across agents").option("-g, --global", "List global configs instead of project").option("-a, --agent <agents...>", "Filter by specific agents").option("--json", "Output as JSON").action((options) => {
+  try {
+    const entries = listInstalledMcpServers({
+      global: Boolean(options.global),
+      cwd: process.cwd(),
+      agents: parseMcpAgentList(options.agent)
+    });
+    if (options.json) {
+      console.log(JSON.stringify(entries, null, 2));
+      return;
+    }
+    if (entries.length === 0) {
+      logger.warn("No MCP servers installed");
+      return;
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const existing = grouped.get(entry.serverName) ?? [];
+      existing.push(entry);
+      grouped.set(entry.serverName, existing);
+    }
+    for (const [serverName, group] of grouped) {
+      const agentLabels = group.map((record) => record.agent).join(", ");
+      console.log(`  ${import_picocolors13.default.bold(serverName)} ${import_picocolors13.default.dim(`[${agentLabels}]`)}`);
+      const firstPath = group[0]?.path;
+      if (firstPath) console.log(`    ${import_picocolors13.default.dim(firstPath)}`);
+    }
+  } catch (error) {
+    logger.error(toErrorMessage(error));
+    process.exitCode = 1;
   }
-  return allSuccess;
-};
+});
+
+// src/cli/manage.ts
+var import_commander3 = require("commander");
+var import_picocolors16 = __toESM(require("picocolors"), 1);
 
 // src/interactive/wizard-manage.ts
 var import_prompts8 = require("@inquirer/prompts");
-var import_picocolors13 = __toESM(require("picocolors"), 1);
+var import_picocolors15 = __toESM(require("picocolors"), 1);
 
 // src/utils/display-server-details.ts
-var import_picocolors12 = __toESM(require("picocolors"), 1);
+var import_picocolors14 = __toESM(require("picocolors"), 1);
 var displayServerDetails = ({
   serverName,
   config,
@@ -2748,81 +3038,50 @@ var displayServerDetails = ({
   global: isGlobal,
   titlePrefix = "MCP Server Details"
 }) => {
-  console.log("\n" + import_picocolors12.default.cyan(import_picocolors12.default.bold(`${titlePrefix}: [${serverName}]`)));
+  console.log("\n" + import_picocolors14.default.cyan(import_picocolors14.default.bold(`${titlePrefix}: [${serverName}]`)));
   if (isGlobal !== void 0) {
-    console.log(`  ${import_picocolors12.default.bold("Scope:")} ${isGlobal ? "Global" : "Project"}`);
+    console.log(`  ${import_picocolors14.default.bold("Scope:")} ${isGlobal ? "Global" : "Project"}`);
   }
   if (agents && agents.length > 0) {
     console.log(
-      `  ${import_picocolors12.default.bold("Configured Agents:")} ${import_picocolors12.default.green(agents.map((a) => getMcpAgentConfig(a).displayName).join(", "))}`
+      `  ${import_picocolors14.default.bold("Configured Agents:")} ${import_picocolors14.default.green(agents.map((a) => getMcpAgentConfig(a).displayName).join(", "))}`
     );
   }
   if (hasDivergence) {
     console.log(
-      `  ${import_picocolors12.default.yellow(import_picocolors12.default.bold("Notice:"))} ${import_picocolors12.default.yellow("Configurations differ across installed agents. Showing configuration from the first agent.")}`
+      `  ${import_picocolors14.default.yellow(import_picocolors14.default.bold("Notice:"))} ${import_picocolors14.default.yellow("Configurations differ across installed agents. Showing configuration from the first agent.")}`
     );
   }
   const isRemote = Boolean(config.url && config.url.length > 0);
   if (isRemote) {
-    console.log(`  ${import_picocolors12.default.bold("Transport:")} ${import_picocolors12.default.magenta(config.type ?? "http")}`);
-    console.log(`  ${import_picocolors12.default.bold("URL:")} ${import_picocolors12.default.dim(config.url ?? "")}`);
+    console.log(`  ${import_picocolors14.default.bold("Transport:")} ${import_picocolors14.default.magenta(config.type ?? "http")}`);
+    console.log(`  ${import_picocolors14.default.bold("URL:")} ${import_picocolors14.default.dim(config.url ?? "")}`);
     const headerKeys = Object.keys(config.headers ?? {});
     if (headerKeys.length > 0) {
-      console.log(`  ${import_picocolors12.default.bold("Headers:")} ${import_picocolors12.default.cyan(String(headerKeys.length))}`);
+      console.log(`  ${import_picocolors14.default.bold("Headers:")} ${import_picocolors14.default.cyan(String(headerKeys.length))}`);
       for (const [k, v] of Object.entries(config.headers ?? {})) {
-        console.log(`    ${import_picocolors12.default.bold(k)}: ${import_picocolors12.default.dim(maskSecretHeader(k, v))}`);
+        console.log(`    ${import_picocolors14.default.bold(k)}: ${import_picocolors14.default.dim(maskSecretHeader(k, v))}`);
       }
     } else {
-      console.log(`  ${import_picocolors12.default.bold("Headers:")} ${import_picocolors12.default.dim("(none)")}`);
+      console.log(`  ${import_picocolors14.default.bold("Headers:")} ${import_picocolors14.default.dim("(none)")}`);
     }
   } else {
-    console.log(`  ${import_picocolors12.default.bold("Command:")} ${import_picocolors12.default.magenta(config.command ?? "")}`);
+    console.log(`  ${import_picocolors14.default.bold("Command:")} ${import_picocolors14.default.magenta(config.command ?? "")}`);
     const argsStr = config.args && config.args.length > 0 ? config.args.join(" ") : "(none)";
-    console.log(`  ${import_picocolors12.default.bold("Arguments:")} ${import_picocolors12.default.dim(argsStr)}`);
+    console.log(`  ${import_picocolors14.default.bold("Arguments:")} ${import_picocolors14.default.dim(argsStr)}`);
     const envKeys = Object.keys(config.env ?? {});
     if (envKeys.length > 0) {
-      console.log(`  ${import_picocolors12.default.bold("Environment Variables:")} ${import_picocolors12.default.cyan(String(envKeys.length))}`);
+      console.log(`  ${import_picocolors14.default.bold("Environment Variables:")} ${import_picocolors14.default.cyan(String(envKeys.length))}`);
       for (const [k, v] of Object.entries(config.env ?? {})) {
-        console.log(`    ${import_picocolors12.default.bold(k)}=${import_picocolors12.default.dim(maskSecretValue(k, v))}`);
+        console.log(`    ${import_picocolors14.default.bold(k)}=${import_picocolors14.default.dim(maskSecretValue(k, v))}`);
       }
     } else {
-      console.log(`  ${import_picocolors12.default.bold("Environment Variables:")} ${import_picocolors12.default.dim("(none)")}`);
+      console.log(`  ${import_picocolors14.default.bold("Environment Variables:")} ${import_picocolors14.default.dim("(none)")}`);
     }
   }
   console.log();
 };
 
-// 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 = normalizeServerConfig(item.config);
-    let entry = grouped.get(item.serverName);
-    if (!entry) {
-      entry = {
-        serverName: item.serverName,
-        agents: [],
-        paths: [],
-        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);
-    }
-    if (!entry.paths.includes(item.path)) {
-      entry.paths.push(item.path);
-    }
-  }
-  return grouped;
-};
-
 // src/interactive/wizard-manage.ts
 var promptSwitchServerType = async (currentConfig, serverName) => {
   const isRemote = Boolean(currentConfig.url && currentConfig.url.length > 0);
@@ -2834,11 +3093,11 @@ var promptSwitchServerType = async (currentConfig, serverName) => {
     const newArgs = await promptEditArgs([]);
     const newEnv = await promptEditEnvConfig({});
     logger.success(`Switched [${serverName}] configuration to stdio mode`);
-    return {
+    return toStdioServerConfig({
       command: newCmd.trim(),
       args: newArgs.length > 0 ? newArgs : void 0,
       env: Object.keys(newEnv).length > 0 ? newEnv : void 0
-    };
+    });
   }
   const newUrl = await (0, import_prompts8.input)({
     message: "Remote server URL:",
@@ -2861,11 +3120,13 @@ var promptSwitchServerType = async (currentConfig, serverName) => {
   });
   const newHeaders = await promptEditHeadersConfig({});
   logger.success(`Switched [${serverName}] configuration to remote mode`);
-  return {
-    url: newUrl.trim(),
-    type: transport,
-    headers: Object.keys(newHeaders).length > 0 ? newHeaders : void 0
-  };
+  return toRemoteServerConfig(
+    {
+      url: newUrl.trim(),
+      headers: Object.keys(newHeaders).length > 0 ? newHeaders : void 0
+    },
+    transport
+  );
 };
 var handleEditServerConfig = async (options) => {
   const { targetGroup } = options;
@@ -2963,7 +3224,7 @@ var handleEditServerConfig = async (options) => {
     } else if (editAction === "save") {
       let targetAgents = targetGroup.agents;
       if (targetGroup.agents.length > 1) {
-        const sortedAgents = sortAgentsWithClusters(targetGroup.agents, { global: isGlobal, cwd });
+        const sortedAgents = agentConfigStore.sortAgentsByClusters(targetGroup.agents, { global: isGlobal, cwd });
         const choices = buildLinkedAgentChoices({
           agents: sortedAgents,
           checkedAgents: sortedAgents,
@@ -2992,7 +3253,7 @@ var handleEditServerConfig = async (options) => {
       });
       if (resolution.incompatible.length > 0) {
         for (const item of resolution.incompatible) {
-          logger.warn(`Skipping ${import_picocolors13.default.cyan(item.agent)}: ${item.reason}`);
+          logger.warn(`Skipping ${import_picocolors15.default.cyan(item.agent)}: ${item.reason}`);
         }
       }
       if (resolution.compatibleAgents.length === 0) {
@@ -3025,10 +3286,10 @@ var handleEditServerConfig = async (options) => {
           updatedAny = true;
           succeededAgents.push(res.agent);
           logger.success(
-            `${import_picocolors13.default.cyan(res.agent)}: Successfully updated configuration in ${import_picocolors13.default.dim(res.path)}${formatCoHostedBadge("configured", res.coConfiguredAgents)}`
+            `${import_picocolors15.default.cyan(res.agent)}: Successfully updated configuration in ${import_picocolors15.default.dim(res.path)}${formatCoHostedBadge("configured", res.coConfiguredAgents)}`
           );
         } else {
-          logger.error(`${import_picocolors13.default.cyan(res.agent)}: Update failed - ${res.error}`);
+          logger.error(`${import_picocolors15.default.cyan(res.agent)}: Update failed - ${res.error}`);
         }
       }
       if (updatedAny) {
@@ -3046,16 +3307,14 @@ var wizardManage = async (options = {}) => {
     defaultGlobal: options.global,
     message: "Select MCP scope to inspect and manage:"
   });
-  const installed = listInstalledMcpServers({ global: isGlobal, cwd });
-  if (installed.length === 0) {
+  const grouped = queryGroupedInstalledServers({ global: isGlobal, cwd });
+  if (grouped.size === 0) {
     logger.warn(`No configured MCP servers found in ${isGlobal ? "global" : "project"} scope`);
     return;
   }
-  const grouped = groupInstalledServersByName(installed);
   let pendingServerName = options.serverName;
   const refreshGroupedServers = () => {
-    const freshInstalled = listInstalledMcpServers({ global: isGlobal, cwd });
-    const freshGrouped = groupInstalledServersByName(freshInstalled);
+    const freshGrouped = queryGroupedInstalledServers({ global: isGlobal, cwd });
     grouped.clear();
     for (const [name, grp] of freshGrouped) {
       grouped.set(name, grp);
@@ -3071,7 +3330,7 @@ var wizardManage = async (options = {}) => {
       const choices = Array.from(grouped.values()).map((g) => {
         const agentNames = g.agents.map((a) => getMcpAgentConfig(a).displayName).join(", ");
         return {
-          name: `${import_picocolors13.default.bold(g.serverName)} ${import_picocolors13.default.dim(`(configured in: ${agentNames})`)}`,
+          name: `${import_picocolors15.default.bold(g.serverName)} ${import_picocolors15.default.dim(`(configured in: ${agentNames})`)}`,
           value: g.serverName
         };
       });
@@ -3132,7 +3391,7 @@ var wizardManage = async (options = {}) => {
         );
         continue;
       }
-      const candidateAgents = sortAgentsWithClusters(rawCandidateAgents, { global: isGlobal, cwd });
+      const candidateAgents = agentConfigStore.sortAgentsByClusters(rawCandidateAgents, { global: isGlobal, cwd });
       const choices = buildLinkedAgentChoices({
         agents: candidateAgents,
         checkedAgents: [],
@@ -3160,7 +3419,7 @@ var wizardManage = async (options = {}) => {
         cwd
       });
       for (const item of syncResult.incompatible) {
-        logger.warn(`Skipping ${import_picocolors13.default.cyan(item.agent)}: ${item.reason}`);
+        logger.warn(`Skipping ${import_picocolors15.default.cyan(item.agent)}: ${item.reason}`);
       }
       for (const res of syncResult.results) {
         if (syncResult.incompatible.some((i) => i.agent === res.agent)) {
@@ -3168,187 +3427,21 @@ var wizardManage = async (options = {}) => {
         }
         if (res.success) {
           logger.success(
-            `${import_picocolors13.default.cyan(res.agent)}: Successfully synced to ${import_picocolors13.default.dim(res.path)}${formatCoHostedBadge("configured", res.coConfiguredAgents)}`
+            `${import_picocolors15.default.cyan(res.agent)}: Successfully synced to ${import_picocolors15.default.dim(res.path)}${formatCoHostedBadge("configured", res.coConfiguredAgents)}`
           );
           targetGroup.agents.push(res.agent);
         } else {
-          logger.error(`${import_picocolors13.default.cyan(res.agent)}: Sync failed - ${res.error}`);
+          logger.error(`${import_picocolors15.default.cyan(res.agent)}: Sync failed - ${res.error}`);
         }
       }
-      refreshGroupedServers();
-    }
-  }
-};
-
-// src/interactive/wizard-remove.ts
-var import_prompts9 = require("@inquirer/prompts");
-var import_picocolors14 = __toESM(require("picocolors"), 1);
-var wizardRemove = async (options = {}) => {
-  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_picocolors14.default.bold(g.serverName)} ${import_picocolors14.default.dim(`(installed in: ${g.agents.map((a) => getMcpAgentConfig(a).displayName).join(", ")})`)}`,
-      value: g.serverName
-    }));
-    serverName = await (0, import_prompts9.select)({
-      message: "Select MCP server to remove:",
-      choices
-    });
-  }
-  const rawInstalledAgents = serverMap.get(serverName)?.agents || [];
-  if (rawInstalledAgents.length === 0) {
-    logger.warn(`No agents found with [${serverName}] installed`);
-    return false;
-  }
-  const installedAgents = sortAgentsWithClusters(rawInstalledAgents, { global: isGlobal, cwd });
-  let targetAgents = options.agents;
-  if (!targetAgents || targetAgents.length === 0) {
-    const choices = buildLinkedAgentChoices({
-      agents: installedAgents,
-      checkedAgents: installedAgents,
-      scopeOptions: { global: isGlobal, cwd }
-    });
-    targetAgents = await linkedCheckbox({
-      message: `Select agents to remove [${serverName}] from:`,
-      choices,
-      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 confirmed = await (0, import_prompts9.confirm)({
-    message: `Confirm removing MCP server [${serverName}] from ${targetAgents.join(", ")}?`,
-    default: true
-  });
-  if (!confirmed) {
-    logger.warn("Operation cancelled");
-    return false;
-  }
-  const results = removeMcpServer({
-    name: serverName,
-    agents: targetAgents,
-    global: isGlobal,
-    cwd
-  });
-  let removedCount = 0;
-  for (const res of results) {
-    if (res.removed) {
-      logger.success(
-        `${import_picocolors14.default.cyan(res.agent)}: Successfully removed from ${import_picocolors14.default.dim(res.path)}${formatCoHostedBadge("affected", res.coAffectedAgents)}`
-      );
-      removedCount++;
-    } else if (res.error) {
-      logger.error(`${import_picocolors14.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;
-};
-
-// src/interactive/main-menu.ts
-var mainMenu = async () => {
-  console.log();
-  console.log(import_picocolors15.default.bold(import_picocolors15.default.cyan("mcps - Cross-Platform MCP Manager for AI Coding Agents")));
-  console.log(import_picocolors15.default.dim("Cross-platform MCP server configuration & synchronization tool"));
-  console.log();
-  while (true) {
-    try {
-      const action = await (0, import_prompts10.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_picocolors15.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_picocolors15.default.dim("Exited."));
-        break;
-      }
-      throw error;
-    }
-  }
-};
-
-// src/utils/resolve-transport.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)`);
-};
-
-// src/cli/manage.ts
-var import_commander = require("commander");
-var import_picocolors16 = __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`);
+      refreshGroupedServers();
     }
-    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;
   }
-  return result;
 };
 
 // src/cli/manage.ts
 var requireTargetServerGroup = (serverName, scope) => {
-  const installed = listInstalledMcpServers(scope);
-  const grouped = groupInstalledServersByName(installed);
+  const grouped = queryGroupedInstalledServers(scope);
   const targetGroup = grouped.get(serverName);
   if (!targetGroup) {
     logger.error(
@@ -3359,18 +3452,13 @@ var requireTargetServerGroup = (serverName, scope) => {
   }
   return targetGroup;
 };
-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("--clear-headers", "Clear all HTTP headers for remote servers").option("--env <env...>", "Env var for stdio servers (KEY=VALUE), repeatable").option("--clear-env", "Clear all environment variables for stdio servers").option("--args <args...>", "CLI arguments for stdio/package servers").option("--clear-args", "Clear all 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) => {
+var mcpManageCommand = new import_commander3.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("--clear-headers", "Clear all HTTP headers for remote servers").option("--env <env...>", "Env var for stdio servers (KEY=VALUE), repeatable").option("--clear-env", "Clear all environment variables for stdio servers").option("--args <args...>", "CLI arguments for stdio/package servers").option("--clear-args", "Clear all 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 || Boolean(options.clearArgs) || options.env !== void 0 || Boolean(options.clearEnv) || options.header !== void 0 || Boolean(options.clearHeaders) || options.url !== void 0 || options.transport !== void 0;
     const isInteractive = Boolean(process.stdin.isTTY && !options.yes);
     if (hasModifications) {
-      if (options.url !== void 0 && options.command !== void 0) {
-        logger.error('Cannot specify both "--url" (remote) and "--command" (stdio) simultaneously.');
-        process.exitCode = 1;
-        return;
-      }
       if (!serverName) {
         logger.error('Missing required argument: "server-name" when passing modification flags.');
         process.exitCode = 1;
@@ -3380,64 +3468,34 @@ var mcpManageCommand = new import_commander.Command("manage").description("Inspe
       if (!targetGroup) {
         return;
       }
-      const isCurrentRemote = Boolean(targetGroup.config.url && targetGroup.config.url.length > 0);
-      const willBeRemote = options.url !== void 0 ? true : options.command !== void 0 ? false : isCurrentRemote;
-      if (willBeRemote) {
-        const ignoredStdioFlags = [];
-        if (options.env !== void 0) ignoredStdioFlags.push("--env");
-        if (options.clearEnv) ignoredStdioFlags.push("--clear-env");
-        if (options.args !== void 0) ignoredStdioFlags.push("--args");
-        if (options.clearArgs) ignoredStdioFlags.push("--clear-args");
-        if (ignoredStdioFlags.length > 0) {
-          const hint = options.url !== void 0 ? "When configuring a remote server, stdio flags are ignored." : "Use --command to switch to stdio mode.";
-          logger.warn(
-            `Server "${serverName}" is a remote server. The following stdio flags will be ignored: ${ignoredStdioFlags.join(", ")}. ${hint}`
-          );
-        }
-      } else {
-        const ignoredRemoteFlags = [];
-        if (options.header !== void 0) ignoredRemoteFlags.push("--header");
-        if (options.clearHeaders) ignoredRemoteFlags.push("--clear-headers");
-        if (options.transport !== void 0) ignoredRemoteFlags.push("--transport");
-        if (ignoredRemoteFlags.length > 0) {
-          const hint = options.command !== void 0 ? "When configuring a stdio server, remote flags are ignored." : "Use --url to switch to remote mode.";
-          logger.warn(
-            `Server "${serverName}" is a stdio server. The following remote flags will be ignored: ${ignoredRemoteFlags.join(", ")}. ${hint}`
-          );
-        }
-      }
-      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 = resolveTransport(options.transport);
-      }
-      if (options.clearEnv) {
-        incomingDelta.env = void 0;
-      }
-      if (options.env !== void 0) {
-        const parsedEnv = parseKeyValueList(options.env, "=");
-        const baseEnv = options.clearEnv ? {} : targetGroup.config.env ?? {};
-        incomingDelta.env = { ...baseEnv, ...parsedEnv };
-      }
-      if (options.clearHeaders) {
-        incomingDelta.headers = void 0;
+      const parsedEnv = options.env !== void 0 ? parseKeyValueList(options.env, "=") : void 0;
+      const parsedHeaders = options.header !== void 0 ? parseKeyValueList(options.header, ":") : void 0;
+      let deltaResult;
+      try {
+        deltaResult = applyServerConfigDelta(targetGroup.config, {
+          command: options.command,
+          args: options.args,
+          clearArgs: options.clearArgs,
+          env: parsedEnv,
+          clearEnv: options.clearEnv,
+          url: options.url,
+          transport: resolveTransport(options.transport),
+          headers: parsedHeaders,
+          clearHeaders: options.clearHeaders
+        });
+      } catch (error) {
+        logger.error(toErrorMessage(error));
+        process.exitCode = 1;
+        return;
       }
-      if (options.header !== void 0) {
-        const parsedHeaders = parseKeyValueList(options.header, ":");
-        const baseHeaders = options.clearHeaders ? {} : targetGroup.config.headers ?? {};
-        incomingDelta.headers = { ...baseHeaders, ...parsedHeaders };
+      if (deltaResult.ignoredFlags.length > 0) {
+        const isRemote = deltaResult.protocol === "remote";
+        const hint = isRemote ? options.url !== void 0 ? "When configuring a remote server, stdio flags are ignored." : "Use --command to switch to stdio mode." : options.command !== void 0 ? "When configuring a stdio server, remote flags are ignored." : "Use --url to switch to remote mode.";
+        logger.warn(
+          `Server "${serverName}" is a ${isRemote ? "remote" : "stdio"} server. The following ${isRemote ? "stdio" : "remote"} flags will be ignored: ${deltaResult.ignoredFlags.join(", ")}. ${hint}`
+        );
       }
+      const incomingDelta = deltaResult.config;
       let targetAgents = targetGroup.agents;
       if (options.agent !== void 0) {
         const parsed = parseMcpAgentList(options.agent);
@@ -3522,129 +3580,96 @@ var mcpManageCommand = new import_commander.Command("manage").description("Inspe
   }
 });
 
-// src/utils/format-agent-list.ts
-var formatAgentList = (agentList, emptyLabel = "(none)") => agentList.length === 0 ? emptyLabel : agentList.join(", ");
+// src/cli/remove.ts
+var import_commander4 = require("commander");
+var import_picocolors18 = __toESM(require("picocolors"), 1);
 
-// src/cli/add.ts
-var mcpAddCommand = new import_commander2.Command("add").description("Add an MCP server to coding agents").argument("[source]", "Remote URL, npm package, or command line").option("-a, --agent <agents...>", "Target specific agents (use '*' for all)").option("-g, --global", "Install to user-level config instead of project").option("-t, --transport <type>", "Transport type for remote servers (http or sse)").option("--header <header...>", "HTTP header (Key: Value), repeatable").option("--env <env...>", "Env var for stdio servers (KEY=VALUE), repeatable").option("--args <args...>", "CLI arguments for stdio/package servers").option("-n, --name <name>", "Server name override").option("-y, --yes", "Skip all prompts").option("--all", "Install to all supported agents").action(async (source, options) => {
-  try {
-    const isInteractive = Boolean(process.stdin.isTTY && !options.yes);
-    if (!source) {
-      if (isInteractive) {
-        const success = await wizardAdd({
-          name: options.name,
-          global: options.global,
-          args: options.args,
-          transport: resolveTransport(options.transport),
-          headers: parseKeyValueList(options.header, ":"),
-          env: parseKeyValueList(options.env, "="),
-          agents: options.all ? getMcpAgentTypes() : parseMcpAgentList(options.agent)
-        });
-        if (!success) process.exitCode = 1;
-        return;
-      }
-      logger.error('Missing required argument: "source" (e.g. mcps add @modelcontextprotocol/server-filesystem)');
-      process.exitCode = 1;
-      return;
-    }
-    const parsed = parseMcpSource(source);
-    const cwd = process.cwd();
-    const isGlobal = Boolean(options.global);
-    const explicitTransport = resolveTransport(options.transport);
-    const transport = explicitTransport ?? (parsed.type === "remote" ? "http" : "stdio");
-    const resolvedTargets = resolveTargetAgents({
-      requested: options.agent,
-      all: options.all,
-      global: isGlobal,
-      cwd,
-      transport
-    });
-    if (resolvedTargets.agents.length === 0) {
-      const message = resolvedTargets.diagnostic ?? `No ${isGlobal ? "global" : "project"}-installed MCP agents detected. Pass ${import_picocolors17.default.cyan("-a <agent>")} (e.g. ${import_picocolors17.default.cyan("-a cursor")}) or ${import_picocolors17.default.cyan("--all")} to install.`;
-      logger.warn(message);
-      process.exitCode = 1;
-      return;
-    }
-    if (resolvedTargets.isDetected) {
-      logger.info(
-        `Detected ${isGlobal ? "global" : "project"} agents: ${import_picocolors17.default.cyan(formatAgentList(resolvedTargets.detected, "(none detected)"))}`
-      );
-      if (resolvedTargets.incompatible.length > 0) {
-        const skippedList = resolvedTargets.incompatible.map((item) => `${item.agent} (${item.reason})`).join(", ");
-        logger.info(
-          `Skipping detected agents incompatible with ${transport}: ${import_picocolors17.default.yellow(skippedList)}`
-        );
-      }
-    }
-    const targetAgents = resolvedTargets.isDetected ? resolvedTargets.agents : resolvedTargets.allAgents;
-    const result = installMcpServer({
-      source,
-      name: options.name,
-      agents: targetAgents,
-      args: options.args,
-      global: isGlobal,
-      cwd,
-      transport: explicitTransport,
-      headers: parseKeyValueList(options.header, ":"),
-      env: parseKeyValueList(options.env, "=")
+// src/interactive/wizard-remove.ts
+var import_prompts9 = require("@inquirer/prompts");
+var import_picocolors17 = __toESM(require("picocolors"), 1);
+var wizardRemove = async (options = {}) => {
+  const cwd = options.cwd ?? process.cwd();
+  const isGlobal = await promptScope({
+    cwd,
+    defaultGlobal: options.global,
+    message: "Select scope to remove MCP server from:"
+  });
+  const serverMap = queryGroupedInstalledServers({ global: isGlobal, cwd });
+  if (serverMap.size === 0) {
+    logger.warn(`No installed MCP servers found in ${isGlobal ? "global" : "project"} scope`);
+    return false;
+  }
+  let serverName = options.name;
+  if (!serverName) {
+    const choices = Array.from(serverMap.values()).map((g) => ({
+      name: `${import_picocolors17.default.bold(g.serverName)} ${import_picocolors17.default.dim(`(installed in: ${g.agents.map((a) => getMcpAgentConfig(a).displayName).join(", ")})`)}`,
+      value: g.serverName
+    }));
+    serverName = await (0, import_prompts9.select)({
+      message: "Select MCP server to remove:",
+      choices
     });
-    logger.info(
-      `Installing ${import_picocolors17.default.bold(result.serverName)} (${import_picocolors17.default.cyan(parsed.type)}) to ${import_picocolors17.default.cyan(String(result.results.length))} agent(s)`
-    );
-    for (const record of result.results) {
-      if (record.success) {
-        logger.success(`${import_picocolors17.default.cyan(record.agent)} ${import_picocolors17.default.dim(record.path)}`);
-        logCoHostedNotice("configured", record.coConfiguredAgents);
-      } else {
-        logger.error(`${import_picocolors17.default.cyan(record.agent)}: ${record.error}`);
-      }
-    }
-    if (result.results.some((record) => !record.success)) process.exitCode = 1;
-  } catch (error) {
-    logger.error(toErrorMessage(error));
-    process.exitCode = 1;
   }
-});
-
-// src/cli/list.ts
-var import_commander3 = require("commander");
-var import_picocolors18 = __toESM(require("picocolors"), 1);
-var mcpListCommand = new import_commander3.Command("list").alias("ls").description("List installed MCP servers across agents").option("-g, --global", "List global configs instead of project").option("-a, --agent <agents...>", "Filter by specific agents").option("--json", "Output as JSON").action((options) => {
-  try {
-    const entries = listInstalledMcpServers({
-      global: Boolean(options.global),
-      cwd: process.cwd(),
-      agents: parseMcpAgentList(options.agent)
+  const rawInstalledAgents = serverMap.get(serverName)?.agents || [];
+  if (rawInstalledAgents.length === 0) {
+    logger.warn(`No agents found with [${serverName}] installed`);
+    return false;
+  }
+  const installedAgents = agentConfigStore.sortAgentsByClusters(rawInstalledAgents, { global: isGlobal, cwd });
+  let targetAgents = options.agents;
+  if (!targetAgents || targetAgents.length === 0) {
+    const choices = buildLinkedAgentChoices({
+      agents: installedAgents,
+      checkedAgents: installedAgents,
+      scopeOptions: { global: isGlobal, cwd }
     });
-    if (options.json) {
-      console.log(JSON.stringify(entries, null, 2));
-      return;
-    }
-    if (entries.length === 0) {
-      logger.warn("No MCP servers installed");
-      return;
-    }
-    const grouped = /* @__PURE__ */ new Map();
-    for (const entry of entries) {
-      const existing = grouped.get(entry.serverName) ?? [];
-      existing.push(entry);
-      grouped.set(entry.serverName, existing);
+    targetAgents = await linkedCheckbox({
+      message: `Select agents to remove [${serverName}] from:`,
+      choices,
+      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;
     }
-    for (const [serverName, group] of grouped) {
-      const agentLabels = group.map((record) => record.agent).join(", ");
-      console.log(`  ${import_picocolors18.default.bold(serverName)} ${import_picocolors18.default.dim(`[${agentLabels}]`)}`);
-      const firstPath = group[0]?.path;
-      if (firstPath) console.log(`    ${import_picocolors18.default.dim(firstPath)}`);
+    targetAgents = validAgents;
+  }
+  const confirmed = await (0, import_prompts9.confirm)({
+    message: `Confirm removing MCP server [${serverName}] from ${targetAgents.join(", ")}?`,
+    default: true
+  });
+  if (!confirmed) {
+    logger.warn("Operation cancelled");
+    return false;
+  }
+  const results = removeMcpServer({
+    name: serverName,
+    agents: targetAgents,
+    global: isGlobal,
+    cwd
+  });
+  let removedCount = 0;
+  for (const res of results) {
+    if (res.removed) {
+      logger.success(
+        `${import_picocolors17.default.cyan(res.agent)}: Successfully removed from ${import_picocolors17.default.dim(res.path)}${formatCoHostedBadge("affected", res.coAffectedAgents)}`
+      );
+      removedCount++;
+    } else if (res.error) {
+      logger.error(`${import_picocolors17.default.cyan(res.agent)}: Failed to remove - ${res.error}`);
     }
-  } catch (error) {
-    logger.error(toErrorMessage(error));
-    process.exitCode = 1;
   }
-});
+  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;
+};
 
 // src/cli/remove.ts
-var import_commander4 = require("commander");
-var import_picocolors19 = __toESM(require("picocolors"), 1);
 var mcpRemoveCommand = new import_commander4.Command("remove").alias("rm").description("Remove an MCP server from agent configs").argument("[name]", "Server name").option("-g, --global", "Remove from global scope").option("-a, --agent <agents...>", "Filter by specific agents (use '*' for all)").option("-y, --yes", "Skip confirmation prompts").action(async (name, options) => {
   try {
     const isInteractive = Boolean(process.stdin.isTTY && !options.yes);
@@ -3668,17 +3693,17 @@ var mcpRemoveCommand = new import_commander4.Command("remove").alias("rm").descr
       cwd: process.cwd()
     });
     if (results.length === 0) {
-      logger.warn(`No agent config contained ${import_picocolors19.default.bold(name)}`);
+      logger.warn(`No agent config contained ${import_picocolors18.default.bold(name)}`);
       return;
     }
     for (const record of results) {
       if (record.removed) {
         logger.success(
-          `${import_picocolors19.default.cyan(record.agent)} removed ${import_picocolors19.default.bold(name)} ${import_picocolors19.default.dim(record.path)}`
+          `${import_picocolors18.default.cyan(record.agent)} removed ${import_picocolors18.default.bold(name)} ${import_picocolors18.default.dim(record.path)}`
         );
         logCoHostedNotice("affected", record.coAffectedAgents);
       } else {
-        logger.error(`${import_picocolors19.default.cyan(record.agent)}: ${record.error ?? "not found"}`);
+        logger.error(`${import_picocolors18.default.cyan(record.agent)}: ${record.error ?? "not found"}`);
       }
     }
   } catch (error) {
@@ -3687,8 +3712,61 @@ var mcpRemoveCommand = new import_commander4.Command("remove").alias("rm").descr
   }
 });
 
+// src/interactive/main-menu.ts
+var import_prompts10 = require("@inquirer/prompts");
+var import_picocolors19 = __toESM(require("picocolors"), 1);
+var mainMenu = async () => {
+  console.log();
+  console.log(import_picocolors19.default.bold(import_picocolors19.default.cyan("mcps - Cross-Platform MCP Manager for AI Coding Agents")));
+  console.log(import_picocolors19.default.dim("Cross-platform MCP server configuration & synchronization tool"));
+  console.log();
+  while (true) {
+    try {
+      const action = await (0, import_prompts10.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_picocolors19.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_picocolors19.default.dim("Exited."));
+        break;
+      }
+      throw error;
+    }
+  }
+};
+
 // src/cli.ts
-var VERSION = "0.1.0-beta.3";
+var VERSION = "0.1.0";
 process.on("SIGINT", () => process.exit(0));
 process.on("SIGTERM", () => process.exit(0));
 var program = new import_commander5.Command().name("mcps").description("Install, list, and remove MCP servers across AI coding agents").version(VERSION, "-v, --version", "display the version number");