baychat 0.24.0 → 0.25.0

package/dist/claude-settings.js

@@ -0,0 +1,503 @@
+"use strict";
+// Putting BayChat's context reader into Claude Code's own settings file — and taking it out again.
+//
+// WHAT IS INSTALLED. Three entries in ~/.claude/settings.json, and nothing else:
+//
+//   • `statusLine.command` → a short POSIX shell program (see `wrapperCommand`) that runs THE
+//     PERSON'S OWN status-line command with the same input, in the same shell, and hands BayChat a
+//     copy of the input in the background. Their line never waits for Node.
+//   • `hooks.PreCompact` and `hooks.PostCompact` → `context-hook`, async (it can neither block nor
+//     delay a compaction) and printing nothing.
+//
+// HOW CLAUDE CODE RUNS IT — read from Claude Code 2.1.282's own executor, not assumed: the status
+// line goes through the same function as hooks, which on macOS and Linux is
+// `spawn(command, { shell: true })` — `/bin/sh -c` — with the status JSON on stdin; its stdout is
+// shown ONLY when it exits 0. So the program below is POSIX sh, runs their command with `eval` in
+// that same sh, and ends with their command's exit status. (Windows runs it through Git Bash;
+// installing there is refused until that is proven — see context-hooks-command.ts.)
+//
+// NOTHING DEPENDS ON PATH. Node and the CLI entry are written in by ABSOLUTE path, because Claude
+// Code started from an IDE or a GUI (or under another nvm version) has a different PATH from the
+// shell that ran `install`. If either is gone — `npm uninstall -g baychat` without `uninstall`, an
+// nvm version removed — the program skips BayChat and still runs their command, so their status
+// line keeps rendering exactly as it did.
+//
+// THE ORIGINAL IS KEPT TWICE: base64url in the marker at the front (`: baychat-context-statusline
+// b<…>;`, a no-op), which is what uninstall reads, and single-quoted for `eval`, which is what runs.
+//
+// THE CONSENT. Nothing here runs by itself: `baychat context-hooks install` is the deliberate act,
+// `baychat context-hooks uninstall` the off switch (REMOTE_APPROVAL_HOOK.md is the precedent).
+//
+// NEVER CORRUPT OR LOSE THE FILE:
+//   • a file that does not parse is REFUSED, never overwritten;
+//   • a symlinked settings.json (stow, chezmoi) is followed: the REAL file is edited, in place,
+//     atomically (temp file beside it, then rename), and the link stays a link;
+//   • unknown keys are preserved; the file's mode and indentation are kept;
+//   • every write first copies the file to a backup that is NEVER overwritten: the first is
+//     `settings.json.baychat-backup` (the pre-install original, kept for good), later ones are
+//     timestamped;
+//   • uninstall restores the person's own bytes when the result is the same settings as a backup
+//     (their formatting intact); otherwise — they changed something while installed — it keeps
+//     their change, re-serialises, and SAYS it restored semantically;
+//   • install and uninstall are idempotent.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeSettingsIo = void 0;
+exports.encodeChain = encodeChain;
+exports.decodeChain = decodeChain;
+exports.shQuote = shQuote;
+exports.wrapperCommand = wrapperCommand;
+exports.hookCommand = hookCommand;
+exports.parseWrapper = parseWrapper;
+exports.contextHooksState = contextHooksState;
+exports.installContextHooks = installContextHooks;
+exports.uninstallContextHooks = uninstallContextHooks;
+exports.claudeSettingsPath = claudeSettingsPath;
+exports.settingsBackupPath = settingsBackupPath;
+exports.detectIndent = detectIndent;
+exports.editClaudeSettings = editClaudeSettings;
+exports.readClaudeSettingsState = readClaudeSettingsState;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/** The first release's commands, still recognised so uninstall and upgrade can find them. */
+const LEGACY_STATUSLINE = "baychat context-statusline";
+const LEGACY_HOOK = "baychat context-hook";
+const LEGACY_CHAIN_FLAG = "--chain";
+const STATUSLINE_MARKER = ": baychat-context-statusline ";
+const HOOK_MARKER = ": baychat-context-hook;";
+const HOOK_EVENTS = ["PreCompact", "PostCompact"];
+/** Generous: the hook is async and returns in milliseconds; this only bounds a wedged one. */
+const HOOK_TIMEOUT_SECONDS = 30;
+const isRecord = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+// ─── The commands ────────────────────────────────────────────────────────────
+/** base64url: only [A-Za-z0-9_-], so the result needs no quoting in any shell. */
+function encodeChain(command) {
+    return Buffer.from(command, "utf8").toString("base64url");
+}
+function decodeChain(encoded) {
+    if (!/^[A-Za-z0-9_-]*$/.test(encoded))
+        return undefined;
+    const text = Buffer.from(encoded, "base64url").toString("utf8");
+    // A round trip that does not reproduce the input was not ours.
+    return encodeChain(text) === encoded ? text : undefined;
+}
+/** POSIX single quotes: everything literal; a `'` is closed, escaped and reopened. */
+function shQuote(text) {
+    return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+/** `[ -x node ] && [ -f entry ]`: BayChat is still there to run. */
+function present(launch) {
+    return `[ -x ${shQuote(launch.node)} ] && [ -f ${shQuote(launch.entry)} ]`;
+}
+/**
+ * The status-line program, in POSIX sh:
+ *
+ *   : baychat-context-statusline b<original, base64url>;      ← marker; a no-op
+ *   baychat_in=$(cat; printf x); baychat_in=${baychat_in%x}    ← all of stdin, trailing newlines kept
+ *   if <node and entry exist>; then
+ *     printf '%s' "$baychat_in" | '<node>' '<entry>' context-statusline >/dev/null 2>&1 &   ← background
+ *   fi
+ *   printf '%s' "$baychat_in" | eval '<original>'              ← their line, their exit status
+ *
+ * The background copy has stdout and stderr on /dev/null, so it holds none of Claude Code's pipes
+ * and the line is shown the moment their command ends.
+ */
+function wrapperCommand(original, launch) {
+    const marker = `${STATUSLINE_MARKER}${original === undefined ? "-" : `b${encodeChain(original)}`};`;
+    const read = `baychat_in=$(cat; printf x); baychat_in=\${baychat_in%x};`;
+    const note = `if ${present(launch)}; then printf '%s' "$baychat_in" | ${shQuote(launch.node)} ${shQuote(launch.entry)} context-statusline >/dev/null 2>&1 & fi;`;
+    const theirs = original === undefined ? ":" : `printf '%s' "$baychat_in" | eval ${shQuote(original)}`;
+    return `${marker} ${read} ${note} ${theirs}`;
+}
+/** The compaction hook: runs BayChat if it is still there, else does nothing, silently. */
+function hookCommand(launch) {
+    return `${HOOK_MARKER} if ${present(launch)}; then exec ${shQuote(launch.node)} ${shQuote(launch.entry)} context-hook; fi`;
+}
+/**
+ * Is this status-line command ours, and if so what did it wrap?
+ * `wrapped: undefined` means ours with nothing chained; `ours: false` means somebody else's.
+ * Reads the current format and the first release's.
+ */
+function parseWrapper(command) {
+    if (typeof command !== "string")
+        return { ours: false };
+    const trimmed = command.trim();
+    if (trimmed.startsWith(STATUSLINE_MARKER)) {
+        const token = trimmed.slice(STATUSLINE_MARKER.length).split(";", 1)[0].trim();
+        if (token === "-")
+            return { ours: true };
+        const wrapped = token.startsWith("b") ? decodeChain(token.slice(1)) : undefined;
+        return wrapped === undefined ? { ours: false } : { ours: true, wrapped };
+    }
+    if (trimmed === LEGACY_STATUSLINE)
+        return { ours: true };
+    const prefix = `${LEGACY_STATUSLINE} ${LEGACY_CHAIN_FLAG} `;
+    if (!trimmed.startsWith(prefix))
+        return { ours: false };
+    const wrapped = decodeChain(trimmed.slice(prefix.length).trim());
+    return wrapped === undefined || wrapped === "" ? { ours: false } : { ours: true, wrapped };
+}
+function isOurHook(h) {
+    if (!isRecord(h) || typeof h.command !== "string")
+        return false;
+    const c = h.command.trim();
+    return c === LEGACY_HOOK || c.startsWith(HOOK_MARKER);
+}
+function eventHasOurHook(settings, event) {
+    const hooks = isRecord(settings.hooks) ? settings.hooks : undefined;
+    const groups = hooks && Array.isArray(hooks[event]) ? hooks[event] : [];
+    return groups.some((g) => isRecord(g) && Array.isArray(g.hooks) && g.hooks.some(isOurHook));
+}
+function contextHooksState(settings) {
+    const line = isRecord(settings.statusLine) ? settings.statusLine : undefined;
+    const parsed = parseWrapper(line?.command);
+    return {
+        statusLine: !line ? "none" : parsed.ours ? "ours" : "theirs",
+        ...(parsed.ours && parsed.wrapped !== undefined ? { wrapped: parsed.wrapped } : {}),
+        hooks: { PreCompact: eventHasOurHook(settings, "PreCompact"), PostCompact: eventHasOurHook(settings, "PostCompact") },
+    };
+}
+/**
+ * Add (or bring up to date) the status-line wrapper and the two compaction hooks. Idempotent for
+ * the same `launch`; a different one (another node, another install) rewrites the paths.
+ *
+ * Only `statusLine.command` is replaced; `padding`, `refreshInterval` and anything else stay. A
+ * status line that is not a command is left alone rather than guessed at — the hooks still go in.
+ */
+function installContextHooks(input, launch) {
+    const settings = structuredClone(input);
+    let changed = false;
+    const line = settings.statusLine;
+    if (line === undefined) {
+        settings.statusLine = { type: "command", command: wrapperCommand(undefined, launch) };
+        changed = true;
+    }
+    else if (isRecord(line) && (line.type === undefined || line.type === "command") && typeof line.command === "string") {
+        const parsed = parseWrapper(line.command);
+        const want = wrapperCommand(parsed.ours ? parsed.wrapped : line.command, launch);
+        if (line.command !== want) {
+            settings.statusLine = { ...line, command: want };
+            changed = true;
+        }
+    }
+    const hook = hookCommand(launch);
+    const hooks = isRecord(settings.hooks) ? { ...settings.hooks } : {};
+    let hooksChanged = false;
+    for (const event of HOOK_EVENTS) {
+        const groups = Array.isArray(hooks[event]) ? [...hooks[event]] : [];
+        if (eventHasOurHook(settings, event)) {
+            // Ours already: bring its command up to date (legacy form, or another node).
+            const updated = groups.map((g) => isRecord(g) && Array.isArray(g.hooks)
+                ? { ...g, hooks: g.hooks.map((h) => (isOurHook(h) && h.command !== hook ? { ...h, command: hook } : h)) }
+                : g);
+            if (JSON.stringify(updated) !== JSON.stringify(groups)) {
+                hooks[event] = updated;
+                hooksChanged = true;
+            }
+            continue;
+        }
+        groups.push({ hooks: [{ type: "command", command: hook, async: true, timeout: HOOK_TIMEOUT_SECONDS }] });
+        hooks[event] = groups;
+        hooksChanged = true;
+    }
+    if (hooksChanged) {
+        settings.hooks = hooks;
+        changed = true;
+    }
+    return { settings: changed ? settings : input, changed };
+}
+/**
+ * Remove exactly what `installContextHooks` added (any format). Idempotent.
+ *
+ * The status line goes back to the person's own command; when there was none, ours is removed.
+ * Only OUR hook entries are removed — a group that held other hooks keeps them, and an event
+ * array or `hooks` object is removed only when our removal is what emptied it.
+ */
+function uninstallContextHooks(input) {
+    const settings = structuredClone(input);
+    let changed = false;
+    const line = settings.statusLine;
+    if (isRecord(line)) {
+        const parsed = parseWrapper(line.command);
+        if (parsed.ours) {
+            if (parsed.wrapped === undefined)
+                delete settings.statusLine;
+            else
+                settings.statusLine = { ...line, command: parsed.wrapped };
+            changed = true;
+        }
+    }
+    if (isRecord(settings.hooks)) {
+        const hooks = { ...settings.hooks };
+        let hooksChanged = false;
+        for (const event of HOOK_EVENTS) {
+            if (!Array.isArray(hooks[event]))
+                continue;
+            const before = hooks[event];
+            const after = [];
+            for (const group of before) {
+                if (!isRecord(group) || !Array.isArray(group.hooks) || !group.hooks.some(isOurHook)) {
+                    after.push(group);
+                    continue;
+                }
+                hooksChanged = true;
+                const rest = group.hooks.filter((h) => !isOurHook(h));
+                if (rest.length > 0)
+                    after.push({ ...group, hooks: rest });
+            }
+            if (after.length === before.length && after.every((g, i) => g === before[i]))
+                continue;
+            if (after.length > 0)
+                hooks[event] = after;
+            else
+                delete hooks[event];
+        }
+        if (hooksChanged) {
+            changed = true;
+            if (Object.keys(hooks).length > 0)
+                settings.hooks = hooks;
+            else
+                delete settings.hooks;
+        }
+    }
+    return { settings: changed ? settings : input, changed };
+}
+// ─── The file ────────────────────────────────────────────────────────────────
+function claudeSettingsPath(home = os.homedir()) {
+    return path.join(process.env.CLAUDE_CONFIG_DIR || path.join(home, ".claude"), "settings.json");
+}
+/** The FIRST backup: the pre-install original. Later backups are timestamped beside it. */
+function settingsBackupPath(file) {
+    return `${file}.baychat-backup`;
+}
+/** The indentation the file already uses, so our write changes only what it has to. */
+function detectIndent(text) {
+    const match = /^[{[]\s*\n([ \t]+)\S/.exec(text);
+    if (!match)
+        return 2;
+    return match[1].includes("\t") ? "\t" : match[1].length;
+}
+exports.nodeSettingsIo = {
+    read(file) {
+        try {
+            return fs.readFileSync(file, "utf8");
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return null;
+            throw err;
+        }
+    },
+    write(file, text, mode) {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        // Beside the target, so the rename cannot cross a filesystem (which would not be atomic).
+        const tmp = `${file}.baychat-${process.pid}.tmp`;
+        try {
+            fs.writeFileSync(tmp, text, { mode: mode ?? 0o600 });
+            if (mode !== undefined)
+                fs.chmodSync(tmp, mode);
+            fs.renameSync(tmp, file);
+        }
+        catch (err) {
+            try {
+                fs.unlinkSync(tmp);
+            }
+            catch {
+                /* nothing was left behind */
+            }
+            throw err;
+        }
+    },
+    copyExclusive(from, to) {
+        fs.copyFileSync(from, to, fs.constants.COPYFILE_EXCL);
+    },
+    mode(file) {
+        try {
+            return fs.statSync(file).mode & 0o777;
+        }
+        catch {
+            return undefined;
+        }
+    },
+    realpath(file) {
+        try {
+            return fs.realpathSync(file);
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+            // A dangling symlink is not "no file": writing through it would replace the link.
+            let link = false;
+            try {
+                link = fs.lstatSync(file).isSymbolicLink();
+            }
+            catch {
+                /* truly absent */
+            }
+            if (link)
+                throw new Error(`${file} is a symlink to a file that does not exist, so it was left untouched.`);
+            return file;
+        }
+    },
+    list(dir) {
+        try {
+            return fs.readdirSync(dir);
+        }
+        catch {
+            return [];
+        }
+    },
+    mtime(file) {
+        try {
+            return fs.statSync(file).mtimeMs;
+        }
+        catch {
+            return 0;
+        }
+    },
+};
+/** Copy `file` to a backup that did not exist before. Returns its path. */
+function backUp(file, io) {
+    const first = settingsBackupPath(file);
+    const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+    for (const candidate of [first, `${first}-${stamp}`, ...Array.from({ length: 20 }, (_, i) => `${first}-${stamp}-${i + 2}`)]) {
+        try {
+            io.copyExclusive(file, candidate);
+            return candidate;
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+        }
+    }
+    throw new Error(`Could not find a free backup name beside ${file}; nothing was changed.`);
+}
+/** Every backup of `file`, newest first. */
+function backupsOf(file, io) {
+    const base = path.basename(settingsBackupPath(file));
+    const dir = path.dirname(file);
+    return io
+        .list(dir)
+        .filter((name) => name === base || name.startsWith(`${base}-`))
+        .map((name) => path.join(dir, name))
+        .sort((a, b) => io.mtime(b) - io.mtime(a));
+}
+/** Deep equality of parsed JSON, key order ignored. */
+function sameJson(a, b) {
+    if (Array.isArray(a) || Array.isArray(b)) {
+        return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((v, i) => sameJson(v, b[i]));
+    }
+    if (isRecord(a) && isRecord(b)) {
+        const ka = Object.keys(a);
+        return ka.length === Object.keys(b).length && ka.every((k) => Object.prototype.hasOwnProperty.call(b, k) && sameJson(a[k], b[k]));
+    }
+    return a === b;
+}
+/**
+ * Read → transform → back up → write atomically, on the REAL file. Throws, with the file
+ * untouched, when it does not parse or is not a JSON object.
+ *
+ * `restoreFromBackups` (uninstall): when the result is the same settings as one of the backups,
+ * that backup's exact text is written instead, so the person's formatting comes back too.
+ */
+function editClaudeSettings(file, transform, io = exports.nodeSettingsIo, opts = {}) {
+    const target = io.realpath(file);
+    const text = io.read(target);
+    let settings = {};
+    if (text !== null && text.trim() !== "") {
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            throw new Error(`${target} is not valid JSON, so it was left untouched. Fix it (or move it aside), then run this again.`);
+        }
+        if (!isRecord(parsed)) {
+            throw new Error(`${target} is not a JSON object, so it was left untouched.`);
+        }
+        settings = parsed;
+    }
+    const result = transform(settings);
+    if (!result.changed)
+        return { kind: "unchanged", state: contextHooksState(settings), file: target };
+    let restored;
+    let next = `${JSON.stringify(result.settings, null, text ? detectIndent(text) : 2)}\n`;
+    if (opts.restoreFromBackups) {
+        restored = "semantic";
+        for (const candidate of backupsOf(target, io)) {
+            const old = io.read(candidate);
+            if (old === null)
+                continue;
+            try {
+                if (sameJson(JSON.parse(old), result.settings)) {
+                    next = old;
+                    restored = "exact";
+                    break;
+                }
+            }
+            catch {
+                /* a backup that does not parse cannot be the one */
+            }
+        }
+    }
+    const backup = text !== null ? backUp(target, io) : undefined;
+    io.write(target, next, io.mode(target));
+    return {
+        kind: "written",
+        state: contextHooksState(result.settings),
+        file: target,
+        ...(backup ? { backup } : {}),
+        ...(restored ? { restored } : {}),
+    };
+}
+function readClaudeSettingsState(file, io = exports.nodeSettingsIo) {
+    let text;
+    try {
+        text = io.read(io.realpath(file));
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+    if (text === null || text.trim() === "")
+        return contextHooksState({});
+    try {
+        const parsed = JSON.parse(text);
+        return isRecord(parsed) ? contextHooksState(parsed) : { error: `${file} is not a JSON object` };
+    }
+    catch {
+        return { error: `${file} is not valid JSON` };
+    }
+}

package/dist/context-hooks-command.js

@@ -0,0 +1,165 @@
+"use strict";
+// `baychat context-hooks install | uninstall | status` — the person's switch for Claude Code context
+// reporting. Nothing is ever installed without this command being run (see claude-settings.ts).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentLaunch = currentLaunch;
+exports.launchProblem = launchProblem;
+exports.cmdContextHooks = cmdContextHooks;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const claude_context_1 = require("./claude-context");
+const claude_settings_1 = require("./claude-settings");
+const config_1 = require("./config");
+const USAGE = "Usage: baychat context-hooks <install|uninstall|status>";
+/**
+ * This very CLI, by absolute path: the node running it and the entry file it was started from.
+ * Symlinks resolved, so an npm bin link or an nvm alias cannot move under it later.
+ */
+function currentLaunch() {
+    return { node: fs.realpathSync(process.execPath), entry: fs.realpathSync(process.argv[1] ?? "") };
+}
+/** Why this launch cannot be written into settings.json, or undefined when it can. */
+function launchProblem(launch) {
+    if (/[\\/]_npx[\\/]/.test(launch.entry)) {
+        return "This is a temporary `npx` copy of BayChat, which npm deletes on its own — your status line would lose BayChat without warning. Install it for good (`npm install --global baychat`), then run `baychat context-hooks install` from that.";
+    }
+    if (!fs.existsSync(launch.entry))
+        return `BayChat's own entry file (${launch.entry}) could not be found.`;
+    return undefined;
+}
+function describe(state) {
+    const line = state.statusLine === "ours"
+        ? state.wrapped !== undefined
+            ? `  status line: BayChat reader, running your own command: ${state.wrapped}`
+            : "  status line: BayChat reader (you had no status line of your own)"
+        : state.statusLine === "theirs"
+            ? "  status line: yours, not wrapped — context is not being read"
+            : "  status line: none";
+    return [
+        line,
+        `  PreCompact hook: ${state.hooks.PreCompact ? "installed" : "not installed"}`,
+        `  PostCompact hook: ${state.hooks.PostCompact ? "installed" : "not installed"}`,
+    ];
+}
+async function cmdContextHooks(args, deps = {}) {
+    const out = deps.out ?? ((l) => console.log(l));
+    const err = deps.err ?? ((l) => console.error(l));
+    const file = deps.settingsFile ?? (0, claude_settings_1.claudeSettingsPath)();
+    const sub = args[0];
+    if (sub === "status") {
+        const state = (0, claude_settings_1.readClaudeSettingsState)(file);
+        if ("error" in state) {
+            err(state.error);
+            return 1;
+        }
+        out(`Claude Code context reporting (${file}):`);
+        for (const l of describe(state))
+            out(l);
+        out(`  BayChat login: ${(0, config_1.loadDeviceCredentials)() ? "yes" : "no — run `baychat login`"}`);
+        const until = (0, claude_context_1.backoffUntil)();
+        if (until > Date.now())
+            out(`  server: does not accept context reports yet — next try after ${new Date(until).toLocaleTimeString()}`);
+        out(`  problems, if any, are logged in ${path.join((0, claude_context_1.contextDir)(), "errors.log")}`);
+        return 0;
+    }
+    if (sub === "install") {
+        const platform = deps.platform ?? process.platform;
+        if (platform === "win32") {
+            // Claude Code runs a status line through Git Bash or PowerShell on Windows, and the wrapper
+            // re-runs yours through Node's shell (cmd.exe). Until that is proven to give the same
+            // output, a broken status line is too high a price.
+            err("Not on Windows yet: BayChat could not promise your status line would look exactly the same. Nothing was changed.");
+            return 1;
+        }
+        const launch = (deps.launch ?? currentLaunch)();
+        const problem = launchProblem(launch);
+        if (problem) {
+            err(`${problem} Nothing was changed.`);
+            return 1;
+        }
+        let result;
+        try {
+            result = (0, claude_settings_1.editClaudeSettings)(file, (settings) => (0, claude_settings_1.installContextHooks)(settings, launch));
+        }
+        catch (e) {
+            err(e instanceof Error ? e.message : String(e));
+            return 1;
+        }
+        if (result.kind === "unchanged") {
+            out("Already installed — nothing changed.");
+            for (const l of describe(result.state))
+                out(l);
+            return 0;
+        }
+        out(`Installed in ${result.file}:`);
+        for (const l of describe(result.state))
+            out(l);
+        if (result.backup)
+            out(`Your previous settings are copied to ${result.backup}.`);
+        out("");
+        out("Your status line looks exactly as before: your own command still runs, in the same shell, and BayChat reads a copy of its input in the background.");
+        out(`BayChat is called by absolute path (${launch.node}, ${launch.entry}). If that ever goes away, your status line keeps working without it; run this again after moving Node or BayChat.`);
+        out("BayChat now sees how full each Claude Code session's context is, and when it tidies itself.");
+        out("A status line set in a project's .claude/settings.json takes precedence over this one there.");
+        if (!(0, config_1.loadDeviceCredentials)())
+            out("This computer is not logged in to BayChat yet — run `baychat login`, or nothing can be sent.");
+        out("To undo it: baychat context-hooks uninstall");
+        return 0;
+    }
+    if (sub === "uninstall") {
+        let result;
+        try {
+            result = (0, claude_settings_1.editClaudeSettings)(file, claude_settings_1.uninstallContextHooks, undefined, { restoreFromBackups: true });
+        }
+        catch (e) {
+            err(e instanceof Error ? e.message : String(e));
+            return 1;
+        }
+        if (result.kind === "unchanged") {
+            out("Not installed — nothing changed.");
+            return 0;
+        }
+        out(`Removed from ${result.file}. Your status line is your own command again${result.state.statusLine === "none" ? " (you had none)" : ""}.`);
+        out(result.restored === "exact"
+            ? "Restored byte-for-byte: the file is exactly as you had it before install, formatting included."
+            : "Restored semantically: the same settings you had (and any you changed since), but the file was re-formatted — your hand formatting is in the backups beside it.");
+        if (result.backup)
+            out(`The settings as they were a moment ago are copied to ${result.backup}. Backups are never overwritten; the first one (${(0, claude_settings_1.settingsBackupPath)(result.file)}) is your file from before BayChat ever touched it.`);
+        return 0;
+    }
+    err(USAGE);
+    return 1;
+}