@basein/runner 0.2.12 → 0.3.1

package/dist/config/adapters/claude-code.js

@@ -7,16 +7,25 @@
  * runs. `resolveServers` reports the winner; this module writes there and warns
  * loudly when a lower scope also defines the name.
  *
- * Byte-for-byte reversibility: the *text* of every file touched is stashed before
- * the first edit, together with a hash of what we wrote. On uninstall, a file
- * still matching that hash is restored verbatim; a file edited since is repaired
- * entry-by-entry instead, with a warning. That is the difference between "we put
- * the entries back" and "the file is as you left it".
+ * Byte-for-byte reversibility: the *text* of every project file touched is
+ * stashed before the first edit, together with a hash of what we wrote. On
+ * uninstall, a file still matching that hash — and not changed by anybody else
+ * between two of our writes — is restored verbatim; a file edited since is
+ * repaired entry-by-entry instead, with a warning. `~/.claude.json` is always
+ * repaired entry by entry: it is Claude Code's own, rewritten constantly, and
+ * holds every project's settings.
+ *
+ * Where the wrapped entries go (bir.ts, install): the LOCAL scope, as an
+ * override of the same name — never the team's `.mcp.json`, which gets
+ * committed and would carry this machine's node and runner paths to every
+ * clone, and never the user scope, which applies to every project.
  */
 import { createHash } from "node:crypto";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join, parse as parsePath } from "node:path";
