@codedeck/codedeck 2026.3.1-4.63

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,MAAM;IACrB,MAAM,EAAE;QACN,YAAY,EAAE,MAAM,CAAC;QACrB,mBAAmB,EAAE,MAAM,CAAC;QAC5B,SAAS,EAAE,MAAM,CAAC;QAClB,aAAa,EAAE,MAAM,CAAC;QACtB,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,MAAM,CAAC;QACtB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,aAAa,EAAE,MAAM,CAAC;QACtB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;IACF,MAAM,EAAE;QACN,WAAW,EAAE,MAAM,CAAC;QACpB,cAAc,EAAE,MAAM,EAAE,CAAC;KAC1B,CAAC;IACF,QAAQ,EAAE;QACR,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,QAAQ,EAAE;QACR,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,OAAO,EAAE;QACP,YAAY,EAAE,MAAM,CAAC;QACrB,cAAc,EAAE,MAAM,CAAC;QACvB,mBAAmB,EAAE,MAAM,CAAC;QAC5B,SAAS,EAAE,OAAO,CAAC;KACpB,CAAC;IACF,OAAO,EAAE;QACP,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAC;QAC1B,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,MAAM,EAAE;QACN,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;IACF,EAAE,CAAC,EAAE;QACH,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,GAAG,EAAE;QACH,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,OAAO,CAAC;KACjB,CAAC;CACH;AAgDD,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CA8BlD;AAED,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC"}

package/dist/config.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.resetConfigCache = resetConfigCache;
+const promises_1 = require("fs/promises");
+const os_1 = require("os");
+const path_1 = require("path");
+const yaml_1 = __importDefault(require("yaml"));
+const DEFAULT_CONFIG_PATH = (0, path_1.join)(__dirname, '..', 'config', 'default.yaml');
+function userConfigPath() {
+    return (0, path_1.join)((0, os_1.homedir)(), '.codedeck', 'config.yaml');
+}
+/** Expand ${ENV_VAR} and ${ENV_VAR:-default} patterns in string values */
+function expandEnvVars(value) {
+    return value.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+        const [name, fallback] = expr.split(':-');
+        return process.env[name.trim()] ?? fallback ?? '';
+    });
+}
+function expandConfig(obj) {
+    if (typeof obj === 'string')
+        return expandEnvVars(obj);
+    if (Array.isArray(obj))
+        return obj.map(expandConfig);
+    if (obj && typeof obj === 'object') {
+        return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, expandConfig(v)]));
+    }
+    return obj;
+}
+function expandPaths(obj) {
+    if (typeof obj === 'string' && obj.startsWith('~/')) {
+        return (0, path_1.join)((0, os_1.homedir)(), obj.slice(2));
+    }
+    if (Array.isArray(obj))
+        return obj.map(expandPaths);
+    if (obj && typeof obj === 'object') {
+        return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, expandPaths(v)]));
+    }
+    return obj;
+}
+function deepMerge(base, override) {
+    const result = { ...base };
+    for (const [k, v] of Object.entries(override)) {
+        if (v && typeof v === 'object' && !Array.isArray(v) && result[k] && typeof result[k] === 'object') {
+            result[k] = deepMerge(result[k], v);
+        }
+        else {
+            result[k] = v;
+        }
+    }
+    return result;
+}
+let cachedConfig = null;
+async function loadConfig() {
+    if (cachedConfig)
+        return cachedConfig;
+    const defaultRaw = await (0, promises_1.readFile)(DEFAULT_CONFIG_PATH, 'utf8');
+    let config = yaml_1.default.parse(defaultRaw);
+    // Map server section to cf on defaults before user merge
+    if (config.server) {
+        const s = config.server;
+        config.cf = {
+            workerUrl: s.cfWorkerUrl,
+            apiKey: s.cfApiKey ?? s.apiKey,
+            credentialsPath: s.credentialsPath ?? (0, path_1.join)((0, os_1.homedir)(), '.codedeck', 'server.json'),
+        };
+        delete config.server;
+    }
+    try {
+        const userRaw = await (0, promises_1.readFile)(userConfigPath(), 'utf8');
+        const userConfig = yaml_1.default.parse(userRaw);
+        if (userConfig)
+            config = deepMerge(config, userConfig);
+    }
+    catch {
+        // No user config — use defaults
+    }
+    config = expandConfig(config);
+    config = expandPaths(config);
+    cachedConfig = config;
+    return cachedConfig;
+}
+function resetConfigCache() {
+    cachedConfig = null;
+}
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"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"}

