@wuyax/mcps 0.1.0-beta.3 → 0.1.0

package/dist/{chunk-BUKA3NPJ.js → interactive.cjs}

@@ -1,79 +1,351 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/interactive/index.ts
+var interactive_exports = {};
+__export(interactive_exports, {
+  buildLinkedAgentChoices: () => buildLinkedAgentChoices,
+  formatArgsString: () => formatArgsString,
+  formatEnvText: () => formatEnvText,
+  formatHeadersText: () => formatHeadersText,
+  linkedCheckbox: () => linkedCheckbox,
+  mainMenu: () => mainMenu,
+  parseArgsString: () => parseArgsString,
+  parseEnvText: () => parseEnvText,
+  parseHeadersText: () => parseHeadersText,
+  promptArgsConfig: () => promptArgsConfig,
+  promptEditArgs: () => promptEditArgs,
+  promptEditEnvConfig: () => promptEditEnvConfig,
+  promptEditHeadersConfig: () => promptEditHeadersConfig,
+  promptEditKeyValueConfig: () => promptEditKeyValueConfig,
+  promptEditorText: () => promptEditorText,
+  promptEnvConfig: () => promptEnvConfig,
+  promptHeadersConfig: () => promptHeadersConfig,
+  promptScope: () => promptScope,
+  promptScopeAndAgents: () => promptScopeAndAgents,
+  promptSwitchServerType: () => promptSwitchServerType,
+  readMultilineTextFromTerminal: () => readMultilineTextFromTerminal,
+  wizardAdd: () => wizardAdd,
+  wizardManage: () => wizardManage,
+  wizardRemove: () => wizardRemove
+});
+module.exports = __toCommonJS(interactive_exports);
+
+// src/interactive/prompts/linked-checkbox.ts
+var import_core = require("@inquirer/core");
+var import_picocolors = __toESM(require("picocolors"), 1);
+var defaultTheme = {
+  icon: {
+    checked: import_picocolors.default.green("[x]"),
+    unchecked: import_picocolors.default.dim("[ ]"),
+    cursor: import_picocolors.default.cyan(">"),
+    disabledChecked: import_picocolors.default.dim("[x]"),
+    disabledUnchecked: import_picocolors.default.dim("[-]")
+  },
+  style: {
+    disabled: (text) => import_picocolors.default.dim(text),
+    renderSelectedChoices: (selectedChoices) => selectedChoices.map((choice) => choice.short).join(", "),
+    description: (text) => import_picocolors.default.cyan(text),
+    keysHelpTip: (keys) => keys.map(([key, action]) => `${import_picocolors.default.bold(key)} ${import_picocolors.default.dim(action)}`).join(import_picocolors.default.dim(" | ")),
+    highlight: (text) => import_picocolors.default.cyan(text)
+  },
+  i18n: {
+    disabledError: "This option is disabled and cannot be toggled."
+  }
+};
+function isSelectable(item) {
+  return !import_core.Separator.isSeparator(item) && !item.disabled;
+}
+function isNavigable(item) {
+  return !import_core.Separator.isSeparator(item);
+}
+function isChecked(item) {
+  return !import_core.Separator.isSeparator(item) && item.checked;
+}
+function normalizeChoices(choices) {
+  return choices.map((choice) => {
+    if (import_core.Separator.isSeparator(choice)) {
+      return choice;
+    }
+    if (typeof choice !== "object" || choice === null || !("value" in choice)) {
+      const name2 = String(choice);
+      return {
+        value: choice,
+        name: name2,
+        short: name2,
+        checkedName: name2,
+        disabled: false,
+        checked: false,
+        linkedValues: []
+      };
+    }
+    const name = choice.name ?? String(choice.value);
+    return {
+      value: choice.value,
+      name,
+      short: choice.short ?? name,
+      checkedName: choice.checkedName ?? name,
+      description: choice.description,
+      disabled: choice.disabled ?? false,
+      checked: choice.checked ?? false,
+      linkedValues: choice.linkedValues ?? []
+    };
+  });
+}
+var linkedCheckbox = (0, import_core.createPrompt)(
+  (config, done) => {
+    const { pageSize = 10, loop = true, required, validate = () => true } = config;
+    const theme = (0, import_core.makeTheme)(defaultTheme, config.theme);
+    const [status, setStatus] = (0, import_core.useState)("idle");
+    const prefix = (0, import_core.usePrefix)({ status, theme });
+    const [items, setItems] = (0, import_core.useState)(() => normalizeChoices(config.choices));
+    const bounds = (0, import_core.useMemo)(() => {
+      const first = items.findIndex(isNavigable);
+      let last = -1;
+      for (let i = items.length - 1; i >= 0; i--) {
+        if (isNavigable(items[i])) {
+          last = i;
+          break;
+        }
+      }
+      if (first === -1 || last === -1) {
+        throw new import_core.ValidationError("[linkedCheckbox prompt] No selectable choices.");
+      }
+      return { first, last };
+    }, [items]);
+    const [active, setActive] = (0, import_core.useState)(bounds.first);
+    const [errorMsg, setError] = (0, import_core.useState)();
+    const toggleWithLinked = (targetIndex) => {
+      const targetItem = items[targetIndex];
+      if (!targetItem || import_core.Separator.isSeparator(targetItem) || targetItem.disabled) {
+        return;
+      }
+      const nextChecked = !targetItem.checked;
+      const targetValue = targetItem.value;
+      const linked = new Set(targetItem.linkedValues);
+      setItems(
+        (prevItems) => prevItems.map((item) => {
+          if (import_core.Separator.isSeparator(item) || item.disabled) {
+            return item;
+          }
+          const isTargetOrLinked = item.value === targetValue || linked.has(item.value) || item.linkedValues.includes(targetValue);
+          if (isTargetOrLinked) {
+            return { ...item, checked: nextChecked };
+          }
+          return item;
+        })
+      );
+    };
+    (0, import_core.useKeypress)(async (key) => {
+      if ((0, import_core.isEnterKey)(key)) {
+        const selection = items.filter(isChecked);
+        const isValid = await validate([...selection]);
+        if (required && selection.length === 0) {
+          setError("At least one choice must be selected");
+        } else if (isValid === true) {
+          setStatus("done");
+          done(selection.map((choice) => choice.value));
+        } else {
+          setError(typeof isValid === "string" ? isValid : "You must select a valid value");
+        }
+      } else if ((0, import_core.isUpKey)(key) || (0, import_core.isDownKey)(key)) {
+        if (errorMsg) setError(void 0);
+        if (loop || (0, import_core.isUpKey)(key) && active !== bounds.first || (0, import_core.isDownKey)(key) && active !== bounds.last) {
+          const offset = (0, import_core.isUpKey)(key) ? -1 : 1;
+          let next = active;
+          do {
+            next = (next + offset + items.length) % items.length;
+          } while (!isNavigable(items[next]));
+          setActive(next);
+        }
+      } else if ((0, import_core.isSpaceKey)(key)) {
+        const activeItem = items[active];
+        if (activeItem && !import_core.Separator.isSeparator(activeItem)) {
+          if (activeItem.disabled) {
+            setError(theme.i18n.disabledError);
+          } else {
+            setError(void 0);
+            toggleWithLinked(active);
+          }
+        }
+      } else if (key.name === "a") {
+        const hasUnchecked = items.some((choice) => isSelectable(choice) && !choice.checked);
+        setItems(
+          (prevItems) => prevItems.map((item) => isSelectable(item) ? { ...item, checked: hasUnchecked } : item)
+        );
+      } else if ((0, import_core.isNumberKey)(key)) {
+        const selectedIndex = Number(key.name) - 1;
+        let selectableIndex = -1;
+        const position = items.findIndex((item) => {
+          if (import_core.Separator.isSeparator(item)) return false;
+          selectableIndex++;
+          return selectableIndex === selectedIndex;
+        });
+        const selectedItem = items[position];
+        if (selectedItem && isSelectable(selectedItem)) {
+          setActive(position);
+          setError(void 0);
+          toggleWithLinked(position);
+        }
+      }
+    });
+    const message = theme.style.message(config.message, status);
+    let description;
+    const page = (0, import_core.usePagination)({
+      items,
+      active,
+      renderItem({ item, isActive }) {
+        if (import_core.Separator.isSeparator(item)) {
+          return ` ${item.separator}`;
+        }
+        const cursor = isActive ? theme.icon.cursor : " ";
+        if (item.disabled) {
+          const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
+          const checkbox2 = item.checked ? theme.icon.disabledChecked : theme.icon.disabledUnchecked;
+          return theme.style.disabled(`${cursor} ${checkbox2} ${item.name} ${disabledLabel}`);
+        }
+        if (isActive) {
+          description = item.description;
+        }
+        const checkbox = item.checked ? theme.icon.checked : theme.icon.unchecked;
+        const name = item.checked ? item.checkedName : item.name;
+        const color = isActive ? theme.style.highlight : (x) => x;
+        return color(`${cursor} ${checkbox} ${name}`);
+      },
+      pageSize,
+      loop
+    });
+    if (status === "done") {
+      const selection = items.filter(isChecked);
+      const answer = theme.style.answer(theme.style.renderSelectedChoices(selection, items));
+      return [prefix, message, answer].filter(Boolean).join(" ");
+    }
+    const helpLine = theme.style.keysHelpTip([
+      ["up/down", "navigate"],
+      ["space", "toggle"],
+      ["a", "all"],
+      ["enter", "submit"]
+    ]);
+    const lines = [
+      [prefix, message].filter(Boolean).join(" "),
+      page,
+      helpLine
+    ];
+    if (description) {
+      lines.push(theme.style.description(description));
+    }
+    if (errorMsg) {
+      lines.push(theme.style.error(errorMsg));
+    }
+    return lines.join("\n");
+  }
+);
+
+// src/interactive/utils/build-linked-agent-choices.ts
+var import_picocolors2 = __toESM(require("picocolors"), 1);
+
 // src/agents.ts
-import { existsSync } from "fs";
-import { homedir, platform } from "os";
-import { join } from "path";
-var home = homedir();
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var home = (0, import_node_os.homedir)();
 var getPlatformPaths = () => {
-  const currentPlatform = platform();
+  const currentPlatform = (0, import_node_os.platform)();
   if (currentPlatform === "win32") {
-    const appData = process.env.APPDATA || join(home, "AppData", "Roaming");
+    const appData = process.env.APPDATA || (0, import_node_path.join)(home, "AppData", "Roaming");
     return {
       appSupport: appData,
-      vscodePath: join(appData, "Code", "User"),
-      traePath: join(appData, "Trae", "User"),
-      gooseConfigPath: join(appData, "Block", "goose", "config", "config.yaml"),
-      zedConfigPath: join(appData, "Zed", "settings.json")
+      vscodePath: (0, import_node_path.join)(appData, "Code", "User"),
+      traePath: (0, import_node_path.join)(appData, "Trae", "User"),
+      gooseConfigPath: (0, import_node_path.join)(appData, "Block", "goose", "config", "config.yaml"),
+      zedConfigPath: (0, import_node_path.join)(appData, "Zed", "settings.json")
     };
   }
   if (currentPlatform === "darwin") {
     return {
-      appSupport: join(home, "Library", "Application Support"),
-      vscodePath: join(home, "Library", "Application Support", "Code", "User"),
-      traePath: join(home, "Library", "Application Support", "Trae", "User"),
-      gooseConfigPath: join(home, ".config", "goose", "config.yaml"),
-      zedConfigPath: join(home, ".config", "zed", "settings.json")
+      appSupport: (0, import_node_path.join)(home, "Library", "Application Support"),
+      vscodePath: (0, import_node_path.join)(home, "Library", "Application Support", "Code", "User"),
+      traePath: (0, import_node_path.join)(home, "Library", "Application Support", "Trae", "User"),
+      gooseConfigPath: (0, import_node_path.join)(home, ".config", "goose", "config.yaml"),
+      zedConfigPath: (0, import_node_path.join)(home, ".config", "zed", "settings.json")
     };
   }
-  const configDir = process.env.XDG_CONFIG_HOME || join(home, ".config");
+  const configDir = process.env.XDG_CONFIG_HOME || (0, import_node_path.join)(home, ".config");
   return {
     appSupport: configDir,
-    vscodePath: join(configDir, "Code", "User"),
-    traePath: join(configDir, "Trae", "User"),
-    gooseConfigPath: join(configDir, "goose", "config.yaml"),
-    zedConfigPath: join(configDir, "zed", "settings.json")
+    vscodePath: (0, import_node_path.join)(configDir, "Code", "User"),
+    traePath: (0, import_node_path.join)(configDir, "Trae", "User"),
+    gooseConfigPath: (0, import_node_path.join)(configDir, "goose", "config.yaml"),
+    zedConfigPath: (0, import_node_path.join)(configDir, "zed", "settings.json")
   };
 };
 var { appSupport, vscodePath, traePath, gooseConfigPath, zedConfigPath } = getPlatformPaths();
