baychat 0.23.1 → 0.25.0

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;
+}

package/dist/context-report.js

@@ -0,0 +1,307 @@
+"use strict";
+// How full is an attached agent's context — measured on this machine, reported to BayChat.
+//
+// Three sources feed this module, and each is the runtime's OWN number, never a guess:
+//
+//   • Claude Code — the status-line JSON (`context_window.*`) and the PreCompact/PostCompact
+//     hooks, read by `claude-context.ts` in a process of its own.
+//   • Codex — the `token_count` events in the session's rollout JSONL, tailed by the relay
+//     (`relay/codex-context.ts`).
+//   • ACP agents (dsh, Cursor) — the standard `session/update` → `usage_update { used, size }`,
+//     which the relay used to throw away (`relay/acp/client.ts`).
+//
+// All three become ONE body (contract §7) and go out through ONE function. What this module
+// guarantees, and what every caller relies on:
+//
+//   1. IT NEVER THROWS INTO A CALLER. A context report is a nicety riding beside the relay's
+//      real job (waking sessions); a failure here must never cost a delivery. Failures are
+//      LOGGED — never swallowed — and repeated failures are logged once, not once per sample.
+//   2. IT IS CHEAP. "usage" is throttled: at most one every 15 s per session, sooner only when
+//      the fill moved by a whole percentage point. Compaction events are never throttled.
+//   3. IT IS HARMLESS AGAINST A SERVER THAT DOES NOT HAVE THE ROUTE YET. A 404 with no error
+//      `code` is Express's "no such route" — phase 2 not deployed — and the reporter goes quiet
+//      for an hour instead of sending a doomed request every 15 seconds. A 404 WITH a code
+//      (`SESSION_NOT_FOUND`) is a real refusal about one session and backs off only that one.
+//
+// THE CREDENTIAL. The relay holds a DEVICE credential (`bay_u_…`); a session agent has no token
+// of its own (REMOTE_MCP_SESSIONS.md: "An agent with a sessionKey has no apiToken"). So a device
+// posts to the device surface and names the session, exactly as `/approvals` and the relay's
+// command replies do; an agent token (a standing agent) posts to the agent surface as itself.
+// Recorded in the contract's CHANGES, 2026-09-26.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextReporter = exports.SESSION_REFUSED_BACKOFF_MS = exports.NOT_DEPLOYED_BACKOFF_MS = exports.USAGE_MIN_STEP_PERCENT = exports.USAGE_MIN_INTERVAL_MS = void 0;
+exports.usageDue = usageDue;
+exports.claudeUsageFromStatus = claudeUsageFromStatus;
+exports.claudeAutoCompactAt = claudeAutoCompactAt;
+exports.codexUsageFromTokenCount = codexUsageFromTokenCount;
+exports.codexAutoCompactAt = codexAutoCompactAt;
+exports.acpUsageFromUpdate = acpUsageFromUpdate;
+exports.isDeviceCredential = isDeviceCredential;
+exports.postContextEvent = postContextEvent;
+const api_1 = require("./api");
+// ─── Throttle ────────────────────────────────────────────────────────────────
+exports.USAGE_MIN_INTERVAL_MS = 15_000;
+exports.USAGE_MIN_STEP_PERCENT = 1;
+/** How long a server without the route is left alone. */
+exports.NOT_DEPLOYED_BACKOFF_MS = 60 * 60_000;
+/** How long one session the server refused (ended, not live) is left alone. */
+exports.SESSION_REFUSED_BACKOFF_MS = 5 * 60_000;
+/**
+ * Is this usage sample worth a request?
+ *
+ * Yes when nothing was sent yet, when the window itself changed (a model switch), or when the
+ * fill moved by a whole percentage point. Otherwise yes only once 15 s have passed AND the
+ * number actually moved — a session sitting idle at 43 % sends nothing at all.
+ */
+function usageDue(prev, next, now) {
+    if (!prev)
+        return true;
+    if (prev.size !== next.size || prev.autoCompactAt !== next.autoCompactAt)
+        return true;
+    const step = next.size > 0 ? (Math.abs(next.used - prev.used) / next.size) * 100 : 0;
+    if (step >= exports.USAGE_MIN_STEP_PERCENT)
+        return true;
+    return next.used !== prev.used && now - prev.at >= exports.USAGE_MIN_INTERVAL_MS;
+}
+// ─── Normalisers: one per source ─────────────────────────────────────────────
+const isRecord = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+const count = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? Math.round(v) : undefined;
+/**
+ * Claude Code's status-line JSON → a sample, or null when it carries none yet.
+ *
+ * `current_usage` is the exact per-call count and is preferred; `used` is input + cache writes +
+ * cache reads — the same input-only formula Claude Code's own `used_percentage` uses (docs:
+ * "It does not include output_tokens"). It is null before the first API call and again right
+ * after `/compact`, and then `used_percentage` is the fallback. Neither → null, never a zero:
+ * "no number yet" and "empty" are different claims.
+ */
+function claudeUsageFromStatus(status) {
+    if (!isRecord(status) || !isRecord(status.context_window))
+        return null;
+    const cw = status.context_window;
+    const size = count(cw.context_window_size);
+    if (!size)
+        return null;
+    const cu = cw.current_usage;
+    if (isRecord(cu)) {
+        const parts = [cu.input_tokens, cu.cache_creation_input_tokens, cu.cache_read_input_tokens].map(count);
+        if (parts.every((p) => p !== undefined))
+            return { used: parts.reduce((a, b) => a + b, 0), size };
+    }
+    const pct = typeof cw.used_percentage === "number" && Number.isFinite(cw.used_percentage) ? cw.used_percentage : undefined;
+    if (pct === undefined)
+        return null;
+    return { used: Math.round((Math.max(0, pct) / 100) * size), size };
+}
+/**
+ * Where Claude Code will compact on its own.
+ *
+ * Documented (model-config, "Default auto-compact thresholds"): an explicit window —
+ * `CLAUDE_CODE_AUTO_COMPACT_WINDOW`, else the `autoCompactWindow` setting — capped at the model's
+ * window; otherwise about 967K on a native 1M window and the window itself below that.
+ */
+function claudeAutoCompactAt(size, override) {
+    if (override && override > 0)
+        return Math.min(Math.round(override), size);
+    return size >= 1_000_000 ? 967_000 : size;
+}
+/**
+ * A Codex rollout `event_msg` whose payload is `token_count` → a sample.
+ *
+ * `info.last_token_usage` is the LAST request — what is in the window now. `total_token_usage`
+ * is cumulative across the whole thread (13M on a real rollout against a 258K window) and must
+ * never be used; neither must `codex exec --json`'s totals, which are cumulative too.
+ */
+function codexUsageFromTokenCount(payload) {
+    if (!isRecord(payload) || payload.type !== "token_count" || !isRecord(payload.info))
+        return null;
+    const last = payload.info.last_token_usage;
+    const size = count(payload.info.model_context_window);
+    if (!isRecord(last) || !size)
+        return null;
+    const total = count(last.total_tokens);
+    const used = total ?? (count(last.input_tokens) ?? 0) + (count(last.output_tokens) ?? 0);
+    return { used, size };
+}
+/** Codex compacts on its own at about 90 % of the window (contract §7). */
+function codexAutoCompactAt(size) {
+    return Math.floor(size * 0.9);
+}
+/** ACP `usage_update { used, size }` → a sample. */
+function acpUsageFromUpdate(update) {
+    if (!isRecord(update))
+        return null;
+    const used = count(update.used);
+    const size = count(update.size);
+    return used !== undefined && size ? { used, size } : null;
+}
+/** A device credential names the session; an agent token IS the agent. */
+function isDeviceCredential(auth) {
+    return auth.token.startsWith("bay_u_");
+}
+/**
+ * POST one event. NEVER THROWS — every failure is an outcome.
+ *
+ * `session` is required on the device route (a device owns several sessions and the server must
+ * never pick one for us); on the agent route it is not sent at all.
+ */
+async function postContextEvent(auth, session, event, request = api_1.apiRequest) {
+    try {
+        if (isDeviceCredential(auth)) {
+            if (!session)
+                return { kind: "refused", status: 0, message: "no session named for a device report" };
+            await request(auth, "POST", "/api/device-api/context", { session, ...event });
+        }
+        else {
+            await request(auth, "POST", "/api/agent-api/context", event);
+        }
+        return { kind: "sent" };
+    }
+    catch (err) {
+        if (err instanceof api_1.ApiError) {
+            // Express's own 404 carries no JSON envelope, so no code: the route does not exist here.
+            if (err.status === 404 && !err.code)
+                return { kind: "not-deployed" };
+            if (err.status >= 400 && err.status < 500 && err.status !== 429) {
+                return { kind: "refused", status: err.status, code: err.code, message: err.message };
+            }
+        }
+        return { kind: "failed", message: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * Throttles, sends and backs off, per session, in the relay's process.
+ *
+ * `report` returns immediately and never throws; `idle()` resolves when everything queued has
+ * been attempted (tests, and a clean shutdown).
+ */
+class ContextReporter {
+    deps;
+    sessions = new Map();
+    notDeployedUntil = 0;
+    closed = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    now() {
+        return (this.deps.now ?? Date.now)();
+    }
+    state(session) {
+        let s = this.sessions.get(session);
+        if (!s) {
+            s = { chain: Promise.resolve() };
+            this.sessions.set(session, s);
+        }
+        return s;
+    }
+    report(session, event) {
+        try {
+            if (this.closed)
+                return;
+            const s = this.state(session);
+            if (event.event === "usage") {
+                if (event.used === undefined || event.size === undefined)
+                    return;
+                const sample = { used: event.used, size: event.size, autoCompactAt: event.autoCompactAt };
+                if (!usageDue(s.sent, sample, this.now())) {
+                    this.holdTrailing(session, s, event);
+                    return;
+                }
+                s.timer?.cancel();
+                s.timer = undefined;
+                s.trailing = undefined;
+                // Counted as sent when it is QUEUED, so a burst of samples cannot all pass the throttle
+                // while the first request is still in flight.
+                s.sent = { ...sample, at: this.now() };
+            }
+            else {
+                // A compaction resets the baseline: the next usage is the "after" number and must go.
+                s.sent = undefined;
+                s.trailing = undefined;
+                s.timer?.cancel();
+                s.timer = undefined;
+            }
+            this.enqueue(session, s, event);
+        }
+        catch (err) {
+            this.deps.log(`context: could not queue a report for ${session}: ${errText(err)}`);
+        }
+    }
+    /** Resolves once every queued send has been attempted. */
+    async idle() {
+        await Promise.all([...this.sessions.values()].map((s) => s.chain));
+    }
+    close() {
+        this.closed = true;
+        for (const s of this.sessions.values())
+            s.timer?.cancel();
+    }
+    holdTrailing(session, s, event) {
+        s.trailing = event;
+        if (s.timer || !s.sent)
+            return;
+        const wait = Math.max(0, s.sent.at + exports.USAGE_MIN_INTERVAL_MS - this.now());
+        const setTimer = this.deps.setTimer ??
+            ((fn, ms) => {
+                const t = setTimeout(fn, ms);
+                t.unref?.();
+                return { cancel: () => clearTimeout(t) };
+            });
+        s.timer = setTimer(() => {
+            s.timer = undefined;
+            const held = s.trailing;
+            s.trailing = undefined;
+            // Re-run through `report` so the throttle is the one rule, not a second copy of it.
+            if (held)
+                this.report(session, held);
+        }, wait);
+    }
+    enqueue(session, s, event) {
+        s.chain = s.chain.then(() => this.send(session, s, event)).catch((err) => {
+            this.deps.log(`context: report for ${session} failed unexpectedly: ${errText(err)}`);
+        });
+    }
+    async send(session, s, event) {
+        const now = this.now();
+        if (now < this.notDeployedUntil)
+            return;
+        if (s.refusedUntil && now < s.refusedUntil)
+            return;
+        const auth = this.deps.auth();
+        if (!auth)
+            return;
+        const outcome = await postContextEvent(auth, session, event, this.deps.request ?? api_1.apiRequest);
+        switch (outcome.kind) {
+            case "sent":
+                if (s.lastFailure)
+                    this.deps.log(`context: reports for ${session} are going through again`);
+                s.lastFailure = undefined;
+                return;
+            case "not-deployed":
+                this.notDeployedUntil = this.now() + exports.NOT_DEPLOYED_BACKOFF_MS;
+                this.deps.log("context: this BayChat server does not accept context reports yet — trying again in an hour");
+                return;
+            case "refused": {
+                s.refusedUntil = this.now() + exports.SESSION_REFUSED_BACKOFF_MS;
+                // The sample that was refused was never recorded by the server; the next one must go.
+                s.sent = undefined;
+                this.logOnce(s, `context: BayChat refused a report for ${session} (${outcome.message}${outcome.code ? `, ${outcome.code}` : ""}) — pausing that session's reports for 5 minutes`);
+                return;
+            }
+            case "failed":
+                s.sent = undefined;
+                this.logOnce(s, `context: could not report for ${session} (${outcome.message}) — will retry with the next change`);
+                return;
+        }
+    }
+    logOnce(s, line) {
+        if (s.lastFailure === line)
+            return;
+        s.lastFailure = line;
+        this.deps.log(line);
+    }
+}
+exports.ContextReporter = ContextReporter;
+function errText(err) {
+    return err instanceof Error ? err.message : String(err);
+}