glm-coding-router 1.1.1 → 2.0.0

package/dist/runs/store.js

@@ -0,0 +1,186 @@
+import fs from "node:fs";
+import path from "node:path";
+import { logger } from "../core/logging.js";
+/** The one file every run is guaranteed to leave behind, even when it crashed. */
+export const EVENTS_FILE_NAME = "events.jsonl";
+/** `events.jsonl` inside a run directory; exported so every module spells the path the same way. */
+export function eventsFilePath(runDirPath) {
+    return path.join(runDirPath, EVENTS_FILE_NAME);
+}
+/**
+ * Opens `events.jsonl` in append mode. Append mode is the whole crash story:
+ * the file is never truncated, every line reaches the OS as it is appended,
+ * and a killed process leaves at worst one half-written final line — which
+ * `readEvents` tolerates — and never a summary, which is precisely how
+ * `runs show` tells a crashed run from a finished one.
+ *
+ * `append` may throw (disk full, fd gone); the event bus catches subscriber
+ * exceptions, so a broken store degrades to lost lines instead of a dead run.
+ */
+export function openRunStore(runDirPath) {
+    fs.mkdirSync(runDirPath, { recursive: true });
+    const file = eventsFilePath(runDirPath);
+    const fd = fs.openSync(file, "a");
+    let closed = false;
+    return {
+        path: file,
+        append(event) {
+            if (closed) {
+                logger.debug(`run store: append after close on ${file} skipped`);
+                return;
+            }
+            fs.writeSync(fd, JSON.stringify(event) + "\n", null, "utf8");
+        },
+        flush() {
+            if (!closed) {
+                fs.fsyncSync(fd);
+            }
+        },
+        close() {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            try {
+                fs.fsyncSync(fd);
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        },
+    };
+}
+/**
+ * Reconstructs the event stream from a run directory. A malformed line is
+ * skipped, not fatal — a truncated final line is the normal wreckage of a
+ * crash, and the events before it are exactly what survived. A missing file
+ * yields an empty stream for the same reason: history readers must never
+ * throw on the artifacts a crash leaves behind.
+ */
+export function readEvents(runDirPath) {
+    let text;
+    try {
+        text = fs.readFileSync(eventsFilePath(runDirPath), "utf8");
+    }
+    catch {
+        logger.debug(`run store: no events file in ${runDirPath}`);
+        return [];
+    }
+    const events = [];
+    const lines = text.split(/\r?\n/);
+    for (const [index, line] of lines.entries()) {
+        if (line.trim() === "") {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(line);
+            if (isEventLike(parsed)) {
+                events.push(parsed);
+            }
+            else {
+                logger.debug(`run store: line ${index + 1} in ${runDirPath} is not an event`);
+            }
+        }
+        catch {
+            logger.debug(`run store: skipping malformed line ${index + 1} in ${runDirPath}`);
+        }
+    }
+    return events;
+}
+/**
+ * Rebuilds a summary from events alone. The stream's `RunCompleted` numbers
+ * (A0: taken straight from the result message) are authoritative when
+ * present; the event-derived fallbacks exist so a crashed run still gets a
+ * meaningful summary — that is the entire point of rebuilding rather than
+ * trusting a file the crash prevented us from writing.
+ */
+export function summarize(events) {
+    let state = "CRASHED";
+    let turns = 0;
+    let resultTurns = 0;
+    let resultDurationMs = 0;
+    let durationMs = 0;
+    let tokensIn = 0;
+    let tokensOut = 0;
+    let denied = 0;
+    let retries = 0;
+    let validation = "none";
+    const filesChanged = new Set();
+    for (const event of events) {
+        switch (event.type) {
+            case "TurnStarted":
+                turns = Math.max(turns, event.turn);
+                break;
+            case "FileChanged":
+                filesChanged.add(event.path);
+                break;
+            case "ToolDenied":
+                denied += 1;
+                if (validation === "pending") {
+                    validation = "denied";
+                }
+                break;
+            case "ApiRetry":
+                retries += 1;
+                break;
+            case "ValidationStarted":
+                validation = "pending";
+                break;
+            case "ValidationCompleted":
+                validation = event.ok ? "ok" : "failed";
+                break;
+            case "RunCompleted":
+                state = "COMPLETED";
+                // A run can carry MORE THAN ONE result message: a child that hits
+                // --max-turns and continues emits one per segment. Observed live on
+                // 2026-09-20 — RunFailed(max_turns), then two RunCompleted — where
+                // overwriting made a 21-minute, 64-turn run persist as "88s, 5 turns".
+                // Each result describes only its own segment, so accumulate, and let
+                // the derived turn count win when it is larger.
+                resultTurns += event.turns;
+                resultDurationMs += event.durationMs;
+                tokensIn += event.tokensIn;
+                tokensOut += event.tokensOut;
+                break;
+            case "RunFailed":
+                state = "FAILED";
+                break;
+            case "RunCancelled":
+                state = "CANCELLED";
+                break;
+            default:
+                break;
+        }
+    }
+    // The wall clock is the span of the stream; a sum of per-segment result
+    // durations misses the gaps between them. Take whichever is larger so a
+    // long run can never be reported as a short one.
+    const span = events.length > 0
+        ? Date.parse(events[events.length - 1].ts) - Date.parse(events[0].ts)
+        : 0;
+    durationMs = Math.max(resultDurationMs, Number.isFinite(span) && span > 0 ? span : 0);
+    turns = Math.max(turns, resultTurns);
+    return {
+        id: events.length > 0 ? events[0].runId : "",
+        state,
+        turns,
+        durationMs,
+        filesChanged: [...filesChanged],
+        tokensIn,
+        tokensOut,
+        denied,
+        retries,
+        validation,
+    };
+}
+/**
+ * The runtime check is deliberately just "parses and has a `type` string":
+ * fully validating the union at runtime would duplicate the event model, and
+ * a line that passes this check but carries wrong fields is history written
+ * by a future version — dropping it would lose data forever.
+ */
+function isEventLike(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.type === "string");
+}