-var ampConfigDir = process.env.AMP_HOME?.trim() || join(process.env.XDG_CONFIG_HOME || join(home, ".config"), "amp");
-var ampGlobalConfigPath = existsSync(join(ampConfigDir, "settings.jsonc")) ? join(ampConfigDir, "settings.jsonc") : join(ampConfigDir, "settings.json");
-var antigravityMcpConfigPath = join(home, ".gemini", "config", "mcp_config.json");
-var augmentConfigDir = process.env.AUGMENT_HOME?.trim() || join(home, ".augment");
-var augmentGlobalConfigPath = existsSync(join(augmentConfigDir, "settings.jsonc")) ? join(augmentConfigDir, "settings.jsonc") : join(augmentConfigDir, "settings.json");
-var clineDir = process.env.CLINE_DIR || join(home, ".cline");
-var clineCliConfigPath = join(clineDir, "mcp.json");
-var clineExtensionConfigPath = join(
+var ampConfigDir = process.env.AMP_HOME?.trim() || (0, import_node_path.join)(process.env.XDG_CONFIG_HOME || (0, import_node_path.join)(home, ".config"), "amp");
+var ampGlobalConfigPath = (0, import_node_fs.existsSync)((0, import_node_path.join)(ampConfigDir, "settings.jsonc")) ? (0, import_node_path.join)(ampConfigDir, "settings.jsonc") : (0, import_node_path.join)(ampConfigDir, "settings.json");
+var antigravityMcpConfigPath = (0, import_node_path.join)(home, ".gemini", "config", "mcp_config.json");
+var augmentConfigDir = process.env.AUGMENT_HOME?.trim() || (0, import_node_path.join)(home, ".augment");
+var augmentGlobalConfigPath = (0, import_node_fs.existsSync)((0, import_node_path.join)(augmentConfigDir, "settings.jsonc")) ? (0, import_node_path.join)(augmentConfigDir, "settings.jsonc") : (0, import_node_path.join)(augmentConfigDir, "settings.json");
+var clineDir = process.env.CLINE_DIR || (0, import_node_path.join)(home, ".cline");
+var clineCliConfigPath = (0, import_node_path.join)(clineDir, "mcp.json");
+var clineExtensionConfigPath = (0, import_node_path.join)(
   vscodePath,
   "globalStorage",
   "saoudrizwan.claude-dev",
   "settings",
   "cline_mcp_settings.json"
 );
-var copilotConfigPath = join(
-  process.env.COPILOT_HOME?.trim() || join(home, ".copilot"),
+var copilotConfigPath = (0, import_node_path.join)(
+  process.env.COPILOT_HOME?.trim() || (0, import_node_path.join)(home, ".copilot"),
   "mcp-config.json"
 );
-var grokConfigPath = join(
-  process.env.GROK_HOME?.trim() || join(home, ".grok"),
+var grokConfigPath = (0, import_node_path.join)(
+  process.env.GROK_HOME?.trim() || (0, import_node_path.join)(home, ".grok"),
   "config.toml"
 );
-var kimiCodeConfigPath = join(
-  process.env.KIMI_CODE_HOME?.trim() || join(home, ".kimi-code"),
+var kimiCodeConfigPath = (0, import_node_path.join)(
+  process.env.KIMI_CODE_HOME?.trim() || (0, import_node_path.join)(home, ".kimi-code"),
   "mcp.json"
 );
-var kiroConfigPath = join(
-  process.env.KIRO_HOME?.trim() || join(home, ".kiro"),
+var kiroConfigPath = (0, import_node_path.join)(
+  process.env.KIRO_HOME?.trim() || (0, import_node_path.join)(home, ".kiro"),
   "settings",
   "mcp.json"
 );
-var qoderConfigPath = join(
-  process.env.QODER_HOME?.trim() || join(home, ".qoder"),
+var qoderConfigPath = (0, import_node_path.join)(
+  process.env.QODER_HOME?.trim() || (0, import_node_path.join)(home, ".qoder"),
   "settings.json"
 );
-var qwenCodeConfigPath = join(
-  process.env.QWEN_CODE_HOME?.trim() || process.env.QWEN_HOME?.trim() || join(home, ".qwen"),
+var qwenCodeConfigPath = (0, import_node_path.join)(
+  process.env.QWEN_CODE_HOME?.trim() || process.env.QWEN_HOME?.trim() || (0, import_node_path.join)(home, ".qwen"),
   "settings.json"
 );
-var traeConfigPath = existsSync(join(home, ".trae", "mcp.json")) ? join(home, ".trae", "mcp.json") : join(traePath, "mcp.json");
+var traeConfigPath = (0, import_node_fs.existsSync)((0, import_node_path.join)(home, ".trae", "mcp.json")) ? (0, import_node_path.join)(home, ".trae", "mcp.json") : (0, import_node_path.join)(traePath, "mcp.json");
 var ALL_TRANSPORTS = ["stdio", "http", "sse"];
 var mcpAgents = {
   // https://ampcode.com/docs/markdown/customize/mcp
@@ -85,19 +357,19 @@ var mcpAgents = {
     configKey: "amp.mcpServers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(ampConfigDir) || existsSync(join(home, ".amp")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".amp", "settings.json")) || existsSync(join(cwd, ".amp", "settings.jsonc")) || existsSync(join(cwd, ".amp")),
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)(ampConfigDir) || (0, import_node_fs.existsSync)((0, import_node_path.join)(home, ".amp")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".amp", "settings.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".amp", "settings.jsonc")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".amp")),
     resolveConfigPath: ({ global: isGlobal, cwd }) => {
       if (isGlobal) {
-        if (existsSync(join(ampConfigDir, "settings.jsonc"))) {
-          return join(ampConfigDir, "settings.jsonc");
+        if ((0, import_node_fs.existsSync)((0, import_node_path.join)(ampConfigDir, "settings.jsonc"))) {
+          return (0, import_node_path.join)(ampConfigDir, "settings.jsonc");
         }
         return ampGlobalConfigPath;
       }
-      if (existsSync(join(cwd, ".amp", "settings.jsonc"))) {
-        return join(cwd, ".amp", "settings.jsonc");
+      if ((0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".amp", "settings.jsonc"))) {
+        return (0, import_node_path.join)(cwd, ".amp", "settings.jsonc");
       }
-      return join(cwd, ".amp", "settings.json");
+      return (0, import_node_path.join)(cwd, ".amp", "settings.json");
     },
     transformDialect: "amp"
   },
@@ -109,8 +381,8 @@ var mcpAgents = {
     configKey: "mcpServers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(join(home, ".gemini", "antigravity")) || existsSync(join(home, ".gemini", "config")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".agents", "mcp_config.json")) || existsSync(join(cwd, ".agents"))
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)((0, import_node_path.join)(home, ".gemini", "antigravity")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(home, ".gemini", "config")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".agents", "mcp_config.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".agents"))
   },
   // https://antigravity.google/docs/cli/mcp/
   "antigravity-cli": {
@@ -121,8 +393,8 @@ var mcpAgents = {
     configKey: "mcpServers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(join(home, ".gemini", "antigravity-cli")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".agents", "mcp_config.json")) || existsSync(join(cwd, ".agents"))
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)((0, import_node_path.join)(home, ".gemini", "antigravity-cli")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".agents", "mcp_config.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".agents"))
   },
   // https://docs.augmentcode.com/cli/integrations.md
   augment: {
@@ -133,19 +405,19 @@ var mcpAgents = {
     configKey: "mcpServers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(augmentConfigDir) || existsSync(join(home, ".augment")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".augment", "settings.json")) || existsSync(join(cwd, ".augment", "settings.jsonc")) || existsSync(join(cwd, ".augment")),
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)(augmentConfigDir) || (0, import_node_fs.existsSync)((0, import_node_path.join)(home, ".augment")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".augment", "settings.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".augment", "settings.jsonc")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".augment")),
     resolveConfigPath: ({ global: isGlobal, cwd }) => {
       if (isGlobal) {
-        if (existsSync(join(augmentConfigDir, "settings.jsonc"))) {
-          return join(augmentConfigDir, "settings.jsonc");
+        if ((0, import_node_fs.existsSync)((0, import_node_path.join)(augmentConfigDir, "settings.jsonc"))) {
+          return (0, import_node_path.join)(augmentConfigDir, "settings.jsonc");
         }
         return augmentGlobalConfigPath;
       }
-      if (existsSync(join(cwd, ".augment", "settings.jsonc"))) {
-        return join(cwd, ".augment", "settings.jsonc");
+      if ((0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".augment", "settings.jsonc"))) {
+        return (0, import_node_path.join)(cwd, ".augment", "settings.jsonc");
       }
-      return join(cwd, ".augment", "settings.json");
+      return (0, import_node_path.join)(cwd, ".augment", "settings.json");
     },
     transformDialect: "augment"
   },
@@ -157,13 +429,13 @@ var mcpAgents = {
     configKey: "mcpServers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(clineExtensionConfigPath),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".cline", "mcp.json")) || existsSync(join(cwd, ".cline")),
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)(clineExtensionConfigPath),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".cline", "mcp.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".cline")),
     resolveConfigPath: ({ global: isGlobal, cwd }) => {
       if (isGlobal) {
         return clineExtensionConfigPath;
       }
-      return join(cwd, ".cline", "mcp.json");
+      return (0, import_node_path.join)(cwd, ".cline", "mcp.json");
     },
     transformDialect: "cline"
   },
@@ -176,13 +448,13 @@ var mcpAgents = {
     configKey: "mcpServers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(clineDir),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".cline", "mcp.json")) || existsSync(join(cwd, ".cline")),
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)(clineDir),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".cline", "mcp.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".cline")),
     resolveConfigPath: ({ global: isGlobal, cwd }) => {
       if (isGlobal) {
         return clineCliConfigPath;
       }
-      return join(cwd, ".cline", "mcp.json");
+      return (0, import_node_path.join)(cwd, ".cline", "mcp.json");
     },
     transformDialect: "cline"
   },
@@ -190,59 +462,59 @@ var mcpAgents = {
   "claude-code": {
     name: "claude-code",
     displayName: "Claude Code",
-    globalConfigPath: join(home, ".claude.json"),
+    globalConfigPath: (0, import_node_path.join)(home, ".claude.json"),
     projectConfigPath: ".mcp.json",
     configKey: "mcpServers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(join(home, ".claude.json")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".mcp.json"))
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)((0, import_node_path.join)(home, ".claude.json")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".mcp.json"))
   },
   "claude-desktop": {
     name: "claude-desktop",
     displayName: "Claude Desktop",
-    globalConfigPath: join(appSupport, "Claude", "claude_desktop_config.json"),
+    globalConfigPath: (0, import_node_path.join)(appSupport, "Claude", "claude_desktop_config.json"),
     configKey: "mcpServers",
     format: "jsonc",
     supportedTransports: ["stdio"],
     unsupportedTransportMessage: "Claude Desktop currently supports only stdio MCP servers. Use a package name or command instead of a URL.",
-    detectGlobalInstall: () => existsSync(join(appSupport, "Claude", "claude_desktop_config.json"))
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)((0, import_node_path.join)(appSupport, "Claude", "claude_desktop_config.json"))
   },
   // https://learn.chatgpt.com/docs/extend/mcp?surface=app
   codex: {
     name: "codex",
     displayName: "Codex",
-    globalConfigPath: join(process.env.CODEX_HOME?.trim() || join(home, ".codex"), "config.toml"),
+    globalConfigPath: (0, import_node_path.join)(process.env.CODEX_HOME?.trim() || (0, import_node_path.join)(home, ".codex"), "config.toml"),
     projectConfigPath: ".codex/config.toml",
     configKey: "mcp_servers",
     format: "toml",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(process.env.CODEX_HOME?.trim() || join(home, ".codex")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".codex", "config.toml")),
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)(process.env.CODEX_HOME?.trim() || (0, import_node_path.join)(home, ".codex")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".codex", "config.toml")),
     transformDialect: "augment"
   },
   // https://cursor.com/help/customization/mcp
   cursor: {
     name: "cursor",
     displayName: "Cursor",
-    globalConfigPath: join(home, ".cursor", "mcp.json"),
+    globalConfigPath: (0, import_node_path.join)(home, ".cursor", "mcp.json"),
     projectConfigPath: ".cursor/mcp.json",
     configKey: "mcpServers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(join(home, ".cursor")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".cursor", "mcp.json"))
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)((0, import_node_path.join)(home, ".cursor")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".cursor", "mcp.json"))
   },
   "gemini-cli": {
     name: "gemini-cli",
     displayName: "Gemini CLI",
-    globalConfigPath: join(home, ".gemini", "settings.json"),
+    globalConfigPath: (0, import_node_path.join)(home, ".gemini", "settings.json"),
     projectConfigPath: ".gemini/settings.json",
     configKey: "mcpServers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(join(home, ".gemini")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".gemini", "settings.json"))
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)((0, import_node_path.join)(home, ".gemini")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".gemini", "settings.json"))
   },
   // https://docs.x.ai/build/features/mcp-servers.md
   grok: {
@@ -253,8 +525,8 @@ var mcpAgents = {
     configKey: "mcp_servers",
     format: "toml",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(grokConfigPath) || existsSync(process.env.GROK_HOME?.trim() || join(home, ".grok")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".grok", "config.toml")) || existsSync(join(cwd, ".grok")),
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)(grokConfigPath) || (0, import_node_fs.existsSync)(process.env.GROK_HOME?.trim() || (0, import_node_path.join)(home, ".grok")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".grok", "config.toml")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".grok")),
     transformDialect: "grok"
   },
   // https://goose-docs.ai/docs/guides/config-files/
@@ -266,8 +538,8 @@ var mcpAgents = {
     configKey: "extensions",
     format: "yaml",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(gooseConfigPath),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".goose", "config.yaml")),
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)(gooseConfigPath),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".goose", "config.yaml")),
     transformDialect: "goose"
   },
   "github-copilot-cli": {
@@ -278,8 +550,8 @@ var mcpAgents = {
     configKey: "mcpServers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(copilotConfigPath) || existsSync(process.env.COPILOT_HOME?.trim() || join(home, ".copilot")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".mcp.json")) || existsSync(join(cwd, ".github", "mcp.json")),
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)(copilotConfigPath) || (0, import_node_fs.existsSync)(process.env.COPILOT_HOME?.trim() || (0, import_node_path.join)(home, ".copilot")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".mcp.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".github", "mcp.json")),
     transformDialect: "vscode"
   },
   // https://www.kimi.com/code/docs/en/kimi-code-cli/customization/mcp.html
@@ -291,8 +563,8 @@ var mcpAgents = {
     configKey: "mcpServers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(kimiCodeConfigPath) || existsSync(process.env.KIMI_CODE_HOME?.trim() || join(home, ".kimi-code")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".kimi-code", "mcp.json")) || existsSync(join(cwd, ".kimi-code")),
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)(kimiCodeConfigPath) || (0, import_node_fs.existsSync)(process.env.KIMI_CODE_HOME?.trim() || (0, import_node_path.join)(home, ".kimi-code")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".kimi-code", "mcp.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".kimi-code")),
     transformDialect: "kimi-code"
   },
   // https://kiro.dev/docs/mcp/configuration.md
@@ -304,16 +576,16 @@ var mcpAgents = {
     configKey: "mcpServers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(kiroConfigPath) || existsSync(process.env.KIRO_HOME?.trim() || join(home, ".kiro")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".kiro", "settings", "mcp.json")) || existsSync(join(cwd, ".kiro")),
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)(kiroConfigPath) || (0, import_node_fs.existsSync)(process.env.KIRO_HOME?.trim() || (0, import_node_path.join)(home, ".kiro")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".kiro", "settings", "mcp.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".kiro")),
     transformDialect: "kiro"
   },
   // https://opencode.ai/docs/config/
   opencode: {
     name: "opencode",
     displayName: "OpenCode",
-    globalConfigPath: join(
-      process.env.XDG_CONFIG_HOME || join(home, ".config"),
+    globalConfigPath: (0, import_node_path.join)(
+      process.env.XDG_CONFIG_HOME || (0, import_node_path.join)(home, ".config"),
       "opencode",
       "opencode.json"
     ),
@@ -321,21 +593,21 @@ var mcpAgents = {
     configKey: "mcp",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(join(process.env.XDG_CONFIG_HOME || join(home, ".config"), "opencode")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, "opencode.json")),
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)((0, import_node_path.join)(process.env.XDG_CONFIG_HOME || (0, import_node_path.join)(home, ".config"), "opencode")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "opencode.json")),
     transformDialect: "opencode"
   },
   // https://pi.dev/packages/pi-mcp-extension
   pi: {
     name: "pi",
     displayName: "Pi",
-    globalConfigPath: join(home, ".pi", "agent", "mcp.json"),
+    globalConfigPath: (0, import_node_path.join)(home, ".pi", "agent", "mcp.json"),
     projectConfigPath: ".pi/mcp.json",
     configKey: "mcpServers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(join(home, ".pi")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".pi", "mcp.json")) || existsSync(join(cwd, ".pi")),
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)((0, import_node_path.join)(home, ".pi")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".pi", "mcp.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".pi")),
     transformDialect: "pi"
   },
   // https://docs.qoder.com/zh/cli/mcp-servers.md
@@ -347,14 +619,14 @@ var mcpAgents = {
     configKey: "mcpServers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(qoderConfigPath) || existsSync(process.env.QODER_HOME?.trim() || join(home, ".qoder")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".mcp.json")) || existsSync(join(cwd, ".qoder", "settings.json")) || existsSync(join(cwd, ".qoder")),
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)(qoderConfigPath) || (0, import_node_fs.existsSync)(process.env.QODER_HOME?.trim() || (0, import_node_path.join)(home, ".qoder")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".mcp.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".qoder", "settings.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".qoder")),
     resolveConfigPath: ({ global: isGlobal, cwd }) => {
       if (isGlobal) return qoderConfigPath;
-      if (existsSync(join(cwd, ".qoder", "settings.json"))) {
-        return join(cwd, ".qoder", "settings.json");
+      if ((0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".qoder", "settings.json"))) {
+        return (0, import_node_path.join)(cwd, ".qoder", "settings.json");
       }
-      return join(cwd, ".mcp.json");
+      return (0, import_node_path.join)(cwd, ".mcp.json");
     }
   },
   // https://qwenlm.github.io/qwen-code-docs/en/users/features/mcp/
@@ -366,10 +638,10 @@ var mcpAgents = {
     configKey: "mcpServers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(qwenCodeConfigPath) || existsSync(
-      process.env.QWEN_CODE_HOME?.trim() || process.env.QWEN_HOME?.trim() || join(home, ".qwen")
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)(qwenCodeConfigPath) || (0, import_node_fs.existsSync)(
+      process.env.QWEN_CODE_HOME?.trim() || process.env.QWEN_HOME?.trim() || (0, import_node_path.join)(home, ".qwen")
     ),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".qwen", "settings.json")) || existsSync(join(cwd, ".qwen")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".qwen", "settings.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".qwen")),
     transformDialect: "qwen-code"
   },
   // https://docs.trae.ai/ide/add-mcp-servers?_lang=en
