parawatch 0.0.0-stage → 0.2.0

package/dist/adapters/codex.js

@@ -0,0 +1,185 @@
+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";
+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
+const RAW_HEAD_BYTES = 16 * 1024 * 1024;
+export function codexSessionsDir() {
+    if (process.env.PARAWATCH_CODEX_DIR)
+        return process.env.PARAWATCH_CODEX_DIR;
+    const base = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+    return path.join(base, "sessions");
+}
+const PARENT_IN_CWD = /\/claude-\d+\/[^/]+\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:\/|$)/;
+/** A Claude Code session id when Codex was started from inside that session's scratch space. */
+export function parentFromCwd(cwd) {
+    return cwd ? PARENT_IN_CWD.exec(cwd)?.[1] : undefined;
+}
+function payload(r) {
+    return isObj(r) && isObj(r.payload) ? r.payload : undefined;
+}
+function messageText(p) {
+    const c = p.content;
+    if (!Array.isArray(c))
+        return "";
+    return c
+        .filter(isObj)
+        .map((b) => str(b.text) ?? "")
+        .join("\n")
+        .trim();
+}
+function promptBlock(p) {
+    const c = p.content;
+    if (!Array.isArray(c))
+        return undefined;
+    for (const b of c.filter(isObj)) {
+        const t = (str(b.text) ?? "").trim();
+        if (!t || t.startsWith("<") || t.startsWith("# AGENTS.md instructions"))
+            continue;
+        return t;
+    }
+    return undefined;
+}
+function toolSummary(p) {
+    const name = str(p.name) ?? "tool";
+    let arg = str(p.input) ?? str(p.arguments) ?? "";
+    try {
+        const parsed = JSON.parse(arg);
+        if (isObj(parsed))
+            arg = str(parsed.cmd) ?? str(parsed.command) ?? (Array.isArray(parsed.command) ? parsed.command.join(" ") : arg);
+    }
+    catch {
+        // free-form input
+    }
+    return arg ? `${name}: ${oneLine(arg, 80)}` : name;
+}
+/** The first real prompt in user messages whose lines were too long to parse (inline images). */
+export function promptFromRaw(raw) {
+    for (const line of raw.split("\n")) {
+        if (!line.includes('"role":"user"'))
+            continue;
+        for (const t of textValues(line)) {
+            const v = t.trim();
+            if (v && !v.startsWith("<") && !v.startsWith("# AGENTS.md instructions"))
+                return v;
+        }
+    }
+    return undefined;
+}
+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";
+    const cwd = str(meta?.cwd);
+    const exec = str(meta?.originator) === "codex_exec" || str(meta?.source) === "exec";
+    let prompt;
+    for (const r of head) {
+        const p = payload(r);
+        if (isObj(r) && r.type === "response_item" && p?.type === "message" && p.role === "user") {
+            // skip injected context: environment blocks, image tags, AGENTS.md instructions
+            const t = promptBlock(p);
+            if (t) {
+                prompt = t;
+                break;
+            }
+        }
+    }
+    if (!prompt && rawHead)
+        prompt = promptFromRaw(rawHead());
+    const run = {
+        id,
+        runtime: "codex",
+        kind: exec ? "exec" : "session",
+        title: prompt ? oneLine(prompt, 60) : id.slice(0, 8),
+        cwd,
+        parent: parentFromCwd(cwd),
+        startedAt: str(meta?.timestamp) ?? (isObj(head[0]) ? str(head[0].timestamp) : undefined),
+        state: "working",
+        prompt: prompt ? oneLine(prompt, 400) : undefined,
+    };
+    let lastStart = -1;
+    let lastDone = -1;
+    let lastError = -1;
+    tail.forEach((r, i) => {
+        if (!isObj(r))
+            return;
+        const ts = str(r.timestamp);
+        if (ts && (!run.lastActivity || ts > run.lastActivity))
+            run.lastActivity = ts;
+        const p = payload(r);
+        if (!p)
+            return;
+        if (r.type === "event_msg" && p.type === "task_started")
+            lastStart = i;
+        if (r.type === "event_msg" && p.type === "task_complete") {
+            lastDone = i;
+            const msg = str(p.last_agent_message);
+            if (msg)
+                run.action = oneLine(msg, 100);
+        }
+        if (r.type === "event_msg" && (p.type === "error" || p.type === "turn_aborted"))
+            lastError = i;
+        if (r.type === "response_item" && (p.type === "custom_tool_call" || p.type === "function_call")) {
+            if (i > lastDone)
+                run.action = toolSummary(p);
+        }
+        if (r.type === "response_item" && p.type === "message" && p.role === "assistant" && i > lastDone) {
+            const t = messageText(p);
+            if (t)
+                run.action = oneLine(t, 100);
+        }
+    });
+    if (lastError > Math.max(lastStart, lastDone))
+        run.state = "failed";
+    else if (lastDone > lastStart)
+        run.state = exec ? "done" : "idle";
+    return run;
+}
+function dayDirs(root, sinceMs, now) {
+    const out = [];
+    const day = 86_400_000;
+    for (let t = sinceMs - day; t <= now + day; t += day) {
+        const d = new Date(t);
+        const y = String(d.getFullYear());
+        const m = String(d.getMonth() + 1).padStart(2, "0");
+        const dd = String(d.getDate()).padStart(2, "0");
+        const dir = path.join(root, y, m, dd);
+        if (!out.includes(dir))
+            out.push(dir);
+    }
+    return out;
+}
+export const codex = {
+    name: "codex",
+    scan(opts) {
+        const root = codexSessionsDir();
+        const runs = [];
+        for (const dir of dayDirs(root, opts.sinceMs, opts.now)) {
+            let files;
+            try {
+                files = fs.readdirSync(dir).filter((f) => f.startsWith("rollout-") && f.endsWith(".jsonl"));
+            }
+            catch {
+                continue;
+            }
+            for (const f of files) {
+                const file = path.join(dir, f);
+                try {
+                    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 };
+                    run.activity = logActivity(file, opts.now);
+                    applyStall(run, undefined, opts.now);
+                    runs.push(run);
+                }
+                catch (err) {
+                    runs.push({ id: f, runtime: "codex", kind: "exec", title: f, state: "unknown", source: file, error: `could not read: ${err.message}` });
+                }
+            }
+        }
+        return runs;
+    },
+};
+//# sourceMappingURL=codex.js.map

