@niroai/niro 0.3.0

package/src/mcp/teardown.js

@@ -0,0 +1,673 @@
+#!/usr/bin/env node
+
+/**
+ * Interactive teardown for the Niro MCP Server — the exact inverse of setup.js.
+ *
+ * `niro mcp uninstall` removes everything `niro mcp install` wrote, per editor:
+ *   - the MCP server registration (claude/codex CLI, or the editor's JSON config)
+ *   - the niro hooks in ~/.claude/settings.json (PostCompact + UserPromptSubmit + PreToolUse)
+ *   - the niro section in markdown config (CLAUDE.md / AGENTS.md / Windsurf rules)
+ *   - the generated skills (~/.claude/skills, the shared ~/.agents/skills)
+ *   - Cursor's "niro:*" allowlist entry and project rule
+ *   - (with --all) the mcpServerUrl fallback in ~/.niro/config.json
+ *
+ * It deliberately LEAVES ~/.niro/credentials.json (your `niro login` session) alone —
+ * use `niro logout` for that — and never deletes a user's own CLAUDE.md/AGENTS.md, only
+ * strips the niro-marked section out of them.
+ *
+ * Usage:
+ *   niro mcp uninstall                 # interactive: pick a client (or "all")
+ *   niro mcp uninstall --client codex
+ *   niro mcp uninstall --all [-y]
+ *
+ * The string-surgery helpers (removeMarkerSection, filterNiroHooks, removeMcpServerEntry,
+ * removeNiroFromCursorAllowlist) are pure and unit-tested in test/teardownConfig.test.js.
+ * The niro-hook matchers and the section marker are imported from setup.js so install and
+ * uninstall can never disagree on what counts as "niro's".
+ */
+
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+const { execSync } = require("child_process");
+const { formatPrompt } = require("../lib/prompt");
+const {
+  CLIENTS,
+  NIRO_MD_MARKER,
+  NIRO_MD_SECTIONS,
+  isNiroPostCompactHook,
+  isNiroUserPromptHook,
+  isNiroPreToolUseHook,
+  userHome,
+} = require("./setup");
+
+// ─── pure helpers (unit-tested — no fs, no $HOME) ────────────────────────────
+
+/**
+ * Remove the niro section from markdown `content`. install appends one of `knownSections`
+ * (`\n<marker>\n## Niro MCP\n…body…\n`) — almost always at EOF.
+ *
+ * Primary path: delete the EXACT section text install wrote. Because we match the whole known
+ * block (not "marker → next heading / EOF"), a user's own notes added BELOW the block survive,
+ * the file is restored byte-for-byte, duplicate blocks are all removed, and a differently-worded
+ * example of the marker elsewhere is untouched. Both LF and CRLF copies are tried.
+ *
+ * Fallback (the section text drifted — older install version or a hand-edit): a BOUNDED removal
+ * that strips the marker line and the "## Niro MCP" block it heads but stops at the first blank
+ * line / next heading / EOF, and refuses to touch a marker sitting inside a ``` code fence — so
+ * trailing user content is never swallowed. Returns { content, removed }.
+ */
+function removeMarkerSection(content, marker, knownSections = NIRO_MD_SECTIONS) {
+  if (typeof content !== "string" || !content.includes(marker)) {
+    return { content, removed: false };
+  }
+
+  let next = content;
+  let removed = false;
+
+  // Primary: exact removal of every known section (LF, then a CRLF copy).
+  for (const section of knownSections || []) {
+    for (const variant of [section, section.replace(/\n/g, "\r\n")]) {
+      while (next.includes(variant)) {
+        next = next.replace(variant, "");
+        removed = true;
+      }
+    }
+  }
+
+  // Fallback: any marker that survived exact removal. Loop so multiple drifted blocks are all
+  // handled; stop when no marker remains or a pass makes no progress (e.g. an in-fence marker
+  // we deliberately leave alone), which also prevents an infinite loop.
+  while (next.includes(marker)) {
+    const r = removeMarkerSectionBounded(next, marker);
+    if (!r.removed || r.content === next) break;
+    next = r.content;
+    removed = true;
+  }
+
+  return { content: next, removed };
+}
+
+/**
+ * Bounded fallback for removeMarkerSection: remove the marker line and the "## Niro MCP" block
+ * it heads, stopping at the first blank line, the next heading, or EOF. A marker inside a code
+ * fence is treated as documentation and left untouched. Operates line-wise so CRLF survives.
+ */
+function removeMarkerSectionBounded(content, marker) {
+  const eol = content.includes("\r\n") ? "\r\n" : "\n";
+  const lines = content.split(/\r?\n/);
+  const markerLine = lines.findIndex((l) => l.includes(marker));
+  if (markerLine === -1) return { content, removed: false };
+
+  // If the marker sits inside a ``` fenced block, it's an example, not the installed section.
+  let fences = 0;
+  for (let i = 0; i < markerLine; i++) {
+    if (lines[i].trimStart().startsWith("```")) fences++;
+  }
+  if (fences % 2 === 1) return { content, removed: false };
+
+  let end = markerLine + 1; // exclusive index of the first line to KEEP
+  if (end < lines.length && lines[end].startsWith("## ")) {
+    end++; // the "## Niro MCP" heading
+    while (end < lines.length && lines[end].trim() !== "" && !lines[end].startsWith("#")) {
+      end++; // contiguous niro body lines — stop at a blank line or the next heading
+    }
+  }
+
+  let begin = markerLine;
+  if (begin > 0 && lines[begin - 1].trim() === "") begin--; // drop install's separator blank line
+
+  lines.splice(begin, end - begin);
+  return { content: lines.join(eol), removed: true };
+}
+
+/**
+ * Strip niro's PostCompact and UserPromptSubmit hook entries from a parsed Claude Code
+ * settings object (mutates and returns it). Uses the same matchers install uses. Empty
+ * arrays / an empty `hooks` object are pruned so the file stays tidy. Other hooks are
+ * untouched. Returns { settings, removed } where `removed` is the count deleted.
+ */
+function filterNiroHooks(settings) {
+  let removed = 0;
+  if (!settings || typeof settings !== "object" || !settings.hooks || typeof settings.hooks !== "object") {
+    return { settings, removed };
+  }
+  const hooks = settings.hooks;
+
+  if (Array.isArray(hooks.PostCompact)) {
+    const before = hooks.PostCompact.length;
+    hooks.PostCompact = hooks.PostCompact.filter((h) => !isNiroPostCompactHook(h));
+    removed += before - hooks.PostCompact.length;
+    if (hooks.PostCompact.length === 0) delete hooks.PostCompact;
+  }
+  if (Array.isArray(hooks.UserPromptSubmit)) {
+    const before = hooks.UserPromptSubmit.length;
+    hooks.UserPromptSubmit = hooks.UserPromptSubmit.filter((h) => !isNiroUserPromptHook(h));
+    removed += before - hooks.UserPromptSubmit.length;
+    if (hooks.UserPromptSubmit.length === 0) delete hooks.UserPromptSubmit;
+  }
+  if (Array.isArray(hooks.PreToolUse)) {
+    const before = hooks.PreToolUse.length;
+    hooks.PreToolUse = hooks.PreToolUse.filter((h) => !isNiroPreToolUseHook(h));
+    removed += before - hooks.PreToolUse.length;
+    if (hooks.PreToolUse.length === 0) delete hooks.PreToolUse;
+  }
+  if (Object.keys(hooks).length === 0) delete settings.hooks;
+
+  return { settings, removed };
+}
+
+/**
+ * Delete the `<topLevelKey>.niro` entry from a parsed editor MCP config (mutates and returns
+ * it). Other MCP servers are kept; an emptied top-level object is pruned. `topLevelKey`
+ * defaults to "mcpServers" (most clients); OpenCode uses "mcp", VS Code uses "servers" — see
+ * setup.js's CLIENTS[...].topLevelKey. Returns { config, removed }.
+ */
+function removeMcpServerEntry(config, topLevelKey = "mcpServers") {
+  if (!config || typeof config !== "object" || !config[topLevelKey] || typeof config[topLevelKey] !== "object") {
+    return { config, removed: false };
+  }
+  if (!Object.prototype.hasOwnProperty.call(config[topLevelKey], "niro")) {
+    return { config, removed: false };
+  }
+  delete config[topLevelKey].niro;
+  if (Object.keys(config[topLevelKey]).length === 0) delete config[topLevelKey];
+  return { config, removed: true };
+}
+
+/**
+ * Remove the exact "niro:*" pattern install appended to Cursor's mcpAllowlist (mutates and
+ * returns the parsed permissions object). A broader user pattern like "*:*" is left alone —
+ * install never wrote that, so we never remove it. Returns { data, removed }.
+ */
+function removeNiroFromCursorAllowlist(data) {
+  if (!data || typeof data !== "object" || !Array.isArray(data.mcpAllowlist)) {
+    return { data, removed: false };
+  }
+  const before = data.mcpAllowlist.length;
+  data.mcpAllowlist = data.mcpAllowlist.filter(
+    (e) => !(typeof e === "string" && e.trim().toLowerCase() === "niro:*"),
+  );
+  return { data, removed: data.mcpAllowlist.length < before };
+}
+
+// ─── filesystem wrappers (resolve $HOME, log) ────────────────────────────────
+
+function deleteFileIfPresent(absPath, label) {
+  try {
+    if (!fs.existsSync(absPath)) return false;
+    fs.rmSync(absPath, { force: true });
+    console.log(`  Removed ${label}: ${absPath}`);
+    // Clean up a now-empty generated skill dir (…/skills/niro-skill/).
+    try {
+      const parent = path.dirname(absPath);
+      if (fs.existsSync(parent) && fs.readdirSync(parent).length === 0) fs.rmdirSync(parent);
+    } catch {
+      /* leave the parent if it isn't empty / can't be removed */
+    }
+    return true;
+  } catch (e) {
+    console.warn(`  Could not remove ${label} (${absPath}): ${e.message}`);
+    return false;
+  }
+}
+
+function stripMarkerFromFile(absPath, label) {
+  if (!fs.existsSync(absPath)) return false;
+  let content;
+  try {
+    content = fs.readFileSync(absPath, "utf-8");
+  } catch (e) {
+    console.warn(`  Could not read ${absPath}: ${e.message}`);
+    return false;
+  }
+  const { content: next, removed } = removeMarkerSection(content, NIRO_MD_MARKER);
+  if (!removed) return false;
+  try {
+    fs.writeFileSync(absPath, next);
+    console.log(`  Removed niro section from ${label}: ${absPath}`);
+    return true;
+  } catch (e) {
+    console.warn(`  Could not write ${absPath}: ${e.message}`);
+    return false;
+  }
+}
+
+function stripNiroHooksFromSettings(absPath) {
+  if (!fs.existsSync(absPath)) return false;
+  let settings;
+  try {
+    settings = JSON.parse(fs.readFileSync(absPath, "utf-8"));
+  } catch (e) {
+    console.warn(`  Could not parse ${absPath}: ${e.message} — leaving it untouched.`);
+    return false;
+  }
+  const { removed } = filterNiroHooks(settings);
+  if (!removed) return false;
+  try {
+    fs.writeFileSync(absPath, JSON.stringify(settings, null, 2) + "\n");
+    console.log(`  Removed ${removed} niro hook(s) from ${absPath}`);
+    return true;
+  } catch (e) {
+    console.warn(`  Could not write ${absPath}: ${e.message}`);
+    return false;
+  }
+}
+
+function removeNiroFromJsonConfig(absPath, label, topLevelKey = "mcpServers") {
+  if (!fs.existsSync(absPath)) {
+    console.log(`  ${label} MCP config not found — skipping (${absPath}).`);
+    return false;
+  }
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(absPath, "utf-8"));
+  } catch (e) {
+    console.warn(`  Could not parse ${absPath}: ${e.message} — leaving it untouched.`);
+    return false;
+  }
+  const { removed } = removeMcpServerEntry(config, topLevelKey);
+  if (!removed) {
+    console.log(`  No niro MCP entry in ${label} config — skipping.`);
+    return false;
+  }
+  try {
+    fs.writeFileSync(absPath, JSON.stringify(config, null, 2) + "\n");
+    console.log(`  Removed niro MCP entry from ${label}: ${absPath}`);
+    return true;
+  } catch (e) {
+    console.warn(`  Could not write ${absPath}: ${e.message}`);
+    return false;
+  }
+}
+
+function removeCursorPermissions(absPath) {
+  if (!fs.existsSync(absPath)) return false;
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(absPath, "utf-8"));
+  } catch (e) {
+    console.warn(`  Could not parse ${absPath}: ${e.message} — leaving it untouched.`);
+    return false;
+  }
+  const { removed } = removeNiroFromCursorAllowlist(data);
+  if (!removed) return false;
+  try {
+    fs.writeFileSync(absPath, JSON.stringify(data, null, 2) + "\n");
+    console.log(`  Removed "niro:*" from Cursor permissions: ${absPath}`);
+    return true;
+  } catch (e) {
+    console.warn(`  Could not write ${absPath}: ${e.message}`);
+    return false;
+  }
+}
+
+/**
+ * Best-effort MCP de-registration via an editor CLI. A missing CLI or an already-removed
+ * server are both fine (install tolerates the inverse), so failure is logged softly, never
+ * thrown.
+ */
+function runMcpRemove(cmd, args) {
+  try {
+    execSync([cmd, ...args].join(" "), { stdio: "inherit" });
+    return true;
+  } catch {
+    console.log(`  (${cmd} unavailable or niro already unregistered — skipping.)`);
+    return false;
+  }
+}
+
+/**
+ * Is the niro MCP server still registered for `clientId`? Used to protect the shared
+ * ~/.agents/skills directory (written by BOTH Codex and Windsurf): we only delete it when
+ * the OTHER cross-agent editor is gone, so uninstalling one never breaks the other.
+ */
+function isClientConfigured(clientId) {
+  try {
+    if (clientId === "codex") {
+      const cfg = path.join(userHome(), ".codex", "config.toml");
+      return fs.existsSync(cfg) && fs.readFileSync(cfg, "utf-8").includes("[mcp_servers.niro]");
+    }
+    if (clientId === "windsurf") {
+      const cfg = CLIENTS.windsurf.configPath();
+      if (!fs.existsSync(cfg)) return false;
+      const data = JSON.parse(fs.readFileSync(cfg, "utf-8"));
+      return !!(data && data.mcpServers && data.mcpServers.niro);
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+
+/**
+ * Remove the shared cross-agent skills (~/.agents/skills) on behalf of `forClientId`,
+ * but only if the other cross-agent editor (codex ↔ windsurf) is no longer configured.
+ * Call AFTER that client's own registration has been removed, so the check is accurate.
+ */
+function removeSharedAgentsSkills(forClientId) {
+  const other = forClientId === "codex" ? "windsurf" : "codex";
+  if (isClientConfigured(other)) {
+    console.log(`  Keeping shared ~/.agents/skills — still used by ${other} (use --all to remove everything).`);
+    return;
+  }
+  forceRemoveAgentsSkills();
+}
+
+/**
+ * Delete the shared cross-agent skills unconditionally. Used by the full (--all) uninstall,
+ * where every editor is being torn down, so the "is the other one still configured?" guard
+ * in removeSharedAgentsSkills would (a) never fire correctly mid-sweep — the other client
+ * isn't processed yet — and (b) be pointless since both are going away.
+ */
+function forceRemoveAgentsSkills() {
+  const home = userHome();
+  deleteFileIfPresent(path.join(home, ".agents", "skills", "niro-skill", "SKILL.md"), "shared niro skill");
+  deleteFileIfPresent(path.join(home, ".agents", "skills", "niro-cli", "SKILL.md"), "shared niro-cli skill");
+}
+
+// ─── per-client uninstallers (mirror setup.js's per-client installers) ────────
+
+function uninstallClaudeCode() {
+  console.log("\n  Removing Niro from Claude Code...\n");
+  const home = userHome();
+  runMcpRemove("claude", ["mcp", "remove", "niro", "--scope", "user"]);
+  stripNiroHooksFromSettings(path.join(home, ".claude", "settings.json"));
+  stripMarkerFromFile(path.join(home, ".claude", "CLAUDE.md"), "Claude Code memory");
+  deleteFileIfPresent(path.join(home, ".claude", "skills", "niro-skill", "SKILL.md"), "niro skill");
+  deleteFileIfPresent(path.join(home, ".claude", "skills", "niro-cli", "SKILL.md"), "niro-cli skill");
+}
+
+function uninstallCodex(opts = {}) {
+  console.log("\n  Removing Niro from Codex...\n");
+  const home = userHome();
+  // codex mcp remove drops the whole [mcp_servers.niro] table, incl. the approval-mode line.
+  runMcpRemove("codex", ["mcp", "remove", "niro"]);
+  stripMarkerFromFile(path.join(home, ".codex", "AGENTS.md"), "Codex memory");
+  // On a full sweep the shared skills are removed centrally (forceRemoveAgentsSkills).
+  if (!opts.full) removeSharedAgentsSkills("codex");
+}
+
+function uninstallClaudeDesktop() {
+  console.log("\n  Removing Niro from Claude Desktop...\n");
+  removeNiroFromJsonConfig(CLIENTS["claude-desktop"].configPath(), "Claude Desktop");
+}
+
+function uninstallCursor() {
+  console.log("\n  Removing Niro from Cursor...\n");
+  const home = userHome();
+  removeNiroFromJsonConfig(CLIENTS.cursor.configPath(), "Cursor");
+  removeCursorPermissions(path.join(home, ".cursor", "permissions.json"));
+  // The Cursor rule is project-scoped — it lives in the repo the install was run from.
+  deleteFileIfPresent(path.join(process.cwd(), ".cursor", "rules", "niro.mdc"), "Cursor rule");
+}
+
+function uninstallWindsurf(opts = {}) {
+  console.log("\n  Removing Niro from Windsurf...\n");
+  const home = userHome();
+  removeNiroFromJsonConfig(CLIENTS.windsurf.configPath(), "Windsurf");
+  stripMarkerFromFile(path.join(home, ".codeium", "windsurf", "memories", "global_rules.md"), "Windsurf global rules");
+  // On a full sweep the shared skills are removed centrally (forceRemoveAgentsSkills).
+  if (!opts.full) removeSharedAgentsSkills("windsurf");
+}
+
+function uninstallVsCode() {
+  console.log("\n  Removing Niro from VS Code...\n");
+  removeNiroFromJsonConfig(CLIENTS.vscode.configPath(), "VS Code", "servers");
+}
+
+function uninstallGeminiCli() {
+  console.log("\n  Removing Niro from Gemini CLI...\n");
+  runMcpRemove("gemini", ["mcp", "remove", "-s", "user", "niro"]);
+  stripMarkerFromFile(path.join(userHome(), ".gemini", "GEMINI.md"), "Gemini CLI memory");
+}
+
+function uninstallCopilotCli() {
+  console.log("\n  Removing Niro from GitHub Copilot CLI...\n");
+  runMcpRemove("copilot", ["mcp", "remove", "niro"]);
+  stripMarkerFromFile(path.join(userHome(), ".copilot", "copilot-instructions.md"), "Copilot CLI instructions");
+}
+
+function uninstallFactory() {
+  console.log("\n  Removing Niro from Factory (droid)...\n");
+  runMcpRemove("droid", ["mcp", "remove", "niro"]);
+  stripMarkerFromFile(path.join(userHome(), ".factory", "AGENTS.md"), "Factory AGENTS.md");
+}
+
+function uninstallGoose() {
+  console.log("\n  Removing Niro from Goose...\n");
+  const { gooseConfigPath } = require("./setup");
+  const configPath = gooseConfigPath();
+  if (!fs.existsSync(configPath)) {
+    console.log(`  Goose config not found — skipping (${configPath}).`);
+    return;
+  }
+  let content;
+  try {
+    content = fs.readFileSync(configPath, "utf-8");
+  } catch (e) {
+    console.warn(`  Could not read ${configPath}: ${e.message} — leaving it untouched.`);
+    return;
+  }
+  // Mirrors the bounded block install wrote: the "  niro:" entry and everything indented
+  // under it, stopping at the next line back at 2-space (or shallower) indent.
+  const eol = content.includes("\r\n") ? "\r\n" : "\n";
+  const lines = content.split(/\r?\n/);
+  const start = lines.findIndex((l) => /^ {2}niro:\s*$/.test(l));
+  if (start === -1) {
+    console.log("  No `niro` extension entry in Goose config — skipping.");
+    return;
+  }
+  let end = start + 1;
+  while (end < lines.length && /^( {4,}|\s*$)/.test(lines[end]) && !/^\S/.test(lines[end])) end++;
+  lines.splice(start, end - start);
+  try {
+    fs.writeFileSync(configPath, lines.join(eol));
+    console.log(`  Removed niro extension from Goose config: ${configPath}`);
+  } catch (e) {
+    console.warn(`  Could not write ${configPath}: ${e.message}`);
+  }
+}
+
+function uninstallOpenCode() {
+  console.log("\n  Removing Niro from OpenCode...\n");
+  removeNiroFromJsonConfig(CLIENTS.opencode.configPath(), "OpenCode", "mcp");
+  stripMarkerFromFile(path.join(userHome(), ".config", "opencode", "AGENTS.md"), "OpenCode AGENTS.md");
+}
+
+function uninstallCline() {
+  console.log("\n  Removing Niro from Cline...\n");
+  removeNiroFromJsonConfig(CLIENTS.cline.configPath(), "Cline");
+  deleteFileIfPresent(path.join(userHome(), "Documents", "Cline", "Rules", "niro.md"), "Cline rule");
+}
+
+function uninstallKiro() {
+  console.log("\n  Removing Niro from Kiro...\n");
+  removeNiroFromJsonConfig(CLIENTS.kiro.configPath(), "Kiro");
+  deleteFileIfPresent(path.join(userHome(), ".kiro", "steering", "niro.md"), "Kiro steering file");
+}
+
+/**
+ * Antigravity's configPath() picks legacy-vs-unified based on which files exist RIGHT NOW —
+ * that can differ between install time and uninstall time (e.g. the user upgrades Antigravity
+ * in between, creating the unified file while the legacy one still has the niro entry).
+ * Rather than trust configPath()'s single derived answer here, check both candidate paths and
+ * remove the niro entry from whichever one(s) actually have it, so an install written to
+ * either file is always found.
+ */
+function uninstallAntigravity() {
+  console.log("\n  Removing Niro from Antigravity...\n");
+  const home = userHome();
+  const legacy = path.join(home, ".gemini", "antigravity", "mcp_config.json");
+  const unified = path.join(home, ".gemini", "config", "mcp_config.json");
+  for (const p of [legacy, unified]) {
+    removeNiroFromJsonConfig(p, "Antigravity");
+  }
+}
+
+const UNINSTALLERS = {
+  "claude-code": uninstallClaudeCode,
+  codex: uninstallCodex,
+  "claude-desktop": uninstallClaudeDesktop,
+  cursor: uninstallCursor,
+  windsurf: uninstallWindsurf,
+  vscode: uninstallVsCode,
+  "gemini-cli": uninstallGeminiCli,
+  "copilot-cli": uninstallCopilotCli,
+  factory: uninstallFactory,
+  goose: uninstallGoose,
+  opencode: uninstallOpenCode,
+  cline: uninstallCline,
+  kiro: uninstallKiro,
+  antigravity: uninstallAntigravity,
+};
+
+/**
+ * Drop the mcpServerUrl fallback install saved to ~/.niro/config.json. Only invoked for a
+ * full (--all) uninstall — it's a global, not per-client, value. apiUrl and any other keys
+ * are preserved; credentials.json is never touched here.
+ */
+function removeGlobalMcpServerUrl() {
+  let cfg;
+  try {
+    cfg = require("../lib/config");
+  } catch {
+    return;
+  }
+  try {
+    const current = cfg.load();
+    if (!Object.prototype.hasOwnProperty.call(current, "mcpServerUrl")) return;
+    delete current.mcpServerUrl;
+    fs.writeFileSync(cfg.FILE, JSON.stringify(current, null, 2) + "\n");
+    console.log(`  Removed mcpServerUrl from ${cfg.FILE}`);
+  } catch (e) {
+    console.warn(`  Could not update ~/.niro/config.json: ${e.message}`);
+  }
+}
+
+// ─── interactive entry ───────────────────────────────────────────────────────
+
+function printHeader() {
+  console.log("");
+  console.log("  Niro MCP Server Uninstall");
+  console.log("  -------------------------");
+  console.log("");
+}
+
+function printClients() {
+  console.log("  Clients:");
+  Object.keys(UNINSTALLERS).forEach((id) => {
+    const c = CLIENTS[id];
+    console.log(`    ${id.padEnd(18)} ${c ? c.name : id}`);
+  });
+  console.log(`    ${"all".padEnd(18)} Remove from ALL of the above`);
+  console.log("");
+}
+
+/** Minimal prompt; resolves to the default on empty input or stdin EOF. */
+function ask(rl, question, defaultValue) {
+  const prompt = formatPrompt(question, defaultValue);
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = (answer) => {
+      if (done) return;
+      done = true;
+      rl.removeListener("close", onClose);
+      resolve((answer || "").trim() || defaultValue || "");
+    };
+    const onClose = () => finish("");
+    rl.once("close", onClose);
+    rl.question(prompt, (answer) => finish(answer));
+  });
+}
+
+function runUninstall(targets, isFull) {
+  for (const id of targets) UNINSTALLERS[id]({ full: isFull });
+  if (isFull) {
+    // Every editor is gone — remove the shared cross-agent skills and the global URL.
+    forceRemoveAgentsSkills();
+    removeGlobalMcpServerUrl();
+  }
+
+  console.log("\n  Uninstall complete. Restart your AI assistant for the change to take effect.\n");
+  console.log("  Your `niro login` session is kept — run `niro logout` to clear it.");
+  console.log("  The `niro` command itself is still installed. To remove it too:");
+  console.log("    npm rm -g niro-mcp-and-cli\n");
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  let clientArg = null;
+  let all = false;
+  let assumeYes = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--client" && args[i + 1]) clientArg = args[++i];
+    else if (args[i] === "--all") all = true;
+    else if (args[i] === "-y" || args[i] === "--yes") assumeYes = true;
+  }
+
+  printHeader();
+
+  const allIds = Object.keys(UNINSTALLERS);
+  let targets;
+
+  if (all || clientArg === "all") {
+    targets = allIds;
+  } else if (clientArg) {
+    if (!UNINSTALLERS[clientArg]) {
+      console.error(`  Unknown client: ${clientArg}\n`);
+      printClients();
+      process.exit(1);
+    }
+    targets = [clientArg];
+  } else if (!process.stdin.isTTY) {
+    // Non-interactive with no target: refuse rather than guess.
+    console.error("  No client specified. Pass --client <id> or --all.\n");
+    printClients();
+    process.exit(1);
+  } else {
+    printClients();
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const choice = await ask(rl, "  Remove Niro from which client?", "claude-code");
+    rl.close();
+    if (choice === "all") targets = allIds;
+    else if (UNINSTALLERS[choice]) targets = [choice];
+    else {
+      console.error(`\n  Unknown client: ${choice}\n`);
+      process.exit(1);
+    }
+  }
+
+  const isFull = targets.length === allIds.length;
+
+  if (!assumeYes && process.stdin.isTTY) {
+    console.log(`\n  This removes Niro MCP config from: ${targets.join(", ")}`);
+    console.log("  (Your `niro login` session in ~/.niro/credentials.json is left intact.)\n");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ans = await ask(rl, "  Proceed?", "yes");
+    rl.close();
+    if (!/^y/i.test(ans)) {
+      console.log("\n  Aborted. Nothing was changed.\n");
+      return;
+    }
+  }
+
+  runUninstall(targets, isFull);
+}
+
+// Run the wizard only when invoked directly (niro mcp uninstall). When required as a
+// module (tests), expose the pure helpers without running anything.
+if (require.main === module) {
+  main().catch((err) => {
+    console.error(`Uninstall failed: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  removeMarkerSection,
+  filterNiroHooks,
+  removeMcpServerEntry,
+  removeNiroFromCursorAllowlist,
+  UNINSTALLERS,
+};