baychat 0.34.1 → 0.35.0

package/dist/relay/codex-log.js

@@ -0,0 +1,260 @@
+"use strict";
+// What a relay-run Codex session is doing, written down where its owner can watch it (2026-10-23).
+//
+// A Codex the relay runs has no terminal: the TUI that used to show its commands, diffs and
+// answers is gone, and the room only sees what Codex chooses to say. So the runner writes a
+// plain-text log per session — `~/.baychat/codex-logs/<session>.log`, 0600 — and
+// `baychat relay log <session> [-f]` shows it (in Node, so it works the same on Windows). A
+// session started from the app also gets a `bc-<name>` tmux window running exactly that command,
+// where tmux exists, so "attach and watch" still works.
+//
+// WHAT IS WRITTEN, AND WHAT IS NOT. Turn start (who woke it, how many messages, under which
+// policy) and end (status, duration, tokens); what Codex said; each command with its folder, exit
+// code and last 20 lines of output; each file change as paths, kinds and +/- counts; each card
+// asked, answered or timed out; MCP calls as `server.tool` only — NEVER their arguments, which can
+// carry message text and tokens; errors. Every line is stripped of ANSI escapes and C0/C1 control
+// characters first: this is text Codex (and so, indirectly, anyone in the room) produced, and a
+// terminal reading the log must not be steered by it.
+//
+// BOUNDED. At 5 MB the log is rotated to `<session>.log.1` (one generation kept).
+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.CodexSessionLog = void 0;
+exports.codexLogDir = codexLogDir;
+exports.codexLogFile = codexLogFile;
+exports.cleanLogText = cleanLogText;
+exports.showCodexLog = showCodexLog;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../config");
+const MAX_BYTES = 5 * 1024 * 1024;
+const OUTPUT_TAIL_LINES = 20;
+const TEXT_MAX = 4_000;
+function codexLogDir() {
+    return path.join((0, config_1.configDir)(), "codex-logs");
+}
+/** A session name as a file name: never a path, never hidden, never empty. */
+function codexLogFile(session, dir = codexLogDir()) {
+    const safe = session.replace(/[^A-Za-z0-9._-]/g, "_").replace(/^\.+/, "_").slice(0, 80) || "session";
+    return path.join(dir, `${safe}.log`);
+}
+// ANSI CSI/OSC sequences, then every C0 control but tab and newline, DEL and C1.
+const ANSI = /\u001B\[[0-?]*[ -/]*[@-~]|\u001B\][^\u0007\u001B]*(?:\u0007|\u001B\\)?|\u001B[@-Z\\-_]/g;
+const CONTROL = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g;
+/** Text safe to put in front of a terminal: escapes and control characters removed. */
+function cleanLogText(text) {
+    return text.replace(ANSI, "").replace(/\r\n?/g, "\n").replace(CONTROL, "");
+}
+const clip = (text, max) => (text.length <= max ? text : `${text.slice(0, max - 1)}…`);
+const str = (v) => (typeof v === "string" ? v : "");
+class CodexSessionLog {
+    file;
+    maxBytes;
+    now;
+    tokens;
+    startedAt = 0;
+    broken = false;
+    constructor(session, opts = {}) {
+        this.file = codexLogFile(session, opts.dir);
+        this.maxBytes = opts.maxBytes ?? MAX_BYTES;
+        this.now = opts.now ?? (() => new Date());
+    }
+    /** One entry. Continuation lines are indented so an entry can never pass for another. NEVER THROWS. */
+    line(text) {
+        if (this.broken)
+            return;
+        const body = clip(cleanLogText(text), TEXT_MAX).replace(/\n/g, "\n    ");
+        const entry = `${this.now().toISOString()} ${body}\n`;
+        try {
+            fs.mkdirSync(path.dirname(this.file), { recursive: true, mode: 0o700 });
+            let size = 0;
+            try {
+                size = fs.statSync(this.file).size;
+            }
+            catch {
+                // Not there yet.
+            }
+            if (size + entry.length > this.maxBytes && size > 0)
+                fs.renameSync(this.file, `${this.file}.1`);
+            fs.appendFileSync(this.file, entry, { mode: 0o600 });
+        }
+        catch (err) {
+            // A disk that will not take the log must not take the turn with it. Said once, to stderr.
+            this.broken = true;
+            process.stderr.write(`baychat relay: cannot write ${this.file} — ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+    }
+    turnStart(who, addressed, policy) {
+        this.startedAt = this.now().getTime();
+        this.tokens = undefined;
+        this.line(`── turn: ${addressed} message(s) from ${who} — ${policy}`);
+    }
+    turnEnd(status) {
+        const seconds = this.startedAt ? Math.round((this.now().getTime() - this.startedAt) / 1000) : 0;
+        this.line(`── turn ${status} after ${seconds}s${this.tokens !== undefined ? `, ${this.tokens} tokens in total on this thread` : ""}`);
+    }
+    /** A codex app-server notification, as far as the log cares. Never throws. */
+    notification(method, params) {
+        try {
+            this.describe(method, params);
+        }
+        catch {
+            // A shape this log did not expect: the turn matters more than the line.
+        }
+    }
+    describe(method, params) {
+        if (method === "thread/tokenUsage/updated") {
+            const usage = (params.tokenUsage ?? {});
+            const total = Number(usage.total?.totalTokens);
+            if (Number.isFinite(total))
+                this.tokens = total;
+            return;
+        }
+        if (method === "error") {
+            const error = (params.error ?? params);
+            this.line(`error: ${str(error.message) || "Codex reported an error"}`);
+            return;
+        }
+        if (method !== "item/completed")
+            return;
+        const item = (params.item ?? {});
+        switch (item.type) {
+            case "agentMessage":
+                if (str(item.text))
+                    this.line(`codex: ${str(item.text)}`);
+                return;
+            case "commandExecution": {
+                const output = str(item.aggregatedOutput).replace(/\n+$/, "").split("\n").slice(-OUTPUT_TAIL_LINES).join("\n");
+                const exit = typeof item.exitCode === "number" ? `exit ${item.exitCode}` : str(item.status) || "ended";
+                this.line(`ran: ${str(item.command)}  (in ${str(item.cwd)}) → ${exit}${output ? `\n${output}` : ""}`);
+                return;
+            }
+            case "fileChange": {
+                const changes = Array.isArray(item.changes) ? item.changes : [];
+                const parts = changes.map((c) => {
+                    const change = (c ?? {});
+                    const kind = str((change.kind ?? {}).type) || "update";
+                    const lines = str(change.diff).replace(/\n$/, "").split("\n").filter((l, i, all) => !(all.length === 1 && l === ""));
+                    // In 0.160 an add's or a delete's `diff` is the whole file, unprefixed: every line counts.
+                    const plus = kind === "add" ? lines.length : kind === "delete" ? 0 : lines.filter((l) => l.startsWith("+") && !l.startsWith("+++")).length;
+                    const minus = kind === "delete" ? lines.length : kind === "add" ? 0 : lines.filter((l) => l.startsWith("-") && !l.startsWith("---")).length;
+                    return `${kind} ${str(change.path)} (+${plus}/-${minus})`;
+                });
+                this.line(`files ${str(item.status) || "changed"}: ${parts.join(", ") || "(none listed)"}`);
+                return;
+            }
+            case "mcpToolCall":
+                // Server and tool only: the arguments can carry message text and secrets.
+                this.line(`tool: ${str(item.server)}.${str(item.tool)} → ${str(item.status) || "done"}`);
+                return;
+            default:
+                return;
+        }
+    }
+}
+exports.CodexSessionLog = CodexSessionLog;
+/**
+ * `baychat relay log <session> [-f]`: print the session's log, and with `follow` keep printing
+ * what is added (a rotation starts over at the new file). Resolves when not following, or when
+ * `signal` aborts. Reads by polling — the same on every platform, including Windows.
+ */
+async function showCodexLog(session, opts) {
+    const write = opts.write ?? ((text) => void process.stdout.write(text));
+    const file = codexLogFile(session, opts.dir);
+    const tailBytes = opts.tailBytes ?? 64 * 1024;
+    let position = 0;
+    const readFrom = (from) => {
+        let fd;
+        try {
+            const size = fs.statSync(file).size;
+            if (size < from)
+                from = 0; // rotated: the new file from its start
+            if (size === from)
+                return from;
+            fd = fs.openSync(file, "r");
+            const buffer = Buffer.alloc(size - from);
+            fs.readSync(fd, buffer, 0, buffer.length, from);
+            write(cleanLogText(buffer.toString("utf8")));
+            return size;
+        }
+        catch {
+            return from;
+        }
+        finally {
+            if (fd !== undefined)
+                fs.closeSync(fd);
+        }
+    };
+    let size = -1;
+    try {
+        size = fs.statSync(file).size;
+    }
+    catch {
+        if (!opts.follow) {
+            write(`No log for "${session}" on this computer yet (${file}).\n`);
+            return 1;
+        }
+        write(`Waiting for "${session}" to write its log (${file})…\n`);
+    }
+    if (size >= 0) {
+        // Start a whole line in, a screenful or so from the end.
+        position = Math.max(0, size - tailBytes);
+        if (position > 0) {
+            const head = Buffer.alloc(Math.min(4096, size - position));
+            const fd = fs.openSync(file, "r");
+            try {
+                fs.readSync(fd, head, 0, head.length, position);
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            const newline = head.indexOf(0x0a);
+            position += newline >= 0 ? newline + 1 : 0;
+        }
+        position = readFrom(position);
+    }
+    if (!opts.follow)
+        return 0;
+    await new Promise((resolve) => {
+        const timer = setInterval(() => {
+            position = readFrom(position);
+        }, opts.pollMs ?? 500);
+        opts.signal?.addEventListener("abort", () => {
+            clearInterval(timer);
+            resolve();
+        });
+    });
+    return 0;
+}