package/dist/adapters/index.js

@@ -0,0 +1,18 @@
+import { claudeCode } from "./claudeCode.js";
+import { codex } from "./codex.js";
+export const adapters = [claudeCode, codex];
+export function scanAll(opts, only) {
+    const runs = [];
+    for (const a of adapters) {
+        if (only && !only.includes(a.name))
+            continue;
+        try {
+            runs.push(...a.scan(opts));
+        }
+        catch (err) {
+            runs.push({ id: `${a.name}-error`, runtime: a.name, kind: "session", title: `${a.name} adapter failed`, state: "unknown", error: err.message });
+        }
+    }
+    return runs;
+}
+//# sourceMappingURL=index.js.map

package/dist/adapters/jsonl.js

@@ -0,0 +1,144 @@
+import fs from "node:fs";
+/** Read up to `bytes` from the start of a file, dropping a torn last line. */
+export function readHeadLines(file, bytes) {
+    const fd = fs.openSync(file, "r");
+    try {
+        const buf = Buffer.alloc(bytes);
+        const n = fs.readSync(fd, buf, 0, bytes, 0);
+        const text = buf.subarray(0, n).toString("utf8");
+        const lines = text.split("\n");
+        if (n === bytes)
+            lines.pop();
+        return parseLines(lines);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** Read up to `bytes` from the end of a file, dropping a torn first line. Agent logs can be hundreds of MB. */
+export function readTailLines(file, bytes) {
+    const size = fs.statSync(file).size;
+    const start = Math.max(0, size - bytes);
+    const fd = fs.openSync(file, "r");
+    try {
+        const len = size - start;
+        const buf = Buffer.alloc(len);
+        const n = fs.readSync(fd, buf, 0, len, start);
+        const lines = buf.subarray(0, n).toString("utf8").split("\n");
+        if (start > 0)
+            lines.shift();
+        return parseLines(lines);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** Raw text from the start of a file, for lines too long to parse whole (inline images). */
+export function readHeadText(file, bytes) {
+    const fd = fs.openSync(file, "r");
+    try {
+        const buf = Buffer.alloc(bytes);
+        const n = fs.readSync(fd, buf, 0, bytes, 0);
+        return buf.subarray(0, n).toString("utf8");
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** Every JSON string value of a "text" key found in raw, possibly truncated, JSON text. */
+export function textValues(raw) {
+    const out = [];
+    const re = /"text":"((?:[^"\\]|\\.)*)"/g;
+    for (let m = re.exec(raw); m; m = re.exec(raw)) {
+        try {
+            out.push(JSON.parse(`"${m[1]}"`));
+        }
+        catch {
+            // malformed escape; skip
+        }
+    }
+    return out;
+}
+function parseLines(lines) {
+    const out = [];
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            // skip partial or foreign lines
+        }
+    }
+    return out;
+}
+export function oneLine(s, max = 100) {
+    const flat = s.replace(/\s+/g, " ").trim();
+    return flat.length > max ? flat.slice(0, max - 1) + "…" : flat;
+}
+export function isObj(x) {
+    return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+export function str(x) {
+    return typeof x === "string" ? x : undefined;
+}
+export const ACTIVITY_MINUTES = 60;
+/** Which of the last `window` minutes saw any of these times: minutes before now, ascending. */
+export function activeMinutes(times, now, window = ACTIVITY_MINUTES) {
+    const set = new Set();
+    for (const t of times) {
+        if (!Number.isFinite(t))
+            continue;
+        const m = Math.floor((now - t) / 60_000);
+        if (m >= 0 && m < window)
+            set.add(m);
+    }
+    return [...set].sort((a, b) => a - b);
+}
+const STAMP = /"timestamp":"([^"]{10,40})"/g;
+/** Every record timestamp in raw log text, in milliseconds. */
+export function timestampsIn(text) {
+    const out = [];
+    for (let m = STAMP.exec(text); m; m = STAMP.exec(text)) {
+        const t = Date.parse(m[1]);
+        if (Number.isFinite(t))
+            out.push(t);
+    }
+    STAMP.lastIndex = 0;
+    return out;
+}
+// How far back the first look at a log goes. Later looks read only what was appended since.
+const FIRST_LOOK_BYTES = 16 * 1024 * 1024;
+const seen = new Map();
+/**
+ * The active minutes of an append-only log. A long-running process (the desktop app) keeps what
+ * it has read, so each refresh reads only the new end of the file.
+ */
+export function logActivity(file, now) {
+    const size = fs.statSync(file).size;
+    let entry = seen.get(file);
+    if (!entry || size < entry.offset)
+        entry = { offset: Math.max(0, size - FIRST_LOOK_BYTES), times: [] };
+    if (size > entry.offset) {
+        const fd = fs.openSync(file, "r");
+        try {
+            const len = size - entry.offset;
+            const buf = Buffer.alloc(len);
+            const n = fs.readSync(fd, buf, 0, len, entry.offset);
+            const text = buf.subarray(0, n).toString("utf8");
+            // stop at the last full line so a record being written is read next time
+            const end = text.lastIndexOf("\n") + 1;
+            entry.times.push(...timestampsIn(text.slice(0, end)));
+            entry.offset += Buffer.byteLength(text.slice(0, end), "utf8");
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    const horizon = now - ACTIVITY_MINUTES * 60_000;
+    entry.times = entry.times.filter((t) => t >= horizon);
+    seen.set(file, entry);
+    return activeMinutes(entry.times, now);
+}
+//# sourceMappingURL=jsonl.js.map