@orlan-maker/cli 0.2.2 → 0.3.0

package/dist/agents.js

@@ -1,13 +1,14 @@
 /**
- * The agents the CLI connects: where each one reads skills, its hooks or plugin, and the old Orlan MCP
- * entry that a connect removes (D088). The ids match the web app's connect dialog (agentClients in
+ * The agents the CLI connects: where each one reads skills, and what an older CLI installed that a
+ * connect removes: the plugin, the hooks and the Orlan MCP entry (D088, D102). The ids match the web app's connect dialog (agentClients in
  * @orlan/shared).
  */
 import { execFile } from "node:child_process";
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { access, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
+import { createScanner, findNodeAtLocation, parse as parseJson, parseTree, printParseErrorCode, } from "jsonc-parser";
 import { OrlanError } from "./http.js";
 export const agentIds = ["claude-code", "codex", "cursor", "opencode", "other"];
 export const agentLabels = {
@@ -121,163 +122,182 @@ export function editCodexToml(text) {
     return result ? `${result}\n` : "";
 }
 /**
- * Removes the Orlan key under `section` of a JSON settings file. Every other key stays. Returns true
- * when it removed it.
+ * The JSON settings files are JSON with comments (JSONC): OpenCode reads opencode.json so, and a person
+ * can write comments in hooks.json and mcp.json. jsonc-parser reads them. The edit takes out the text of
+ * one entry and its comma, and nothing else: every comment, the order and the format of the rest stay
+ * (B047). jsonc-parser's own modify() also changes the text around the entry.
  */
-async function removeJsonKey(file, section) {
-    const text = await readText(file);
-    if (!text.includes(`"${MCP_NAME}"`))
-        return false;
-    let settings;
-    try {
-        settings = JSON.parse(text);
+const PARSE_OPTIONS = { allowTrailingComma: true };
+/** SyntaxKind.CommaToken of jsonc-parser: a const enum, which this build cannot import. */
+const COMMA_TOKEN = 5;
+/** The offset of the comma just after the node, comments and white space between them allowed, or -1. */
+function commaAfter(text, node) {
+    const scanner = createScanner(text, true);
+    scanner.setPosition(node.offset + node.length);
+    return scanner.scan() === COMMA_TOKEN ? scanner.getTokenOffset() : -1;
+}
+/** The text without the entry at `where`: a key with its value, or an element of a list. */
+function without(text, where) {
+    const root = parseTree(text, [], PARSE_OPTIONS);
+    const found = root && findNodeAtLocation(root, where);
+    const entry = found?.parent?.type === "property" ? found.parent : found;
+    const siblings = entry?.parent?.children;
+    if (!entry || !siblings)
+        return text;
+    let start = entry.offset;
+    let end = entry.offset + entry.length;
+    const cuts = [];
+    const comma = commaAfter(text, entry);
+    const index = siblings.indexOf(entry);
+    const previous = index > 0 ? siblings[index - 1] : undefined;
+    if (comma >= 0)
+        end = comma + 1;
+    else if (previous && commaAfter(text, previous) >= 0) {
+        // The last entry: the comma before it goes.
+        const before = commaAfter(text, previous);
+        cuts.push([before, before + 1]);
     }
-    catch {
-        throw new OrlanError(`${file} is not plain JSON (it has comments or an error), so Orlan does not change it. ` +
-            `Remove the "${MCP_NAME}" entry under "${section}" by hand, then run this again.`);
+    // An entry on lines of its own takes those lines with it.
+    const lineStart = text.lastIndexOf("\n", start - 1) + 1;
+    const lineEnd = text.indexOf("\n", end);
+    const blank = (part) => part.trim() === "";
+    if (blank(text.slice(lineStart, start)) && blank(text.slice(end, lineEnd === -1 ? text.length : lineEnd))) {
+        start = lineStart;
+        end = lineEnd === -1 ? text.length : lineEnd + 1;
     }
-    const servers = settings[section];
-    if (!servers || typeof servers !== "object" || !(MCP_NAME in servers))
-        return false;
-    delete servers[MCP_NAME];
-    await writeText(file, `${JSON.stringify(settings, null, 2)}\n`);
-    return true;
+    cuts.push([start, end]);
+    return cuts.reduceRight((edited, [from, to]) => edited.slice(0, from) + edited.slice(to), text);
 }
+/** The value of a JSON settings file that can have comments, or {} when it is not an object. */
+const parseJsonc = (text) => {
+    const value = parseJson(text, [], PARSE_OPTIONS);
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+};
+/** The object at `key` of a value, or {} when it is not an object. */
+const field = (value, key) => {
+    const found = value && typeof value === "object" ? value[key] : undefined;
+    return found && typeof found === "object" && !Array.isArray(found) ? found : {};
+};
+/**
+ * Checks that a JSON settings file (comments are allowed) is an object Orlan can edit. Throws before
+ * anything changed, and says what to do by hand.
+ */
+function checkJsonc(file, text, byHand) {
+    const errors = [];
+    const value = parseJson(text, errors, PARSE_OPTIONS);
+    const [error] = errors;
+    if (!error && value && typeof value === "object" && !Array.isArray(value))
+        return;
+    const where = error
+        ? ` (${printParseErrorCode(error.error)} on line ${text.slice(0, error.offset).split("\n").length})`
+        : "";
+    throw new OrlanError(`${file} is not a JSON object${where}, so Orlan changes no file. ${byHand}, then run this again.`);
+}
+/** The change that removes the Orlan key under `section` of a JSON settings file. Every other key stays. */
+async function jsonKeyChange(file, section) {
+    const text = await readText(file);
+    if (!text.includes(`"${MCP_NAME}"`))
+        return undefined;
+    checkJsonc(file, text, `Remove the "${MCP_NAME}" entry under "${section}" by hand`);
+    if (!(MCP_NAME in field(parseJsonc(text), section)))
+        return undefined;
+    return { file, text: without(text, [section, MCP_NAME]), what: "the Orlan MCP entry" };
+}
+/** Runs the claude command. */
 function runClaude(args) {
-    return new Promise((resolve, reject) => {
-        execFile("claude", args, { timeout: 60_000 }, (error, stdout, stderr) => {
-            if (error && error.code === "ENOENT") {
-                reject(new OrlanError("Orlan cannot find the `claude` command. Install Claude Code first."));
-                return;
-            }
-            resolve({ ok: !error, output: `${stdout}${stderr}`.trim() });
-        });
+    return new Promise((resolve) => {
+        execFile("claude", args, { timeout: 60_000 }, (error, stdout, stderr) => resolve({
+            ok: !error,
+            missing: error?.code === "ENOENT",
+            output: `${stdout}${stderr}`.trim(),
+        }));
     });
 }
-/**
- * The Claude Code plugin (F044). This package is the plugin and its own marketplace: the folder with
- * package.json has .claude-plugin/plugin.json and .claude-plugin/marketplace.json. A local marketplace
- * loads the plugin in place, so an update of the package updates the plugin.
- */
-export const CLAUDE_PLUGIN = "orlan@orlan";
-const packageRoot = () => fileURLToPath(new URL("..", import.meta.url));
-/** True when the Orlan plugin is installed and enabled in Claude Code. */
-async function claudePluginEnabled() {
-    const listed = await runClaude(["plugin", "list", "--json"]);
+/** The JSON list a `claude ... --json` command printed, or [] when it failed. */
+function claudeList(listed) {
     if (!listed.ok)
-        return false;
+        return [];
     try {
-        const plugins = JSON.parse(listed.output);
-        return Array.isArray(plugins) && plugins.some((plugin) => plugin.id === CLAUDE_PLUGIN && plugin.enabled);
+        const list = JSON.parse(listed.output);
+        return Array.isArray(list) ? list : [];
     }
     catch {
-        return false;
+        return [];
     }
 }
 /**
- * Installs the Orlan plugin in Claude Code for this user, from this package, when it is not enabled
- * yet. Returns false when Claude Code refused the install.
+ * The Claude Code plugin of CLI 0.1 and 0.2 (F044), and the local marketplace that `orlan connect` added
+ * for it: a marketplace "orlan" from a folder, the orlan package. A marketplace "orlan" from another
+ * source is not one Orlan added, so it stays.
+ */
+export const CLAUDE_PLUGIN = "orlan@orlan";
+/** A marketplace entry of Claude Code that comes from a local folder. */
+const fromFolder = (entry) => field(entry, "source").source === "directory";
+/**
+ * With no claude command, the CLI cannot change Claude Code: the commands that remove what an older
+ * orlan installed, read from Claude Code's own files (B047). Empty when there is nothing.
  */
-export async function installClaudePlugin() {
-    if (await claudePluginEnabled())
-        return true;
-    await runClaude(["plugin", "marketplace", "add", packageRoot(), "--scope", "user"]);
-    const installed = await runClaude(["plugin", "install", CLAUDE_PLUGIN, "--scope", "user"]);
-    return installed.ok && (await claudePluginEnabled());
+async function claudeLeftovers() {
+    const dir = process.env.CLAUDE_CONFIG_DIR || path.join(home(), ".claude");
+    const read = async (file) => parseJsonc(await readText(file));
+    const [settings, installed, known, user] = await Promise.all([
+        read(path.join(dir, "settings.json")),
+        read(path.join(dir, "plugins", "installed_plugins.json")),
+        read(path.join(dir, "plugins", "known_marketplaces.json")),
+        read(process.env.CLAUDE_CONFIG_DIR ? path.join(dir, ".claude.json") : path.join(home(), ".claude.json")),
+    ]);
+    const commands = [];
+    const installs = field(installed, "plugins")[CLAUDE_PLUGIN];
+    if (CLAUDE_PLUGIN in field(settings, "enabledPlugins") || installs !== undefined) {
+        const scopes = new Set((Array.isArray(installs) ? installs : [{}]).map((each) => each?.scope ?? "user"));
+        for (const scope of scopes) {
+            commands.push(`claude plugin uninstall ${CLAUDE_PLUGIN}${scope === "user" ? "" : ` --scope ${scope}`}`);
+        }
+    }
+    if (fromFolder(field(known, "orlan")) || fromFolder(field(field(settings, "extraKnownMarketplaces"), "orlan"))) {
+        commands.push("claude plugin marketplace remove orlan");
+    }
+    if (MCP_NAME in field(user, "mcpServers"))
+        commands.push(`claude mcp remove ${MCP_NAME} --scope user`);
+    return commands;
 }
 /**
- * Takes the Orlan plugin out of Claude Code for this user. The marketplace stays: a person can have
- * added it. With no claude command, or no plugin, it changes nothing.
+ * Takes the old Orlan plugin, its local marketplace and the Orlan MCP entry out of Claude Code, with the
+ * claude command. With no claude command, it gives the commands to run by hand instead.
  */
-export async function uninstallClaudePlugin() {
-    await runClaude(["plugin", "uninstall", CLAUDE_PLUGIN, "--scope", "user"]).catch(() => undefined);
+async function removeFromClaude() {
+    const listed = await runClaude(["plugin", "list", "--json"]);
+    if (listed.missing)
+        return { removed: [], byHand: await claudeLeftovers() };
+    const plugins = claudeList(listed);
+    const marketplaces = claudeList(await runClaude(["plugin", "marketplace", "list", "--json"]));
+    const removed = [];
+    for (const plugin of plugins.filter((each) => each.id === CLAUDE_PLUGIN)) {
+        const scope = plugin.scope ?? "user";
+        if ((await runClaude(["plugin", "uninstall", CLAUDE_PLUGIN, "--scope", scope])).ok) {
+            removed.push(`the Claude Code plugin ${CLAUDE_PLUGIN}`);
+        }
+    }
+    if (marketplaces.some((each) => each.name === "orlan" && each.source === "directory")) {
+        if ((await runClaude(["plugin", "marketplace", "remove", "orlan"])).ok) {
+            removed.push("the local Claude Code marketplace orlan");
+        }
+    }
+    if ((await runClaude(["mcp", "remove", MCP_NAME, "--scope", "user"])).ok)
+        removed.push("the Orlan MCP entry");
+    return { removed: [...new Set(removed)], byHand: [] };
 }
 /**
- * The hooks file of Codex and Cursor (F046). Checked against each tool's documentation on 2026-09-26:
- * - Codex: $CODEX_HOME/hooks.json (default ~/.codex), events SessionStart, UserPromptSubmit,
- *   PermissionRequest, PostToolUse and Stop. A person trusts each hook once with /hooks, and Codex keeps
- *   the trust by file, event and position - https://learn.chatgpt.com/docs/hooks
- * - Cursor: ~/.cursor/hooks.json with `version: 1`, events sessionStart, beforeSubmitPrompt, stop and
- *   sessionEnd. The editor and the cursor-agent CLI read it - https://cursor.com/docs/hooks
+ * The hooks file where CLI 0.2 wrote the Orlan hooks of Codex and Cursor (F046):
+ * $CODEX_HOME/hooks.json (default ~/.codex) and ~/.cursor/hooks.json.
  */
 export function hooksFile(agent) {
     return agent === "codex"
         ? path.join(process.env.CODEX_HOME || path.join(home(), ".codex"), "hooks.json")
         : path.join(home(), ".cursor", "hooks.json");
 }
-/**
- * How many requests in a row a stop hook gives one session before it lets the session stop. Codex has
- * no limit of its own. Cursor drops a hook's follow-up at its loop_limit, 5 by default, which Orlan
- * writes too. Orlan takes no request past this limit, so it never takes a request the harness drops.
- */
-export const STOP_LOOP_LIMIT = 5;
 /** A hook command Orlan wrote ends with `hook <state> --agent codex` or `--agent cursor`. */
 const orlanHookCommand = /\shook (start|stop|working|needs-input|idle|done) --agent (codex|cursor)$/;
-/**
- * The command a hook runs: this Node and this CLI by full path, because a harness started from the
- * desktop (Cursor, the Codex app) often has no `orlan` or `node` on its PATH.
- */
-function hookCommand(args) {
-    return `${JSON.stringify(process.execPath)} ${JSON.stringify(cliMain())} hook ${args}`;
-}
-/** The main file of this CLI: src/main.ts in a checkout, dist/main.js in the npm package. */
-function cliMain() {
-    const source = fileURLToPath(import.meta.url);
-    return path.join(path.dirname(source), `main${path.extname(source)}`);
-}
-/** The Orlan hooks of each harness, by event, in the shape of its hooks.json. */
-function orlanHooks(agent) {
-    if (agent === "codex") {
-        const entry = (args, timeout, statusMessage) => ({
-            hooks: [
-                {
-                    type: "command",
-                    command: hookCommand(`${args} --agent codex`),
-                    timeout,
-                    ...(statusMessage ? { statusMessage } : {}),
-                },
-            ],
-        });
-        return {
-            SessionStart: entry("start", 10, "Reading the Orlan brief"),
-            UserPromptSubmit: entry("working", 5),
-            PermissionRequest: entry("needs-input", 5),
-            PostToolUse: entry("working", 5),
-            Stop: entry("stop", 10, "Checking Orlan for requests"),
-        };
-    }
-    const entry = (args, timeout, more = {}) => ({
-        command: hookCommand(`${args} --agent cursor`),
-        timeout,
-        ...more,
-    });
-    return {
-        sessionStart: entry("start", 10),
-        beforeSubmitPrompt: entry("working", 5),
-        stop: entry("stop", 10, { loop_limit: STOP_LOOP_LIMIT }),
-        sessionEnd: entry("done", 5),
-    };
-}
-/**
- * The line that tells a session what Orlan is and when to load the orlan skill (D088, F090):
- * hooks/orlan-intro.txt of this package. The Claude Code plugin's session-start hook prints the same
- * file, `orlan hook start` adds it for Codex and Cursor, and the OpenCode plugin carries it.
- */
-export async function orlanIntro() {
-    return (await readFile(path.join(packageRoot(), "hooks", "orlan-intro.txt"), "utf8")).trim();
-}
-/**
- * What `orlan hook start` prints: the context lines in the JSON each harness adds to the session.
- * Codex reads hookSpecificOutput.additionalContext of SessionStart, Cursor additional_context of
- * sessionStart (checked 2026-09-30 against https://learn.chatgpt.com/docs/hooks and
- * https://cursor.com/docs/hooks).
- */
-export function sessionStartOutput(agent, lines) {
-    const context = lines.join("\n");
-    return JSON.stringify(agent === "codex"
-        ? { hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: context } }
-        : { additional_context: context });
-}
 /** True for a hook entry Orlan wrote: a Cursor entry with an Orlan command, or a Codex group with one. */
 function isOrlanHook(entry) {
     if (!entry || typeof entry !== "object")
@@ -288,105 +308,100 @@ function isOrlanHook(entry) {
     return Array.isArray(hooks) && hooks.some(isOrlanHook);
 }
 /**
- * The hooks.json settings with the Orlan hooks of `add` in place of the old ones, or with no Orlan
- * hooks when `add` is undefined. Every other hook stays at its place, and an Orlan hook goes back to
- * its place: Codex keeps a person's trust by the position of the hook.
+ * The text of a hooks.json (comments are allowed) with no Orlan hook. Every other hook stays at its
+ * place, and the comments and the format stay. An event with only Orlan hooks goes.
  */
-export function editHooks(settings, add) {
-    const events = { ...(settings.hooks ?? {}) };
-    for (const event of new Set([...Object.keys(events), ...Object.keys(add ?? {})])) {
-        const current = events[event] ?? [];
+export function withoutOrlanHooks(text) {
+    let edited = text;
+    for (const [event, entries] of Object.entries(field(parseJsonc(text), "hooks"))) {
         // Not a list of hooks: not a shape Orlan writes, so it stays as it is.
-        if (!Array.isArray(current))
+        if (!Array.isArray(entries) || !entries.some(isOrlanHook))
             continue;
-        const at = current.findIndex(isOrlanHook);
-        const kept = current.filter((entry) => !isOrlanHook(entry));
-        const mine = add?.[event];
-        if (mine)
-            kept.splice(at === -1 ? kept.length : at, 0, mine);
-        if (kept.length > 0)
-            events[event] = kept;
-        else
-            delete events[event];
+        if (entries.every(isOrlanHook)) {
+            edited = without(edited, ["hooks", event]);
+            continue;
+        }
+        // From the end, so each index still names the same entry.
+        for (let index = entries.length - 1; index >= 0; index--) {
+            if (isOrlanHook(entries[index]))
+                edited = without(edited, ["hooks", event, index]);
+        }
     }
-    return { ...settings, hooks: events };
+    return edited;
 }
-/** Writes the Orlan hooks into the harness's hooks.json, or takes them out. Returns the file. */
-export async function setHooks(agent, install) {
+/** The change that takes the old Orlan hooks out of the hooks.json of Codex or Cursor. */
+async function hooksChange(agent) {
     const file = hooksFile(agent);
     const text = await readText(file);
-    if (!text.trim() && !install)
-        return file;
-    let settings;
-    try {
-        settings = text.trim() ? JSON.parse(text) : {};
-    }
-    catch {
-        throw new OrlanError(`${file} is not plain JSON, so Orlan does not change it. Correct the file, then run this again.`);
-    }
-    const edited = editHooks(settings, install ? orlanHooks(agent) : undefined);
-    await writeText(file, `${JSON.stringify(agent === "cursor" ? { version: 1, ...edited } : edited, null, 2)}\n`);
-    return file;
+    if (!/ hook \S+ --agent (codex|cursor)/.test(text))
+        return undefined;
+    checkJsonc(file, text, `Remove the Orlan hooks (the commands with "hook ... --agent ${agent}") by hand`);
+    const edited = withoutOrlanHooks(text);
+    return edited === text ? undefined : { file, text: edited, what: `the Orlan hooks in ${file}` };
 }
-/**
- * The Orlan plugin of OpenCode (F045), in its global plugins folder: ~/.config/opencode/plugins/ -
- * https://opencode.ai/docs/plugins/ (checked 2026-09-27 against OpenCode 1.18.30).
- */
+/** The OpenCode plugin file of CLI 0.2 (F045), in OpenCode's global plugins folder. */
 export function opencodePluginFile() {
     return path.join(xdgConfig(), "opencode", "plugins", "orlan.js");
 }
-/** The first line of the plugin, so a disconnect removes only a file Orlan wrote. */
+/** The first line of the old plugin, so only a file Orlan wrote is removed. */
 const OPENCODE_PLUGIN_MARK = "// The Orlan plugin for OpenCode (F045).";
-/**
- * The plugin as `orlan connect` writes it: opencode/orlan.js of this package, with this Node and
- * this CLI by full path in place of `orlan` on the PATH, and the Orlan intro line (F090).
- */
-export async function opencodePlugin() {
-    const source = await readFile(path.join(packageRoot(), "opencode", "orlan.js"), "utf8");
-    const line = 'const ORLAN = ["orlan"];';
-    const introLine = 'const INTRO = "";';
-    if (!source.startsWith(OPENCODE_PLUGIN_MARK) || !source.includes(line) || !source.includes(introLine)) {
-        const { name } = JSON.parse(await readFile(path.join(packageRoot(), "package.json"), "utf8"));
-        throw new OrlanError(`The OpenCode plugin of this orlan package is damaged. Install ${name} again.`);
+/** The change that deletes the old Orlan plugin of OpenCode. */
+async function opencodePluginChange() {
+    const file = opencodePluginFile();
+    if (!(await readText(file)).startsWith(OPENCODE_PLUGIN_MARK))
+        return undefined;
+    return { file, text: null, what: `the Orlan plugin ${file}` };
+}
+/** The change that removes the Orlan MCP table from the Codex config.toml. */
+async function codexMcpChange() {
+    const file = mcpFile("codex");
+    const text = await readText(file);
+    const edited = editCodexToml(text);
+    return edited.trimEnd() === text.trimEnd() ? undefined : { file, text: edited, what: "the Orlan MCP entry" };
+}
+/** The changes to the settings files of the agent, in the order they are told. */
+function fileChanges(agent) {
+    switch (agent) {
+        case "codex":
+            return Promise.all([hooksChange("codex"), codexMcpChange()]);
+        case "cursor":
+            return Promise.all([hooksChange("cursor"), jsonKeyChange(mcpFile("cursor"), "mcpServers")]);
+        case "opencode":
+            return Promise.all([opencodePluginChange(), jsonKeyChange(mcpFile("opencode"), "mcp")]);
     }
-    return source
-        .replace(line, `const ORLAN = ${JSON.stringify([process.execPath, cliMain()])};`)
-        .replace(introLine, `const INTRO = ${JSON.stringify(await orlanIntro())};`);
 }
-/** Writes the Orlan plugin into OpenCode's plugins folder, or takes it out. Returns the file. */
-export async function setOpencodePlugin(install) {
-    const file = opencodePluginFile();
-    if (install) {
-        await writeText(file, await opencodePlugin());
+/** Throws when this user cannot write the file's folder: the change could not be made. */
+async function checkWritable(change) {
+    try {
+        await access(path.dirname(change.file), constants.W_OK);
     }
-    else if ((await readText(file)).startsWith(OPENCODE_PLUGIN_MARK)) {
-        await rm(file, { force: true });
+    catch (error) {
+        throw new OrlanError(`Orlan cannot change ${change.file} (${error.code}), so it changes no file. ` +
+            `Remove ${change.what} by hand, then run this again.`);
     }
-    return file;
 }
 /**
- * Removes the Orlan MCP entry that an older `orlan mcp connect` wrote (D088: agents use the orlan
- * command, not MCP). Every other entry stays. Returns true when it removed one.
+ * Plans the removal of what CLI 0.1 and 0.2 installed for the agent besides the skills (D102): the Claude
+ * Code plugin and its local marketplace, the Codex and Cursor hooks, the OpenCode plugin, and the Orlan
+ * MCP entry (D088). Every other entry the person has stays, with its comments. It reads and checks every
+ * file first and throws before it changes any, so it never stops half done (B047). The function it
+ * gives makes the changes, and says what it removed.
  */
-export async function removeMcp(agent) {
-    switch (agent) {
-        case "claude-code": {
-            // With no claude command there is no Claude Code to change.
-            const removed = await runClaude(["mcp", "remove", MCP_NAME, "--scope", "user"]).catch(() => undefined);
-            return removed?.ok ?? false;
-        }
-        case "codex": {
-            const file = mcpFile("codex");
-            const text = await readText(file);
-            const edited = editCodexToml(text);
-            if (edited.trimEnd() === text.trimEnd())
-                return false;
-            await writeText(file, edited);
-            return true;
+export async function planOldInstall(agent) {
+    if (agent === "other")
+        return async () => ({ removed: [], byHand: [] });
+    if (agent === "claude-code")
+        return removeFromClaude;
+    const changes = (await fileChanges(agent)).filter((change) => change !== undefined);
+    for (const change of changes)
+        await checkWritable(change);
+    return async () => {
+        for (const change of changes) {
+            if (change.text === null)
+                await rm(change.file, { force: true });
+            else
+                await writeText(change.file, change.text);
         }
-        case "cursor":
-            return removeJsonKey(mcpFile("cursor"), "mcpServers");
-        case "opencode":
-            return removeJsonKey(mcpFile("opencode"), "mcp");
-    }
+        return { removed: [...new Set(changes.map((change) => change.what))], byHand: [] };
+    };
 }