package/dist/daemon/codex-watcher.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Watches Codex JSONL rollout files for structured events.
+ *
+ * Codex writes per-session rollout files to:
+ *   ~/.codex/sessions/YYYY/MM/DD/rollout-YYYY-MM-DDThh-mm-ss-<uuid>.jsonl
+ *
+ * The first line of each file is a "session_meta" record whose payload.cwd
+ * identifies the project directory. We match files to codedeck sessions by
+ * comparing payload.cwd to the session's workDir.
+ *
+ * Events emitted:
+ *   - user.message   ← event_msg { type: "user_message", message: "..." }
+ *   - assistant.text ← event_msg { type: "agent_message", phase: "final_answer", message: "..." }
+ *
+ * Integration:
+ *   - startWatching(sessionName, workDir) when a codex session starts
+ *   - stopWatching(sessionName) when it stops
+ */
+/**
+ * Read the first line of a rollout file and return payload.cwd if it's a
+ * session_meta record, otherwise null.
+ * Exported for testing.
+ */
+export declare function readCwd(filePath: string): Promise<string | null>;
+/** Exported for testing. */
+export declare function parseLine(sessionName: string, line: string, model?: string): void;
+/**
+ * Scan the last 30 days of session dirs for a rollout file whose session_meta.cwd matches
+ * workDir and whose mtime is > since. Returns the UUID from the filename, or null if not found.
+ * Polls every 1s for up to 60s.
+ */
+export declare function extractNewRolloutUuid(workDir: string, since: number): Promise<string | null>;
+/**
+ * Find the full path of a rollout file by UUID, scanning the last 30 days.
+ * Returns null if not found.
+ */
+export declare function findRolloutPathByUuid(uuid: string): Promise<string | null>;
+export declare function startWatching(sessionName: string, workDir: string, model?: string): Promise<void>;
+export declare function isWatching(sessionName: string): boolean;
+/**
+ * Watch a specific rollout file directly (used when UUID is already known).
+ * The file is expected to already exist.
+ */
+export declare function startWatchingSpecificFile(sessionName: string, filePath: string, model?: string): Promise<void>;
+export declare function stopWatching(sessionName: string): void;
+//# sourceMappingURL=codex-watcher.d.ts.map

package/dist/daemon/codex-watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-watcher.d.ts","sourceRoot":"","sources":["../../src/daemon/codex-watcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AA+BH;;;;GAIG;AACH,wBAAsB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAwBtE;AAkDD,4BAA4B;AAC5B,wBAAgB,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAoDjF;AAyGD;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAkClG;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAkBhF;AAID,wBAAsB,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgDvG;AAED,wBAAgB,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;GAGG;AACH,wBAAsB,yBAAyB,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAiCpH;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAWtD"}

package/dist/daemon/codex-watcher.js