package/dist/runs/ulid.js

@@ -0,0 +1,112 @@
+import { randomBytes } from "node:crypto";
+/**
+ * ULID generation (specs/v2-architecture.md, Phase B).
+ *
+ * Lexicographic sort order equals chronological order — that property, not
+ * the id's shape, is why runs use ULIDs instead of UUIDs: the run history is
+ * browsed by sorting ids as plain strings.
+ */
+/** Crockford base32: no I, L, O or U, so no visually ambiguous character ever appears in a run id. */
+const ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+const TIME_LEN = 10;
+const RANDOM_BYTES = 10; // 80 bits = exactly 16 base32 chars × 5 bits
+/**
+ * Process-wide monotonic state: the last timestamp used and the random
+ * component it was paired with. Two ids in the same millisecond must still
+ * order, so the second one increments the first one's randomness instead of
+ * drawing fresh bytes.
+ */
+let lastTime = -1;
+let lastRandom = null;
+/**
+ * A 26-char ULID: 10 chars of millisecond timestamp (most significant first)
+ * followed by 16 chars of randomness. Monotonic within the process — same-ms
+ * calls increment the 80-bit random component as a big-endian integer, so
+ * generated ids never collide and always sort after their predecessors.
+ * `now` is injectable so tests can pin and freeze time.
+ */
+export function ulid(now = Date.now) {
+    let time = now();
+    let random = null;
+    // `<=` rather than `===` also absorbs a clock that jumps backwards: reusing
+    // the last timestamp with an incremented random part preserves the invariant
+    // that actually matters — generation order == sort order.
+    if (lastRandom !== null && time <= lastTime) {
+        random = incrementRandom(lastRandom);
+        if (random === null) {
+            // All 80 random bits overflowed (probability 2^-80). Spin to the next
+            // millisecond rather than return a value that sorts before its
+            // predecessor; if the clock never advances (a frozen injected clock),
+            // step the timestamp ourselves — still strictly after the previous id.
+            let spins = 0;
+            do {
+                time = now();
+            } while (time <= lastTime && ++spins < 1_000_000);
+            if (time <= lastTime) {
+                time = lastTime + 1;
+            }
+            random = randomBytes(RANDOM_BYTES);
+        }
+        else {
+            time = lastTime;
+        }
+    }
+    else {
+        random = randomBytes(RANDOM_BYTES);
+    }
+    lastTime = time;
+    lastRandom = random;
+    return encodeTime(time) + encodeRandom(random);
+}
+/** `run_` + a ULID (doc §5): the prefix makes run ids self-describing in logs, dirs and file names. */
+export function runId(now = Date.now) {
+    return `run_${ulid(now)}`;
+}
+/**
+ * A 48-bit millisecond timestamp fits exactly in a double, so plain division
+ * encodes it most-significant-first into 10 chars — which is what makes the
+ * time part of the string sort chronologically.
+ */
+function encodeTime(time) {
+    let chars = "";
+    let remaining = time;
+    for (let count = 0; count < TIME_LEN; count++) {
+        chars = ENCODING[remaining % 32] + chars;
+        remaining = Math.floor(remaining / 32);
+    }
+    return chars;
+}
+/**
+ * 10 bytes → 16 × 5-bit symbols, big-endian. 80 is a multiple of 5, so the
+ * bit funnel drains exactly with nothing left over.
+ */
+function encodeRandom(bytes) {
+    let chars = "";
+    let buffer = 0;
+    let bits = 0;
+    for (const byte of bytes) {
+        buffer = (buffer << 8) | byte;
+        bits += 8;
+        while (bits >= 5) {
+            bits -= 5;
+            chars += ENCODING[(buffer >>> bits) & 31];
+        }
+    }
+    return chars;
+}
+/**
+ * +1 on the 80-bit random component read as a big-endian integer. Returns
+ * null when every bit was already 1 — the caller must then move to a new
+ * millisecond, because a wrapped value would sort before its predecessor.
+ */
+function incrementRandom(bytes) {
+    const next = Uint8Array.from(bytes);
+    for (let index = next.length - 1; index >= 0; index--) {
+        if (next[index] < 0xff) {
+            next[index] += 1;
+            return next;
+        }
+        next[index] = 0;
+    }
+    return null;
+}