@@ -381,16 +653,16 @@ var mcpAgents = {
     configKey: "mcpServers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(traeConfigPath) || existsSync(join(home, ".trae", "mcp.json")) || existsSync(join(home, ".trae")) || existsSync(traePath) || existsSync(join(appSupport, "Trae")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".trae", "mcp.json")) || existsSync(join(cwd, ".trae")),
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)(traeConfigPath) || (0, import_node_fs.existsSync)((0, import_node_path.join)(home, ".trae", "mcp.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(home, ".trae")) || (0, import_node_fs.existsSync)(traePath) || (0, import_node_fs.existsSync)((0, import_node_path.join)(appSupport, "Trae")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".trae", "mcp.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".trae")),
     resolveConfigPath: ({ global: isGlobal, cwd }) => {
       if (isGlobal) {
-        if (existsSync(join(home, ".trae", "mcp.json"))) {
-          return join(home, ".trae", "mcp.json");
+        if ((0, import_node_fs.existsSync)((0, import_node_path.join)(home, ".trae", "mcp.json"))) {
+          return (0, import_node_path.join)(home, ".trae", "mcp.json");
         }
         return traeConfigPath;
       }
-      return join(cwd, ".trae", "mcp.json");
+      return (0, import_node_path.join)(cwd, ".trae", "mcp.json");
     },
     transformDialect: "trae"
   },
@@ -398,13 +670,13 @@ var mcpAgents = {
   vscode: {
     name: "vscode",
     displayName: "VS Code",
-    globalConfigPath: join(vscodePath, "mcp.json"),
+    globalConfigPath: (0, import_node_path.join)(vscodePath, "mcp.json"),
     projectConfigPath: ".vscode/mcp.json",
     configKey: "servers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(join(vscodePath, "mcp.json")) || existsSync(vscodePath),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".vscode", "mcp.json")),
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)((0, import_node_path.join)(vscodePath, "mcp.json")) || (0, import_node_fs.existsSync)(vscodePath),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".vscode", "mcp.json")),
     transformDialect: "vscode"
   },
   // https://zed.dev/docs/ai/mcp.md
@@ -416,8 +688,8 @@ var mcpAgents = {
     configKey: "context_servers",
     format: "jsonc",
     supportedTransports: ALL_TRANSPORTS,
-    detectGlobalInstall: () => existsSync(zedConfigPath) || existsSync(join(process.env.XDG_CONFIG_HOME || join(home, ".config"), "zed")) || existsSync(join(appSupport, "Zed")),
-    detectProjectInstall: (cwd) => existsSync(join(cwd, ".zed", "settings.json")),
+    detectGlobalInstall: () => (0, import_node_fs.existsSync)(zedConfigPath) || (0, import_node_fs.existsSync)((0, import_node_path.join)(process.env.XDG_CONFIG_HOME || (0, import_node_path.join)(home, ".config"), "zed")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(appSupport, "Zed")),
+    detectProjectInstall: (cwd) => (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".zed", "settings.json")),
     transformDialect: "zed"
   }
 };
@@ -463,6 +735,84 @@ var detectProjectInstalledMcpAgents = (cwd) => getMcpAgentTypes().filter(
 var detectGloballyInstalledMcpAgents = () => getMcpAgentTypes().filter((type) => mcpAgents[type].detectGlobalInstall());
 var getMcpAgentsSupportingProjectScope = () => getMcpAgentTypes().filter((type) => Boolean(mcpAgents[type].projectConfigPath));
 
+// 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);
+
+// src/utils/get-nested-value.ts
+var getNestedValue = (source, dottedKey) => {
+  if (!source) return void 0;
+  if (dottedKey in source) return source[dottedKey];
+  const segments = dottedKey.split(".");
+  let cursor = source;
+  for (const segment of segments) {
+    if (!isPlainObject(cursor)) return void 0;
+    cursor = cursor[segment];
+  }
+  return cursor;
+};
+
+// src/formats/json.ts
+var import_node_fs3 = require("fs");
+var import_jsonc_parser = require("jsonc-parser");
+
+// src/utils/ensure-parent-dir.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var ensureParentDir = (filePath) => {
+  const parentDir = (0, import_node_path2.dirname)(filePath);
+  if (!(0, import_node_fs2.existsSync)(parentDir)) (0, import_node_fs2.mkdirSync)(parentDir, { recursive: true });
+};
+
+// src/utils/set-nested-value.ts
+var DANGEROUS_KEY_SEGMENTS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "prototype",
+  "constructor"
+]);
+var assertSafeSegment = (segment) => {
+  if (DANGEROUS_KEY_SEGMENTS.has(segment)) {
+    throw new Error(`Refusing to write to unsafe key segment "${segment}"`);
+  }
+};
+var setNestedValue = (target, dottedKey, value) => {
+  if (dottedKey in target) {
+    assertSafeSegment(dottedKey);
+    target[dottedKey] = value;
+    return;
+  }
+  const segments = dottedKey.split(".");
+  let cursor = target;
+  for (let segmentIndex = 0; segmentIndex < segments.length - 1; segmentIndex += 1) {
+    const segment = segments[segmentIndex];
+    assertSafeSegment(segment);
+    const existing = cursor[segment];
+    if (isPlainObject(existing)) {
+      cursor = existing;
+      continue;
+    }
+    const next = {};
+    cursor[segment] = next;
+    cursor = next;
+  }
+  const finalSegment = segments[segments.length - 1];
+  assertSafeSegment(finalSegment);
+  cursor[finalSegment] = value;
+};
+
+// src/utils/walk-nested-object.ts
+var walkNestedObject = (root, segments) => {
+  let cursor = root;
+  for (const segment of segments) {
+    if (!isPlainObject(cursor)) return void 0;
+    cursor = cursor[segment];
+  }
+  return isPlainObject(cursor) ? cursor : void 0;
+};
+
 // src/constants.ts
 var DEFAULT_REMOTE_TRANSPORT = "http";
 var NPX_COMMAND = "npx";
@@ -506,164 +856,21 @@ 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
-var buildMcpServerConfig = (parsed, options = {}) => {
-  if (parsed.type === "remote") {
-    const config2 = {
-      type: options.transport ?? DEFAULT_REMOTE_TRANSPORT,
-      url: parsed.value
-    };
-    if (options.headers && Object.keys(options.headers).length > 0) {
-      config2.headers = options.headers;
-    }
-    return config2;
-  }
-  if (parsed.type === "command") {
-    const parts = parsed.value.split(/\s+/);
-    const command = parts[0] ?? "";
-    const args = parts.slice(1);
-    if (options.args && options.args.length > 0) {
-      args.push(...options.args);
-    }
-    const config2 = { command, args };
-    if (options.env && Object.keys(options.env).length > 0) {
-      config2.env = options.env;
-    }
-    return config2;
-  }
-  const packageArgs = [NPX_DASH_Y, parsed.value];
-  if (options.args && options.args.length > 0) {
-    packageArgs.push(...options.args);
-  }
-  const config = {
-    command: NPX_COMMAND,
-    args: packageArgs
-  };
-  if (options.env && Object.keys(options.env).length > 0) {
-    config.env = options.env;
-  }
-  return config;
-};
-
-// src/parse-server-config.ts
-var isRemoteServerConfig = (config) => typeof config.url === "string" && config.url.length > 0;
-var isStdioServerConfig = (config) => typeof config.command === "string" && config.command.length > 0;
-var parseServerConfig = (raw) => {
-  if (!raw || typeof raw !== "object") return {};
-  const data = raw;
-  const rawUrl = typeof data.url === "string" && data.url.trim().length > 0 ? data.url.trim() : void 0;
-  const rawHttpUrl = typeof data.httpUrl === "string" && data.httpUrl.trim().length > 0 ? data.httpUrl.trim() : void 0;
-  const remoteUrl = rawHttpUrl ?? rawUrl;
-  if (remoteUrl) {
-    const transport = data.type === "sse" || data.transport === "sse" ? "sse" : "http";
-    const headers = data.headers && typeof data.headers === "object" ? data.headers : void 0;
-    return {
-      type: transport,
-      url: remoteUrl,
-      headers
-    };
-  }
-  if (typeof data.command === "string" && data.command.trim().length > 0) {
-    const args = Array.isArray(data.args) ? data.args.filter((item) => typeof item === "string") : void 0;
-    const env = data.env && typeof data.env === "object" ? data.env : void 0;
-    return {
-      command: data.command.trim(),
-      args,
-      env
-    };
-  }
-  return {};
-};
-
-// src/utils/is-plain-object.ts
-var isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-
-// src/utils/get-nested-value.ts
-var getNestedValue = (source, dottedKey) => {
-  if (!source) return void 0;
-  if (dottedKey in source) return source[dottedKey];
-  const segments = dottedKey.split(".");
-  let cursor = source;
-  for (const segment of segments) {
-    if (!isPlainObject(cursor)) return void 0;
-    cursor = cursor[segment];
-  }
-  return cursor;
-};
-
-// src/formats/json.ts
-import { existsSync as existsSync3, readFileSync, writeFileSync } from "fs";
-import { applyEdits, modify, parse as parseJsonc } from "jsonc-parser";
-
-// src/utils/ensure-parent-dir.ts
-import { existsSync as existsSync2, mkdirSync } from "fs";
-import { dirname } from "path";
-var ensureParentDir = (filePath) => {
-  const parentDir = dirname(filePath);
-  if (!existsSync2(parentDir)) mkdirSync(parentDir, { recursive: true });
-};
-
-// src/utils/set-nested-value.ts
-var DANGEROUS_KEY_SEGMENTS = /* @__PURE__ */ new Set([
-  "__proto__",
-  "prototype",
-  "constructor"
-]);
-var assertSafeSegment = (segment) => {
-  if (DANGEROUS_KEY_SEGMENTS.has(segment)) {
-    throw new Error(`Refusing to write to unsafe key segment "${segment}"`);
-  }
-};
-var setNestedValue = (target, dottedKey, value) => {
-  if (dottedKey in target) {
-    assertSafeSegment(dottedKey);
-    target[dottedKey] = value;
-    return;
-  }
-  const segments = dottedKey.split(".");
-  let cursor = target;
-  for (let segmentIndex = 0; segmentIndex < segments.length - 1; segmentIndex += 1) {
-    const segment = segments[segmentIndex];
-    assertSafeSegment(segment);
-    const existing = cursor[segment];
-    if (isPlainObject(existing)) {
-      cursor = existing;
-      continue;
-    }
-    const next = {};
-    cursor[segment] = next;
-    cursor = next;
-  }
-  const finalSegment = segments[segments.length - 1];
-  assertSafeSegment(finalSegment);
-  cursor[finalSegment] = value;
-};
-
-// src/utils/walk-nested-object.ts
-var walkNestedObject = (root, segments) => {
-  let cursor = root;
-  for (const segment of segments) {
-    if (!isPlainObject(cursor)) return void 0;
-    cursor = cursor[segment];
-  }
-  return isPlainObject(cursor) ? cursor : void 0;
-};
-
 // src/formats/json.ts
 var JSONC_FORMATTING = {
   insertSpaces: true,
   tabSize: DEFAULT_JSON_INDENT_SPACES,
   eol: "\n"
 };
-var readFileOrEmpty = (filePath) => existsSync3(filePath) ? readFileSync(filePath, "utf-8") : "";
+var readFileOrEmpty = (filePath) => (0, import_node_fs3.existsSync)(filePath) ? (0, import_node_fs3.readFileSync)(filePath, "utf-8") : "";
 var writeWithTrailingNewline = (filePath, contents) => {
-  writeFileSync(filePath, contents.endsWith("\n") ? contents : `${contents}
+  (0, import_node_fs3.writeFileSync)(filePath, contents.endsWith("\n") ? contents : `${contents}
 `, "utf-8");
 };
 var readJsoncConfig = (filePath) => {
   const raw = readFileOrEmpty(filePath);
   if (!raw.trim()) return {};
-  const parsed = parseJsonc(raw);
+  const parsed = (0, import_jsonc_parser.parse)(raw);
   return isPlainObject(parsed) ? parsed : {};
 };
 var resolvePathPrefix = (root, dottedKey) => {
@@ -681,10 +888,10 @@ var setJsoncNestedValue = (filePath, dottedKey, serverName, serverConfig) => {
   const existing = readJsoncConfig(filePath);
   const pathPrefix = resolvePathPrefix(existing, dottedKey);
   const path = [...pathPrefix, serverName];
-  const edits = modify(sourceText, path, serverConfig, {
+  const edits = (0, import_jsonc_parser.modify)(sourceText, path, serverConfig, {
     formattingOptions: JSONC_FORMATTING
   });
-  writeWithTrailingNewline(filePath, applyEdits(sourceText, edits));
+  writeWithTrailingNewline(filePath, (0, import_jsonc_parser.applyEdits)(sourceText, edits));
 };
 var writeJsonConfigAtKey = (filePath, dottedKey, serverName, serverConfig) => {
   ensureParentDir(filePath);
@@ -698,7 +905,7 @@ var writeJsonConfigAtKey = (filePath, dottedKey, serverName, serverConfig) => {
   } else {
     setNestedValue(existing, dottedKey, servers);
   }
-  writeFileSync(
+  (0, import_node_fs3.writeFileSync)(
     filePath,
     `${JSON.stringify(existing, null, DEFAULT_JSON_INDENT_SPACES)}
 `,
@@ -706,25 +913,25 @@ var writeJsonConfigAtKey = (filePath, dottedKey, serverName, serverConfig) => {
   );
 };
 var removeJsoncConfigKey = (filePath, dottedKey, serverName) => {
-  if (!existsSync3(filePath)) return false;
-  const sourceText = readFileSync(filePath, "utf-8");
+  if (!(0, import_node_fs3.existsSync)(filePath)) return false;
+  const sourceText = (0, import_node_fs3.readFileSync)(filePath, "utf-8");
   if (!sourceText.trim()) return false;
   const existing = readJsoncConfig(filePath);
   const pathPrefix = resolvePathPrefix(existing, dottedKey);
   const parentObject = walkNestedObject(existing, pathPrefix);
   if (!parentObject || !(serverName in parentObject)) return false;
   const path = [...pathPrefix, serverName];
-  const edits = modify(sourceText, path, void 0, {
+  const edits = (0, import_jsonc_parser.modify)(sourceText, path, void 0, {
     formattingOptions: JSONC_FORMATTING
   });
   if (edits.length === 0) return false;
-  writeWithTrailingNewline(filePath, applyEdits(sourceText, edits));
+  writeWithTrailingNewline(filePath, (0, import_jsonc_parser.applyEdits)(sourceText, edits));
   return true;
 };
 
 // src/formats/toml.ts
-import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import TOML from "@iarna/toml";
+var import_node_fs4 = require("fs");
+var import_toml = __toESM(require("@iarna/toml"), 1);
 
 // src/utils/delete-nested-value.ts
 var DANGEROUS_KEY_SEGMENTS2 = /* @__PURE__ */ new Set([
@@ -757,10 +964,10 @@ var deleteNestedValue = (target, dottedKey) => {
 // src/formats/toml.ts
 var toTomlJsonMap = (value) => JSON.parse(JSON.stringify(value));
 var readTomlConfig = (filePath) => {
-  if (!existsSync4(filePath)) return {};
-  const raw = readFileSync2(filePath, "utf-8");
+  if (!(0, import_node_fs4.existsSync)(filePath)) return {};
+  const raw = (0, import_node_fs4.readFileSync)(filePath, "utf-8");
   if (!raw.trim()) return {};
-  const parsed = TOML.parse(raw);
+  const parsed = import_toml.default.parse(raw);
   return isPlainObject(parsed) ? parsed : {};
 };
 var writeTomlConfigAtKey = (filePath, dottedKey, serverName, serverConfig) => {
@@ -770,24 +977,24 @@ var writeTomlConfigAtKey = (filePath, dottedKey, serverName, serverConfig) => {
   const servers = existingServers ? { ...existingServers } : {};
   servers[serverName] = serverConfig;
   setNestedValue(existing, dottedKey, servers);
-  writeFileSync2(filePath, TOML.stringify(toTomlJsonMap(existing)), "utf-8");
+  (0, import_node_fs4.writeFileSync)(filePath, import_toml.default.stringify(toTomlJsonMap(existing)), "utf-8");
 };
 var removeTomlConfigKey = (filePath, dottedKey, serverName) => {
-  if (!existsSync4(filePath)) return false;
+  if (!(0, import_node_fs4.existsSync)(filePath)) return false;
   const existing = readTomlConfig(filePath);
   const didRemove = deleteNestedValue(existing, `${dottedKey}.${serverName}`);
-  if (didRemove) writeFileSync2(filePath, TOML.stringify(toTomlJsonMap(existing)), "utf-8");
+  if (didRemove) (0, import_node_fs4.writeFileSync)(filePath, import_toml.default.stringify(toTomlJsonMap(existing)), "utf-8");
   return didRemove;
 };
 
 // src/formats/yaml.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var import_node_fs5 = require("fs");
+var import_yaml = require("yaml");
 var readYamlConfig = (filePath) => {
-  if (!existsSync5(filePath)) return {};
-  const raw = readFileSync3(filePath, "utf-8");
+  if (!(0, import_node_fs5.existsSync)(filePath)) return {};
+  const raw = (0, import_node_fs5.readFileSync)(filePath, "utf-8");
   if (!raw.trim()) return {};
-  const parsed = parseYaml(raw);
+  const parsed = (0, import_yaml.parse)(raw);
   return isPlainObject(parsed) ? parsed : {};
 };
 var writeYamlConfigAtKey = (filePath, dottedKey, serverName, serverConfig) => {
@@ -797,13 +1004,13 @@ var writeYamlConfigAtKey = (filePath, dottedKey, serverName, serverConfig) => {
   const servers = existingServers ? { ...existingServers } : {};
   servers[serverName] = serverConfig;
   setNestedValue(existing, dottedKey, servers);
-  writeFileSync3(filePath, stringifyYaml(existing), "utf-8");
+  (0, import_node_fs5.writeFileSync)(filePath, (0, import_yaml.stringify)(existing), "utf-8");
 };
 var removeYamlConfigKey = (filePath, dottedKey, serverName) => {
-  if (!existsSync5(filePath)) return false;
+  if (!(0, import_node_fs5.existsSync)(filePath)) return false;
   const existing = readYamlConfig(filePath);
   const didRemove = deleteNestedValue(existing, `${dottedKey}.${serverName}`);
-  if (didRemove) writeFileSync3(filePath, stringifyYaml(existing), "utf-8");
+  if (didRemove) (0, import_node_fs5.writeFileSync)(filePath, (0, import_yaml.stringify)(existing), "utf-8");
   return didRemove;
 };
 
@@ -858,181 +1065,6 @@ var listServersInConfigFile = (filePath, format, dottedKey) => {
   return isPlainObject(entries) ? entries : {};
 };
 
-// src/config-store.ts
-import { existsSync as existsSync6 } from "fs";
-
-// src/resolve-config-target.ts
-import { join as join2 } from "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 ? join2(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 existsSync6(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: {
@@ -1230,9 +1262,6 @@ var transformServerConfig = (serverName, config, dialect, _context) => {
   }
   return transformStdioConfig(serverName, config, options);
 };
-var createAgentTransform = (dialect) => {
-  return (serverName, config, context) => transformServerConfig(serverName, config, dialect, context);
-};
 var transformServerConfigForAgent = (agent, serverName, config, context = { global: false }) => {
   if (agent.transformConfig) {
     return agent.transformConfig(serverName, config, context);
@@ -1243,389 +1272,415 @@ var transformServerConfigForAgent = (agent, serverName, config, context = { glob
   return config;
 };
 
-// src/installer.ts
-var installMcpServerForAgent = (serverName, serverConfig, agentType, options = {}) => {
-  const agent = getMcpAgentConfig(agentType);
+// src/utils/to-error-message.ts
+var toErrorMessage = (error, fallback = "Unknown error") => error instanceof Error ? error.message : fallback;
+
+// src/config-store.ts
+var resolveMcpConfigTarget = (agent, options = {}) => {
   const isGlobal = options.global ?? false;
-  const { target } = agentConfigStore.resolveTarget(agent, options);
-  const coHosted = getCoHostedAgents(agentType, options);
-  try {
-    const transformed = transformServerConfigForAgent(agent, serverName, serverConfig, {
-      global: isGlobal
-    });
-    agentConfigStore.writeServer(agent, serverName, transformed, options);
-    return {
-      agent: agentType,
-      success: true,
-      path: target.configPath,
-      coConfiguredAgents: coHosted.length > 0 ? coHosted : void 0
-    };
-  } catch (error) {
-    return {
-      agent: agentType,
-      success: false,
-      path: target.configPath,
-      error: toErrorMessage(error)
-    };
-  }
+  const cwd = options.cwd ?? process.cwd();
+  const configPath = agent.resolveConfigPath ? agent.resolveConfigPath({ global: isGlobal, cwd }) : !isGlobal && agent.projectConfigPath ? (0, import_node_path3.join)(cwd, agent.projectConfigPath) : agent.globalConfigPath;
+  const configKey = !isGlobal && agent.projectConfigKey ? agent.projectConfigKey : agent.configKey;
+  return { configPath, configKey };
 };
-var installMcpServerForAgents = (serverName, serverConfig, agentTypes, options = {}) => {
-  const clusters = resolveConfigClusters(agentTypes, 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
-      });
-      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 getCandidateAgentsForScope = (options = {}) => {
+  return options.global ? getMcpAgentTypes() : getMcpAgentsSupportingProjectScope();
 };
-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
-      };
+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}`);
     }
