@wuyax/mcps 0.1.0-beta.2 → 0.1.0

package/dist/chunk-AWD3VQ3S.js

@@ -0,0 +1,1624 @@
+import {
+  SECRET_HEADER_PATTERN,
+  SECRET_KEY_PATTERN,
+  agentConfigStore,
+  getMcpAgentConfig,
+  getMcpAgentTypes,
+  getMcpAgentsSupportingProjectScope,
+  installMcpServer,
+  maskSecretHeader,
+  maskSecretValue,
+  parseMcpSource,
+  queryGroupedInstalledServers,
+  removeMcpServer,
+  resolveTargetAgents,
+  toRemoteServerConfig,
+  toStdioServerConfig,
+  updateMcpServer
+} from "./chunk-O3BRJFEC.js";
+
+// src/interactive/utils/build-linked-agent-choices.ts
+import pc from "picocolors";
+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);
+      }
+    }
+  }
+  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 ? pc.green(" [detected]") : "";
+    const sharedBadge = coHosted.length > 0 ? pc.dim(` [shared: ${coHosted.join(", ")}]`) : "";
+    const label = `${displayName} ${pc.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
+    };
+  });
+};
+
+// 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 pc2 from "picocolors";
+var defaultTheme = {
+  icon: {
+    checked: pc2.green("[x]"),
+    unchecked: pc2.dim("[ ]"),
+    cursor: pc2.cyan(">"),
+    disabledChecked: pc2.dim("[x]"),
+    disabledUnchecked: pc2.dim("[-]")
+  },
+  style: {
+    disabled: (text) => pc2.dim(text),
+    renderSelectedChoices: (selectedChoices) => selectedChoices.map((choice) => choice.short).join(", "),
+    description: (text) => pc2.cyan(text),
+    keysHelpTip: (keys) => keys.map(([key, action]) => `${pc2.bold(key)} ${pc2.dim(action)}`).join(pc2.dim(" | ")),
+    highlight: (text) => pc2.cyan(text)
+  },
+  i18n: {
+    disabledError: "This option is disabled and cannot be toggled."
+  }
+};
+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));
+    }
+    if (errorMsg) {
+      lines.push(theme.style.error(errorMsg));
+    }
+    return lines.join("\n");
+  }
+);
+
+// src/interactive/prompts/scope.ts
+import { select } from "@inquirer/prompts";
+import pc3 from "picocolors";
+var promptScope = async (options = {}) => {
+  const initialGlobal = options.defaultGlobal ?? options.global;
+  if (initialGlobal !== void 0) {
+    return initialGlobal;
+  }
+  const cwd = options.cwd ?? process.cwd();
+  return select({
+    message: options.message ?? "Select MCP scope:",
+    choices: [
+      {
+        name: `Current Project - ${pc3.dim(cwd)}`,
+        value: false
+      },
+      {
+        name: `Global User Config - ${pc3.dim("applies across all projects")}`,
+        value: true
+      }
+    ]
+  });
+};
+
+// src/interactive/prompts/agents.ts
+import pc5 from "picocolors";
+
+// src/utils/logger.ts
+import pc4 from "picocolors";
+var logger = {
+  info: (message) => {
+    console.log(pc4.cyan("i"), message);
+  },
+  success: (message) => {
+    console.log(pc4.green("\u221A"), message);
+  },
+  warn: (message) => {
+    console.log(pc4.yellow("!"), message);
+  },
+  error: (message) => {
+    console.error(pc4.red("x"), message);
+  }
+};
+
+// src/interactive/prompts/agents.ts
+var promptScopeAndAgents = async (options = {}) => {
+  const cwd = options.cwd ?? process.cwd();
+  const isGlobal = await promptScope({
+    cwd,
+    defaultGlobal: options.defaultGlobal,
+    message: "Select MCP installation scope:"
+  });
+  const resolution = resolveTargetAgents({
+    global: isGlobal,
+    cwd
+  });
+  const detected = resolution.detected;
+  const rawAvailable = isGlobal ? getMcpAgentTypes() : getMcpAgentsSupportingProjectScope();
+  const availableAgentTypes = agentConfigStore.sortAgentsByClusters(rawAvailable, {
+    global: isGlobal,
+    cwd
+  });
+  if (detected.length > 0) {
+    logger.info(
+      `Detected configured agents: ${pc5.cyan(detected.map((a) => getMcpAgentConfig(a).displayName).join(", "))}`
+    );
+  } else {
+    logger.warn(`No active ${isGlobal ? "global" : "project"} agents detected`);
+  }
+  const defaultChecked = options.defaultAgents && options.defaultAgents.length > 0 ? options.defaultAgents : detected;
+  const choices = buildLinkedAgentChoices({
+    agents: availableAgentTypes,
+    checkedAgents: defaultChecked,
+    detectedAgents: detected,
+    scopeOptions: { global: isGlobal, cwd }
+  });
+  const selectedAgents = await linkedCheckbox({
+    message: "Select target agents (Space to select, Enter to confirm):",
+    choices,
+    validate: (chosen) => {
+      if (chosen.length === 0) {
+        return "Please select at least one agent";
+      }
+      return true;
+    }
+  });
+  return {
+    global: isGlobal,
+    agents: selectedAgents
+  };
+};
+
+// src/interactive/prompts/args.ts
+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/multiline.ts
+import { createInterface } from "readline";
+import { editor } from "@inquirer/prompts";
+import pc6 from "picocolors";
+var readMultilineTextFromTerminal = async (message, endHint = "When done pasting, enter END on a new line or press Enter twice to finish") => {
+  console.log(pc6.cyan(`
+${message}`));
+  console.log(pc6.dim(`  (Hint: ${endHint})
+`));
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const lines = [];
+    let consecutiveEmpty = 0;
+    const cleanup = () => {
+      rl.removeAllListeners();
+      rl.close();
+    };
+    rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (trimmed === "END") {
+        cleanup();
+        resolve(lines.join("\n"));
+        return;
+      }
+      if (line === "") {
+        consecutiveEmpty++;
+        if (lines.length > 0) {
+          cleanup();
+          resolve(lines.join("\n"));
+          return;
+        }
+        if (consecutiveEmpty >= 2) {
+          cleanup();
+          resolve("");
+          return;
+        }
+      } else {
+        consecutiveEmpty = 0;
+        lines.push(line);
+      }
+    });
+    rl.on("close", () => {
+      resolve(lines.join("\n"));
+    });
+  });
+};
+var promptEditorText = async (options) => {
+  try {
+    return await editor({
+      message: options.message,
+      default: options.defaultText ?? "",
+      postfix: options.postfix
+    });
+  } catch {
+    return readMultilineTextFromTerminal(options.message);
+  }
+};
+
+// src/interactive/prompts/kv.ts
+import { confirm as confirm2, input as input2, password, select as select2 } from "@inquirer/prompts";
+import pc7 from "picocolors";
+var promptEditKeyValueConfig = async (currentItems = {}, options) => {
+  let items = { ...currentItems };
+  while (true) {
+    const keys = Object.keys(items);
+    console.log();
+    if (keys.length === 0) {
+      console.log(pc7.dim(`  No ${options.itemsNoun} configured.`));
+    } else {
+      console.log(pc7.cyan(pc7.bold(`  Configured ${options.title} (${keys.length}):`)));
+      for (const [k, v] of Object.entries(items)) {
+        const sep = options.separator === "=" ? "=" : ": ";
+        console.log(`    ${pc7.bold(k)}${sep}${pc7.dim(options.maskValue(k, v))}`);
+      }
+    }
+    console.log();
+    const choice = await select2({
+      message: `Manage ${options.itemsNoun}:`,
+      choices: [
+        {
+          name: "Open in system default editor ($EDITOR)",
+          value: "editor"
+        },
+        {
+          name: `Add or modify a ${options.itemNoun}`,
+          value: "upsert"
+        },
+        ...keys.length > 0 ? [
+          {
+            name: `Delete a ${options.itemNoun}`,
+            value: "delete"
+          }
+        ] : [],
+        {
+          name: `Paste multiline ${options.itemsNoun} into terminal`,
+          value: "paste"
+        },
+        ...keys.length > 0 ? [
+          {
+            name: `Clear all ${options.itemsNoun}`,
+            value: "clear"
+          }
+        ] : [],
+        {
+          name: `Done (finish editing ${options.itemsNoun})`,
+          value: "done"
+        }
+      ]
+    });
+    if (choice === "done") {
+      return items;
+    }
+    if (choice === "editor") {
+      const defaultText = options.formatText(items);
+      const text = await promptEditorText({
+        message: options.editorMessage,
+        postfix: options.editorPostfix,
+        defaultText
+      });
+      const parsed = options.parseText(text);
+      items = parsed;
+      logger.success(`${options.title} updated (${Object.keys(items).length} total)`);
+    } else if (choice === "upsert") {
+      const key = await input2({
+        message: options.keyPromptMessage,
+        validate: (val) => {
+          const trimmed = val.trim();
+          if (!trimmed) return `${options.itemNoun} name cannot be empty`;
+          if (/\s/.test(trimmed)) return `${options.itemNoun} name cannot contain spaces`;
+          return true;
+        }
+      });
+      const trimmedKey = key.trim();
+      const existingVal = items[trimmedKey];
+      const isSecret = options.isSecretKey(trimmedKey);
+      let newVal;
+      if (isSecret) {
+        newVal = await password({
+          message: existingVal !== void 0 ? `New value for (${trimmedKey}) [leave empty to keep current]:` : `${options.valuePromptMessage} for (${trimmedKey}) [sensitive content masked]:`,
+          mask: "*"
+        });
+        if (existingVal !== void 0 && newVal === "") {
+          newVal = existingVal;
+        }
+      } else {
+        newVal = await input2({
+          message: `${options.valuePromptMessage} for (${trimmedKey}):`,
+          default: existingVal
+        });
+      }
+      items[trimmedKey] = newVal;
+      logger.success(`${existingVal !== void 0 ? "Updated" : "Added"}: ${pc7.cyan(trimmedKey)}`);
+    } else if (choice === "delete") {
+      const toDelete = await select2({
+        message: `Select ${options.itemNoun} to delete:`,
+        choices: [
+          ...keys.map((k) => ({ name: k, value: k })),
+          { name: "Cancel", value: "__cancel__" }
+        ]
+      });
+      if (toDelete !== "__cancel__") {
+        delete items[toDelete];
+        logger.success(`Deleted: ${pc7.cyan(toDelete)}`);
+      }
+    } else if (choice === "paste") {
+      const pasted = await readMultilineTextFromTerminal(options.pasteMessage);
+      const parsed = options.parseText(pasted);
+      const count = Object.keys(parsed).length;
+      if (count === 0) {
+        logger.warn(`No valid ${options.itemsNoun} recognized`);
+      } else {
+        if (keys.length > 0) {
+          const pasteMode = await select2({
+            message: `How to apply pasted ${options.itemsNoun}?`,
+            choices: [
+              { name: `Merge with existing ${options.itemsNoun}`, value: "merge" },
+              { name: `Replace all existing ${options.itemsNoun}`, value: "replace" }
+            ]
+          });
+          if (pasteMode === "replace") {
+            items = parsed;
+          } else {
+            Object.assign(items, parsed);
+          }
+        } else {
+          items = parsed;
+        }
+        logger.success(`Successfully applied ${pc7.cyan(String(count))} ${options.itemsNoun}`);
+      }
+    } else if (choice === "clear") {
+      const confirmClear = await confirm2({
+        message: `Are you sure you want to clear all ${options.itemsNoun}?`,
+        default: false
+      });
+      if (confirmClear) {
+        items = {};
+        logger.success(`Cleared all ${options.itemsNoun}`);
+      }
+    }
+  }
+};
+
+// src/interactive/prompts/env.ts
+import { input as input3, password as password2, select as select3 } from "@inquirer/prompts";
+import pc8 from "picocolors";
+var formatEnvText = (env) => {
+  return Object.entries(env).map(([key, value]) => {
+    if (/[\s"']/.test(value)) {
+      return `${key}="${value.replace(/"/g, '\\"')}"`;
+    }
+    return `${key}=${value}`;
+  }).join("\n");
+};
+var parseEnvText = (rawText) => {
+  const result = {};
+  const lines = rawText.split(/\r?\n/);
+  for (const rawLine of lines) {
+    let line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    if (line.startsWith("export ")) {
+      line = line.slice(7).trim();
+    }
+    const eqIndex = line.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = line.slice(0, eqIndex).trim();
+    let value = line.slice(eqIndex + 1).trim();
+    if (!key) continue;
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+};
+var promptEnvConfig = async (initialEnv = {}) => {
+  const env = { ...initialEnv };
+  const initialCount = Object.keys(env).length;
+  if (initialCount > 0) {
+    logger.info(`Includes ${pc8.cyan(String(initialCount))} preset environment variables`);
+  }
+  const mode = await select3({
+    message: "Configure environment variables?",
+    choices: [
+      {
+        name: "Skip / None",
+        value: "skip"
+      },
+      {
+        name: "Paste multiline .env text into terminal",
+        value: "paste"
+      },
+      {
+        name: "Open in system default editor ($EDITOR)",
+        value: "editor"
+      },
+      {
+        name: "Enter key-value pairs one by one",
+        value: "manual"
+      }
+    ]
+  });
+  if (mode === "skip") {
+    return env;
+  }
+  if (mode === "paste" || mode === "editor") {
+    const pasted = mode === "editor" ? await promptEditorText({
+      message: "Paste or edit environment variables in editor, then save and exit:",
+      postfix: ".env",
+      defaultText: formatEnvText(env)
+    }) : await readMultilineTextFromTerminal("Paste .env formatted content (multiline supported):");
+    const parsed = parseEnvText(pasted);
+    const count = Object.keys(parsed).length;
+    if (count === 0) {
+      logger.warn("No valid KEY=VALUE pairs recognized");
+    } else {
+      Object.assign(env, parsed);
+      logger.success(`Successfully parsed ${pc8.cyan(String(count))} environment variables:`);
+      for (const [k, v] of Object.entries(parsed)) {
+        console.log(`  ${pc8.bold(k)}=${pc8.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({
+      message: "Variable name (Key, leave empty to finish):",
+      validate: (val2) => {
+        const trimmed = val2.trim();
+        if (!trimmed) return true;
+        if (/\s/.test(trimmed)) return "Variable name cannot contain spaces";
+        return true;
+      }
+    });
+    const trimmedKey = key.trim();
+    if (!trimmedKey) break;
+    const isSecret = SECRET_KEY_PATTERN.test(trimmedKey);
+    let val;
+    if (isSecret) {
+      val = await password2({
+        message: `Value for (${trimmedKey}) [secret masked]:`,
+        mask: "*"
+      });
+    } else {
+      val = await input3({
+        message: `Value for (${trimmedKey}):`
+      });
+    }
+    env[trimmedKey] = val;
+    logger.success(`Added: ${pc8.cyan(trimmedKey)}`);
+  }
+  return env;
+};
+var promptEditEnvConfig = async (currentEnv = {}) => promptEditKeyValueConfig(currentEnv, {
+  title: "Environment Variables",
+  itemNoun: "variable",
+  itemsNoun: "environment variables",
+  separator: "=",
+  editorPostfix: ".env",
+  editorMessage: "Edit environment variables in editor, then save and exit:",
+  pasteMessage: "Paste .env formatted content (multiline supported):",
+  keyPromptMessage: "Variable name (Key):",
+  valuePromptMessage: "Value",
+  isSecretKey: (k) => SECRET_KEY_PATTERN.test(k),
+  maskValue: maskSecretValue,
+  formatText: formatEnvText,
+  parseText: parseEnvText
+});
+
+// src/interactive/prompts/headers.ts
+import { input as input4, password as password3, select as select4 } from "@inquirer/prompts";
+import pc9 from "picocolors";
+var formatHeadersText = (headers) => {
+  return Object.entries(headers).map(([key, value]) => `${key}: ${value}`).join("\n");
+};
+var parseHeadersText = (rawText) => {
+  const result = {};
+  const lines = rawText.split(/\r?\n/);
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const colonIndex = line.indexOf(":");
+    const equalIndex = line.indexOf("=");
+    let splitIndex = -1;
+    if (colonIndex !== -1 && equalIndex !== -1) {
+      splitIndex = Math.min(colonIndex, equalIndex);
+    } else if (colonIndex !== -1) {
+      splitIndex = colonIndex;
+    } else {
+      splitIndex = equalIndex;
+    }
+    if (splitIndex === -1) continue;
+    const key = line.slice(0, splitIndex).trim();
+    let value = line.slice(splitIndex + 1).trim();
+    if (!key) continue;
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+};
+var promptHeadersConfig = async (initialHeaders = {}) => {
+  const headers = { ...initialHeaders };
+  const mode = await select4({
+    message: "Select HTTP headers configuration method:",
+    choices: [
+      {
+        name: "Paste multiline headers into terminal (Key: Value format)",
+        value: "paste"
+      },
+      {
+        name: "Open in system default editor ($EDITOR)",
+        value: "editor"
+      },
+      {
+        name: "Enter headers one by one (e.g. Authorization: Bearer ...)",
+        value: "manual"
+      },
+      {
+        name: "Skip / None",
+        value: "skip"
+      }
+    ]
+  });
+  if (mode === "skip") {
+    return headers;
+  }
+  if (mode === "paste" || mode === "editor") {
+    const pasted = mode === "editor" ? await promptEditorText({
+      message: "Paste or edit HTTP headers in editor, then save and exit:",
+      defaultText: formatHeadersText(headers)
+    }) : await readMultilineTextFromTerminal(
+      "Paste HTTP headers content (multiline supported, e.g. Authorization: Bearer ...):"
+    );
+    const parsed = parseHeadersText(pasted);
+    const count = Object.keys(parsed).length;
+    if (count === 0) {
+      logger.warn("No valid Key: Value pairs recognized");
+    } else {
+      Object.assign(headers, parsed);
+      logger.success(`Successfully parsed ${pc9.cyan(String(count))} headers:`);
+      for (const [k, v] of Object.entries(parsed)) {
+        console.log(`  ${pc9.bold(k)}: ${pc9.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({
+      message: "Header name (e.g. Authorization, leave empty to finish):",
+      validate: (val2) => {
+        const trimmed = val2.trim();
+        if (!trimmed) return true;
+        if (/\s/.test(trimmed)) return "Header name cannot contain spaces";
+        return true;
+      }
+    });
+    const trimmedName = name.trim();
+    if (!trimmedName) break;
+    const isSecret = SECRET_HEADER_PATTERN.test(trimmedName);
+    let val;
+    if (isSecret) {
+      val = await password3({
+        message: `Header value for (${trimmedName}) [sensitive content masked]:`,
+        mask: "*"
+      });
+    } else {
+      val = await input4({
+        message: `Header value for (${trimmedName}):`
+      });
+    }
+    headers[trimmedName] = val;
+    logger.success(`Added: ${pc9.cyan(trimmedName)}`);
+  }
+  return headers;
+};
+var promptEditHeadersConfig = async (currentHeaders = {}) => promptEditKeyValueConfig(currentHeaders, {
+  title: "HTTP Headers",
+  itemNoun: "header",
+  itemsNoun: "HTTP headers",
+  separator: ":",
+  editorMessage: "Edit HTTP headers in editor, then save and exit:",
+  pasteMessage: "Paste HTTP headers content (multiline supported, e.g. Authorization: Bearer ...):",
+  keyPromptMessage: "Header name (e.g. Authorization):",
+  valuePromptMessage: "Header value",
+  isSecretKey: (k) => SECRET_HEADER_PATTERN.test(k),
+  maskValue: maskSecretHeader,
+  formatText: formatHeadersText,
+  parseText: parseHeadersText
+});
+
+// src/interactive/wizard-add.ts
+import { confirm as confirm5, input as input5, select as select5 } from "@inquirer/prompts";
+import pc11 from "picocolors";
+
+// src/utils/co-hosted-feedback.ts
+import pc10 from "picocolors";
+var formatCoHostedBadge = (kind, agents) => {
+  if (!agents || agents.length === 0) return "";
+  const label = kind === "configured" ? "co-configured" : "co-affected";
+  return ` ${pc10.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(
+    `  ${pc10.dim("Note:")} ${actionText} co-hosted agent(s): ${pc10.yellow(agents.join(", "))}`
+  );
+};
+
+// 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();
+      }
+    }
+  }
+  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" + 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})`);
+  }
+  console.log();
+  const proceed = await confirm5({
+    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 ${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 allSuccess;
+};
+
+// src/interactive/wizard-manage.ts
+import { confirm as confirm6, input as input6, select as select6 } from "@inquirer/prompts";
+import pc13 from "picocolors";
+
+// src/utils/display-server-details.ts
+import pc12 from "picocolors";
+var displayServerDetails = ({
+  serverName,
+  config,
+  agents,
+  hasDivergence,
+  global: isGlobal,
+  titlePrefix = "MCP Server Details"
+}) => {
+  console.log("\n" + pc12.cyan(pc12.bold(`${titlePrefix}: [${serverName}]`)));
+  if (isGlobal !== void 0) {
+    console.log(`  ${pc12.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(", "))}`
+    );
+  }
+  if (hasDivergence) {
+    console.log(
+      `  ${pc12.yellow(pc12.bold("Notice:"))} ${pc12.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 ?? "")}`);
+    const headerKeys = Object.keys(config.headers ?? {});
+    if (headerKeys.length > 0) {
+      console.log(`  ${pc12.bold("Headers:")} ${pc12.cyan(String(headerKeys.length))}`);
+      for (const [k, v] of Object.entries(config.headers ?? {})) {
+        console.log(`    ${pc12.bold(k)}: ${pc12.dim(maskSecretHeader(k, v))}`);
+      }
+    } else {
+      console.log(`  ${pc12.bold("Headers:")} ${pc12.dim("(none)")}`);
+    }
+  } else {
+    console.log(`  ${pc12.bold("Command:")} ${pc12.magenta(config.command ?? "")}`);
+    const argsStr = config.args && config.args.length > 0 ? config.args.join(" ") : "(none)";
+    console.log(`  ${pc12.bold("Arguments:")} ${pc12.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/wizard-manage.ts
+var promptSwitchServerType = async (currentConfig, serverName) => {
+  const isRemote = Boolean(currentConfig.url && currentConfig.url.length > 0);
+  if (isRemote) {
+    const newCmd = await input6({
+      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 toStdioServerConfig({
+      command: newCmd.trim(),
+      args: newArgs.length > 0 ? newArgs : void 0,
+      env: Object.keys(newEnv).length > 0 ? newEnv : void 0
+    });
+  }
+  const newUrl = await input6({
+    message: "Remote server URL:",
+    validate: (val) => {
+      const trimmed = val.trim();
+      if (!trimmed) return "URL cannot be empty";
+      if (!/^https?:\/\//i.test(trimmed)) {
+        return "Please enter a valid URL starting with http:// or https://";
+      }
+      return true;
+    }
+  });
+  const transport = await select6({
+    message: "Select remote transport protocol:",
+    choices: [
+      { name: "HTTP", value: "http" },
+      { name: "SSE (Server-Sent Events)", value: "sse" }
+    ],
+    default: "http"
+  });
+  const newHeaders = await promptEditHeadersConfig({});
+  logger.success(`Switched [${serverName}] configuration to remote mode`);
+  return toRemoteServerConfig(
+    {
+      url: newUrl.trim(),
+      headers: Object.keys(newHeaders).length > 0 ? newHeaders : void 0
+    },
+    transport
+  );
+};
+var handleEditServerConfig = async (options) => {
+  const { targetGroup } = options;
+  const isGlobal = options.global ?? false;
+  const cwd = options.cwd ?? process.cwd();
+  const serverName = targetGroup.serverName;
+  let workingConfig = {
+    ...targetGroup.config,
+    args: targetGroup.config.args ? [...targetGroup.config.args] : void 0,
+    env: targetGroup.config.env ? { ...targetGroup.config.env } : void 0,
+    headers: targetGroup.config.headers ? { ...targetGroup.config.headers } : void 0
+  };
+  while (true) {
+    const isRemote = Boolean(workingConfig.url && workingConfig.url.length > 0);
+    displayServerDetails({
+      serverName,
+      config: workingConfig,
+      titlePrefix: "Edit Server Configuration"
+    });
+    const editChoices = isRemote ? [
+      { name: "Edit HTTP Headers (headers)", value: "headers" },
+      { name: "Edit Remote URL (url)", value: "url" },
+      { name: "Edit Transport Protocol (type)", value: "transport" },
+      { name: "Switch to local command (stdio)", value: "switch_type" },
+      { name: "Reset changes to original", value: "reset" },
+      { name: "Save and apply changes", value: "save" },
+      { name: "Cancel (discard changes)", value: "cancel" }
+    ] : [
+      { name: "Edit Environment Variables (env)", value: "env" },
+      { name: "Edit Command Arguments (args)", value: "args" },
+      { name: "Edit Executable Command (command)", value: "command" },
+      { name: "Switch to remote server (HTTP/SSE)", value: "switch_type" },
+      { name: "Reset changes to original", value: "reset" },
+      { name: "Save and apply changes", value: "save" },
+      { name: "Cancel (discard changes)", value: "cancel" }
+    ];
+    const editAction = await select6({
+      message: `What would you like to modify in [${serverName}]?`,
+      choices: editChoices
+    });
+    if (editAction === "cancel") {
+      logger.info("Modification cancelled; changes discarded");
+      return;
+    }
+    if (editAction === "reset") {
+      workingConfig = {
+        ...targetGroup.config,
+        args: targetGroup.config.args ? [...targetGroup.config.args] : void 0,
+        env: targetGroup.config.env ? { ...targetGroup.config.env } : void 0,
+        headers: targetGroup.config.headers ? { ...targetGroup.config.headers } : void 0
+      };
+      logger.info("Configuration reset to original");
+      continue;
+    }
+    if (editAction === "switch_type") {
+      workingConfig = await promptSwitchServerType(workingConfig, serverName);
+      continue;
+    }
+    if (editAction === "env") {
+      workingConfig.env = await promptEditEnvConfig(workingConfig.env ?? {});
+    } else if (editAction === "args") {
+      workingConfig.args = await promptEditArgs(workingConfig.args ?? []);
+    } else if (editAction === "command") {
+      const newCmd = await input6({
+        message: "Executable command:",
+        default: workingConfig.command,
+        validate: (val) => val.trim() ? true : "Command cannot be empty"
+      });
+      workingConfig.command = newCmd.trim();
+    } else if (editAction === "headers") {
+      workingConfig.headers = await promptEditHeadersConfig(workingConfig.headers ?? {});
+    } else if (editAction === "url") {
+      const newUrl = await input6({
+        message: "Remote server URL:",
+        default: workingConfig.url,
+        validate: (val) => {
+          const trimmed = val.trim();
+          if (!trimmed) return "URL cannot be empty";
+          if (!/^https?:\/\//i.test(trimmed)) {
+            return "Please enter a valid URL starting with http:// or https://";
+          }
+          return true;
+        }
+      });
+      workingConfig.url = newUrl.trim();
+    } else if (editAction === "transport") {
+      workingConfig.type = await select6({
+        message: "Select remote transport protocol:",
+        choices: [
+          { name: "HTTP", value: "http" },
+          { name: "SSE (Server-Sent Events)", value: "sse" }
+        ],
+        default: workingConfig.type === "sse" ? "sse" : "http"
+      });
+    } else if (editAction === "save") {
+      let targetAgents = targetGroup.agents;
+      if (targetGroup.agents.length > 1) {
+        const sortedAgents = agentConfigStore.sortAgentsByClusters(targetGroup.agents, { global: isGlobal, cwd });
+        const choices = buildLinkedAgentChoices({
+          agents: sortedAgents,
+          checkedAgents: sortedAgents,
+          scopeOptions: { global: isGlobal, cwd }
+        });
+        targetAgents = await linkedCheckbox({
+          message: "Select agents to update configuration (Space to toggle):",
+          choices,
+          loop: false,
+          validate: (ans) => ans.length === 0 ? "Please select at least one agent" : true
+        });
+        if (targetAgents.length < targetGroup.agents.length) {
+          const unselected = targetGroup.agents.filter((a) => !targetAgents.includes(a));
+          const unselectedNames = unselected.map((a) => getMcpAgentConfig(a).displayName).join(", ");
+          logger.info(
+            `Note: Updating only a subset of agents. Server configurations will diverge from: ${unselectedNames}.`
+          );
+        }
+      }
+      const requestedTransport = workingConfig.url ? workingConfig.type ?? "http" : "stdio";
+      const resolution = resolveTargetAgents({
+        requested: targetAgents,
+        global: isGlobal,
+        cwd,
+        transport: requestedTransport
+      });
+      if (resolution.incompatible.length > 0) {
+        for (const item of resolution.incompatible) {
+          logger.warn(`Skipping ${pc13.cyan(item.agent)}: ${item.reason}`);
+        }
+      }
+      if (resolution.compatibleAgents.length === 0) {
+        logger.error(
+          `None of the selected agents support ${requestedTransport} transport. Cannot update.`
+        );
+        continue;
+      }
+      const agentNames = resolution.compatibleAgents.map((a) => getMcpAgentConfig(a).displayName).join(", ");
+      const confirmed = await confirm6({
+        message: `Confirm updating configuration for [${serverName}] across: ${agentNames}?`,
+        default: true
+      });
+      if (!confirmed) {
+        logger.warn("Update cancelled");
+        continue;
+      }
+      const updateResult = updateMcpServer({
+        serverName,
+        config: workingConfig,
+        previousConfig: targetGroup.config,
+        agents: resolution.compatibleAgents,
+        global: isGlobal,
+        cwd
+      });
+      let updatedAny = false;
+      const succeededAgents = [];
+      for (const res of updateResult.results) {
+        if (res.success) {
+          updatedAny = true;
+          succeededAgents.push(res.agent);
+          logger.success(
+            `${pc13.cyan(res.agent)}: Successfully updated configuration in ${pc13.dim(res.path)}${formatCoHostedBadge("configured", res.coConfiguredAgents)}`
+          );
+        } else {
+          logger.error(`${pc13.cyan(res.agent)}: Update failed - ${res.error}`);
+        }
+      }
+      if (updatedAny) {
+        targetGroup.config = updateResult.config;
+        logger.success(`Configuration for [${serverName}] updated successfully!`);
+        return;
+      }
+    }
+  }
+};
+var wizardManage = async (options = {}) => {
+  const cwd = options.cwd ?? process.cwd();
+  const isGlobal = await promptScope({
+    cwd,
+    defaultGlobal: options.global,
+    message: "Select MCP scope to inspect and manage:"
+  });
+  const grouped = queryGroupedInstalledServers({ global: isGlobal, cwd });
+  if (grouped.size === 0) {
+    logger.warn(`No configured MCP servers found in ${isGlobal ? "global" : "project"} scope`);
+    return;
+  }
+  let pendingServerName = options.serverName;
+  const refreshGroupedServers = () => {
+    const freshGrouped = queryGroupedInstalledServers({ global: isGlobal, cwd });
+    grouped.clear();
+    for (const [name, grp] of freshGrouped) {
+      grouped.set(name, grp);
+    }
+  };
+  while (true) {
+    let chosenServerName;
+    if (pendingServerName && grouped.has(pendingServerName)) {
+      chosenServerName = pendingServerName;
+      pendingServerName = void 0;
+    } else {
+      pendingServerName = void 0;
+      const choices = Array.from(grouped.values()).map((g) => {
+        const agentNames = g.agents.map((a) => getMcpAgentConfig(a).displayName).join(", ");
+        return {
+          name: `${pc13.bold(g.serverName)} ${pc13.dim(`(configured in: ${agentNames})`)}`,
+          value: g.serverName
+        };
+      });
+      choices.push({
+        name: `Back`,
+        value: "__back__"
+      });
+      chosenServerName = await select6({
+        message: "Select MCP server to manage or sync:",
+        choices
+      });
+      if (chosenServerName === "__back__") {
+        return;
+      }
+    }
+    const targetGroup = grouped.get(chosenServerName);
+    if (!targetGroup) continue;
+    displayServerDetails({
+      serverName: chosenServerName,
+      config: targetGroup.config,
+      agents: targetGroup.agents,
+      global: isGlobal,
+      hasDivergence: targetGroup.hasDivergence
+    });
+    const action = await select6({
+      message: `What would you like to do with [${chosenServerName}]?`,
+      choices: [
+        {
+          name: "Edit server configuration",
+          value: "edit"
+        },
+        {
+          name: "Sync / clone to other agents",
+          value: "sync"
+        },
+        {
+          name: "Back to list",
+          value: "back"
+        }
+      ]
+    });
+    if (action === "back") continue;
+    if (action === "edit") {
+      await handleEditServerConfig({
+        targetGroup,
+        global: isGlobal,
+        cwd
+      });
+      refreshGroupedServers();
+      continue;
+    }
+    if (action === "sync") {
+      const allAllowedAgents = isGlobal ? getMcpAgentTypes() : getMcpAgentsSupportingProjectScope();
+      const rawCandidateAgents = allAllowedAgents.filter((a) => !targetGroup.agents.includes(a));
+      if (rawCandidateAgents.length === 0) {
+        logger.info(
+          "All supported agents in this scope already have this MCP server configured; no sync needed"
+        );
+        continue;
+      }
+      const candidateAgents = agentConfigStore.sortAgentsByClusters(rawCandidateAgents, { global: isGlobal, cwd });
+      const choices = buildLinkedAgentChoices({
+        agents: candidateAgents,
+        checkedAgents: [],
+        scopeOptions: { global: isGlobal, cwd }
+      });
+      const selectedToSync = await linkedCheckbox({
+        message: "Select target agents to sync to (Space to select):",
+        choices,
+        loop: false,
+        validate: (ans) => ans.length === 0 ? "Please select at least one agent" : true
+      });
+      const confirmed = await confirm6({
+        message: `Confirm syncing configuration of [${chosenServerName}] to: ${selectedToSync.join(", ")}?`,
+        default: true
+      });
+      if (!confirmed) {
+        logger.warn("Sync cancelled");
+        continue;
+      }
+      const syncResult = updateMcpServer({
+        serverName: chosenServerName,
+        config: targetGroup.config,
+        agents: selectedToSync,
+        global: isGlobal,
+        cwd
+      });
+      for (const item of syncResult.incompatible) {
+        logger.warn(`Skipping ${pc13.cyan(item.agent)}: ${item.reason}`);
+      }
+      for (const res of syncResult.results) {
+        if (syncResult.incompatible.some((i) => i.agent === res.agent)) {
+          continue;
+        }
+        if (res.success) {
+          logger.success(
+            `${pc13.cyan(res.agent)}: Successfully synced to ${pc13.dim(res.path)}${formatCoHostedBadge("configured", res.coConfiguredAgents)}`
+          );
+          targetGroup.agents.push(res.agent);
+        } else {
+          logger.error(`${pc13.cyan(res.agent)}: Sync failed - ${res.error}`);
+        }
+      }
+      refreshGroupedServers();
+    }
+  }
+};
+
+// src/interactive/wizard-remove.ts
+import { confirm as confirm7, select as select7 } from "@inquirer/prompts";
+import pc14 from "picocolors";
+var wizardRemove = async (options = {}) => {
+  const cwd = options.cwd ?? process.cwd();
+  const isGlobal = await promptScope({
+    cwd,
+    defaultGlobal: options.global,
+    message: "Select scope to remove MCP server from:"
+  });
+  const serverMap = queryGroupedInstalledServers({ global: isGlobal, cwd });
+  if (serverMap.size === 0) {
+    logger.warn(`No installed MCP servers found in ${isGlobal ? "global" : "project"} scope`);
+    return false;
+  }
+  let serverName = options.name;
+  if (!serverName) {
+    const choices = Array.from(serverMap.values()).map((g) => ({
+      name: `${pc14.bold(g.serverName)} ${pc14.dim(`(installed in: ${g.agents.map((a) => getMcpAgentConfig(a).displayName).join(", ")})`)}`,
+      value: g.serverName
+    }));
+    serverName = await select7({
+      message: "Select MCP server to remove:",
+      choices
+    });
+  }
+  const rawInstalledAgents = serverMap.get(serverName)?.agents || [];
+  if (rawInstalledAgents.length === 0) {
+    logger.warn(`No agents found with [${serverName}] installed`);
+    return false;
+  }
+  const installedAgents = agentConfigStore.sortAgentsByClusters(rawInstalledAgents, { global: isGlobal, cwd });
+  let targetAgents = options.agents;
+  if (!targetAgents || targetAgents.length === 0) {
+    const choices = buildLinkedAgentChoices({
+      agents: installedAgents,
+      checkedAgents: installedAgents,
+      scopeOptions: { global: isGlobal, cwd }
+    });
+    targetAgents = await linkedCheckbox({
+      message: `Select agents to remove [${serverName}] from:`,
+      choices,
+      validate: (ans) => ans.length === 0 ? "Please select at least one agent" : true
+    });
+  } else {
+    const validAgents = targetAgents.filter((agent) => installedAgents.includes(agent));
+    if (validAgents.length === 0) {
+      logger.warn(`None of the specified agents (${targetAgents.join(", ")}) have [${serverName}] installed`);
+      return false;
+    }
+    targetAgents = validAgents;
+  }
+  const confirmed = await confirm7({
+    message: `Confirm removing MCP server [${serverName}] from ${targetAgents.join(", ")}?`,
+    default: true
+  });
+  if (!confirmed) {
+    logger.warn("Operation cancelled");
+    return false;
+  }
+  const results = removeMcpServer({
+    name: serverName,
+    agents: targetAgents,
+    global: isGlobal,
+    cwd
+  });
+  let removedCount = 0;
+  for (const res of results) {
+    if (res.removed) {
+      logger.success(
+        `${pc14.cyan(res.agent)}: Successfully removed from ${pc14.dim(res.path)}${formatCoHostedBadge("affected", res.coAffectedAgents)}`
+      );
+      removedCount++;
+    } else if (res.error) {
+      logger.error(`${pc14.cyan(res.agent)}: Failed to remove - ${res.error}`);
+    }
+  }
+  if (removedCount > 0) {
+    logger.success(`Successfully removed [${serverName}] from ${removedCount} agent(s)`);
+    return true;
+  }
+  logger.warn(`Failed to remove [${serverName}] from specified agents`);
+  return false;
+};
+
+// src/interactive/main-menu.ts
+import { select as select8 } from "@inquirer/prompts";
+import pc15 from "picocolors";
+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();
+  while (true) {
+    try {
+      const action = await select8({
+        message: "Select an action:",
+        choices: [
+          {
+            name: "Add MCP Server",
+            value: "add"
+          },
+          {
+            name: "Manage & Sync Installed MCP Servers",
+            value: "manage"
+          },
+          {
+            name: "Remove MCP Server",
+            value: "remove"
+          },
+          {
+            name: "Exit",
+            value: "exit"
+          }
+        ]
+      });
+      if (action === "exit") {
+        console.log(pc15.dim("Goodbye!"));
+        break;
+      }
+      if (action === "add") {
+        await wizardAdd();
+      } else if (action === "manage") {
+        await wizardManage();
+      } else if (action === "remove") {
+        await wizardRemove();
+      }
+      console.log();
+    } catch (error) {
+      if (error?.name === "ExitPromptError") {
+        console.log("\n" + pc15.dim("Exited."));
+        break;
+      }
+      throw error;
+    }
+  }
+};
+
+export {
+  logger,
+  logCoHostedNotice,
+  buildLinkedAgentChoices,
+  linkedCheckbox,
+  promptScope,
+  promptScopeAndAgents,
+  parseArgsString,
+  promptArgsConfig,
+  formatArgsString,
+  promptEditArgs,
+  readMultilineTextFromTerminal,
+  promptEditorText,
+  promptEditKeyValueConfig,
+  formatEnvText,
+  parseEnvText,
+  promptEnvConfig,
+  promptEditEnvConfig,
+  formatHeadersText,
+  parseHeadersText,
+  promptHeadersConfig,
+  promptEditHeadersConfig,
+  wizardAdd,
+  displayServerDetails,
+  promptSwitchServerType,
+  wizardManage,
+  wizardRemove,
+  mainMenu
+};