parawatch 0.3.17 → 0.3.18

package/dist/adapters/codex.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { applyStall } from "./claudeCode.js";
-import { isObj, logActivity, oneLine, readHeadLines, readHeadText, readTailLines, str, textValues } from "./jsonl.js";
+import { isObj, lastLineWith, logActivity, oneLine, readHeadLines, readHeadText, readTailLines, str, textValues } from "./jsonl.js";
 const HEAD_BYTES = 128 * 1024;
 const TAIL_BYTES = 256 * 1024;
 // prompts can sit behind several inline base64 images on one line; read this far only when needed
@@ -85,6 +85,19 @@ export function codexSettings(lines) {
     const options = [sandbox ? (SANDBOXES[sandbox] ?? sandbox) : undefined, approval ? (APPROVALS[approval] ?? approval) : undefined].filter((x) => !!x);
     return { model: str(tc.model), effort: str(tc.effort) ?? str(tc.reasoning_effort) ?? (isObj(tc.collaboration_mode) && isObj(tc.collaboration_mode.settings) ? str(tc.collaboration_mode.settings.reasoning_effort) : undefined), options: options.length ? options : undefined };
 }
+/** What the last turn ran with, per log: a long log is searched once, then only where it grew. */
+const middle = new Map();
+/** The settings of a log whose last `turn_context` sits between its head and tail. */
+export function settingsInMiddle(file) {
+    const size = fs.statSync(file).size;
+    const known = middle.get(file);
+    if (known && known.size === size)
+        return known.settings;
+    const found = lastLineWith(file, '"type":"turn_context"', known && known.size < size ? Math.max(0, known.size - 64) : 0);
+    const settings = found ? codexSettings([found]) : (known?.settings ?? {});
+    middle.set(file, { size, settings });
+    return settings;
+}
 export function readCodexLog(head, tail, rawHead) {
     const meta = head.map(payload).find((p, i) => p && isObj(head[i]) && head[i].type === "session_meta");
     const id = str(meta?.id) ?? str(meta?.session_id) ?? "unknown";
@@ -188,6 +201,8 @@ export const codex = {
                     if (fs.statSync(file).mtimeMs < opts.sinceMs)
                         continue;
                     const run = { ...readCodexLog(readHeadLines(file, HEAD_BYTES), readTailLines(file, TAIL_BYTES), () => readHeadText(file, RAW_HEAD_BYTES)), source: file };
+                    if (!run.model)
+                        Object.assign(run, settingsInMiddle(file));
                     run.activity = logActivity(file, opts.now);
                     applyStall(run, undefined, opts.now);
                     runs.push(run);

package/dist/adapters/jsonl.js

@@ -141,4 +141,70 @@ export function logActivity(file, now) {
     seen.set(file, entry);
     return activeMinutes(entry.times, now);
 }
+/**
+ * The last line holding `marker` in the part of a file after byte `from`, parsed, searching back
+ * from the end a megabyte at a time. For a record written once a turn that can sit anywhere in a
+ * log of many megabytes, between what the head and tail readings cover.
+ */
+export function lastLineWith(file, marker, from = 0, maxLine = 4 * 1024 * 1024) {
+    const size = fs.statSync(file).size;
+    const needle = Buffer.from(marker);
+    const CHUNK = 1024 * 1024;
+    const fd = fs.openSync(file, "r");
+    try {
+        let end = size;
+        while (end > from) {
+            const start = Math.max(from, end - CHUNK);
+            // overlap by the marker's length, so one cut in two is still found
+            const len = Math.min(size, end + needle.length) - start;
+            const buf = Buffer.alloc(len);
+            const n = fs.readSync(fd, buf, 0, len, start);
+            const at = buf.subarray(0, n).lastIndexOf(needle);
+            if (at >= 0)
+                return lineAt(fd, size, start + at, maxLine);
+            end = start;
+        }
+        return undefined;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** The whole line around a byte position, parsed; undefined when it is too long or not JSON. */
+function lineAt(fd, size, pos, maxLine) {
+    const STEP = 64 * 1024;
+    let lineStart = pos;
+    while (lineStart > 0 && pos - lineStart < maxLine) {
+        const from = Math.max(0, lineStart - STEP);
+        const buf = Buffer.alloc(lineStart - from);
+        fs.readSync(fd, buf, 0, buf.length, from);
+        const nl = buf.lastIndexOf(10);
+        if (nl >= 0) {
+            lineStart = from + nl + 1;
+            break;
+        }
+        lineStart = from;
+    }
+    let lineEnd = pos;
+    while (lineEnd < size && lineEnd - lineStart < maxLine) {
+        const buf = Buffer.alloc(Math.min(STEP, size - lineEnd));
+        fs.readSync(fd, buf, 0, buf.length, lineEnd);
+        const nl = buf.indexOf(10);
+        if (nl >= 0) {
+            lineEnd += nl;
+            break;
+        }
+        lineEnd += buf.length;
+    }
+    if (lineEnd - lineStart >= maxLine)
+        return undefined;
+    const buf = Buffer.alloc(lineEnd - lineStart);
+    fs.readSync(fd, buf, 0, buf.length, lineStart);
+    try {
+        return JSON.parse(buf.toString("utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
 //# sourceMappingURL=jsonl.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parawatch",
-  "version": "0.3.17",
+  "version": "0.3.18",
   "description": "A control tower for people running many AI coding agents in parallel: see what is running, what needs you, and wake the right agent when you answer.",
   "keywords": [
     "ai-agents",