-    return installedMap.get(agentType);
-  });
-};
-
-// 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);
+    writeServerToConfigFile(
+      target.filePath,
+      target.format,
+      target.dottedKey,
+      serverName,
+      serverConfig
+    );
   }
-  return resolved;
-};
-
-// 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;
+  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);
   }
-  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();
+var AgentConfigStore = class {
+  constructor(adapter = new FsConfigStoreAdapter()) {
+    this.adapter = adapter;
   }
-  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);
-    }
+  adapter;
+  getAdapter() {
+    return this.adapter;
   }
-  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.";
-    }
+  // ---- Single-agent primitives ----
+  resolveTarget(agent, options = {}) {
+    const agentConfig = typeof agent === "string" ? getMcpAgentConfig(agent) : agent;
+    const target = resolveMcpConfigTarget(agentConfig, options);
+    return { agent: agentConfig, target };
   }
-  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;
+  resolveDescriptor(agent, options = {}) {
+    const { agent: agentConfig, target } = this.resolveTarget(agent, options);
+    return {
+      filePath: target.configPath,
+      format: agentConfig.format,
+      dottedKey: target.configKey
+    };
   }
-  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;
+  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;
   }
-};
-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);
+  read(agent, options = {}) {
+    const descriptor = this.resolveDescriptor(agent, options);
+    if (!this.adapter.exists(descriptor.filePath)) {
+      return {};
+    }
+    return this.adapter.read(descriptor);
   }
-  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."
-    );
+  readServer(agent, serverName, options = {}) {
+    const { exists, servers } = this.listServers(agent, options);
+    if (!exists) return void 0;
+    return servers[serverName];
   }
-  if (REMOTE_URL_REGEX.test(trimmed)) {
-    return {
-      type: "remote",
-      value: trimmed,
-      inferredName: inferNameFromUrl(trimmed)
-    };
+  // ---- 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));
   }
-  if (HAS_WHITESPACE_REGEX.test(trimmed)) {
-    return {
-      type: "command",
-      value: trimmed,
-      inferredName: inferNameFromCommand(trimmed)
-    };
+};
+var agentConfigStore = new AgentConfigStore();
+
+// src/interactive/utils/build-linked-agent-choices.ts
+var buildLinkedAgentChoices = (options) => {
+  const { agents, checkedAgents, detectedAgents = [], scopeOptions = {} } = options;
+  const alignedCheckedSet = new Set(checkedAgents);
+  for (const agent of checkedAgents) {
+    const coHosted = agentConfigStore.getCoHostedAgents(agent, scopeOptions);
+    for (const co of coHosted) {
+      if (agents.includes(co)) {
+        alignedCheckedSet.add(co);
+      }
+    }
   }
-  if (PACKAGE_NAME_REGEX.test(trimmed)) {
+  return agents.map((agent) => {
+    const config = getMcpAgentConfig(agent);
+    const displayName = config?.displayName ?? agent;
+    const isDetected = detectedAgents.includes(agent);
+    const coHosted = agentConfigStore.getCoHostedAgents(agent, scopeOptions).filter(
+      (co) => agents.includes(co)
+    );
+    const detectedBadge = isDetected ? import_picocolors2.default.green(" [detected]") : "";
+    const sharedBadge = coHosted.length > 0 ? import_picocolors2.default.dim(` [shared: ${coHosted.join(", ")}]`) : "";
+    const label = `${displayName} ${import_picocolors2.default.dim(`(${agent})`)}${detectedBadge}${sharedBadge}`;
     return {
-      type: "package",
-      value: trimmed,
-      inferredName: extractPackageName(trimmed)
+      name: label,
+      value: agent,
+      checked: alignedCheckedSet.has(agent),
+      linkedValues: coHosted,
+      description: coHosted.length > 0 ? `Linked with ${coHosted.map((a) => getMcpAgentConfig(a).displayName).join(", ")} (shared configuration)` : void 0
     };
-  }
-  return {
-    type: "command",
-    value: trimmed,
-    inferredName: inferNameFromCommand(trimmed)
-  };
+  });
 };
-var isRemoteMcpSource = (parsed) => parsed.type === "remote";
 