-import { claudeJsonPath, parseJsonFile, projectKeyFor } from "../resolve.js";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, parse as parsePath, resolve as resolvePath } from "node:path";
+import { writeFileAtomic } from "../../util/atomic-write.js";
+import { FIRST_PROJECT_PORT, PACKAGE_NAME } from "../generate.js";
+import { claudeJsonPath, parseJsonFile, parseJsonText, projectKeyFor, } from "../resolve.js";
 export function claudeCodePaths(cwd, claudeJsonOverride) {
     return {
         claudeJson: claudeJsonPath(claudeJsonOverride),
@@ -34,12 +43,20 @@ export const LOCAL_SETTINGS_EXCLUDE = ".claude/settings.local.json";
  * `.git/info/exclude`, never `.gitignore`: the first is the person's own,
  * untracked list; the second is a file the team owns and would see in a diff.
  * Walks up from `dir` to find the repository, follows a worktree's `gitdir:`
- * pointer, and appends the line once. Returns the exclude file's path when the
+ * pointer to the repository's common git directory (the only exclude file git
+ * reads for a linked worktree), and appends the line once. Returns the exclude file's path when the
  * line is there (added or already present), undefined outside a repository or
  * when the file could not be written — an exclude that fails is a note, not a
  * failed install.
  */
 export function ensureGitExclude(dir, line = LOCAL_SETTINGS_EXCLUDE) {
+    return ensureGitExcludeLine(dir, line)?.path;
+}
+/**
+ * {@link ensureGitExclude}, also saying whether the line was ADDED now (false:
+ * it was already there — somebody's own, which uninstall must leave alone).
+ */
+export function ensureGitExcludeLine(dir, line = LOCAL_SETTINGS_EXCLUDE) {
     let gitDir;
     let current = dir;
     for (;;) {
@@ -51,9 +68,12 @@ export function ensureGitExclude(dir, line = LOCAL_SETTINGS_EXCLUDE) {
                 }
                 else {
                     // A worktree or submodule: `.git` is a file naming the real directory.
+                    // RESOLVED, not joined: `git worktree add` writes an absolute
+                    // pointer, and join() would nest it under this directory — a junk
+                    // `home/…/.git/worktrees/<name>/info/exclude` tree in the checkout.
                     const pointer = readFileSync(candidate, "utf8").match(/^gitdir:\s*(.+)$/m)?.[1]?.trim();
                     if (pointer)
-                        gitDir = join(current, pointer);
+                        gitDir = commonGitDir(resolvePath(current, pointer));
                 }
             }
             catch {
@@ -66,7 +86,9 @@ export function ensureGitExclude(dir, line = LOCAL_SETTINGS_EXCLUDE) {
             break;
         current = parent;
     }
-    if (!gitDir)
+    // A pointer to nowhere (a moved or pruned repository) is no repository: its
+    // directory is never created here.
+    if (!gitDir || !existsSync(gitDir))
         return undefined;
     try {
         const infoDir = join(gitDir, "info");
@@ -77,13 +99,33 @@ export function ensureGitExclude(dir, line = LOCAL_SETTINGS_EXCLUDE) {
         if (!lines.includes(line)) {
             const sep = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
             appendFileSync(exclude, `${sep}${line}\n`);
+            return { path: exclude, added: true };
         }
-        return exclude;
+        return { path: exclude, added: false };
     }
     catch {
         return undefined;
     }
 }
+/**
+ * The git directory whose `info/exclude` git actually reads for `gitDir`. A
+ * linked worktree's own directory (`<repo>/.git/worktrees/<name>`) has a
+ * `commondir` file naming the repository's, and git reads only that one's
+ * exclude file — a line in the per-worktree one is ignored. A submodule's
+ * `.git/modules/<name>` has no `commondir` and is its own.
+ */
+function commonGitDir(gitDir) {
+    try {
+        const commondir = join(gitDir, "commondir");
+        if (!existsSync(commondir))
+            return gitDir;
+        const common = readFileSync(commondir, "utf8").trim();
+        return common ? resolvePath(gitDir, common) : gitDir;
+    }
+    catch {
+        return gitDir;
+    }
+}
 /** Undo {@link ensureGitExclude}: drop the line, leave everything else. */
 export function removeGitExclude(dir, line = LOCAL_SETTINGS_EXCLUDE) {
     const exclude = ensureGitExclude(dir, line); // finds the file (and would add the line, which is there)
@@ -94,7 +136,7 @@ export function removeGitExclude(dir, line = LOCAL_SETTINGS_EXCLUDE) {
             .split(/\r?\n/)
             .filter((l) => l.trim() !== line);
         const text = kept.join("\n").replace(/\n+$/, "");
-        writeFileSync(exclude, text ? `${text}\n` : "");
+        writeFileAtomic(exclude, text ? `${text}\n` : "");
         return exclude;
     }
     catch {
@@ -110,24 +152,29 @@ export function removeGitExclude(dir, line = LOCAL_SETTINGS_EXCLUDE) {
  * settings, so the question is never asked. Returns the file's new text.
  */
 export function enableMcpjsonServers(settingsPath, names) {
-    const parsed = parseJsonFile(settingsPath) ?? {};
-    const current = Array.isArray(parsed.enabledMcpjsonServers)
-        ? parsed.enabledMcpjsonServers.map(String)
-        : [];
-    parsed.enabledMcpjsonServers = [...new Set([...current, ...names])];
-    return writeJson(settingsPath, parsed);
+    return editJson(settingsPath, (parsed) => {
+        const current = Array.isArray(parsed.enabledMcpjsonServers)
+            ? parsed.enabledMcpjsonServers.map(String)
+            : [];
+        parsed.enabledMcpjsonServers = [...new Set([...current, ...names])];
+    });
 }
 /** Undo {@link enableMcpjsonServers} for `names`; drops the key when empty. */
 export function disableMcpjsonServers(settingsPath, names) {
     const parsed = parseJsonFile(settingsPath);
     if (!parsed || !Array.isArray(parsed.enabledMcpjsonServers))
         return undefined;
-    const kept = parsed.enabledMcpjsonServers.map(String).filter((n) => !names.includes(n));
-    if (kept.length === 0)
-        delete parsed.enabledMcpjsonServers;
-    else
-        parsed.enabledMcpjsonServers = kept;
-    return writeJson(settingsPath, parsed);
+    if (!parsed.enabledMcpjsonServers.map(String).some((n) => names.includes(n)))
+        return undefined;
+    return editJson(settingsPath, (fresh) => {
+        if (!Array.isArray(fresh.enabledMcpjsonServers))
+            return;
+        const kept = fresh.enabledMcpjsonServers.map(String).filter((n) => !names.includes(n));
+        if (kept.length === 0)
+            delete fresh.enabledMcpjsonServers;
+        else
+            fresh.enabledMcpjsonServers = kept;
+    });
 }
 /** True when `settingsPath` holds any hook of ours. */
 export function hasBirHooks(settingsPath) {
@@ -167,11 +214,51 @@ export function readTextOrNull(path) {
         return null;
     }
 }
-function writeJson(path, value) {
-    const text = JSON.stringify(value, null, 2) + "\n";
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, text, "utf8");
-    return text;
+/**
+ * Read-modify-write one JSON file, safely:
+ *
+ *   - a file that is not plain JSON (comments, trailing commas, a torn write)
+ *     is REFUSED with an error naming it, never rewritten from a guess;
+ *   - the file is re-read just before the write, and the edit is applied again
+ *     to the fresh text when somebody else changed it in between (Claude Code
+ *     rewrites `~/.claude.json` constantly, and a lost update there loses a
+ *     server the user just added, or ours);
+ *   - the write itself is atomic (util/atomic-write.ts), so Claude Code never
+ *     reads a half-written config, and a symlinked file stays a symlink.
+ *
+ * `mutate` gets a fresh parse each attempt and must not keep state between
+ * calls. Returns the text written, for the sidecar's hash.
+ */
+export function editJson(path, mutate) {
+    for (let attempt = 0;; attempt += 1) {
+        const before = readTextOrNull(path);
+        const value = before === null ? {} : parseJsonText(before, path);
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            throw new Error(`refusing to rewrite ${path}: it is not a JSON object`);
+        }
+        const parsed = value;
+        mutate(parsed);
+        const text = JSON.stringify(parsed, null, 2) + "\n";
+        if (attempt < 3 && readTextOrNull(path) !== before)
+            continue;
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileAtomic(path, text);
+        return text;
+    }
+}
+/**
+ * Throw (naming the file) when `path` exists and is not a plain JSON object —
+ * so an install can refuse up front, before it has written anything, instead
+ * of stopping halfway through with some files changed and others not.
+ */
+export function assertEditableJson(path) {
+    const text = readTextOrNull(path);
+    if (text === null)
+        return;
+    const value = parseJsonText(text, path);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`${path} is not a JSON object`);
+    }
 }
 /**
  * Set (or delete, with `entry === null`) one MCP server entry in `scope`.
@@ -179,27 +266,78 @@ function writeJson(path, value) {
  */
 export function setServerEntry(scope, cwd, name, entry, paths) {
     const file = fileForScope(scope, paths);
-    const parsed = parseJsonFile(file) ?? {};
-    if (scope === "local") {
-        const projects = parsed.projects ?? {};
-        const key = projectKeyFor(projects, cwd);
-        const project = projects[key] ?? {};
-        const servers = { ...(project.mcpServers ?? {}) };
-        if (entry === null)
-            delete servers[name];
-        else
-            servers[name] = entry;
-        parsed.projects = { ...projects, [key]: { ...project, mcpServers: servers } };
-    }
-    else {
-        const servers = { ...(parsed.mcpServers ?? {}) };
+    const text = editJson(file, (parsed) => {
+        if (scope === "local") {
+            const projects = parsed.projects ?? {};
+            const key = projectKeyFor(projects, cwd);
+            const project = projects[key] ?? {};
+            const servers = { ...(project.mcpServers ?? {}) };
+            if (entry === null)
+                delete servers[name];
+            else
+                servers[name] = entry;
+            parsed.projects = { ...projects, [key]: { ...project, mcpServers: servers } };
+        }
+        else {
+            const servers = { ...(parsed.mcpServers ?? {}) };
+            if (entry === null)
+                delete servers[name];
+            else
+                servers[name] = entry;
+            parsed.mcpServers = servers;
+        }
+    });
+    return { file, text };
+}
+/**
+ * Set (or delete) one entry of the local scope under each of `keys` in
+ * `~/.claude.json`, in ONE atomic edit. `shouldTouch` sees the entry currently
+ * under a key (or undefined) and may veto that key — so a user's own entry
+ * under another spelling of the project is never overwritten or deleted.
+ * Returns the text written and the keys actually changed (none: no write).
+ */
+export function setLocalEntries(claudeJson, keys, name, entry, shouldTouch = () => true) {
+    let changed = [];
+    const probe = parseJsonFile(claudeJson);
+    const wanted = keys.filter((key) => {
+        const current = probe?.projects?.[key]?.mcpServers?.[name];
+        if (!shouldTouch(current))
+            return false;
         if (entry === null)
-            delete servers[name];
-        else
-            servers[name] = entry;
-        parsed.mcpServers = servers;
-    }
-    return { file, text: writeJson(file, parsed) };
+            return current !== undefined;
+        return JSON.stringify(current) !== JSON.stringify(entry);
+    });
+    if (wanted.length === 0)
+        return { keys: [] };
+    const text = editJson(claudeJson, (parsed) => {
+        changed = [];
+        const projects = { ...(parsed.projects ?? {}) };
+        for (const key of keys) {
+            const project = projects[key] ?? {};
+            const current = project.mcpServers?.[name];
+            if (!shouldTouch(current))
+                continue;
+            if (entry === null && current === undefined)
+                continue;
+            const servers = { ...(project.mcpServers ?? {}) };
+            if (entry === null)
+                delete servers[name];
+            else
+                servers[name] = entry;
+            const next = { ...project, mcpServers: servers };
+            // A project key holding nothing but an empty `mcpServers` is one an
+            // install created before Claude Code ever ran there (Claude Code's own
+            // entries carry its trust and permission state). Taking our last entry
+            // out takes the key with it, so uninstall leaves the file as it found it.
+            if (entry === null && Object.keys(next).length === 1 && Object.keys(servers).length === 0)
+                delete projects[key];
+            else
+                projects[key] = next;
+            changed.push(key);
+        }
+        parsed.projects = projects;
+    });
+    return { text, keys: changed };
 }
 // ── hooks ──────────────────────────────────────────────────────────────────
 /**
@@ -210,49 +348,67 @@ export function setServerEntry(scope, cwd, name, entry, paths) {
  * only listens to the success one records a step that never closes.
  * `SubagentStart` / `SubagentStop` carry `agent_id`, which is what lets a
  * subagent's steps be attributed rather than silently interleaved.
+ *
+ * THE TIMEOUTS ARE THE USER'S WORST CASE. Claude Code waits for a hung hook up
+ * to its `timeout`, so each number here is how long a slow or blackholed
+ * service could make a person wait — at every prompt, every tool call, every
+ * `/exit`. The control server keeps its own per-route deadlines well inside
+ * them (prompt ≤ 7 s, tool/pre ≤ 12 s, tool/post and stop ≤ 2 s, end ≤ 1 s,
+ * start ≤ 2 s) and answers `{}` on overrun, so these are the second line of
+ * defence, not a budget to spend. SessionEnd matters twice: Claude Code's own
+ * default for it is 1.5 s, and whatever is written here RAISES that — the 30 it
+ * used to be turned every `/exit` during a service incident into a 30 s wait.
+ * A re-run of `bir setup` rewrites existing installs with these.
  */
 export const HOOK_ROUTES = [
-    { event: "SessionStart", route: "/session/start", matcher: "", timeout: 10 },
-    // 15s, not 5s, because this hook now awaits the similar-prompt match before it
-    // can return a steering directive (docs/calculatedReplay.md §10). The wait is
-    // itself bounded by `BIR_MATCH_BUDGET_MS` (2.5s), well inside this; the extra
-    // headroom is for a slow first embed on the service, not for us to spend.
+    // The HTTP form, used only when no self-starting hook can be written.
+    { event: "SessionStart", route: "/session/start", matcher: "", timeout: 5 },
+    // Awaits the similar-prompt match and the derivation before it can return a
+    // steering directive (docs/calculatedReplay.md §10); the server caps the
+    // whole route at 7 s.
     //
     // It must NEVER become `async`. An async hook is fire-and-forget, so it cannot
     // return `additionalContext` at all — replay would silently never arm.
-    { event: "UserPromptSubmit", route: "/session/prompt", matcher: "", timeout: 15 },
+    { event: "UserPromptSubmit", route: "/session/prompt", matcher: "", timeout: 10 },
     // PreToolUse and PostToolUse are likewise NOT async, and that is load-bearing
     // twice over: correlation needs `updatedInput` back, and a steered replay needs
     // step N's output threaded into `respParams` *before* step N+1's input is
-    // computed (docs/calculatedReplay.md §7.3).
-    { event: "PreToolUse", route: "/tool/pre", matcher: "*", timeout: 30 },
-    { event: "PostToolUse", route: "/tool/post", matcher: "*", timeout: 30 },
-    { event: "PostToolUseFailure", route: "/tool/post", matcher: "*", timeout: 30 },
-    { event: "SubagentStart", route: "/session/agent", matcher: "", timeout: 5 },
-    { event: "SubagentStop", route: "/session/agent", matcher: "", timeout: 5 },
-    { event: "Stop", route: "/session/stop", matcher: "", timeout: 10 },
-    { event: "StopFailure", route: "/session/stop", matcher: "", timeout: 10 },
+    // computed (docs/calculatedReplay.md §7.3). PreToolUse may run an in-hook
+    // replay step, capped by the server at 12 s.
+    { event: "PreToolUse", route: "/tool/pre", matcher: "*", timeout: 15 },
+    { event: "PostToolUse", route: "/tool/post", matcher: "*", timeout: 5 },
+    { event: "PostToolUseFailure", route: "/tool/post", matcher: "*", timeout: 5 },
+    { event: "SubagentStart", route: "/session/agent", matcher: "", timeout: 3 },
+    { event: "SubagentStop", route: "/session/agent", matcher: "", timeout: 3 },
+    { event: "Stop", route: "/session/stop", matcher: "", timeout: 5 },
+    { event: "StopFailure", route: "/session/stop", matcher: "", timeout: 5 },
     // NOT async. An async hook is fire-and-forget, and `SessionEnd` fires while the
     // host is exiting — the exit wins that race and the request is never sent, so
-    // every run was left unfinished on the server. It is cheap to wait for now
-    // (`Stop` has already sealed the run; this only drains the queue), and a run
-    // that is actually finished is worth a few hundred milliseconds at shutdown.
-    { event: "SessionEnd", route: "/session/end", matcher: "", timeout: 30 },
+    // every run was left unfinished on the server. The server answers within 1 s
+    // and finishes the upload in the background; 3 s is margin, not a wait.
+    { event: "SessionEnd", route: "/session/end", matcher: "", timeout: 3 },
 ];
 /**
  * The argument that makes a 'bir-hooks' invocation the SessionStart hook.
  * Exported so the binary and the adapter cannot drift apart on the spelling.
  */
 export const ENSURE_ARG = "ensure";
-/** How long SessionStart may wait for a background recorder to come up. */
-export const ENSURE_TIMEOUT_S = 30;
+/**
+ * How long SessionStart may wait for a background recorder to come up. The
+ * ensure hook keeps its own budget at 12 s or less and always exits 0; this is
+ * the host's ceiling on top of it.
+ */
+export const ENSURE_TIMEOUT_S = 15;
 /** Build the 'hooks' block pointing at a control server. */
 export function buildHooksBlock(controlUrl, token, opts = {}) {
     const base = controlUrl.replace(/\/+$/, "");
     const block = {};
     for (const { event, route, matcher, timeout, async } of HOOK_ROUTES) {
         let hook;
-        if (event === "SessionStart" && opts.ensure) {
+        if (event === "SessionStart" && opts.ensure && "command" in opts.ensure) {
+            hook = { type: "command", command: opts.ensure.command, args: [...opts.ensure.args], timeout: ENSURE_TIMEOUT_S };
+        }
+        else if (event === "SessionStart" && opts.ensure && "node" in opts.ensure) {
             hook = {
                 type: "command",
                 command: opts.ensure.node,
@@ -275,55 +431,89 @@ export function buildHooksBlock(controlUrl, token, opts = {}) {
     }
     return block;
 }
+/** A loopback bearer token as `bir install` makes them: 32 random bytes, hex. */
+const OUR_TOKEN = /^Bearer [0-9a-f]{64}$/i;
 /**
- * True when a hook entry is one of ours: an HTTP hook aimed at a control-server
- * route, or the exec-form command hook that starts the recorder.
+ * True when a hook entry is one of ours, and only then — install and uninstall
+ * delete what this says is ours, so a false positive deletes somebody's hook.
+ *
+ *   HTTP: a loopback URL (127.0.0.1 / localhost / [::1]) whose path is exactly
+ *         one of our routes, AND either our kind of bearer token or a port in
+ *         the range `bir` allocates (the token-less 0.2.8 shape). A hook to
+ *         `https://hooks.example.com/session/end` is somebody else's.
+ *   exec: our self-starting SessionStart hook — `bir-hooks.js ensure`, or the
+ *         npx form `… -p @basein/runner@<v> bir-hooks ensure`.
  */
 export function isBirHook(entry) {
-    const e = entry;
-    const url = e.url ?? "";
-    if (HOOK_ROUTES.some(({ route }) => url.endsWith(route)))
-        return true;
+    const e = (entry ?? {});
+    if (typeof e.url === "string" && e.url) {
+        let url;
+        try {
+            url = new URL(e.url);
+        }
+        catch {
+            return false;
+        }
+        if (!["127.0.0.1", "localhost", "[::1]"].includes(url.hostname))
+            return false;
+        if (!HOOK_ROUTES.some(({ route }) => url.pathname === route))
+            return false;
+        const auth = e.headers?.Authorization;
+        if (typeof auth === "string" && OUR_TOKEN.test(auth))
+            return true;
+        const port = Number(url.port);
+        return port >= FIRST_PROJECT_PORT && port < FIRST_PROJECT_PORT + 200;
+    }
     if (Array.isArray(e.args)) {
         const args = e.args.map(String);
-        return args.some((a) => /[\\/]bir-hooks\.js$/.test(a)) && args.includes(ENSURE_ARG);
+        if (!args.includes(ENSURE_ARG))
+            return false;
+        if (args.some((a) => /[\\/]bir-hooks\.js$/.test(a)))
+            return true;
+        return args.includes("bir-hooks") && args.some((a) => a.startsWith(PACKAGE_NAME));
     }
     return false;
 }
 /**
  * Merge our hooks into a settings file, leaving every other hook alone. Returns
  * the new text. Our own entries are replaced rather than appended, so repeated
- * installs stay idempotent.
+ * installs stay idempotent — hook by hook: a user's own hook that happens to
+ * share a matcher group with one of ours stays exactly where it is.
  */
 export function installHooks(settingsPath, block) {
-    const parsed = parseJsonFile(settingsPath) ?? {};
-    const hooks = { ...(parsed.hooks ?? {}) };
-    for (const [event, matchers] of Object.entries(block)) {
-        const existing = (hooks[event] ?? []).filter((m) => !(m.hooks ?? []).some((h) => isBirHook(h)));
-        hooks[event] = [...existing, ...matchers];
-    }
-    parsed.hooks = hooks;
-    return writeJson(settingsPath, parsed);
+    return editJson(settingsPath, (parsed) => {
+        const hooks = { ...(parsed.hooks ?? {}) };
+        for (const [event, matchers] of Object.entries(block)) {
+            const existing = (hooks[event] ?? [])
+                .map((m) => ({ ...m, hooks: (m.hooks ?? []).filter((h) => !isBirHook(h)) }))
+                .filter((m) => m.hooks.length > 0);
+            hooks[event] = [...existing, ...matchers];
+        }
+        parsed.hooks = hooks;
+    });
 }
 /** Remove only our hook entries, and drop events left empty. */
 export function uninstallHooks(settingsPath) {
     const parsed = parseJsonFile(settingsPath);
     if (!parsed?.hooks)
         return undefined;
-    const hooks = { ...parsed.hooks };
-    for (const [event, matchers] of Object.entries(hooks)) {
-        const kept = (matchers ?? [])
-            .map((m) => ({ ...m, hooks: (m.hooks ?? []).filter((h) => !isBirHook(h)) }))
-            .filter((m) => m.hooks.length > 0);
-        if (kept.length === 0)
-            delete hooks[event];
+    return editJson(settingsPath, (fresh) => {
+        if (!fresh.hooks)
+            return;
+        const hooks = { ...fresh.hooks };
+        for (const [event, matchers] of Object.entries(hooks)) {
+            const kept = (matchers ?? [])
+                .map((m) => ({ ...m, hooks: (m.hooks ?? []).filter((h) => !isBirHook(h)) }))
+                .filter((m) => m.hooks.length > 0);
+            if (kept.length === 0)
+                delete hooks[event];
+            else
+                hooks[event] = kept;
+        }
+        if (Object.keys(hooks).length === 0)
+            delete fresh.hooks;
         else
-            hooks[event] = kept;
-    }
-    if (Object.keys(hooks).length === 0)
-        delete parsed.hooks;
-    else
-        parsed.hooks = hooks;
-    return writeJson(settingsPath, parsed);
+            fresh.hooks = hooks;
+    });
 }
 //# sourceMappingURL=claude-code.js.map

package/dist/config/adapters/generic.d.ts

@@ -8,7 +8,10 @@
  * user and never looks for one.
  *
  * There are no scopes here: the file given is the whole configuration, and it is
- * both the read source and the write target.
+ * both the read source and the write target. Writes go through the same safe
+ * edit as Claude Code's files (claude-code.ts, `editJson`): refused when the
+ * file is not plain JSON, re-applied if the client rewrote it meanwhile, and
+ * atomic.
  */
 import { type McpServerConfig } from "../resolve.js";
 export declare function readGenericServers(path: string): Record<string, McpServerConfig>;

package/dist/config/adapters/generic.js

@@ -8,10 +8,12 @@
  * user and never looks for one.
  *
  * There are no scopes here: the file given is the whole configuration, and it is
- * both the read source and the write target.
+ * both the read source and the write target. Writes go through the same safe
+ * edit as Claude Code's files (claude-code.ts, `editJson`): refused when the
+ * file is not plain JSON, re-applied if the client rewrote it meanwhile, and
+ * atomic.
  */
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { editJson } from "./claude-code.js";
 import { parseJsonFile } from "../resolve.js";
 export function readGenericServers(path) {
     const parsed = parseJsonFile(path);
@@ -21,16 +23,13 @@ export function readGenericServers(path) {
 }
 /** Set or delete one entry, preserving every other key in the file. */
 export function setGenericServerEntry(path, name, entry) {
-    const parsed = parseJsonFile(path) ?? {};
-    const servers = { ...(parsed.mcpServers ?? {}) };
-    if (entry === null)
-        delete servers[name];
-    else
-        servers[name] = entry;
-    parsed.mcpServers = servers;
-    const text = JSON.stringify(parsed, null, 2) + "\n";
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, text, "utf8");
-    return text;
+    return editJson(path, (parsed) => {
+        const servers = { ...(parsed.mcpServers ?? {}) };
+        if (entry === null)
+            delete servers[name];
+        else
+            servers[name] = entry;
+        parsed.mcpServers = servers;
+    });
 }
 //# sourceMappingURL=generic.js.map