drawio-mcp-server 2.1.1 → 2.3.0

package/build/install/hosts/codex.js

@@ -0,0 +1,171 @@
+import { promises as fs } from "node:fs";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { stringify } from "smol-toml";
+export const codexAdapter = {
+    id: "codex",
+    displayName: "Codex CLI",
+    defaultPaths() {
+        return [join(homedir(), ".codex", "config.toml")];
+    },
+    async detect() {
+        return existsSync(codexAdapter.defaultPaths()[0]) ? "installed" : "absent";
+    },
+    async read(path) {
+        if (!existsSync(path))
+            return "";
+        return fs.readFile(path, "utf8");
+    },
+    merge(source, entry, name, { uninstall }) {
+        return mergeTomlBlock(source, name, uninstall ? null : blockBody(entry));
+    },
+    diffLabel() {
+        return codexAdapter.defaultPaths()[0];
+    },
+};
+function blockBody(entry) {
+    const table = {
+        command: entry.command,
+        args: entry.args,
+    };
+    // `smol-toml` renders arrays/inline-tables with padding spaces
+    // (`[ "a", "b" ]`); normalize to the compact style used elsewhere in this
+    // project's generated configs (`["a", "b"]`).
+    const base = stringify(table)
+        .trim()
+        .replace(/\[ /g, "[")
+        .replace(/ \]/g, "]");
+    const envKeys = Object.keys(entry.env);
+    if (envKeys.length === 0)
+        return base;
+    // `smol-toml`'s `stringify` renders a nested object as a `[env]` sub-table
+    // header on its own line, which `removeBlock` (below) mistakes for a
+    // sibling top-level table -- corrupting idempotent merges and leaking
+    // secrets on uninstall (the header + its keys survive as an orphan
+    // block). Render `env` as a single-line inline table instead, which stays
+    // inside this block and cannot be mistaken for a new `[table]` header.
+    const envLine = `env = { ${envKeys
+        .map((k) => `${tomlKey(k)} = ${tomlString(entry.env[k])}`)
+        .join(", ")} }`;
+    return `${base}\n${envLine}`;
+}
+const BARE_KEY = /^[A-Za-z0-9_-]+$/;
+function tomlKey(key) {
+    return BARE_KEY.test(key) ? key : tomlString(key);
+}
+function tomlString(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+/**
+ * Insert, replace, or remove a single TOML table (identified by its dotted
+ * `key`, e.g. `mcp_servers.drawio`) in `source`, leaving every other byte of
+ * the file untouched.
+ *
+ * `smol-toml`'s `parse` -> `stringify` round-trip (as sketched in the task
+ * brief) discards *all* comments and reformats the entire document -- not
+ * just the table being edited. That fails round-trip expectations for any
+ * config a human may have hand-edited. Splicing the target table's text
+ * directly avoids touching unrelated tables, comments, or blank-line layout.
+ */
+function mergeTomlBlock(source, name, body) {
+    const header = `[mcp_servers.${name}]`;
+    const lines = source.length > 0 ? source.split("\n") : [];
+    assertNoInlineInParentForm(lines, name);
+    const spliced = removeBlock(lines, name);
+    if (body === null)
+        return spliced.join("\n");
+    return appendBlock(spliced, header, body).join("\n");
+}
+/**
+ * Does `line` open the `[mcp_servers.<name>]` table, tolerating TOML-legal
+ * variants a hand-authored config might use: a quoted key segment
+ * (`[mcp_servers."drawio"]`) and/or whitespace around the `.` separator
+ * (`[mcp_servers . drawio]`)?
+ */
+function isTargetHeader(line, name) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("[") || !trimmed.endsWith("]"))
+        return false;
+    const inner = trimmed.slice(1, -1).trim();
+    const segments = inner.split(/\s*\.\s*/).map(unquoteTomlKey);
+    return (segments.length === 2 &&
+        segments[0] === "mcp_servers" &&
+        segments[1] === name);
+}
+function unquoteTomlKey(segment) {
+    const s = segment.trim();
+    if (s.length >= 2) {
+        const first = s[0];
+        const last = s[s.length - 1];
+        if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+            return s.slice(1, -1);
+        }
+    }
+    return s;
+}
+/**
+ * The inline-in-parent form (`[mcp_servers]` header followed by a bare
+ * `<name> = { ... }` assignment) is a different TOML structure from a
+ * nested `[mcp_servers.<name>]` table, and this tool's block-splice merge
+ * doesn't understand it. Rather than silently corrupt a hand-authored
+ * config (e.g. by appending a second, conflicting `drawio` entry), fail
+ * loudly and tell the user how to fix it.
+ */
+function assertNoInlineInParentForm(lines, name) {
+    const startIdx = lines.findIndex((line) => {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("[") || !trimmed.endsWith("]"))
+            return false;
+        return trimmed.slice(1, -1).trim() === "mcp_servers";
+    });
+    if (startIdx === -1)
+        return;
+    const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const assignment = new RegExp(`^\\s*(?:${escapedName}|"${escapedName}"|'${escapedName}')\\s*=`);
+    for (let i = startIdx + 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^\s*\[[A-Za-z_"]/.test(line))
+            break;
+        if (assignment.test(line)) {
+            throw new Error(`Found "${name}" defined inline under [mcp_servers] (e.g. \`${name} = { ... }\`), ` +
+                `which this tool doesn't support. Please move the entry into a ` +
+                `[mcp_servers.${name}] table, or use --config-path to point at a different config file.`);
+        }
+    }
+}
+function removeBlock(lines, name) {
+    const startIdx = lines.findIndex((line) => isTargetHeader(line, name));
+    if (startIdx === -1)
+        return lines;
+    let endIdx = lines.length;
+    for (let i = startIdx + 1; i < lines.length; i++) {
+        if (/^\s*\[[A-Za-z_"]/.test(lines[i])) {
+            endIdx = i;
+            break;
+        }
+    }
+    // Drop trailing blank lines that belong to the removed block.
+    while (endIdx > startIdx + 1 && lines[endIdx - 1].trim() === "") {
+        endIdx--;
+    }
+    const before = lines.slice(0, startIdx);
+    // Drop the single blank separator line preceding the block, if any, so
+    // removal doesn't leave a double blank line behind.
+    if (before.length > 0 && before[before.length - 1].trim() === "") {
+        before.pop();
+    }
+    const after = lines.slice(endIdx);
+    return [...before, ...after];
+}
+function appendBlock(lines, header, body) {
+    const bodyLines = body.split("\n");
+    // Drop the single trailing empty element representing the file's final
+    // newline, so we don't accumulate blank lines across repeated merges.
+    const trimmed = lines.length > 0 && lines[lines.length - 1] === ""
+        ? lines.slice(0, -1)
+        : lines;
+    if (trimmed.length === 0)
+        return [header, ...bodyLines, ""];
+    return [...trimmed, "", header, ...bodyLines, ""];
+}

package/build/install/hosts/codex.test.js

@@ -0,0 +1,124 @@
+import { describe, it, expect } from "@jest/globals";
+import { codexAdapter } from "./codex.js";
+const ENTRY = {
+    command: "npx",
+    args: ["-y", "drawio-mcp-server", "--editor"],
+    env: {},
+    transport: "stdio",
+};
+describe("codexAdapter.merge", () => {
+    it("inserts [mcp_servers.drawio] into empty file", () => {
+        const out = codexAdapter.merge("", ENTRY, "drawio", { uninstall: false });
+        expect(out).toContain("[mcp_servers.drawio]");
+        expect(out).toContain('command = "npx"');
+        expect(out).toContain('args = ["-y", "drawio-mcp-server", "--editor"]');
+    });
+    it("preserves existing entries and comments", () => {
+        const source = [
+            "# my codex config",
+            "[mcp_servers.other]",
+            'command = "other-server"',
+            "",
+        ].join("\n");
+        const out = codexAdapter.merge(source, ENTRY, "drawio", {
+            uninstall: false,
+        });
+        expect(out).toContain("# my codex config");
+        expect(out).toContain("[mcp_servers.other]");
+        expect(out).toContain('command = "other-server"');
+        expect(out).toContain("[mcp_servers.drawio]");
+    });
+    it("updates existing drawio entry idempotently", () => {
+        const source = ["[mcp_servers.drawio]", 'command = "old"', ""].join("\n");
+        const out1 = codexAdapter.merge(source, ENTRY, "drawio", {
+            uninstall: false,
+        });
+        const out2 = codexAdapter.merge(out1, ENTRY, "drawio", {
+            uninstall: false,
+        });
+        expect(out2).toBe(out1);
+        expect(out1).toContain('command = "npx"');
+        expect(out1).not.toContain('command = "old"');
+    });
+    it("removes entry on uninstall and leaves other blocks intact", () => {
+        const source = [
+            "[mcp_servers.other]",
+            'command = "other"',
+            "",
+            "[mcp_servers.drawio]",
+            'command = "npx"',
+            "",
+        ].join("\n");
+        const out = codexAdapter.merge(source, ENTRY, "drawio", {
+            uninstall: true,
+        });
+        expect(out).toContain("[mcp_servers.other]");
+        expect(out).not.toContain("[mcp_servers.drawio]");
+    });
+    it("round-trips non-empty env idempotently and removes env on uninstall", () => {
+        const withEnv = {
+            command: "npx",
+            args: ["-y", "drawio-mcp-server", "--editor"],
+            env: { FOO: "bar", HELLO: "world" },
+            transport: "stdio",
+        };
+        const first = codexAdapter.merge("", withEnv, "drawio", {
+            uninstall: false,
+        });
+        expect(first).toContain("[mcp_servers.drawio]");
+        expect(first).toContain("env = {");
+        expect(first).toContain('FOO = "bar"');
+        expect(first).toContain('HELLO = "world"');
+        const second = codexAdapter.merge(first, withEnv, "drawio", {
+            uninstall: false,
+        });
+        expect(second).toBe(first);
+        const removed = codexAdapter.merge(first, withEnv, "drawio", {
+            uninstall: true,
+        });
+        expect(removed).not.toContain("[mcp_servers.drawio]");
+        expect(removed).not.toContain("FOO");
+        expect(removed).not.toContain("HELLO");
+        expect(removed).not.toContain("[env]");
+        expect(removed).not.toContain("bar");
+    });
+    it("recognizes quoted-key header form", () => {
+        const src = '[mcp_servers."drawio"]\ncommand = "old"\n';
+        const out = codexAdapter.merge(src, ENTRY, "drawio", { uninstall: false });
+        // Should update in place, not append a duplicate block.
+        expect((out.match(/\[mcp_servers/g) ?? []).length).toBe(1);
+        expect(out).toContain('command = "npx"');
+    });
+    it("recognizes whitespace-around-dot header form", () => {
+        const src = '[mcp_servers . drawio]\ncommand = "old"\n';
+        const out = codexAdapter.merge(src, ENTRY, "drawio", { uninstall: false });
+        expect((out.match(/\[mcp_servers/g) ?? []).length).toBe(1);
+        expect(out).toContain('command = "npx"');
+    });
+    it("throws on unsupported inline-in-parent form", () => {
+        const src = '[mcp_servers]\ndrawio = { command = "old" }\n';
+        expect(() => codexAdapter.merge(src, ENTRY, "drawio", { uninstall: false })).toThrow(/inline-in-parent|move.*mcp_servers\.drawio/i);
+    });
+    it("does not confuse an indented [ array element with a sibling table header", () => {
+        // Not real drawio schema, but proves robustness for future keys.
+        const src = [
+            "[mcp_servers.drawio]",
+            'command = "old"',
+            "args = [",
+            "  [1, 2, 3],",
+            "]",
+            "",
+            "[mcp_servers.other]",
+            'command = "x"',
+        ].join("\n");
+        const out = codexAdapter.merge(src, ENTRY, "drawio", { uninstall: false });
+        expect(out).toContain("[mcp_servers.other]");
+        expect(out).toContain('command = "x"');
+    });
+});
+describe("codexAdapter.defaultPaths", () => {
+    it("points at ~/.codex/config.toml", () => {
+        const paths = codexAdapter.defaultPaths();
+        expect(paths[0]).toMatch(/\.codex\/config\.toml$/);
+    });
+});

package/build/install/hosts/index.js

@@ -0,0 +1,15 @@
+import { claudeCodeAdapter } from "./claude-code.js";
+import { claudeDesktopAdapter } from "./claude-desktop.js";
+import { codexAdapter } from "./codex.js";
+import { opencodeAdapter } from "./opencode.js";
+import { zedAdapter } from "./zed.js";
+export const HOST_ADAPTERS = {
+    [codexAdapter.id]: codexAdapter,
+    [zedAdapter.id]: zedAdapter,
+    [opencodeAdapter.id]: opencodeAdapter,
+    [claudeDesktopAdapter.id]: claudeDesktopAdapter,
+    [claudeCodeAdapter.id]: claudeCodeAdapter,
+};
+export function listHostIds() {
+    return Object.keys(HOST_ADAPTERS);
+}

package/build/install/hosts/opencode.js

@@ -0,0 +1,48 @@
+import { existsSync, promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { applyEdits, modify, parse } from "jsonc-parser";
+export const opencodeAdapter = {
+    id: "opencode",
+    displayName: "OpenCode",
+    defaultPaths() {
+        const cwd = process.cwd();
+        const local = ["opencode.json", "opencode.jsonc"]
+            .map((f) => join(cwd, f))
+            .filter(existsSync);
+        const global = join(homedir(), ".config", "opencode", "opencode.json");
+        return local.length > 0 ? [...local, global] : [global];
+    },
+    async detect() {
+        return existsSync(opencodeAdapter.defaultPaths()[0])
+            ? "installed"
+            : "absent";
+    },
+    async read(path) {
+        return existsSync(path) ? fs.readFile(path, "utf8") : "";
+    },
+    merge(source, entry, name, { uninstall }) {
+        const text = source.trim() === "" ? "{}\n" : source;
+        const parsed = parse(text);
+        if (!parsed || typeof parsed !== "object")
+            throw new Error("opencode config is not a JSON object");
+        const edits = uninstall
+            ? modify(text, ["mcp", name], undefined, {
+                formattingOptions: { insertSpaces: true, tabSize: 2 },
+            })
+            : modify(text, ["mcp", name], toValue(entry), {
+                formattingOptions: { insertSpaces: true, tabSize: 2 },
+            });
+        return applyEdits(text, edits);
+    },
+    diffLabel() {
+        return opencodeAdapter.defaultPaths()[0];
+    },
+};
+function toValue(entry) {
+    return {
+        type: "local",
+        command: [entry.command, ...entry.args],
+        enabled: true,
+    };
+}

package/build/install/hosts/opencode.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { opencodeAdapter } from "./opencode.js";
+const ENTRY = {
+    command: "npx",
+    args: ["-y", "drawio-mcp-server", "--editor"],
+    env: {},
+    transport: "stdio",
+};
+describe("opencodeAdapter.merge", () => {
+    it("adds mcp.drawio entry with type: local", () => {
+        const out = opencodeAdapter.merge("", ENTRY, "drawio", {
+            uninstall: false,
+        });
+        const parsed = JSON.parse(out);
+        expect(parsed.mcp.drawio).toEqual({
+            type: "local",
+            command: ["npx", "-y", "drawio-mcp-server", "--editor"],
+            enabled: true,
+        });
+    });
+    it("preserves the $schema field", () => {
+        const source = JSON.stringify({ $schema: "https://opencode.ai/config.json", mcp: {} }, null, 2);
+        const out = opencodeAdapter.merge(source, ENTRY, "drawio", {
+            uninstall: false,
+        });
+        const parsed = JSON.parse(out);
+        expect(parsed["$schema"]).toBe("https://opencode.ai/config.json");
+    });
+    it("uninstall removes the entry", () => {
+        const source = JSON.stringify({
+            mcp: { drawio: { type: "local", command: ["old"] } },
+        });
+        const out = opencodeAdapter.merge(source, ENTRY, "drawio", {
+            uninstall: true,
+        });
+        expect(JSON.parse(out).mcp).toEqual({});
+    });
+});
+describe("opencodeAdapter.defaultPaths", () => {
+    let dir;
+    beforeEach(() => {
+        dir = mkdtempSync(join(tmpdir(), "opencode-"));
+        process.chdir(dir);
+    });
+    afterEach(() => {
+        rmSync(dir, { recursive: true, force: true });
+    });
+    it("returns project config first when present", () => {
+        writeFileSync(join(dir, "opencode.json"), "{}");
+        const paths = opencodeAdapter.defaultPaths();
+        expect(paths[0]).toBe(join(dir, "opencode.json"));
+    });
+    it("falls back to global ~/.config/opencode/opencode.json otherwise", () => {
+        const paths = opencodeAdapter.defaultPaths();
+        expect(paths[paths.length - 1]).toMatch(/\.config\/opencode\/opencode\.json$/);
+    });
+});

package/build/install/hosts/zed.js

@@ -0,0 +1,37 @@
+import { existsSync, promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { applyEdits, modify, parse } from "jsonc-parser";
+export const zedAdapter = {
+    id: "zed",
+    displayName: "Zed",
+    defaultPaths() {
+        return [join(homedir(), ".config", "zed", "settings.json")];
+    },
+    async detect() {
+        return existsSync(zedAdapter.defaultPaths()[0]) ? "installed" : "absent";
+    },
+    async read(path) {
+        return existsSync(path) ? fs.readFile(path, "utf8") : "";
+    },
+    merge(source, entry, name, { uninstall }) {
+        let text = source.trim() === "" ? "{}\n" : source;
+        const parsed = parse(text);
+        if (!parsed || typeof parsed !== "object")
+            text = "{}\n";
+        const edits = uninstall
+            ? modify(text, ["context_servers", name], undefined, {
+                formattingOptions: { insertSpaces: true, tabSize: 2 },
+            })
+            : modify(text, ["context_servers", name], toValue(entry), {
+                formattingOptions: { insertSpaces: true, tabSize: 2 },
+            });
+        return applyEdits(text, edits);
+    },
+    diffLabel() {
+        return zedAdapter.defaultPaths()[0];
+    },
+};
+function toValue(entry) {
+    return { command: entry.command, args: entry.args, env: entry.env };
+}

package/build/install/hosts/zed.test.js

@@ -0,0 +1,47 @@
+import { describe, it, expect } from "@jest/globals";
+import { zedAdapter } from "./zed.js";
+const ENTRY = {
+    command: "npx",
+    args: ["-y", "drawio-mcp-server", "--editor"],
+    env: {},
+    transport: "stdio",
+};
+describe("zedAdapter.merge", () => {
+    it("adds context_servers.drawio to empty file", () => {
+        const out = zedAdapter.merge("", ENTRY, "drawio", { uninstall: false });
+        const parsed = JSON.parse(out);
+        expect(parsed.context_servers.drawio).toEqual({
+            command: "npx",
+            args: ["-y", "drawio-mcp-server", "--editor"],
+            env: {},
+        });
+    });
+    it("preserves other keys", () => {
+        const source = JSON.stringify({ theme: "One Dark", context_servers: { other: { command: "x" } } }, null, 2);
+        const out = zedAdapter.merge(source, ENTRY, "drawio", { uninstall: false });
+        const parsed = JSON.parse(out);
+        expect(parsed.theme).toBe("One Dark");
+        expect(parsed.context_servers.other).toEqual({ command: "x" });
+        expect(parsed.context_servers.drawio.command).toBe("npx");
+    });
+    it("uninstall removes the entry", () => {
+        const source = JSON.stringify({
+            context_servers: { drawio: { command: "old" } },
+        });
+        const out = zedAdapter.merge(source, ENTRY, "drawio", { uninstall: true });
+        expect(JSON.parse(out).context_servers).toEqual({});
+    });
+    it("uninstall on missing entry is a no-op", () => {
+        const source = JSON.stringify({
+            context_servers: { other: { command: "x" } },
+        });
+        const out = zedAdapter.merge(source, ENTRY, "drawio", { uninstall: true });
+        expect(JSON.parse(out).context_servers.other).toEqual({ command: "x" });
+    });
+});
+describe("zedAdapter.defaultPaths", () => {
+    it("points at ~/.config/zed/settings.json", () => {
+        const [p] = zedAdapter.defaultPaths();
+        expect(p).toMatch(/\.config\/zed\/settings\.json$/);
+    });
+});

package/build/install/index.js

@@ -0,0 +1,170 @@
+import { promises as fs } from "node:fs";
+import { existsSync } from "node:fs";
+import { HOST_ADAPTERS } from "./hosts/index.js";
+import { atomicWrite, ensureBackup, unifiedDiff } from "./config-io.js";
+const SUPPORTED_HOSTS = new Set([
+    "claude-code",
+    "claude-desktop",
+    "codex",
+    "zed",
+    "opencode",
+    "all",
+]);
+export function parseArgs(argv) {
+    if (argv.length === 0) {
+        throw new Error("host required — usage: drawio-mcp-server install <host> [options]");
+    }
+    const host = argv[0];
+    if (!SUPPORTED_HOSTS.has(host)) {
+        throw new Error(`unknown host: ${host} (supported: ${[...SUPPORTED_HOSTS].join(", ")})`);
+    }
+    const opts = {
+        host,
+        name: "drawio",
+        editor: true,
+        httpPort: 3000,
+        extraArgs: [],
+        env: {},
+        configPath: undefined,
+        configPathByHost: {},
+        print: false,
+        dryRun: false,
+        uninstall: false,
+        yes: false,
+    };
+    let i = 1;
+    while (i < argv.length) {
+        const flag = argv[i];
+        switch (flag) {
+            case "--name":
+                opts.name = argv[++i];
+                break;
+            case "--editor":
+                opts.editor = true;
+                break;
+            case "--no-editor":
+                opts.editor = false;
+                break;
+            case "--http-port":
+                opts.httpPort = Number.parseInt(argv[++i], 10);
+                break;
+            case "--extra-arg":
+                opts.extraArgs.push(argv[++i]);
+                break;
+            case "--env": {
+                const kv = argv[++i];
+                const eq = kv.indexOf("=");
+                if (eq <= 0)
+                    throw new Error(`invalid --env: expected KEY=VALUE, got ${kv}`);
+                opts.env[kv.slice(0, eq)] = kv.slice(eq + 1);
+                break;
+            }
+            case "--config-path": {
+                const raw = argv[++i];
+                const eq = raw.indexOf("=");
+                if (eq > 0) {
+                    opts.configPathByHost[raw.slice(0, eq)] = raw.slice(eq + 1);
+                }
+                else {
+                    opts.configPath = raw;
+                }
+                break;
+            }
+            case "--print":
+                opts.print = true;
+                break;
+            case "--dry-run":
+                opts.dryRun = true;
+                break;
+            case "--uninstall":
+                opts.uninstall = true;
+                break;
+            case "--yes":
+                opts.yes = true;
+                break;
+            default:
+                throw new Error(`unknown option: ${flag}`);
+        }
+        i++;
+    }
+    return opts;
+}
+export function buildEntry(opts) {
+    const args = ["-y", "drawio-mcp-server"];
+    if (opts.editor)
+        args.push("--editor");
+    if (opts.httpPort !== 3000)
+        args.push("--http-port", String(opts.httpPort));
+    for (const a of opts.extraArgs)
+        args.push(a);
+    return { command: "npx", args, env: opts.env, transport: "stdio" };
+}
+export async function runInstall(argv) {
+    let opts;
+    try {
+        opts = parseArgs(argv);
+    }
+    catch (err) {
+        process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    if (opts.host === "all") {
+        return applyAll(opts);
+    }
+    const adapter = HOST_ADAPTERS[opts.host];
+    if (!adapter) {
+        process.stderr.write(`unsupported host: ${opts.host}\n`);
+        return 1;
+    }
+    return applySingle(adapter, opts);
+}
+async function applyAll(opts) {
+    let exitCode = 0;
+    for (const [id, adapter] of Object.entries(HOST_ADAPTERS)) {
+        const detect = await adapter.detect();
+        const explicit = opts.configPathByHost[id];
+        if (detect === "absent" && !explicit) {
+            process.stderr.write(`skip ${id}: not installed\n`);
+            continue;
+        }
+        const perHostOpts = {
+            ...opts,
+            host: id,
+            configPath: explicit ?? opts.configPath,
+        };
+        const code = await applySingle(adapter, perHostOpts);
+        if (code !== 0)
+            exitCode = code;
+    }
+    return exitCode;
+}
+async function applySingle(adapter, opts) {
+    const target = opts.configPath ?? adapter.defaultPaths()[0];
+    const source = existsSync(target) ? await fs.readFile(target, "utf8") : "";
+    const entry = buildEntry(opts);
+    const next = adapter.merge(source, entry, opts.name, {
+        uninstall: opts.uninstall,
+    });
+    if (opts.print) {
+        process.stdout.write(next.endsWith("\n") ? next : `${next}\n`);
+        return 0;
+    }
+    if (source === next) {
+        process.stderr.write(`no change: ${target}\n`);
+        return 0;
+    }
+    const diff = unifiedDiff(source, next, target);
+    if (opts.dryRun) {
+        process.stderr.write(diff);
+        return 0;
+    }
+    if (existsSync(target) && !opts.yes) {
+        process.stderr.write(diff);
+        process.stderr.write(`\nRe-run with --yes to apply changes.\n`);
+        return 4;
+    }
+    await ensureBackup(target);
+    await atomicWrite(target, next);
+    process.stderr.write(`updated: ${target}\n`);
+    return 0;
+}