baychat 0.23.1 → 0.25.0

package/dist/claude-context.js

@@ -0,0 +1,311 @@
+"use strict";
+// Claude Code's context numbers, read where Claude Code publishes them, and sent to BayChat.
+//
+// Three commands, all installed by `baychat context-hooks install` (see claude-settings.ts) and all run
+// BY CLAUDE CODE, never by a person:
+//
+//   baychat context-statusline                   Started IN THE BACKGROUND by the status-line
+//                                                program (claude-settings.ts), with a copy of the
+//                                                status JSON: notes the numbers, prints nothing.
+//                                                The person's own command runs in the shell, not
+//                                                here, so their line never waits for Node.
+//                                                (`--chain <b64>` is the first release's form, in
+//                                                which this process also ran their command; still
+//                                                honoured until `install` rewrites it.)
+//   baychat context-hook                         PreCompact / PostCompact (async): notes the tidy.
+//   baychat context-flush --claude <id>          Detached, spawned by the two above: sends what
+//                                                was noted, then exits.
+//
+// ── NOTHING HERE MAY SLOW THE STATUS LINE OR THE SESSION ──────────────────────────────────
+//
+// The noting is a few small local file operations and no network; if a report is due, a DETACHED
+// `context-flush` sends it. Diagnostics go to ~/.baychat/context/errors.log, never the terminal.
+// This module loads nothing heavy — `index.ts` routes these three commands here without ever
+// requiring the rest of the CLI (MCP SDK and all).
+//
+// ── WHICH BAYCHAT SESSION IS THIS? ───────────────────────────────────────────────────────
+//
+// Identified, never guessed (the relay's rule, AGENT_RELAY.md): the relay's registry names the
+// Claude session id it recorded at attach, or the transcript shows this Claude session calling
+// BayChat's tools with `session: "<name>"`. Neither → nothing is sent. A device with one live
+// BayChat session is NOT evidence that this Claude window is that session.
+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.FAST_CONTEXT_COMMANDS = exports.defaultClaudeContextDeps = exports.sessionFromTranscript = exports.runContextFlush = exports.identifySession = exports.readState = exports.readAll = exports.logContextError = exports.contextDir = exports.backoffUntil = void 0;
+exports.noteStatus = noteStatus;
+exports.runContextStatusline = runContextStatusline;
+exports.lastCompactBoundary = lastCompactBoundary;
+exports.noteCompactHook = noteCompactHook;
+exports.runContextHook = runContextHook;
+exports.runFastContextCommand = runFastContextCommand;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const claude_context_flush_1 = require("./claude-context-flush");
+const claude_context_state_1 = require("./claude-context-state");
+const claude_settings_1 = require("./claude-settings");
+const context_report_1 = require("./context-report");
+// The state helpers and the sender live beside this file; re-exported so callers and tests have
+// one module to import from.
+var claude_context_state_2 = require("./claude-context-state");
+Object.defineProperty(exports, "backoffUntil", { enumerable: true, get: function () { return claude_context_state_2.backoffUntil; } });
+Object.defineProperty(exports, "contextDir", { enumerable: true, get: function () { return claude_context_state_2.contextDir; } });
+Object.defineProperty(exports, "logContextError", { enumerable: true, get: function () { return claude_context_state_2.logContextError; } });
+Object.defineProperty(exports, "readAll", { enumerable: true, get: function () { return claude_context_state_2.readAll; } });
+Object.defineProperty(exports, "readState", { enumerable: true, get: function () { return claude_context_state_2.readState; } });
+var claude_context_flush_2 = require("./claude-context-flush");
+Object.defineProperty(exports, "identifySession", { enumerable: true, get: function () { return claude_context_flush_2.identifySession; } });
+Object.defineProperty(exports, "runContextFlush", { enumerable: true, get: function () { return claude_context_flush_2.runContextFlush; } });
+Object.defineProperty(exports, "sessionFromTranscript", { enumerable: true, get: function () { return claude_context_flush_2.sessionFromTranscript; } });
+function defaultStartFlush(sid) {
+    // `process.argv[1]` is the CLI entry that is running now; `execArgv` carries a loader such as
+    // tsx when there is one. No PATH lookup, no shell.
+    const child = (0, child_process_1.spawn)(process.execPath, [...process.execArgv, process.argv[1], "context-flush", "--claude", sid], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+        env: process.env,
+    });
+    child.on("error", (err) => (0, claude_context_state_1.logContextError)(`could not start context-flush: ${(0, claude_context_state_1.errText)(err)}`));
+    child.unref();
+}
+function defaultRunChained(command, input) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            // The person's command, in a shell, exactly as Claude Code would have run it (`sh -c` on
+            // macOS and Linux). stdout and stderr are OURS, inherited — not piped and re-written — so
+            // nothing we do can reorder, re-encode or delay a byte of what it prints.
+            child = (0, child_process_1.spawn)(command, { shell: true, stdio: ["pipe", "inherit", "inherit"], env: process.env });
+        }
+        catch (err) {
+            (0, claude_context_state_1.logContextError)(`your status-line command could not start: ${(0, claude_context_state_1.errText)(err)}`);
+            return resolve(0);
+        }
+        const forward = (signal) => () => child.kill(signal);
+        const handlers = ["SIGTERM", "SIGINT", "SIGHUP"].map((sig) => [sig, forward(sig)]);
+        for (const [sig, fn] of handlers)
+            process.once(sig, fn);
+        child.on("error", (err) => (0, claude_context_state_1.logContextError)(`your status-line command failed: ${(0, claude_context_state_1.errText)(err)}`));
+        child.stdin?.on("error", () => {
+            /* a command that does not read its input closes the pipe early — that is its right */
+        });
+        child.stdin?.end(input);
+        child.on("close", (code, signal) => {
+            for (const [sig, fn] of handlers)
+                process.removeListener(sig, fn);
+            resolve(code ?? (signal ? 1 : 0));
+        });
+    });
+}
+const defaultClaudeContextDeps = () => ({
+    now: Date.now,
+    env: process.env,
+    startFlush: defaultStartFlush,
+    runChained: defaultRunChained,
+});
+exports.defaultClaudeContextDeps = defaultClaudeContextDeps;
+// ─── The status line ─────────────────────────────────────────────────────────
+/** `autoCompactWindow` from Claude Code's settings, or the env var that overrides it. */
+function autoCompactOverride(env) {
+    const fromEnv = Number(env.CLAUDE_CODE_AUTO_COMPACT_WINDOW);
+    if (Number.isFinite(fromEnv) && fromEnv > 0)
+        return fromEnv;
+    try {
+        const settings = JSON.parse(fs.readFileSync((0, claude_settings_1.claudeSettingsPath)(), "utf8"));
+        const v = settings.autoCompactWindow;
+        return typeof v === "number" && v > 0 ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Note one status-line sample. Local files only, no network. Returns true when a flush was started.
+ * Throws only on a programming error; the caller logs it.
+ */
+function noteStatus(raw, deps) {
+    let status;
+    try {
+        status = JSON.parse(raw);
+    }
+    catch {
+        return false; // not ours to judge; the person's command already got the same input
+    }
+    const sid = (0, claude_context_state_1.safeId)(status?.session_id);
+    const sample = (0, context_report_1.claudeUsageFromStatus)(status);
+    if (!sid || !sample)
+        return false;
+    const autoCompactAt = (0, context_report_1.claudeAutoCompactAt)(sample.size, autoCompactOverride(deps.env));
+    const now = deps.now();
+    const state = (0, claude_context_state_1.readState)(sid);
+    if (state.unidentifiedAt && now - state.unidentifiedAt < claude_context_state_1.UNIDENTIFIED_RETRY_MS)
+        return false;
+    if (!(0, context_report_1.usageDue)(state.lastQueued, { ...sample, autoCompactAt }, now))
+        return false;
+    (0, claude_context_state_1.enqueue)(state, { runtime: "claude-code", event: "usage", used: sample.used, size: sample.size, autoCompactAt, source: "exact" });
+    state.lastQueued = { ...sample, autoCompactAt, at: now };
+    if (typeof status.transcript_path === "string")
+        state.transcriptPath = status.transcript_path;
+    (0, claude_context_state_1.writeState)(state);
+    if ((0, claude_context_state_1.backoffUntil)() > now)
+        return false;
+    deps.startFlush(sid);
+    return true;
+}
+/**
+ * `baychat context-statusline [--chain <b64>]`. Returns the chained command's exit code, so the
+ * status line behaves exactly as the person's own command did.
+ */
+async function runContextStatusline(argv, stdin = process.stdin, deps = (0, exports.defaultClaudeContextDeps)()) {
+    const i = argv.indexOf("--chain");
+    const encoded = i >= 0 ? argv[i + 1] : undefined;
+    const chained = encoded !== undefined ? (0, claude_settings_1.decodeChain)(encoded) : undefined;
+    if (encoded !== undefined && chained === undefined) {
+        (0, claude_context_state_1.logContextError)("the status-line command BayChat wraps could not be decoded — run `baychat context-hooks uninstall` and install again");
+    }
+    const raw = await (0, claude_context_state_1.readAll)(stdin);
+    // Theirs first: nothing below may delay the line they see.
+    const theirs = chained !== undefined ? deps.runChained(chained, raw) : Promise.resolve(0);
+    try {
+        noteStatus(raw, deps);
+    }
+    catch (err) {
+        (0, claude_context_state_1.logContextError)(`status line: ${(0, claude_context_state_1.errText)(err)}`);
+    }
+    return theirs;
+}
+const num = (v) => (typeof v === "number" && Number.isFinite(v) && v >= 0 ? Math.round(v) : undefined);
+const trig = (v) => (v === "auto" || v === "manual" ? v : undefined);
+/**
+ * The last `compact_boundary` in a Claude transcript.
+ *
+ * Measured on a real transcript (Claude Code 2.1.282): `{"type":"system","subtype":
+ * "compact_boundary", "timestamp": …, "compactMetadata": {"trigger":"manual","preTokens":534691,
+ * "postTokens":20936, …}}`. The snake_case spelling (`compact_metadata.pre_tokens`) that some
+ * write-ups describe is accepted too.
+ */
+function lastCompactBoundary(transcriptText) {
+    const lines = transcriptText.split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        if (!line.includes("compact_boundary"))
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry.subtype !== "compact_boundary")
+            continue;
+        const meta = (entry.compactMetadata ?? entry.compact_metadata);
+        const at = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : NaN;
+        return {
+            trigger: trig(meta?.trigger),
+            preTokens: num(meta?.preTokens ?? meta?.pre_tokens),
+            postTokens: num(meta?.postTokens ?? meta?.post_tokens),
+            ...(Number.isFinite(at) ? { at } : {}),
+        };
+    }
+    return undefined;
+}
+/** Note one PreCompact / PostCompact. Returns true when a flush was started. */
+function noteCompactHook(raw, deps) {
+    let input;
+    try {
+        input = JSON.parse(raw);
+    }
+    catch {
+        return false;
+    }
+    const sid = (0, claude_context_state_1.safeId)(input?.session_id);
+    const name = input?.hook_event_name;
+    if (!sid || (name !== "PreCompact" && name !== "PostCompact"))
+        return false;
+    const state = (0, claude_context_state_1.readState)(sid);
+    const trigger = trig(input.trigger);
+    const transcript = typeof input.transcript_path === "string" ? input.transcript_path : state.transcriptPath;
+    if (transcript)
+        state.transcriptPath = transcript;
+    const base = { runtime: "claude-code", source: "exact", ...(trigger ? { trigger } : {}) };
+    if (name === "PreCompact") {
+        const before = state.lastQueued?.used;
+        (0, claude_context_state_1.enqueue)(state, { ...base, event: "compact_start", ...(before !== undefined ? { beforeTokens: before } : {}) });
+    }
+    else {
+        const boundary = transcript ? lastCompactBoundary((0, claude_context_state_1.readTail)(transcript, claude_context_state_1.BOUNDARY_TAIL_BYTES)) : undefined;
+        const fresh = boundary && (boundary.at === undefined || deps.now() - boundary.at <= claude_context_state_1.BOUNDARY_FRESH_MS) ? boundary : undefined;
+        const before = fresh?.preTokens ?? state.lastQueued?.used;
+        (0, claude_context_state_1.enqueue)(state, {
+            ...base,
+            ...(trigger ? {} : fresh?.trigger ? { trigger: fresh.trigger } : {}),
+            event: "compact_end",
+            ...(before !== undefined ? { beforeTokens: before } : {}),
+            ...(fresh?.postTokens !== undefined ? { afterTokens: fresh.postTokens } : {}),
+        });
+        // The window was just rewritten: the next status line's number must go out at once.
+        state.lastQueued = undefined;
+    }
+    (0, claude_context_state_1.writeState)(state);
+    if ((0, claude_context_state_1.backoffUntil)() > deps.now())
+        return false;
+    deps.startFlush(sid);
+    return true;
+}
+/** `baychat context-hook`. Prints nothing and always exits 0: exit 2 would BLOCK a compaction. */
+async function runContextHook(stdin = process.stdin, deps = (0, exports.defaultClaudeContextDeps)()) {
+    try {
+        noteCompactHook(await (0, claude_context_state_1.readAll)(stdin), deps);
+    }
+    catch (err) {
+        (0, claude_context_state_1.logContextError)(`compaction hook: ${(0, claude_context_state_1.errText)(err)}`);
+    }
+    return 0;
+}
+/** The three commands this module owns, for `index.ts`'s fast dispatch. */
+exports.FAST_CONTEXT_COMMANDS = new Set(["context-statusline", "context-hook", "context-flush"]);
+async function runFastContextCommand(command, argv) {
+    switch (command) {
+        case "context-statusline":
+            return runContextStatusline(argv);
+        case "context-hook":
+            return runContextHook();
+        case "context-flush":
+            return (0, claude_context_flush_1.runContextFlush)(argv);
+        default:
+            return 0;
+    }
+}