-// src/install-mcp-server.ts
-var installMcpServer = (options) => {
-  const parsed = parseMcpSource(options.source);
-  const isGlobal = options.global ?? false;
+// src/interactive/prompts/scope.ts
+var import_prompts = require("@inquirer/prompts");
+var import_picocolors3 = __toESM(require("picocolors"), 1);
+var promptScope = async (options = {}) => {
+  const initialGlobal = options.defaultGlobal ?? options.global;
+  if (initialGlobal !== void 0) {
+    return initialGlobal;
+  }
   const cwd = options.cwd ?? process.cwd();
-  const serverName = options.name ?? parsed.inferredName;
-  const serverConfig = buildMcpServerConfig(parsed, {
-    transport: options.transport,
-    headers: options.headers,
-    env: options.env,
-    args: options.args
-  });
-  const requestedTransport = parsed.type === "remote" ? serverConfig.type ?? "http" : "stdio";
-  const { allAgents, incompatible } = resolveTargetAgents({
-    requested: options.agents,
-    global: isGlobal,
-    cwd,
-    transport: requestedTransport
-  });
-  const results = installToCompatibleAgents(serverName, serverConfig, {
-    allAgents,
-    incompatible,
-    global: isGlobal,
-    cwd
+  return (0, import_prompts.select)({
+    message: options.message ?? "Select MCP scope:",
+    choices: [
+      {
+        name: `Current Project - ${import_picocolors3.default.dim(cwd)}`,
+        value: false
+      },
+      {
+        name: `Global User Config - ${import_picocolors3.default.dim("applies across all projects")}`,
+        value: true
+      }
+    ]
   });
-  return { serverName, config: serverConfig, results };
 };
 
-// src/list.ts
-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)) {
-      collected.push({
-        serverName,
-        agent: agentType,
-        path,
-        config: rawConfig,
-        serverConfig: parseServerConfig(rawConfig)
-      });
+// src/interactive/prompts/agents.ts
+var import_picocolors5 = __toESM(require("picocolors"), 1);
+
+// src/server-config.ts
+var buildMcpServerConfig = (parsed, options = {}) => {
+  if (parsed.type === "remote") {
+    const config2 = {
+      type: options.transport ?? DEFAULT_REMOTE_TRANSPORT,
+      url: parsed.value
+    };
+    if (options.headers && Object.keys(options.headers).length > 0) {
+      config2.headers = options.headers;
     }
+    return config2;
   }
-  return collected;
+  if (parsed.type === "command") {
+    const parts = parsed.value.split(/\s+/);
+    const command = parts[0] ?? "";
+    const args = parts.slice(1);
+    if (options.args && options.args.length > 0) {
+      args.push(...options.args);
+    }
+    const config2 = { command, args };
+    if (options.env && Object.keys(options.env).length > 0) {
+      config2.env = options.env;
+    }
+    return config2;
+  }
+  const packageArgs = [NPX_DASH_Y, parsed.value];
+  if (options.args && options.args.length > 0) {
+    packageArgs.push(...options.args);
+  }
+  const config = {
+    command: NPX_COMMAND,
+    args: packageArgs
+  };
+  if (options.env && Object.keys(options.env).length > 0) {
+    config.env = options.env;
+  }
+  return config;
 };
-
-// src/remove.ts
-var removeMcpServerFromAgent = (serverName, agentType, options = {}) => {
-  const agent = getMcpAgentConfig(agentType);
-  const { target } = agentConfigStore.resolveTarget(agent, options);
-  const coHosted = getCoHostedAgents(agentType, options);
-  try {
-    const { removed } = agentConfigStore.removeServer(agent, serverName, options);
+var parseServerConfig = (raw) => {
+  if (!raw || typeof raw !== "object") return {};
+  const data = raw;
+  const rawUrl = typeof data.url === "string" && data.url.trim().length > 0 ? data.url.trim() : void 0;
+  const rawHttpUrl = typeof data.httpUrl === "string" && data.httpUrl.trim().length > 0 ? data.httpUrl.trim() : void 0;
+  const remoteUrl = rawHttpUrl ?? rawUrl;
+  if (remoteUrl) {
+    const transport = data.type === "sse" || data.transport === "sse" ? "sse" : "http";
+    const headers = data.headers && typeof data.headers === "object" ? data.headers : void 0;
     return {
-      agent: agentType,
-      path: target.configPath,
-      removed,
-      coAffectedAgents: removed && coHosted.length > 0 ? coHosted : void 0
+      type: transport,
+      url: remoteUrl,
+      headers
     };
-  } catch (error) {
+  }
+  if (typeof data.command === "string" && data.command.trim().length > 0) {
+    const args = Array.isArray(data.args) ? data.args.filter((item) => typeof item === "string") : void 0;
+    const env = data.env && typeof data.env === "object" ? data.env : void 0;
     return {
-      agent: agentType,
-      path: target.configPath,
-      removed: false,
-      error: toErrorMessage(error)
+      command: data.command.trim(),
+      args,
+      env
     };
   }
+  return {};
 };
-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
-        });
-      }
-    }
-  }
-  return results;
-};
-
-// src/update-mcp-server.ts
 var toRemoteServerConfig = (config, defaultTransport = "http") => {
   const {
     command: _droppedCommand,
@@ -1651,15 +1706,16 @@ 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";
   }
-  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) => {
@@ -1677,40 +1733,263 @@ var sanitizeUpdatedServerConfig = (incoming, previous) => {
     case "merge-remote": {
       return toRemoteServerConfig({ ...previous, ...incoming }, targetTransport);
     }
-    case "merge-stdio": {
+    case "merge-stdio":
+    default: {
       return toStdioServerConfig({ ...previous, ...incoming });
     }
   }
 };
-var updateMcpServer = (options) => {
-  const isGlobal = options.global ?? false;
-  const cwd = options.cwd ?? process.cwd();
-  let previousConfig = options.previousConfig;
-  if (!previousConfig) {
-    const existing = listInstalledMcpServers({
-      global: isGlobal,
-      cwd,
-      agents: options.agents
-    });
-    const found = existing.find((s) => s.serverName === options.serverName && s.serverConfig);
-    if (found) {
-      previousConfig = found.serverConfig;
-    }
-  }
-  const serverConfig = sanitizeUpdatedServerConfig(options.config, previousConfig);
-  let targetAgents = options.agents;
-  if (!targetAgents || targetAgents.length === 0) {
-    const existing = listInstalledMcpServers({ global: isGlobal, cwd });
-    targetAgents = existing.filter((s) => s.serverName === options.serverName).map((s) => s.agent);
+
+// 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 requestedTransport = serverConfig.url ? serverConfig.type ?? "http" : "stdio";
-  const { allAgents, incompatible } = resolveTargetAgents({
-    requested: targetAgents,
-    global: isGlobal,
-    cwd,
-    transport: requestedTransport
-  });
-  const results = installToCompatibleAgents(options.serverName, serverConfig, {
+  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/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);
+  const isGlobal = options.global ?? false;
+  const cwd = options.cwd ?? process.cwd();
+  const serverName = options.name ?? parsed.inferredName;
+  const serverConfig = buildMcpServerConfig(parsed, {
+    transport: options.transport,
+    headers: options.headers,
+    env: options.env,
+    args: options.args
+  });
+  const requestedTransport = parsed.type === "remote" ? serverConfig.type ?? "http" : "stdio";
+  const { allAgents, incompatible } = resolveTargetAgents({
+    requested: options.agents,
+    global: isGlobal,
+    cwd,
+    transport: requestedTransport
+  });
+  const results = installToCompatibleAgents(serverName, serverConfig, {
+    allAgents,
+    incompatible,
+    global: isGlobal,
+    cwd
+  });
+  return { serverName, config: serverConfig, results };
+};
+
+// src/list.ts
+var listInstalledMcpServers = (options = {}) => {
+  const agentTypes = options.agents ?? getMcpAgentTypes();
+  const collected = [];
+  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: item.agent,
+        path: item.path,
+        config: rawConfig,
+        serverConfig: parseServerConfig(rawConfig)
+      });
+    }
+  }
+  return collected;
+};
+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;
+      }
+    }
+    if (!entry.agents.includes(item.agent)) {
+      entry.agents.push(item.agent);
+    }
+    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();
+  let previousConfig = options.previousConfig;
+  if (!previousConfig) {
+    const existing = listInstalledMcpServers({
+      global: isGlobal,
+      cwd,
+      agents: options.agents
+    });
+    const found = existing.find((s) => s.serverName === options.serverName && s.serverConfig);
+    if (found) {
+      previousConfig = found.serverConfig;
+    }
+  }
+  const serverConfig = sanitizeUpdatedServerConfig(options.config, previousConfig);
+  let targetAgents = options.agents;
+  if (!targetAgents || targetAgents.length === 0) {
+    const existing = listInstalledMcpServers({ global: isGlobal, cwd });
+    targetAgents = existing.filter((s) => s.serverName === options.serverName).map((s) => s.agent);
+  }
+  const requestedTransport = serverConfig.url ? serverConfig.type ?? "http" : "stdio";
+  const { allAgents, incompatible } = resolveTargetAgents({
+    requested: targetAgents,
+    global: isGlobal,
+    cwd,
+    transport: requestedTransport
+  });
+  const results = installToCompatibleAgents(options.serverName, serverConfig, {
     allAgents,
     incompatible,
     global: isGlobal,
@@ -1724,331 +2003,123 @@ var updateMcpServer = (options) => {
   };
 };
 
-// src/interactive/main-menu.ts
-import { select as select8 } from "@inquirer/prompts";
-import pc15 from "picocolors";
-
-// src/interactive/wizard-add.ts
-import { confirm as confirm5, input as input5, select as select5 } from "@inquirer/prompts";
-import pc11 from "picocolors";
-
-// src/utils/co-hosted-feedback.ts
-import pc2 from "picocolors";
+// 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/logger.ts
-import pc from "picocolors";
-var logger = {
-  info: (message) => {
-    console.log(pc.cyan("i"), message);
-  },
-  success: (message) => {
-    console.log(pc.green("\u221A"), message);
-  },
-  warn: (message) => {
-    console.log(pc.yellow("!"), message);
-  },
-  error: (message) => {
-    console.error(pc.red("x"), message);
+// 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)}`;
 };
-
-// src/utils/co-hosted-feedback.ts
-var formatCoHostedBadge = (kind, agents) => {
-  if (!agents || agents.length === 0) return "";
-  const label = kind === "configured" ? "co-configured" : "co-affected";
-  return ` ${pc2.yellow(`(${label}: ${agents.join(", ")})`)}`;
-};
-var logCoHostedNotice = (kind, agents) => {
-  if (!agents || agents.length === 0) return;
-  const actionText = kind === "configured" ? "Also configured for" : "Also affects";
-  logger.info(
-    `  ${pc2.dim("Note:")} ${actionText} co-hosted agent(s): ${pc2.yellow(agents.join(", "))}`
-  );
+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/agents.ts
-import pc6 from "picocolors";
-
-// src/interactive/utils/build-linked-agent-choices.ts
-import pc3 from "picocolors";
-var buildLinkedAgentChoices = (options) => {
-  const { agents, checkedAgents, detectedAgents = [], scopeOptions = {} } = options;
-  const alignedCheckedSet = new Set(checkedAgents);
-  for (const agent of checkedAgents) {
-    const coHosted = getCoHostedAgents(agent, scopeOptions);
-    for (const co of coHosted) {
-      if (agents.includes(co)) {
-        alignedCheckedSet.add(co);
-      }
-    }
+// 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 agents.map((agent) => {
-    const config = getMcpAgentConfig(agent);
-    const displayName = config?.displayName ?? agent;
-    const isDetected = detectedAgents.includes(agent);
-    const coHosted = getCoHostedAgents(agent, scopeOptions).filter(
-      (co) => agents.includes(co)
-    );
-    const detectedBadge = isDetected ? pc3.green(" [detected]") : "";
-    const sharedBadge = coHosted.length > 0 ? pc3.dim(` [shared: ${coHosted.join(", ")}]`) : "";
-    const label = `${displayName} ${pc3.dim(`(${agent})`)}${detectedBadge}${sharedBadge}`;
-    return {
-      name: label,
-      value: agent,
-      checked: alignedCheckedSet.has(agent),
-      linkedValues: coHosted,
-      description: coHosted.length > 0 ? `Linked with ${coHosted.map((a) => getMcpAgentConfig(a).displayName).join(", ")} (shared configuration)` : void 0
-    };
-  });
+  return resolved;
 };
 
-// src/interactive/prompts/linked-checkbox.ts
-import {
-  Separator,
-  ValidationError,
-  createPrompt,
-  isDownKey,
-  isEnterKey,
-  isNumberKey,
-  isSpaceKey,
-  isUpKey,
-  makeTheme,
-  useKeypress,
-  useMemo,
-  usePagination,
-  usePrefix,
-  useState
-} from "@inquirer/core";
-import pc4 from "picocolors";
-var defaultTheme = {
-  icon: {
-    checked: pc4.green("[x]"),
-    unchecked: pc4.dim("[ ]"),
-    cursor: pc4.cyan(">"),
-    disabledChecked: pc4.dim("[x]"),
-    disabledUnchecked: pc4.dim("[-]")
-  },
-  style: {
-    disabled: (text) => pc4.dim(text),
-    renderSelectedChoices: (selectedChoices) => selectedChoices.map((choice) => choice.short).join(", "),
-    description: (text) => pc4.cyan(text),
-    keysHelpTip: (keys) => keys.map(([key, action]) => `${pc4.bold(key)} ${pc4.dim(action)}`).join(pc4.dim(" | ")),
-    highlight: (text) => pc4.cyan(text)
-  },
-  i18n: {
-    disabledError: "This option is disabled and cannot be toggled."
+// 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;
   }
+  return parseMcpAgentList(rawList);
 };
-function isSelectable(item) {
-  return !Separator.isSeparator(item) && !item.disabled;
-}
-function isNavigable(item) {
-  return !Separator.isSeparator(item);
-}
-function isChecked(item) {
-  return !Separator.isSeparator(item) && item.checked;
-}
-function normalizeChoices(choices) {
-  return choices.map((choice) => {
-    if (Separator.isSeparator(choice)) {
-      return choice;
-    }
-    if (typeof choice !== "object" || choice === null || !("value" in choice)) {
-      const name2 = String(choice);
-      return {
-        value: choice,
-        name: name2,
-        short: name2,
-        checkedName: name2,
-        disabled: false,
-        checked: false,
-        linkedValues: []
-      };
-    }
-    const name = choice.name ?? String(choice.value);
-    return {
-      value: choice.value,
-      name,
-      short: choice.short ?? name,
-      checkedName: choice.checkedName ?? name,
-      description: choice.description,
-      disabled: choice.disabled ?? false,
-      checked: choice.checked ?? false,
-      linkedValues: choice.linkedValues ?? []
-    };
-  });
-}
-var linkedCheckbox = createPrompt(
-  (config, done) => {
-    const { pageSize = 10, loop = true, required, validate = () => true } = config;
-    const theme = makeTheme(defaultTheme, config.theme);
-    const [status, setStatus] = useState("idle");
-    const prefix = usePrefix({ status, theme });
-    const [items, setItems] = useState(() => normalizeChoices(config.choices));
-    const bounds = useMemo(() => {
-      const first = items.findIndex(isNavigable);
-      let last = -1;
-      for (let i = items.length - 1; i >= 0; i--) {
-        if (isNavigable(items[i])) {
-          last = i;
-          break;
-        }
-      }
-      if (first === -1 || last === -1) {
-        throw new ValidationError("[linkedCheckbox prompt] No selectable choices.");
-      }
-      return { first, last };
-    }, [items]);
-    const [active, setActive] = useState(bounds.first);
-    const [errorMsg, setError] = useState();
-    const toggleWithLinked = (targetIndex) => {
-      const targetItem = items[targetIndex];
-      if (!targetItem || Separator.isSeparator(targetItem) || targetItem.disabled) {
-        return;
-      }
-      const nextChecked = !targetItem.checked;
-      const targetValue = targetItem.value;
-      const linked = new Set(targetItem.linkedValues);
-      setItems(
-        (prevItems) => prevItems.map((item) => {
-          if (Separator.isSeparator(item) || item.disabled) {
-            return item;
-          }
-          const isTargetOrLinked = item.value === targetValue || linked.has(item.value) || item.linkedValues.includes(targetValue);
-          if (isTargetOrLinked) {
-            return { ...item, checked: nextChecked };
-          }
-          return item;
-        })
-      );
-    };
-    useKeypress(async (key) => {
-      if (isEnterKey(key)) {
-        const selection = items.filter(isChecked);
-        const isValid = await validate([...selection]);
-        if (required && selection.length === 0) {
-          setError("At least one choice must be selected");
-        } else if (isValid === true) {
-          setStatus("done");
-          done(selection.map((choice) => choice.value));
-        } else {
-          setError(typeof isValid === "string" ? isValid : "You must select a valid value");
-        }
-      } else if (isUpKey(key) || isDownKey(key)) {
-        if (errorMsg) setError(void 0);
-        if (loop || isUpKey(key) && active !== bounds.first || isDownKey(key) && active !== bounds.last) {
-          const offset = isUpKey(key) ? -1 : 1;
-          let next = active;
-          do {
-            next = (next + offset + items.length) % items.length;
-          } while (!isNavigable(items[next]));
-          setActive(next);
-        }
-      } else if (isSpaceKey(key)) {
-        const activeItem = items[active];
-        if (activeItem && !Separator.isSeparator(activeItem)) {
-          if (activeItem.disabled) {
-            setError(theme.i18n.disabledError);
-          } else {
-            setError(void 0);
-            toggleWithLinked(active);
-          }
-        }
-      } else if (key.name === "a") {
-        const hasUnchecked = items.some((choice) => isSelectable(choice) && !choice.checked);
-        setItems(
-          (prevItems) => prevItems.map((item) => isSelectable(item) ? { ...item, checked: hasUnchecked } : item)
-        );
-      } else if (isNumberKey(key)) {
-        const selectedIndex = Number(key.name) - 1;
-        let selectableIndex = -1;
-        const position = items.findIndex((item) => {
-          if (Separator.isSeparator(item)) return false;
-          selectableIndex++;
-          return selectableIndex === selectedIndex;
-        });
-        const selectedItem = items[position];
-        if (selectedItem && isSelectable(selectedItem)) {
-          setActive(position);
-          setError(void 0);
-          toggleWithLinked(position);
-        }
-      }
-    });
-    const message = theme.style.message(config.message, status);
-    let description;
-    const page = usePagination({
-      items,
-      active,
-      renderItem({ item, isActive }) {
-        if (Separator.isSeparator(item)) {
-          return ` ${item.separator}`;
-        }
-        const cursor = isActive ? theme.icon.cursor : " ";
-        if (item.disabled) {
-          const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
-          const checkbox2 = item.checked ? theme.icon.disabledChecked : theme.icon.disabledUnchecked;
-          return theme.style.disabled(`${cursor} ${checkbox2} ${item.name} ${disabledLabel}`);
-        }
-        if (isActive) {
-          description = item.description;
-        }
-        const checkbox = item.checked ? theme.icon.checked : theme.icon.unchecked;
-        const name = item.checked ? item.checkedName : item.name;
-        const color = isActive ? theme.style.highlight : (x) => x;
-        return color(`${cursor} ${checkbox} ${name}`);
-      },
-      pageSize,
-      loop
-    });
-    if (status === "done") {
-      const selection = items.filter(isChecked);
-      const answer = theme.style.answer(theme.style.renderSelectedChoices(selection, items));
-      return [prefix, message, answer].filter(Boolean).join(" ");
-    }
-    const helpLine = theme.style.keysHelpTip([
-      ["up/down", "navigate"],
-      ["space", "toggle"],
-      ["a", "all"],
-      ["enter", "submit"]
-    ]);
-    const lines = [
-      [prefix, message].filter(Boolean).join(" "),
-      page,
-      helpLine
-    ];
-    if (description) {
-      lines.push(theme.style.description(description));
+var resolveTargetAgents = (query = {}) => {
+  const cwd = query.cwd ?? process.cwd();
+  const isGlobal = query.global ?? false;
+  let explicitAgents = normalizeRequestedAgents(query.requested);
+  if (query.all) {
+    explicitAgents = getMcpAgentTypes();
+  }
+  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 (errorMsg) {
-      lines.push(theme.style.error(errorMsg));
+  }
+  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 lines.join("\n");
   }
-);
+  return {
+    agents: compatibleAgents,
+    compatibleAgents,
+    allAgents,
+    candidateAgents: allAgents,
+    detected,
+    isDetected,
+    incompatible,
+    diagnostic
+  };
+};
 
-// src/interactive/prompts/scope.ts
-import { select } from "@inquirer/prompts";
-import pc5 from "picocolors";
-var promptScope = async (options = {}) => {
-  const initialGlobal = options.defaultGlobal ?? options.global;
-  if (initialGlobal !== void 0) {
-    return initialGlobal;
+// src/utils/logger.ts
+var import_picocolors4 = __toESM(require("picocolors"), 1);
+var logger = {
+  info: (message) => {
+    console.log(import_picocolors4.default.cyan("i"), message);
+  },
+  success: (message) => {
+    console.log(import_picocolors4.default.green("\u221A"), message);
+  },
+  warn: (message) => {
+    console.log(import_picocolors4.default.yellow("!"), message);
+  },
+  error: (message) => {
+    console.error(import_picocolors4.default.red("x"), message);
   }
-  const cwd = options.cwd ?? process.cwd();
-  return select({
-    message: options.message ?? "Select MCP scope:",
-    choices: [
-      {
-        name: `Current Project - ${pc5.dim(cwd)}`,
-        value: false
-      },
-      {
-        name: `Global User Config - ${pc5.dim("applies across all projects")}`,
-        value: true
-      }
-    ]
-  });
 };
 
 // src/interactive/prompts/agents.ts
@@ -2065,10 +2136,13 @@ 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: ${pc6.cyan(detected.map((a) => getMcpAgentConfig(a).displayName).join(", "))}`
+      `Detected configured agents: ${import_picocolors5.default.cyan(detected.map((a) => getMcpAgentConfig(a).displayName).join(", "))}`
     );
   } else {
     logger.warn(`No active ${isGlobal ? "global" : "project"} agents detected`);
@@ -2096,86 +2170,25 @@ var promptScopeAndAgents = async (options = {}) => {
   };
 };
 
-// src/interactive/prompts/args.ts
-import { confirm, input } from "@inquirer/prompts";
-var parseArgsString = (rawText) => {
-  const matches = rawText.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g);
-  if (!matches) return [];
-  return matches.map((arg) => {
-    if (arg.startsWith('"') && arg.endsWith('"') || arg.startsWith("'") && arg.endsWith("'")) {
-      return arg.slice(1, -1);
-    }
-    return arg;
-  });
-};
-var promptArgsConfig = async (initialArgs = []) => {
-  if (initialArgs.length > 0) {
-    return initialArgs;
-  }
-  const needArgs = await confirm({
-    message: "Configure command arguments (e.g. file paths, connection strings)?",
-    default: false
-  });
-  if (!needArgs) {
-    return [];
-  }
-  const raw = await input({
-    message: "Enter command arguments (space-separated, wrap paths with spaces in quotes):",
-    validate: (val) => val.trim() ? true : "Arguments cannot be empty"
-  });
-  return parseArgsString(raw.trim());
-};
-var formatArgsString = (args) => {
-  return args.map((arg) => arg.includes(" ") || arg.includes('"') ? `"${arg.replace(/"/g, '\\"')}"` : arg).join(" ");
-};
-var promptEditArgs = async (currentArgs = []) => {
-  const defaultStr = formatArgsString(currentArgs);
-  const raw = await input({
-    message: "Edit command arguments (space-separated, wrap paths with spaces in quotes, leave empty to clear):",
-    default: defaultStr
-  });
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return [];
-  }
-  return parseArgsString(trimmed);
-};
-
 // src/interactive/prompts/env.ts
-import { input as input3, password as password2, select as select3 } from "@inquirer/prompts";
-import pc9 from "picocolors";
-
-// 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)}`;
-};
+var import_prompts4 = require("@inquirer/prompts");
+var import_picocolors8 = __toESM(require("picocolors"), 1);
 
 // src/interactive/prompts/kv.ts