@@ -0,0 +1,533 @@
+"use strict";
+/**
+ * Watches Codex JSONL rollout files for structured events.
+ *
+ * Codex writes per-session rollout files to:
+ *   ~/.codex/sessions/YYYY/MM/DD/rollout-YYYY-MM-DDThh-mm-ss-<uuid>.jsonl
+ *
+ * The first line of each file is a "session_meta" record whose payload.cwd
+ * identifies the project directory. We match files to codedeck sessions by
+ * comparing payload.cwd to the session's workDir.
+ *
+ * Events emitted:
+ *   - user.message   ← event_msg { type: "user_message", message: "..." }
+ *   - assistant.text ← event_msg { type: "agent_message", phase: "final_answer", message: "..." }
+ *
+ * Integration:
+ *   - startWatching(sessionName, workDir) when a codex session starts
+ *   - stopWatching(sessionName) when it stops
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCwd = readCwd;
+exports.parseLine = parseLine;
+exports.extractNewRolloutUuid = extractNewRolloutUuid;
+exports.findRolloutPathByUuid = findRolloutPathByUuid;
+exports.startWatching = startWatching;
+exports.isWatching = isWatching;
+exports.startWatchingSpecificFile = startWatchingSpecificFile;
+exports.stopWatching = stopWatching;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const os_1 = require("os");
+const timeline_emitter_js_1 = require("./timeline-emitter.js");
+const logger_js_1 = __importDefault(require("../util/logger.js"));
+// ── Path helpers ───────────────────────────────────────────────────────────────
+/** Return ~/.codex/sessions/YYYY/MM/DD for a given Date. */
+function codexSessionDir(d) {
+    const yyyy = d.getUTCFullYear();
+    const mm = String(d.getUTCMonth() + 1).padStart(2, '0');
+    const dd = String(d.getUTCDate()).padStart(2, '0');
+    return (0, path_1.join)((0, os_1.homedir)(), '.codex', 'sessions', String(yyyy), mm, dd);
+}
+/** Return the last 30 days of session dirs (newest first). */
+function recentSessionDirs() {
+    const dirs = [];
+    for (let i = 0; i < 30; i++) {
+        const d = new Date(Date.now() - i * 86_400_000);
+        dirs.push(codexSessionDir(d));
+    }
+    return dirs;
+}
+// ── JSONL matching ─────────────────────────────────────────────────────────────
+/**
+ * Read the first line of a rollout file and return payload.cwd if it's a
+ * session_meta record, otherwise null.
+ * Exported for testing.
+ */
+async function readCwd(filePath) {
+    let fh = null;
+    try {
+        fh = await (0, promises_1.open)(filePath, 'r');
+        // The session_meta first line can be very large (includes full conversation context).
+        // Read only the first 4KB — enough to find the "cwd" field which appears early.
+        // We extract cwd via regex instead of full JSON.parse to avoid truncation issues.
+        const buf = Buffer.allocUnsafe(4096);
+        const { bytesRead } = await fh.read(buf, 0, 4096, 0);
+        if (bytesRead === 0)
+            return null;
+        const snippet = buf.subarray(0, bytesRead).toString('utf8');
+        // Verify this is a session_meta line
+        if (!snippet.includes('"session_meta"'))
+            return null;
+        // Extract "cwd":"..." value — cwd paths don't contain quotes or backslashes
+        const m = /"cwd"\s*:\s*"([^"]+)"/.exec(snippet);
+        return m ? m[1] : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fh)
+            await fh.close().catch(() => { });
+    }
+}
+/**
+ * Find the most recent rollout-*.jsonl in dir whose session_meta.cwd matches workDir.
+ * Returns the file path, or null if none found.
+ */
+async function findLatestRollout(dir, workDir) {
+    let entries;
+    try {
+        entries = await (0, promises_1.readdir)(dir);
+    }
+    catch {
+        return null;
+    }
+    const rollouts = entries.filter((e) => e.startsWith('rollout-') && e.endsWith('.jsonl'));
+    if (rollouts.length === 0)
+        return null;
+    // Sort newest first by filename (timestamps embedded in name)
+    rollouts.sort((a, b) => b.localeCompare(a));
+    for (const name of rollouts) {
+        const fpath = (0, path_1.join)(dir, name);
+        const cwd = await readCwd(fpath);
+        if (cwd && normalizePath(cwd) === normalizePath(workDir)) {
+            return fpath;
+        }
+    }
+    return null;
+}
+function normalizePath(p) {
+    return p.replace(/\/+$/, '');
+}
+// ── JSONL parsing ──────────────────────────────────────────────────────────────
+// Debounce buffers for streaming final_answer events.
+// Codex emits a new final_answer snapshot on every token; we only want the last one.
+const finalAnswerBuffers = new Map();
+const FINAL_ANSWER_DEBOUNCE_MS = 600;
+function flushFinalAnswer(sessionName) {
+    const buf = finalAnswerBuffers.get(sessionName);
+    if (!buf)
+        return;
+    finalAnswerBuffers.delete(sessionName);
+    timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'assistant.text', { text: buf.text, streaming: false }, { source: 'daemon', confidence: 'high' });
+}
+/** Exported for testing. */
+function parseLine(sessionName, line, model) {
+    if (!line.trim())
+        return;
+    let raw;
+    try {
+        raw = JSON.parse(line);
+    }
+    catch {
+        return;
+    }
+    if (raw['type'] !== 'event_msg')
+        return;
+    const payload = raw['payload'];
+    if (!payload)
+        return;
+    const evtType = payload['type'];
+    if (evtType === 'token_count') {
+        const info = payload['info'];
+        const last = info?.['last_token_usage'];
+        const ctxWin = info?.['model_context_window'] ?? 1_000_000;
+        if (last && typeof last['input_tokens'] === 'number') {
+            timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'usage.update', {
+                inputTokens: last['input_tokens'],
+                cacheTokens: last['cached_input_tokens'] ?? 0,
+                contextWindow: ctxWin,
+                ...(model ? { model } : {}),
+            }, { source: 'daemon', confidence: 'high' });
+        }
+        return;
+    }
+    if (evtType === 'user_message') {
+        // Flush any pending assistant text before a new user message
+        flushFinalAnswer(sessionName);
+        const text = payload['message'];
+        if (text?.trim()) {
+            timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'user.message', { text }, { source: 'daemon', confidence: 'high' });
+        }
+        return;
+    }
+    if (evtType === 'agent_message' && payload['phase'] === 'final_answer') {
+        const text = payload['message'];
+        if (!text?.trim())
+            return;
+        // Debounce: buffer the latest snapshot and reset the timer
+        const existing = finalAnswerBuffers.get(sessionName);
+        if (existing)
+            clearTimeout(existing.timer);
+        const timer = setTimeout(() => flushFinalAnswer(sessionName), FINAL_ANSWER_DEBOUNCE_MS);
+        finalAnswerBuffers.set(sessionName, { text, timer });
+    }
+}
+// ── History replay ─────────────────────────────────────────────────────────────
+const HISTORY_LINES = 200;
+async function emitRecentHistory(sessionName, filePath, model) {
+    let fh = null;
+    try {
+        fh = await (0, promises_1.open)(filePath, 'r');
+        const { size } = await fh.stat();
+        if (size === 0)
+            return;
+        const readSize = Math.min(size, 256 * 1024);
+        const buf = Buffer.allocUnsafe(readSize);
+        const { bytesRead } = await fh.read(buf, 0, readSize, size - readSize);
+        if (bytesRead === 0)
+            return;
+        const chunk = buf.subarray(0, bytesRead).toString('utf8');
+        const lines = chunk.split('\n');
+        const startIdx = size > readSize ? 1 : 0; // skip possible partial first line
+        const historyEvents = [];
+        let lastTokenPayload = null;
+        for (let i = startIdx; i < lines.length; i++) {
+            const line = lines[i];
+            if (!line.trim())
+                continue;
+            let raw;
+            try {
+                raw = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (raw['type'] !== 'event_msg')
+                continue;
+            const payload = raw['payload'];
+            if (!payload)
+                continue;
+            const evtType = payload['type'];
+            if (evtType === 'user_message') {
+                const text = payload['message'];
+                if (text?.trim())
+                    historyEvents.push({ type: 'user', text });
+            }
+            else if (evtType === 'agent_message' && payload['phase'] === 'final_answer') {
+                const text = payload['message'];
+                if (!text?.trim())
+                    continue;
+                const last = historyEvents[historyEvents.length - 1];
+                if (last?.type === 'assistant') {
+                    last.text = text;
+                }
+                else {
+                    historyEvents.push({ type: 'assistant', text });
+                }
+            }
+            else if (evtType === 'token_count') {
+                const info = payload['info'];
+                const last = info?.['last_token_usage'];
+                const ctxWin = info?.['model_context_window'] ?? 1_000_000;
+                if (last && typeof last['input_tokens'] === 'number') {
+                    lastTokenPayload = {
+                        inputTokens: last['input_tokens'],
+                        cacheTokens: last['cached_input_tokens'] ?? 0,
+                        contextWindow: ctxWin,
+                    };
+                }
+            }
+        }
+        // Emit deduplicated history (most recent HISTORY_LINES events)
+        const slice = historyEvents.slice(-HISTORY_LINES);
+        for (const ev of slice) {
+            if (ev.type === 'user') {
+                timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'user.message', { text: ev.text }, { source: 'daemon', confidence: 'high' });
+            }
+            else {
+                timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'assistant.text', { text: ev.text, streaming: false }, { source: 'daemon', confidence: 'high' });
+            }
+        }
+        // Emit last usage snapshot so the context bar populates on load
+        if (lastTokenPayload) {
+            timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'usage.update', { ...lastTokenPayload, ...(model ? { model } : {}) }, { source: 'daemon', confidence: 'high' });
+        }
+    }
+    catch {
+        // best-effort
+    }
+    finally {
+        if (fh)
+            await fh.close().catch(() => { });
+    }
+}
+const watchers = new Map();
+// ── UUID extraction helpers ────────────────────────────────────────────────────
+const UUID_RE = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/;
+/**
+ * Scan the last 30 days of session dirs for a rollout file whose session_meta.cwd matches
+ * workDir and whose mtime is > since. Returns the UUID from the filename, or null if not found.
+ * Polls every 1s for up to 60s.
+ */
+async function extractNewRolloutUuid(workDir, since) {
+    for (let attempt = 0; attempt < 60; attempt++) {
+        for (const dir of recentSessionDirs()) {
+            let entries;
+            try {
+                entries = await (0, promises_1.readdir)(dir);
+            }
+            catch {
+                continue;
+            }
+            const rollouts = entries.filter((e) => e.startsWith('rollout-') && e.endsWith('.jsonl'));
+            for (const filename of rollouts) {
+                const uuidMatch = UUID_RE.exec(filename);
+                if (!uuidMatch)
+                    continue;
+                const fpath = (0, path_1.join)(dir, filename);
+                try {
+                    const s = await (0, promises_1.stat)(fpath);
+                    if (s.mtimeMs <= since)
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+                const cwd = await readCwd(fpath);
+                if (cwd && normalizePath(cwd) === normalizePath(workDir)) {
+                    return uuidMatch[1];
+                }
+            }
+        }
+        await new Promise((r) => setTimeout(r, 1000));
+    }
+    return null;
+}
+/**
+ * Find the full path of a rollout file by UUID, scanning the last 30 days.
+ * Returns null if not found.
+ */
+async function findRolloutPathByUuid(uuid) {
+    for (const dir of recentSessionDirs()) {
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const filename of entries) {
+            if (!filename.startsWith('rollout-') || !filename.endsWith('.jsonl'))
+                continue;
+            const uuidMatch = UUID_RE.exec(filename);
+            if (uuidMatch && uuidMatch[1] === uuid) {
+                return (0, path_1.join)(dir, filename);
+            }
+        }
+    }
+    return null;
+}
+// ── Public API ─────────────────────────────────────────────────────────────────
+async function startWatching(sessionName, workDir, model) {
+    if (watchers.has(sessionName)) {
+        stopWatching(sessionName);
+    }
+    const state = {
+        workDir,
+        activeFile: null,
+        fileOffset: 0,
+        abort: new AbortController(),
+        stopped: false,
+        ...(model ? { model } : {}),
+    };
+    watchers.set(sessionName, state);
+    // Search recent dirs for existing rollout matching workDir
+    for (const dir of recentSessionDirs()) {
+        const found = await findLatestRollout(dir, workDir);
+        if (found) {
+            try {
+                const s = await (0, promises_1.stat)(found);
+                state.activeFile = found;
+                state.fileOffset = s.size;
+                await emitRecentHistory(sessionName, found, state.model);
+            }
+            catch {
+                state.activeFile = found;
+                state.fileOffset = 0;
+            }
+            break;
+        }
+    }
+    // Poll every 2s as fallback (fs.watch on macOS misses file appends)
+    state.pollTimer = setInterval(() => {
+        void drainNewLines(sessionName, state);
+    }, 2000);
+    // Watch all recent dirs for new/modified rollout files.
+    // Only start a watcher for dirs that exist (or today's dir which Codex may create soon).
+    const todayDir = codexSessionDir(new Date());
+    for (const dir of recentSessionDirs()) {
+        const isToday = dir === todayDir;
+        if (!isToday) {
+            // Skip non-existent historical dirs to avoid WARN spam
+            try {
+                await (0, promises_1.stat)(dir);
+            }
+            catch {
+                continue;
+            }
+        }
+        void watchDir(sessionName, state, dir);
+    }
+}
+function isWatching(sessionName) {
+    return watchers.has(sessionName);
+}
+/**
+ * Watch a specific rollout file directly (used when UUID is already known).
+ * The file is expected to already exist.
+ */
+async function startWatchingSpecificFile(sessionName, filePath, model) {
+    if (watchers.has(sessionName)) {
+        stopWatching(sessionName);
+    }
+    let fileSize = 0;
+    try {
+        const s = await (0, promises_1.stat)(filePath);
+        fileSize = s.size;
+    }
+    catch {
+        // file may not exist yet — start from 0
+    }
+    const dir = filePath.substring(0, filePath.lastIndexOf('/'));
+    const state = {
+        workDir: dir,
+        activeFile: filePath,
+        fileOffset: fileSize,
+        abort: new AbortController(),
+        stopped: false,
+        ...(model ? { model } : {}),
+    };
+    watchers.set(sessionName, state);
+    await emitRecentHistory(sessionName, filePath, state.model);
+    // Poll every 2s as fallback
+    state.pollTimer = setInterval(() => {
+        void drainNewLines(sessionName, state);
+    }, 2000);
+    // Watch the parent dir for changes to this specific file
+    void watchDir(sessionName, state, dir);
+}
+function stopWatching(sessionName) {
+    const state = watchers.get(sessionName);
+    if (!state)
+        return;
+    state.stopped = true;
+    state.abort.abort();
+    if (state.pollTimer)
+        clearInterval(state.pollTimer);
+    watchers.delete(sessionName);
+    // Flush any buffered final_answer on stop
+    flushFinalAnswer(sessionName);
+    const buf = finalAnswerBuffers.get(sessionName);
+    if (buf) {
+        clearTimeout(buf.timer);
+        finalAnswerBuffers.delete(sessionName);
+    }
+}
+// ── Internal watcher logic ─────────────────────────────────────────────────────
+async function watchDir(sessionName, state, dir) {
+    // Wait for dir to exist (Codex may not have created it yet)
+    for (let i = 0; i < 60; i++) {
+        if (state.stopped)
+            return;
+        try {
+            await (0, promises_1.stat)(dir);
+            break;
+        }
+        catch {
+            await new Promise((r) => setTimeout(r, 1000));
+        }
+    }
+    if (state.stopped)
+        return;
+    try {
+        const watcher = (0, promises_1.watch)(dir, { persistent: false, signal: state.abort.signal });
+        for await (const event of watcher) {
+            if (state.stopped)
+                break;
+            if (typeof event.filename !== 'string')
+                continue;
+            if (!event.filename.startsWith('rollout-') || !event.filename.endsWith('.jsonl'))
+                continue;
+            const changedFile = (0, path_1.join)(dir, event.filename);
+            if (changedFile !== state.activeFile) {
+                // New file — check if it matches our workDir and is newer
+                const cwd = await readCwd(changedFile);
+                if (!cwd || normalizePath(cwd) !== normalizePath(state.workDir))
+                    continue;
+                const isNewer = await checkNewer(changedFile, state.activeFile);
+                if (isNewer || !state.activeFile) {
+                    logger_js_1.default.debug({ sessionName, file: event.filename }, 'codex-watcher: switching to new rollout file');
+                    state.activeFile = changedFile;
+                    state.fileOffset = 0;
+                }
+                else {
+                    continue;
+                }
+            }
+            await drainNewLines(sessionName, state);
+        }
+    }
+    catch (err) {
+        if (!state.stopped) {
+            logger_js_1.default.warn({ sessionName, dir, err }, 'codex-watcher: dir watch error');
+        }
+    }
+}
+async function checkNewer(candidate, current) {
+    if (!current)
+        return true;
+    try {
+        const [cs, curS] = await Promise.all([(0, promises_1.stat)(candidate), (0, promises_1.stat)(current)]);
+        return cs.mtimeMs > curS.mtimeMs;
+    }
+    catch {
+        return false;
+    }
+}
+async function drainNewLines(sessionName, state) {
+    if (!state.activeFile)
+        return;
+    let fh = null;
+    try {
+        fh = await (0, promises_1.open)(state.activeFile, 'r');
+        const fileStat = await fh.stat();
+        if (fileStat.size <= state.fileOffset)
+            return;
+        const buf = Buffer.allocUnsafe(fileStat.size - state.fileOffset);
+        const { bytesRead } = await fh.read(buf, 0, buf.length, state.fileOffset);
+        if (bytesRead === 0)
+            return;
+        state.fileOffset += bytesRead;
+        const chunk = buf.subarray(0, bytesRead).toString('utf8');
+        for (const line of chunk.split('\n')) {
+            if (state.stopped)
+                break;
+            parseLine(sessionName, line, state.model);
+        }
+    }
+    catch (err) {
+        if (!state.stopped) {
+            logger_js_1.default.debug({ sessionName, err }, 'codex-watcher: drain error');
+        }
+    }
+    finally {
+        if (fh)
+            await fh.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=codex-watcher.js.map