-import { confirm as confirm2, input as input2, password, select as select2 } from "@inquirer/prompts";
-import pc8 from "picocolors";
+var import_prompts3 = require("@inquirer/prompts");
+var import_picocolors7 = __toESM(require("picocolors"), 1);
 
 // src/interactive/prompts/multiline.ts
-import { createInterface } from "readline";
-import { editor } from "@inquirer/prompts";
-import pc7 from "picocolors";
+var import_node_readline = require("readline");
+var import_prompts2 = require("@inquirer/prompts");
+var import_picocolors6 = __toESM(require("picocolors"), 1);
 var readMultilineTextFromTerminal = async (message, endHint = "When done pasting, enter END on a new line or press Enter twice to finish") => {
-  console.log(pc7.cyan(`
+  console.log(import_picocolors6.default.cyan(`
 ${message}`));
-  console.log(pc7.dim(`  (Hint: ${endHint})
+  console.log(import_picocolors6.default.dim(`  (Hint: ${endHint})
 `));
   return new Promise((resolve) => {
-    const rl = createInterface({
+    const rl = (0, import_node_readline.createInterface)({
       input: process.stdin,
       output: process.stdout
     });
@@ -2216,7 +2229,7 @@ ${message}`));
 };
 var promptEditorText = async (options) => {
   try {
-    return await editor({
+    return await (0, import_prompts2.editor)({
       message: options.message,
       default: options.defaultText ?? "",
       postfix: options.postfix
@@ -2233,16 +2246,16 @@ var promptEditKeyValueConfig = async (currentItems = {}, options) => {
     const keys = Object.keys(items);
     console.log();
     if (keys.length === 0) {
-      console.log(pc8.dim(`  No ${options.itemsNoun} configured.`));
+      console.log(import_picocolors7.default.dim(`  No ${options.itemsNoun} configured.`));
     } else {
-      console.log(pc8.cyan(pc8.bold(`  Configured ${options.title} (${keys.length}):`)));
+      console.log(import_picocolors7.default.cyan(import_picocolors7.default.bold(`  Configured ${options.title} (${keys.length}):`)));
       for (const [k, v] of Object.entries(items)) {
         const sep = options.separator === "=" ? "=" : ": ";
-        console.log(`    ${pc8.bold(k)}${sep}${pc8.dim(options.maskValue(k, v))}`);
+        console.log(`    ${import_picocolors7.default.bold(k)}${sep}${import_picocolors7.default.dim(options.maskValue(k, v))}`);
       }
     }
     console.log();
-    const choice = await select2({
+    const choice = await (0, import_prompts3.select)({
       message: `Manage ${options.itemsNoun}:`,
       choices: [
         {
@@ -2289,7 +2302,7 @@ var promptEditKeyValueConfig = async (currentItems = {}, options) => {
       items = parsed;
       logger.success(`${options.title} updated (${Object.keys(items).length} total)`);
     } else if (choice === "upsert") {
-      const key = await input2({
+      const key = await (0, import_prompts3.input)({
         message: options.keyPromptMessage,
         validate: (val) => {
           const trimmed = val.trim();
@@ -2303,7 +2316,7 @@ var promptEditKeyValueConfig = async (currentItems = {}, options) => {
       const isSecret = options.isSecretKey(trimmedKey);
       let newVal;
       if (isSecret) {
-        newVal = await password({
+        newVal = await (0, import_prompts3.password)({
           message: existingVal !== void 0 ? `New value for (${trimmedKey}) [leave empty to keep current]:` : `${options.valuePromptMessage} for (${trimmedKey}) [sensitive content masked]:`,
           mask: "*"
         });
@@ -2311,15 +2324,15 @@ var promptEditKeyValueConfig = async (currentItems = {}, options) => {
           newVal = existingVal;
         }
       } else {
-        newVal = await input2({
+        newVal = await (0, import_prompts3.input)({
           message: `${options.valuePromptMessage} for (${trimmedKey}):`,
           default: existingVal
         });
       }
       items[trimmedKey] = newVal;
-      logger.success(`${existingVal !== void 0 ? "Updated" : "Added"}: ${pc8.cyan(trimmedKey)}`);
+      logger.success(`${existingVal !== void 0 ? "Updated" : "Added"}: ${import_picocolors7.default.cyan(trimmedKey)}`);
     } else if (choice === "delete") {
-      const toDelete = await select2({
+      const toDelete = await (0, import_prompts3.select)({
         message: `Select ${options.itemNoun} to delete:`,
         choices: [
           ...keys.map((k) => ({ name: k, value: k })),
@@ -2328,7 +2341,7 @@ var promptEditKeyValueConfig = async (currentItems = {}, options) => {
       });
       if (toDelete !== "__cancel__") {
         delete items[toDelete];
-        logger.success(`Deleted: ${pc8.cyan(toDelete)}`);
+        logger.success(`Deleted: ${import_picocolors7.default.cyan(toDelete)}`);
       }
     } else if (choice === "paste") {
       const pasted = await readMultilineTextFromTerminal(options.pasteMessage);
@@ -2338,7 +2351,7 @@ var promptEditKeyValueConfig = async (currentItems = {}, options) => {
         logger.warn(`No valid ${options.itemsNoun} recognized`);
       } else {
         if (keys.length > 0) {
-          const pasteMode = await select2({
+          const pasteMode = await (0, import_prompts3.select)({
             message: `How to apply pasted ${options.itemsNoun}?`,
             choices: [
               { name: `Merge with existing ${options.itemsNoun}`, value: "merge" },
@@ -2353,10 +2366,10 @@ var promptEditKeyValueConfig = async (currentItems = {}, options) => {
         } else {
           items = parsed;
         }
-        logger.success(`Successfully applied ${pc8.cyan(String(count))} ${options.itemsNoun}`);
+        logger.success(`Successfully applied ${import_picocolors7.default.cyan(String(count))} ${options.itemsNoun}`);
       }
     } else if (choice === "clear") {
-      const confirmClear = await confirm2({
+      const confirmClear = await (0, import_prompts3.confirm)({
         message: `Are you sure you want to clear all ${options.itemsNoun}?`,
         default: false
       });
@@ -2402,9 +2415,9 @@ var promptEnvConfig = async (initialEnv = {}) => {
   const env = { ...initialEnv };
   const initialCount = Object.keys(env).length;
   if (initialCount > 0) {
-    logger.info(`Includes ${pc9.cyan(String(initialCount))} preset environment variables`);
+    logger.info(`Includes ${import_picocolors8.default.cyan(String(initialCount))} preset environment variables`);
   }
-  const mode = await select3({
+  const mode = await (0, import_prompts4.select)({
     message: "Configure environment variables?",
     choices: [
       {
@@ -2440,16 +2453,16 @@ var promptEnvConfig = async (initialEnv = {}) => {
       logger.warn("No valid KEY=VALUE pairs recognized");
     } else {
       Object.assign(env, parsed);
-      logger.success(`Successfully parsed ${pc9.cyan(String(count))} environment variables:`);
+      logger.success(`Successfully parsed ${import_picocolors8.default.cyan(String(count))} environment variables:`);
       for (const [k, v] of Object.entries(parsed)) {
-        console.log(`  ${pc9.bold(k)}=${pc9.dim(maskSecretValue(k, v))}`);
+        console.log(`  ${import_picocolors8.default.bold(k)}=${import_picocolors8.default.dim(maskSecretValue(k, v))}`);
       }
     }
     return env;
   }
   logger.info("Entering environment variables (leave key empty and press enter to finish):");
   while (true) {
-    const key = await input3({
+    const key = await (0, import_prompts4.input)({
       message: "Variable name (Key, leave empty to finish):",
       validate: (val2) => {
         const trimmed = val2.trim();
@@ -2463,17 +2476,17 @@ var promptEnvConfig = async (initialEnv = {}) => {
     const isSecret = SECRET_KEY_PATTERN.test(trimmedKey);
     let val;
     if (isSecret) {
-      val = await password2({
+      val = await (0, import_prompts4.password)({
         message: `Value for (${trimmedKey}) [secret masked]:`,
         mask: "*"
       });
     } else {
-      val = await input3({
+      val = await (0, import_prompts4.input)({
         message: `Value for (${trimmedKey}):`
       });
     }
     env[trimmedKey] = val;
-    logger.success(`Added: ${pc9.cyan(trimmedKey)}`);
+    logger.success(`Added: ${import_picocolors8.default.cyan(trimmedKey)}`);
   }
   return env;
 };
@@ -2494,8 +2507,8 @@ var promptEditEnvConfig = async (currentEnv = {}) => promptEditKeyValueConfig(cu
 });
 
 // src/interactive/prompts/headers.ts
-import { input as input4, password as password3, select as select4 } from "@inquirer/prompts";
-import pc10 from "picocolors";
+var import_prompts5 = require("@inquirer/prompts");
+var import_picocolors9 = __toESM(require("picocolors"), 1);
 var formatHeadersText = (headers) => {
   return Object.entries(headers).map(([key, value]) => `${key}: ${value}`).join("\n");
 };
@@ -2528,7 +2541,7 @@ var parseHeadersText = (rawText) => {
 };
 var promptHeadersConfig = async (initialHeaders = {}) => {
   const headers = { ...initialHeaders };
-  const mode = await select4({
+  const mode = await (0, import_prompts5.select)({
     message: "Select HTTP headers configuration method:",
     choices: [
       {
@@ -2565,16 +2578,16 @@ var promptHeadersConfig = async (initialHeaders = {}) => {
       logger.warn("No valid Key: Value pairs recognized");
     } else {
       Object.assign(headers, parsed);
-      logger.success(`Successfully parsed ${pc10.cyan(String(count))} headers:`);
+      logger.success(`Successfully parsed ${import_picocolors9.default.cyan(String(count))} headers:`);
       for (const [k, v] of Object.entries(parsed)) {
-        console.log(`  ${pc10.bold(k)}: ${pc10.dim(maskSecretHeader(k, v))}`);
+        console.log(`  ${import_picocolors9.default.bold(k)}: ${import_picocolors9.default.dim(maskSecretHeader(k, v))}`);
       }
     }
     return headers;
   }
   logger.info("Entering HTTP headers (leave header name empty and press enter to finish):");
   while (true) {
-    const name = await input4({
+    const name = await (0, import_prompts5.input)({
       message: "Header name (e.g. Authorization, leave empty to finish):",
       validate: (val2) => {
         const trimmed = val2.trim();
@@ -2588,17 +2601,17 @@ var promptHeadersConfig = async (initialHeaders = {}) => {
     const isSecret = SECRET_HEADER_PATTERN.test(trimmedName);
     let val;
     if (isSecret) {
-      val = await password3({
+      val = await (0, import_prompts5.password)({
         message: `Header value for (${trimmedName}) [sensitive content masked]:`,
         mask: "*"
       });
     } else {
-      val = await input4({
+      val = await (0, import_prompts5.input)({
         message: `Header value for (${trimmedName}):`
       });
     }
     headers[trimmedName] = val;
-    logger.success(`Added: ${pc10.cyan(trimmedName)}`);
+    logger.success(`Added: ${import_picocolors9.default.cyan(trimmedName)}`);
   }
   return headers;
 };
@@ -2617,165 +2630,57 @@ var promptEditHeadersConfig = async (currentHeaders = {}) => promptEditKeyValueC
   parseText: parseHeadersText
 });
 
-// src/interactive/wizard-add.ts
-var wizardAdd = async (initial = {}) => {
-  const cwd = initial.cwd ?? process.cwd();
-  logger.info(pc11.bold("Welcome to the MCP interactive add wizard"));
-  let source = initial.source;
-  if (!source) {
-    const sourceType = await select5({
-      message: "Select MCP server type:",
-      choices: [
-        {
-          name: "npm package (run via npx)",
-          value: "npm"
-        },
-        {
-          name: "Remote MCP server (via HTTP / SSE URL)",
-          value: "remote"
-        },
-        {
-          name: "Local command / script / Docker (stdio)",
-          value: "command"
-        }
-      ]
-    });
-    if (sourceType === "npm") {
-      source = await input5({
-        message: "Enter npm package name (e.g. @modelcontextprotocol/server-postgres):",
-        validate: (val) => val.trim() ? true : "Package name cannot be empty"
-      });
-    } else if (sourceType === "remote") {
-      source = await input5({
-        message: "Enter remote server URL (e.g. https://mcp.example.com/sse):",
-        validate: (val) => {
-          const trimmed = val.trim();
-          if (!trimmed) return "URL cannot be empty";
-          if (!/^https?:\/\//i.test(trimmed)) return "Please enter a valid URL starting with http:// or https://";
-          return true;
-        }
-      });
-    } else {
-      source = await input5({
-        message: "Enter command and arguments (e.g. python -m my_mcp_server or docker run ...):",
-        validate: (val) => val.trim() ? true : "Command cannot be empty"
-      });
-    }
-  }
-  source = source.trim();
-  const parsed = parseMcpSource(source);
-  let serverName = initial.name;
-  if (!serverName) {
-    serverName = await input5({
-      message: "MCP server name:",
-      default: parsed.inferredName,
-      validate: (val) => val.trim() ? true : "Server name cannot be empty"
-    });
-  }
-  serverName = serverName.trim();
-  let transport = initial.transport;
-  let headers = initial.headers ?? {};
-  if (parsed.type === "remote") {
-    if (!transport) {
-      const isSseUrl = /\/sse\b/i.test(parsed.value);
-      transport = await select5({
-        message: "Select remote transport protocol:",
-        choices: [
-          { name: "HTTP", value: "http" },
-          { name: "SSE (Server-Sent Events)", value: "sse" }
-        ],
-        default: isSseUrl ? "sse" : "http"
-      });
-    }
-    if (Object.keys(headers).length === 0) {
-      const needHeader = await confirm5({
-        message: "Configure HTTP headers (e.g. Authorization Bearer token)?",
-        default: false
-      });
-      if (needHeader) {
-        headers = await promptHeadersConfig();
-      }
+// src/interactive/prompts/args.ts
+var import_prompts6 = require("@inquirer/prompts");
+var parseArgsString = (rawText) => {
+  const matches = rawText.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g);
+  if (!matches) return [];
+  return matches.map((arg) => {
+    if (arg.startsWith('"') && arg.endsWith('"') || arg.startsWith("'") && arg.endsWith("'")) {
+      return arg.slice(1, -1);
     }
-  }
-  const { global: isGlobal, agents: selectedAgents } = await promptScopeAndAgents({
-    cwd,
-    defaultGlobal: initial.global,
-    defaultAgents: initial.agents
+    return arg;
   });
-  let args = initial.args ?? [];
-  if (parsed.type !== "remote") {
-    args = await promptArgsConfig(args);
-  }
-  let env = initial.env ?? {};
-  if (parsed.type !== "remote") {
-    env = await promptEnvConfig(env);
-  }
-  console.log("\n" + pc11.cyan(pc11.bold("Configuration Preview:")));
-  console.log(`  ${pc11.bold("Server Name:")} ${pc11.green(serverName)}`);
-  console.log(`  ${pc11.bold("Server Type:")} ${pc11.magenta(parsed.type)}`);
-  console.log(`  ${pc11.bold("Source/Command:")} ${pc11.dim(source)}`);
-  console.log(`  ${pc11.bold("Scope:")} ${isGlobal ? pc11.yellow("Global") : pc11.blue("Project")}`);
-  console.log(`  ${pc11.bold("Target Agents:")} ${pc11.cyan(selectedAgents.join(", "))}`);
-  if (args.length > 0) {
-    console.log(`  ${pc11.bold("Arguments:")} ${pc11.dim(args.join(" "))}`);
-  }
-  if (transport) {
-    console.log(`  ${pc11.bold("Transport:")} ${pc11.magenta(transport)}`);
-  }
-  const envKeys = Object.keys(env);
-  if (envKeys.length > 0) {
-    console.log(`  ${pc11.bold("Environment Variables:")} ${pc11.dim(envKeys.join(", "))} (${envKeys.length})`);
-  }
-  const headerKeys = Object.keys(headers);
-  if (headerKeys.length > 0) {
-    console.log(`  ${pc11.bold("Headers:")} ${pc11.dim(headerKeys.join(", "))} (${headerKeys.length})`);
+};
+var promptArgsConfig = async (initialArgs = []) => {
+  if (initialArgs.length > 0) {
+    return initialArgs;
   }
-  console.log();
-  const proceed = await confirm5({
-    message: "Confirm installation with this configuration?",
-    default: true
+  const needArgs = await (0, import_prompts6.confirm)({
+    message: "Configure command arguments (e.g. file paths, connection strings)?",
+    default: false
   });
-  if (!proceed) {
-    logger.warn("Operation cancelled");
-    return false;
+  if (!needArgs) {
+    return [];
   }
-  const result = installMcpServer({
-    source,
-    name: serverName,
-    agents: selectedAgents,
-    args,
-    global: isGlobal,
-    cwd,
-    transport,
-    headers,
-    env
+  const raw = await (0, import_prompts6.input)({
+    message: "Enter command arguments (space-separated, wrap paths with spaces in quotes):",
+    validate: (val) => val.trim() ? true : "Arguments cannot be empty"
   });
-  logger.info(
-    `Writing ${pc11.bold(result.serverName)} to ${pc11.cyan(String(result.results.length))} agent config files...`
-  );
-  let allSuccess = true;
-  for (const record of result.results) {
-    if (record.success) {
-      logger.success(
-        `${pc11.cyan(record.agent)}: Successfully written to ${pc11.dim(record.path)}${formatCoHostedBadge("configured", record.coConfiguredAgents)}`
-      );
-    } else {
-      allSuccess = false;
-      logger.error(`${pc11.cyan(record.agent)}: Failed to write - ${record.error}`);
-    }
-  }
-  if (allSuccess) {
-    logger.success(pc11.bold(`MCP server "${serverName}" configured successfully!`));
+  return parseArgsString(raw.trim());
+};
+var formatArgsString = (args) => {
+  return args.map((arg) => arg.includes(" ") || arg.includes('"') ? `"${arg.replace(/"/g, '\\"')}"` : arg).join(" ");
+};
+var promptEditArgs = async (currentArgs = []) => {
+  const defaultStr = formatArgsString(currentArgs);
+  const raw = await (0, import_prompts6.input)({
+    message: "Edit command arguments (space-separated, wrap paths with spaces in quotes, leave empty to clear):",
+    default: defaultStr
+  });
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return [];
   }
-  return allSuccess;
+  return parseArgsString(trimmed);
 };
 
 // src/interactive/wizard-manage.ts
-import { confirm as confirm6, input as input6, select as select6 } from "@inquirer/prompts";
-import pc13 from "picocolors";
+var import_prompts7 = require("@inquirer/prompts");
+var import_picocolors12 = __toESM(require("picocolors"), 1);
 
 // src/utils/display-server-details.ts
-import pc12 from "picocolors";
+var import_picocolors10 = __toESM(require("picocolors"), 1);
 var displayServerDetails = ({
   serverName,
   config,
@@ -2784,99 +2689,76 @@ var displayServerDetails = ({
   global: isGlobal,
   titlePrefix = "MCP Server Details"
 }) => {
-  console.log("\n" + pc12.cyan(pc12.bold(`${titlePrefix}: [${serverName}]`)));
+  console.log("\n" + import_picocolors10.default.cyan(import_picocolors10.default.bold(`${titlePrefix}: [${serverName}]`)));
   if (isGlobal !== void 0) {
-    console.log(`  ${pc12.bold("Scope:")} ${isGlobal ? "Global" : "Project"}`);
+    console.log(`  ${import_picocolors10.default.bold("Scope:")} ${isGlobal ? "Global" : "Project"}`);
   }
   if (agents && agents.length > 0) {
     console.log(
-      `  ${pc12.bold("Configured Agents:")} ${pc12.green(agents.map((a) => getMcpAgentConfig(a).displayName).join(", "))}`
+      `  ${import_picocolors10.default.bold("Configured Agents:")} ${import_picocolors10.default.green(agents.map((a) => getMcpAgentConfig(a).displayName).join(", "))}`
     );
   }
   if (hasDivergence) {
     console.log(
-      `  ${pc12.yellow(pc12.bold("Notice:"))} ${pc12.yellow("Configurations differ across installed agents. Showing configuration from the first agent.")}`
+      `  ${import_picocolors10.default.yellow(import_picocolors10.default.bold("Notice:"))} ${import_picocolors10.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(`  ${pc12.bold("Transport:")} ${pc12.magenta(config.type ?? "http")}`);
-    console.log(`  ${pc12.bold("URL:")} ${pc12.dim(config.url ?? "")}`);
+    console.log(`  ${import_picocolors10.default.bold("Transport:")} ${import_picocolors10.default.magenta(config.type ?? "http")}`);
+    console.log(`  ${import_picocolors10.default.bold("URL:")} ${import_picocolors10.default.dim(config.url ?? "")}`);
     const headerKeys = Object.keys(config.headers ?? {});
     if (headerKeys.length > 0) {
-      console.log(`  ${pc12.bold("Headers:")} ${pc12.cyan(String(headerKeys.length))}`);
+      console.log(`  ${import_picocolors10.default.bold("Headers:")} ${import_picocolors10.default.cyan(String(headerKeys.length))}`);
       for (const [k, v] of Object.entries(config.headers ?? {})) {
-        console.log(`    ${pc12.bold(k)}: ${pc12.dim(maskSecretHeader(k, v))}`);
+        console.log(`    ${import_picocolors10.default.bold(k)}: ${import_picocolors10.default.dim(maskSecretHeader(k, v))}`);
       }
     } else {
-      console.log(`  ${pc12.bold("Headers:")} ${pc12.dim("(none)")}`);
+      console.log(`  ${import_picocolors10.default.bold("Headers:")} ${import_picocolors10.default.dim("(none)")}`);
     }
   } else {
-    console.log(`  ${pc12.bold("Command:")} ${pc12.magenta(config.command ?? "")}`);
+    console.log(`  ${import_picocolors10.default.bold("Command:")} ${import_picocolors10.default.magenta(config.command ?? "")}`);
     const argsStr = config.args && config.args.length > 0 ? config.args.join(" ") : "(none)";
-    console.log(`  ${pc12.bold("Arguments:")} ${pc12.dim(argsStr)}`);
+    console.log(`  ${import_picocolors10.default.bold("Arguments:")} ${import_picocolors10.default.dim(argsStr)}`);
     const envKeys = Object.keys(config.env ?? {});
     if (envKeys.length > 0) {
-      console.log(`  ${pc12.bold("Environment Variables:")} ${pc12.cyan(String(envKeys.length))}`);
-      for (const [k, v] of Object.entries(config.env ?? {})) {
-        console.log(`    ${pc12.bold(k)}=${pc12.dim(maskSecretValue(k, v))}`);
-      }
-    } else {
-      console.log(`  ${pc12.bold("Environment Variables:")} ${pc12.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;
+      console.log(`  ${import_picocolors10.default.bold("Environment Variables:")} ${import_picocolors10.default.cyan(String(envKeys.length))}`);
+      for (const [k, v] of Object.entries(config.env ?? {})) {
+        console.log(`    ${import_picocolors10.default.bold(k)}=${import_picocolors10.default.dim(maskSecretValue(k, v))}`);
       }
-    }
-    if (!entry.agents.includes(item.agent)) {
-      entry.agents.push(item.agent);
-    }
-    if (!entry.paths.includes(item.path)) {
-      entry.paths.push(item.path);
+    } else {
+      console.log(`  ${import_picocolors10.default.bold("Environment Variables:")} ${import_picocolors10.default.dim("(none)")}`);
     }
   }
-  return grouped;
+  console.log();
+};
+
+// src/utils/co-hosted-feedback.ts
+var import_picocolors11 = __toESM(require("picocolors"), 1);
+var formatCoHostedBadge = (kind, agents) => {
+  if (!agents || agents.length === 0) return "";
+  const label = kind === "configured" ? "co-configured" : "co-affected";
+  return ` ${import_picocolors11.default.yellow(`(${label}: ${agents.join(", ")})`)}`;
 };
 
 // src/interactive/wizard-manage.ts
 var promptSwitchServerType = async (currentConfig, serverName) => {
   const isRemote = Boolean(currentConfig.url && currentConfig.url.length > 0);
   if (isRemote) {
-    const newCmd = await input6({
+    const newCmd = await (0, import_prompts7.input)({
       message: "Executable command (e.g. node, npx):",
       validate: (val) => val.trim() ? true : "Command cannot be empty"
     });
     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 input6({
+  const newUrl = await (0, import_prompts7.input)({
     message: "Remote server URL:",
     validate: (val) => {
       const trimmed = val.trim();
@@ -2887,7 +2769,7 @@ var promptSwitchServerType = async (currentConfig, serverName) => {
       return true;
     }
   });
-  const transport = await select6({
+  const transport = await (0, import_prompts7.select)({
     message: "Select remote transport protocol:",
     choices: [
       { name: "HTTP", value: "http" },
@@ -2897,11 +2779,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;
@@ -2938,7 +2822,7 @@ var handleEditServerConfig = async (options) => {
       { name: "Save and apply changes", value: "save" },
       { name: "Cancel (discard changes)", value: "cancel" }
     ];
-    const editAction = await select6({
+    const editAction = await (0, import_prompts7.select)({
       message: `What would you like to modify in [${serverName}]?`,
       choices: editChoices
     });
@@ -2965,7 +2849,7 @@ var handleEditServerConfig = async (options) => {
     } else if (editAction === "args") {
       workingConfig.args = await promptEditArgs(workingConfig.args ?? []);
     } else if (editAction === "command") {
-      const newCmd = await input6({
+      const newCmd = await (0, import_prompts7.input)({
         message: "Executable command:",
         default: workingConfig.command,
         validate: (val) => val.trim() ? true : "Command cannot be empty"
@@ -2974,7 +2858,7 @@ var handleEditServerConfig = async (options) => {
     } else if (editAction === "headers") {
       workingConfig.headers = await promptEditHeadersConfig(workingConfig.headers ?? {});
     } else if (editAction === "url") {
-      const newUrl = await input6({
+      const newUrl = await (0, import_prompts7.input)({
         message: "Remote server URL:",
         default: workingConfig.url,
         validate: (val) => {
@@ -2988,7 +2872,7 @@ var handleEditServerConfig = async (options) => {
       });
       workingConfig.url = newUrl.trim();
     } else if (editAction === "transport") {
-      workingConfig.type = await select6({
+      workingConfig.type = await (0, import_prompts7.select)({
         message: "Select remote transport protocol:",
         choices: [
           { name: "HTTP", value: "http" },
@@ -2999,7 +2883,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,
@@ -3028,7 +2912,7 @@ var handleEditServerConfig = async (options) => {
       });
       if (resolution.incompatible.length > 0) {
         for (const item of resolution.incompatible) {
-          logger.warn(`Skipping ${pc13.cyan(item.agent)}: ${item.reason}`);
+          logger.warn(`Skipping ${import_picocolors12.default.cyan(item.agent)}: ${item.reason}`);
         }
       }
       if (resolution.compatibleAgents.length === 0) {
@@ -3038,7 +2922,7 @@ var handleEditServerConfig = async (options) => {
         continue;
       }
       const agentNames = resolution.compatibleAgents.map((a) => getMcpAgentConfig(a).displayName).join(", ");
-      const confirmed = await confirm6({
+      const confirmed = await (0, import_prompts7.confirm)({
         message: `Confirm updating configuration for [${serverName}] across: ${agentNames}?`,
         default: true
       });
@@ -3061,10 +2945,10 @@ var handleEditServerConfig = async (options) => {
           updatedAny = true;
           succeededAgents.push(res.agent);
           logger.success(
-            `${pc13.cyan(res.agent)}: Successfully updated configuration in ${pc13.dim(res.path)}${formatCoHostedBadge("configured", res.coConfiguredAgents)}`
+            `${import_picocolors12.default.cyan(res.agent)}: Successfully updated configuration in ${import_picocolors12.default.dim(res.path)}${formatCoHostedBadge("configured", res.coConfiguredAgents)}`
           );
         } else {
-          logger.error(`${pc13.cyan(res.agent)}: Update failed - ${res.error}`);
+          logger.error(`${import_picocolors12.default.cyan(res.agent)}: Update failed - ${res.error}`);
         }
       }
       if (updatedAny) {
@@ -3082,16 +2966,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);
@@ -3107,7 +2989,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: `${pc13.bold(g.serverName)} ${pc13.dim(`(configured in: ${agentNames})`)}`,
+          name: `${import_picocolors12.default.bold(g.serverName)} ${import_picocolors12.default.dim(`(configured in: ${agentNames})`)}`,
           value: g.serverName
         };
       });
@@ -3115,7 +2997,7 @@ var wizardManage = async (options = {}) => {
         name: `Back`,
         value: "__back__"
       });
-      chosenServerName = await select6({
+      chosenServerName = await (0, import_prompts7.select)({
         message: "Select MCP server to manage or sync:",
         choices
       });
@@ -3132,7 +3014,7 @@ var wizardManage = async (options = {}) => {
       global: isGlobal,
       hasDivergence: targetGroup.hasDivergence
     });
-    const action = await select6({
+    const action = await (0, import_prompts7.select)({
       message: `What would you like to do with [${chosenServerName}]?`,
       choices: [
         {
@@ -3168,7 +3050,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: [],
@@ -3180,7 +3062,7 @@ var wizardManage = async (options = {}) => {
         loop: false,
         validate: (ans) => ans.length === 0 ? "Please select at least one agent" : true
       });
-      const confirmed = await confirm6({
+      const confirmed = await (0, import_prompts7.confirm)({
         message: `Confirm syncing configuration of [${chosenServerName}] to: ${selectedToSync.join(", ")}?`,
         default: true
       });
@@ -3196,7 +3078,7 @@ var wizardManage = async (options = {}) => {
         cwd
       });
       for (const item of syncResult.incompatible) {
-        logger.warn(`Skipping ${pc13.cyan(item.agent)}: ${item.reason}`);
+        logger.warn(`Skipping ${import_picocolors12.default.cyan(item.agent)}: ${item.reason}`);
       }
       for (const res of syncResult.results) {
         if (syncResult.incompatible.some((i) => i.agent === res.agent)) {
@@ -3204,11 +3086,11 @@ var wizardManage = async (options = {}) => {
         }
         if (res.success) {
           logger.success(
-            `${pc13.cyan(res.agent)}: Successfully synced to ${pc13.dim(res.path)}${formatCoHostedBadge("configured", res.coConfiguredAgents)}`
+            `${import_picocolors12.default.cyan(res.agent)}: Successfully synced to ${import_picocolors12.default.dim(res.path)}${formatCoHostedBadge("configured", res.coConfiguredAgents)}`
           );
           targetGroup.agents.push(res.agent);
         } else {
-          logger.error(`${pc13.cyan(res.agent)}: Sync failed - ${res.error}`);
+          logger.error(`${import_picocolors12.default.cyan(res.agent)}: Sync failed - ${res.error}`);
         }
       }
       refreshGroupedServers();
@@ -3216,9 +3098,168 @@ var wizardManage = async (options = {}) => {
   }
 };
 
+// src/interactive/main-menu.ts
+var import_prompts10 = require("@inquirer/prompts");
+var import_picocolors15 = __toESM(require("picocolors"), 1);
+
+// src/interactive/wizard-add.ts
+var import_prompts8 = require("@inquirer/prompts");
+var import_picocolors13 = __toESM(require("picocolors"), 1);
+var wizardAdd = async (initial = {}) => {
+  const cwd = initial.cwd ?? process.cwd();
+  logger.info(import_picocolors13.default.bold("Welcome to the MCP interactive add wizard"));
+  let source = initial.source;
+  if (!source) {
+    const sourceType = await (0, import_prompts8.select)({
+      message: "Select MCP server type:",
+      choices: [
+        {
+          name: "npm package (run via npx)",
+          value: "npm"
+        },
+        {
+          name: "Remote MCP server (via HTTP / SSE URL)",
+          value: "remote"
+        },
+        {
+          name: "Local command / script / Docker (stdio)",
+          value: "command"
+        }
+      ]
+    });
+    if (sourceType === "npm") {
+      source = await (0, import_prompts8.input)({
+        message: "Enter npm package name (e.g. @modelcontextprotocol/server-postgres):",
+        validate: (val) => val.trim() ? true : "Package name cannot be empty"
+      });
+    } else if (sourceType === "remote") {
+      source = await (0, import_prompts8.input)({
+        message: "Enter remote server URL (e.g. https://mcp.example.com/sse):",
+        validate: (val) => {
+          const trimmed = val.trim();
+          if (!trimmed) return "URL cannot be empty";
+          if (!/^https?:\/\//i.test(trimmed)) return "Please enter a valid URL starting with http:// or https://";
+          return true;
+        }
+      });
+    } else {
+      source = await (0, import_prompts8.input)({
+        message: "Enter command and arguments (e.g. python -m my_mcp_server or docker run ...):",
+        validate: (val) => val.trim() ? true : "Command cannot be empty"
+      });
+    }
+  }
+  source = source.trim();
+  const parsed = parseMcpSource(source);
+  let serverName = initial.name;
+  if (!serverName) {
+    serverName = await (0, import_prompts8.input)({
+      message: "MCP server name:",
+      default: parsed.inferredName,
+      validate: (val) => val.trim() ? true : "Server name cannot be empty"
+    });
+  }
+  serverName = serverName.trim();
+  let transport = initial.transport;
+  let headers = initial.headers ?? {};
+  if (parsed.type === "remote") {
+    if (!transport) {
+      const isSseUrl = /\/sse\b/i.test(parsed.value);
+      transport = await (0, import_prompts8.select)({
+        message: "Select remote transport protocol:",
+        choices: [
+          { name: "HTTP", value: "http" },
+          { name: "SSE (Server-Sent Events)", value: "sse" }
+        ],
+        default: isSseUrl ? "sse" : "http"
+      });
+    }
+    if (Object.keys(headers).length === 0) {
+      const needHeader = await (0, import_prompts8.confirm)({
+        message: "Configure HTTP headers (e.g. Authorization Bearer token)?",
+        default: false
+      });
+      if (needHeader) {
+        headers = await promptHeadersConfig();
+      }
+    }
+  }
+  const { global: isGlobal, agents: selectedAgents } = await promptScopeAndAgents({
+    cwd,
+    defaultGlobal: initial.global,
+    defaultAgents: initial.agents
+  });
+  let args = initial.args ?? [];
+  if (parsed.type !== "remote") {
+    args = await promptArgsConfig(args);
+  }
+  let env = initial.env ?? {};
+  if (parsed.type !== "remote") {
+    env = await promptEnvConfig(env);
+  }
+  console.log("\n" + import_picocolors13.default.cyan(import_picocolors13.default.bold("Configuration Preview:")));
+  console.log(`  ${import_picocolors13.default.bold("Server Name:")} ${import_picocolors13.default.green(serverName)}`);
+  console.log(`  ${import_picocolors13.default.bold("Server Type:")} ${import_picocolors13.default.magenta(parsed.type)}`);
+  console.log(`  ${import_picocolors13.default.bold("Source/Command:")} ${import_picocolors13.default.dim(source)}`);
+  console.log(`  ${import_picocolors13.default.bold("Scope:")} ${isGlobal ? import_picocolors13.default.yellow("Global") : import_picocolors13.default.blue("Project")}`);
+  console.log(`  ${import_picocolors13.default.bold("Target Agents:")} ${import_picocolors13.default.cyan(selectedAgents.join(", "))}`);
+  if (args.length > 0) {
+    console.log(`  ${import_picocolors13.default.bold("Arguments:")} ${import_picocolors13.default.dim(args.join(" "))}`);
+  }
+  if (transport) {
+    console.log(`  ${import_picocolors13.default.bold("Transport:")} ${import_picocolors13.default.magenta(transport)}`);
+  }
+  const envKeys = Object.keys(env);
+  if (envKeys.length > 0) {
+    console.log(`  ${import_picocolors13.default.bold("Environment Variables:")} ${import_picocolors13.default.dim(envKeys.join(", "))} (${envKeys.length})`);
+  }
+  const headerKeys = Object.keys(headers);
+  if (headerKeys.length > 0) {
+    console.log(`  ${import_picocolors13.default.bold("Headers:")} ${import_picocolors13.default.dim(headerKeys.join(", "))} (${headerKeys.length})`);
+  }
+  console.log();
+  const proceed = await (0, import_prompts8.confirm)({
+    message: "Confirm installation with this configuration?",
+    default: true
+  });
+  if (!proceed) {
+    logger.warn("Operation cancelled");
+    return false;
+  }
+  const result = installMcpServer({
+    source,
+    name: serverName,
+    agents: selectedAgents,
+    args,
+    global: isGlobal,
+    cwd,
+    transport,
+    headers,
+    env
+  });
+  logger.info(
+    `Writing ${import_picocolors13.default.bold(result.serverName)} to ${import_picocolors13.default.cyan(String(result.results.length))} agent config files...`
+  );
+  let allSuccess = true;
+  for (const record of result.results) {
+    if (record.success) {
+      logger.success(
+        `${import_picocolors13.default.cyan(record.agent)}: Successfully written to ${import_picocolors13.default.dim(record.path)}${formatCoHostedBadge("configured", record.coConfiguredAgents)}`
+      );
+    } else {
+      allSuccess = false;
+      logger.error(`${import_picocolors13.default.cyan(record.agent)}: Failed to write - ${record.error}`);
+    }
+  }
+  if (allSuccess) {
+    logger.success(import_picocolors13.default.bold(`MCP server "${serverName}" configured successfully!`));
+  }
+  return allSuccess;
+};
+
 // src/interactive/wizard-remove.ts
-import { confirm as confirm7, select as select7 } from "@inquirer/prompts";
-import pc14 from "picocolors";
+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({
@@ -3226,19 +3267,18 @@ var wizardRemove = async (options = {}) => {
     defaultGlobal: options.global,
     message: "Select scope to remove MCP server from:"
   });
-  const installed = listInstalledMcpServers({ global: isGlobal, cwd });
-  if (installed.length === 0) {
+  const serverMap = queryGroupedInstalledServers({ global: isGlobal, cwd });
+  if (serverMap.size === 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: `${pc14.bold(g.serverName)} ${pc14.dim(`(installed in: ${g.agents.map((a) => getMcpAgentConfig(a).displayName).join(", ")})`)}`,
+      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 select7({
+    serverName = await (0, import_prompts9.select)({
       message: "Select MCP server to remove:",
       choices
     });
@@ -3248,7 +3288,7 @@ var wizardRemove = async (options = {}) => {
     logger.warn(`No agents found with [${serverName}] installed`);
     return false;
   }
-  const installedAgents = sortAgentsWithClusters(rawInstalledAgents, { global: isGlobal, cwd });
+  const installedAgents = agentConfigStore.sortAgentsByClusters(rawInstalledAgents, { global: isGlobal, cwd });
   let targetAgents = options.agents;
   if (!targetAgents || targetAgents.length === 0) {
     const choices = buildLinkedAgentChoices({
@@ -3269,7 +3309,7 @@ var wizardRemove = async (options = {}) => {
     }
     targetAgents = validAgents;
   }
-  const confirmed = await confirm7({
+  const confirmed = await (0, import_prompts9.confirm)({
     message: `Confirm removing MCP server [${serverName}] from ${targetAgents.join(", ")}?`,
     default: true
   });
@@ -3287,11 +3327,11 @@ var wizardRemove = async (options = {}) => {
   for (const res of results) {
     if (res.removed) {
       logger.success(
-        `${pc14.cyan(res.agent)}: Successfully removed from ${pc14.dim(res.path)}${formatCoHostedBadge("affected", res.coAffectedAgents)}`
+        `${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(`${pc14.cyan(res.agent)}: Failed to remove - ${res.error}`);
+      logger.error(`${import_picocolors14.default.cyan(res.agent)}: Failed to remove - ${res.error}`);
     }
   }
   if (removedCount > 0) {
@@ -3305,12 +3345,12 @@ var wizardRemove = async (options = {}) => {
 // src/interactive/main-menu.ts
 var mainMenu = async () => {
   console.log();
-  console.log(pc15.bold(pc15.cyan("mcps - Cross-Platform MCP Manager for AI Coding Agents")));
-  console.log(pc15.dim("Cross-platform MCP server configuration & synchronization tool"));
+  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 select8({
+      const action = await (0, import_prompts10.select)({
         message: "Select an action:",
         choices: [
           {
@@ -3332,7 +3372,7 @@ var mainMenu = async () => {
         ]
       });
       if (action === "exit") {
-        console.log(pc15.dim("Goodbye!"));
+        console.log(import_picocolors15.default.dim("Goodbye!"));
         break;
       }
       if (action === "add") {
@@ -3345,301 +3385,37 @@ var mainMenu = async () => {
       console.log();
     } catch (error) {
       if (error?.name === "ExitPromptError") {
-        console.log("\n" + pc15.dim("Exited."));
+        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
-import { Command } from "commander";
-import pc16 from "picocolors";
-
-// 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/cli/manage.ts
-var requireTargetServerGroup = (serverName, scope) => {
-  const installed = listInstalledMcpServers(scope);
-  const grouped = groupInstalledServersByName(installed);
-  const targetGroup = grouped.get(serverName);
-  if (!targetGroup) {
-    logger.error(
-      `MCP server "${serverName}" is not configured in ${scope.global ? "global" : "project"} scope.`
-    );
-    process.exitCode = 1;
-    return void 0;
-  }
-  return targetGroup;
-};
-var mcpManageCommand = new 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;
-        return;
-      }
-      const targetGroup = requireTargetServerGroup(serverName, { global: isGlobal, cwd });
-      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;
-      }
-      if (options.header !== void 0) {
-        const parsedHeaders = parseKeyValueList(options.header, ":");
-        const baseHeaders = options.clearHeaders ? {} : targetGroup.config.headers ?? {};
-        incomingDelta.headers = { ...baseHeaders, ...parsedHeaders };
-      }
-      let targetAgents = targetGroup.agents;
-      if (options.agent !== void 0) {
-        const parsed = parseMcpAgentList(options.agent);
-        if (!parsed || parsed.length === 0) {
-          logger.error(`No valid agents recognized from: "${options.agent.join(", ")}".`);
-          process.exitCode = 1;
-          return;
-        }
-        targetAgents = parsed;
-      }
-      const updateResult = updateMcpServer({
-        serverName,
-        config: incomingDelta,
-        previousConfig: targetGroup.config,
-        agents: targetAgents,
-        global: isGlobal,
-        cwd
-      });
-      for (const item of updateResult.incompatible) {
-        logger.warn(`Skipping ${pc16.cyan(item.agent)}: ${item.reason}`);
-      }
-      const attemptedResults = updateResult.results.filter(
-        (r) => !updateResult.incompatible.some((i) => i.agent === r.agent)
-      );
-      if (attemptedResults.length === 0) {
-        const requestedTransport = updateResult.config.url ? updateResult.config.type ?? "http" : "stdio";
-        logger.error(
-          `None of the target agents support ${requestedTransport} transport. Update aborted.`
-        );
-        process.exitCode = 1;
-        return;
-      }
-      logger.info(
-        `Updating ${pc16.bold(serverName)} across ${pc16.cyan(String(attemptedResults.length))} agent(s)...`
-      );
-      let allSuccess = true;
-      for (const res of attemptedResults) {
-        if (res.success) {
-          logger.success(`${pc16.cyan(res.agent)}: Successfully updated in ${pc16.dim(res.path)}`);
-          logCoHostedNotice("configured", res.coConfiguredAgents);
-        } else {
-          allSuccess = false;
-          logger.error(`${pc16.cyan(res.agent)}: Update failed - ${res.error}`);
-        }
-      }
-      if (!allSuccess) {
-        process.exitCode = 1;
-      }
-      return;
-    }
-    if (!isInteractive) {
-      if (!serverName) {
-        logger.error(
-          'Missing required argument: "server-name" for non-interactive manage command. Specify a server name or use interactive terminal.'
-        );
-        process.exitCode = 1;
-        return;
-      }
-      const targetGroup = requireTargetServerGroup(serverName, { global: isGlobal, cwd });
-      if (!targetGroup) {
-        return;
-      }
-      displayServerDetails({
-        serverName,
-        config: targetGroup.config,
-        agents: targetGroup.agents,
-        global: isGlobal,
-        hasDivergence: targetGroup.hasDivergence
-      });
-      return;
-    }
-    await wizardManage({
-      global: options.global,
-      serverName
-    });
-  } catch (error) {
-    if (error && typeof error === "object" && "name" in error && error.name === "ExitPromptError") {
-      process.exit(0);
-    }
-    logger.error(toErrorMessage(error));
-    process.exitCode = 1;
-  }
-});
-
-export {
-  mcpAgents,
-  mcpAgentAliases,
-  getMcpAgentConfig,
-  getMcpAgentTypes,
-  isMcpAgentType,
-  resolveMcpAgentAlias,
-  isMcpTransportSupported,
-  detectProjectInstalledMcpAgents,
-  detectGloballyInstalledMcpAgents,
-  getMcpAgentsSupportingProjectScope,
-  DEFAULT_REMOTE_TRANSPORT,
-  NPX_COMMAND,
-  NPX_DASH_Y,
-  buildMcpServerConfig,
-  isRemoteServerConfig,
-  isStdioServerConfig,
-  parseServerConfig,
-  readConfigFile,
-  writeServerToConfigFile,
-  removeServerFromConfigFile,
-  listServersInConfigFile,
-  resolveMcpConfigTarget,
-  AgentConfigStore,
-  agentConfigStore,
-  toErrorMessage,
-  getCandidateAgentsForScope,
-  getCoHostedAgents,
-  resolveConfigClusters,
-  sortAgentsWithClusters,
-  transformServerConfig,
-  createAgentTransform,
-  transformServerConfigForAgent,
-  installMcpServerForAgent,
-  installMcpServerForAgents,
-  installToCompatibleAgents,
-  parseMcpAgentList,
-  resolveTargetAgents,
-  extractPackageName,
-  parseMcpSource,
-  isRemoteMcpSource,
-  installMcpServer,
-  listInstalledMcpServers,
-  removeMcpServerFromAgent,
-  removeMcpServer,
-  toRemoteServerConfig,
-  toStdioServerConfig,
-  detectUpdateTransition,
-  sanitizeUpdatedServerConfig,
-  updateMcpServer,
-  logger,
-  logCoHostedNotice,
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   buildLinkedAgentChoices,
+  formatArgsString,
+  formatEnvText,
+  formatHeadersText,
   linkedCheckbox,
-  promptScope,
-  promptScopeAndAgents,
+  mainMenu,
   parseArgsString,
+  parseEnvText,
+  parseHeadersText,
   promptArgsConfig,
-  formatArgsString,
   promptEditArgs,
-  SECRET_KEY_PATTERN,
-  maskSecretValue,
-  SECRET_HEADER_PATTERN,
-  maskSecretHeader,
+  promptEditEnvConfig,
+  promptEditHeadersConfig,
   promptEditKeyValueConfig,
-  formatEnvText,
-  parseEnvText,
+  promptEditorText,
   promptEnvConfig,
-  promptEditEnvConfig,
-  formatHeadersText,
-  parseHeadersText,
   promptHeadersConfig,
-  promptEditHeadersConfig,
-  wizardAdd,
-  displayServerDetails,
-  normalizeServerConfig,
-  groupInstalledServersByName,
+  promptScope,
+  promptScopeAndAgents,
   promptSwitchServerType,
+  readMultilineTextFromTerminal,
+  wizardAdd,
   wizardManage,
-  wizardRemove,
-  mainMenu,
-  resolveTransport,
-  parseKeyValueList,
-  mcpManageCommand
-};
+  wizardRemove
+});