@kelceyp/caw-server 1.0.280 → 1.0.282

package/dist/transcript-tailer.mjs

@@ -0,0 +1,206 @@
+// TranscriptTailer — polls a Claude Code session transcript JSONL file, forwards
+// post-baseline entries to a consumer, and recovers transparently when the file
+// shrinks, is replaced (dev/ino change), tears mid-write, or contains
+// non-final unparseable lines. Sibling of `pty-wrapper.mjs`; not imported by it
+// at this task's end-of-task (wired in at Task 6).
+//
+// Instance-owned mutable state — no module-level mutables. Two instances
+// constructed against the same fixture path do not share state.
+
+import * as fs from 'node:fs';
+
+const TORN_PREFIX = 'tailTranscript: torn trailing line at cursor=';
+const REOPENED_PREFIX = 'tailTranscript: reopened path=';
+const UNPARSEABLE_PREFIX = 'tailTranscript: non-final unparseable line at offset=';
+const UNUSABLE_PREFIX = 'tailTranscript: boundary unusable, cause=';
+const READ_ERROR_PREFIX = 'tailTranscript: read error:';
+
+// Regex UUID extraction — used by the pre-baseline walk and re-walks so a
+// single unparseable line cannot poison the baseline the way per-line
+// JSON.parse would.
+const UUID_REGEX = /"uuid"\s*:\s*"([0-9a-fA-F-]+)"/g;
+
+function extractUuidsInto(text, set) {
+    UUID_REGEX.lastIndex = 0;
+    let match;
+    while ((match = UUID_REGEX.exec(text)) !== null) {
+        set.add(match[1]);
+    }
+}
+
+export function createTranscriptTailer({ log } = {}) {
+    const emit = typeof log === 'function'
+        ? log
+        : (message) => { process.stderr.write(message + '\n'); };
+
+    const state = {
+        path: null,
+        dev: null,
+        ino: null,
+        cursor: 0,
+        preBaselineUUIDs: new Set(),
+        processedUUIDs: new Set(),
+        boundaryEstablished: false,
+        unusable: false,
+        closed: false,
+    };
+
+    function setUnusable(cause) {
+        if (state.unusable) return;
+        state.unusable = true;
+        emit(`${UNUSABLE_PREFIX}${cause} — subsequent ticks will return no entries`);
+    }
+
+    function initialiseBoundary(path, options = {}) {
+        if (state.boundaryEstablished) return;
+        state.boundaryEstablished = true;
+        state.path = path;
+        const { resume = false } = options;
+        if (!resume) {
+            state.cursor = 0;
+            state.preBaselineUUIDs = new Set();
+            return;
+        }
+        // Case B: --resume — synchronous pre-spawn baseline take.
+        try {
+            const stats = fs.statSync(path);
+            const content = fs.readFileSync(path, 'utf-8');
+            state.dev = stats.dev;
+            state.ino = stats.ino;
+            state.cursor = stats.size;
+            state.preBaselineUUIDs = new Set();
+            extractUuidsInto(content, state.preBaselineUUIDs);
+        } catch {
+            setUnusable('readError');
+        }
+    }
+
+    function reopenAndRewalkBoundary() {
+        if (!state.boundaryEstablished) return;
+        if (state.unusable) return;
+        try {
+            const prevDev = state.dev;
+            const prevIno = state.ino;
+            const stats = fs.statSync(state.path);
+            const content = fs.readFileSync(state.path, 'utf-8');
+            const rebuilt = new Set();
+            extractUuidsInto(content, rebuilt);
+            state.dev = stats.dev;
+            state.ino = stats.ino;
+            state.cursor = stats.size;
+            state.preBaselineUUIDs = rebuilt;
+            emit(
+                `${REOPENED_PREFIX}${state.path} dev=${state.dev} ino=${state.ino} `
+                + `(was dev=${prevDev} ino=${prevIno}), cursor=0, `
+                + `re-walking to rebuild preBaselineUUIDs (${rebuilt.size} entries suppressed from forwarding)`
+            );
+        } catch {
+            setUnusable('reopenFailed');
+        }
+    }
+
+    function tick() {
+        if (!state.boundaryEstablished) return [];
+        if (state.unusable) return [];
+        if (state.closed) return [];
+
+        let stats;
+        try {
+            stats = fs.statSync(state.path);
+        } catch (err) {
+            if (err && err.code === 'ENOENT') return [];
+            emit(`${READ_ERROR_PREFIX} ${err && err.message ? err.message : String(err)}`);
+            return [];
+        }
+
+        if (state.dev !== null && state.ino !== null) {
+            if (stats.dev !== state.dev || stats.ino !== state.ino || stats.size < state.cursor) {
+                reopenAndRewalkBoundary();
+                return [];
+            }
+        } else {
+            // First successful stat since boundary establishment (Case A): record
+            // (dev, ino) implicitly so subsequent ticks can detect replacement.
+            state.dev = stats.dev;
+            state.ino = stats.ino;
+        }
+
+        if (stats.size <= state.cursor) return [];
+
+        const toRead = stats.size - state.cursor;
+        let buf;
+        try {
+            const fd = fs.openSync(state.path, 'r');
+            try {
+                buf = Buffer.alloc(toRead);
+                let totalRead = 0;
+                while (totalRead < toRead) {
+                    const n = fs.readSync(fd, buf, totalRead, toRead - totalRead, state.cursor + totalRead);
+                    if (n === 0) break;
+                    totalRead += n;
+                }
+                if (totalRead < toRead) buf = buf.slice(0, totalRead);
+            } finally {
+                fs.closeSync(fd);
+            }
+        } catch (err) {
+            emit(`${READ_ERROR_PREFIX} ${err && err.message ? err.message : String(err)}`);
+            return [];
+        }
+
+        const entries = [];
+        const startCursor = state.cursor;
+        let localOffset = 0;
+
+        while (localOffset < buf.length) {
+            const nlIdx = buf.indexOf(0x0A, localOffset);
+            if (nlIdx === -1) {
+                // Incomplete trailing line — leave cursor at its start; re-read next poll.
+                const tornPos = startCursor + localOffset;
+                state.cursor = tornPos;
+                emit(`${TORN_PREFIX}${tornPos}, deferring; will re-read next poll`);
+                return entries;
+            }
+            const line = buf.slice(localOffset, nlIdx).toString('utf-8');
+            const lineByteOffset = startCursor + localOffset;
+
+            if (line.length > 0) {
+                let entry;
+                let parsed = false;
+                try {
+                    entry = JSON.parse(line);
+                    parsed = true;
+                } catch {
+                    emit(`${UNPARSEABLE_PREFIX}${lineByteOffset} — skipping (cursor still advances)`);
+                }
+                if (parsed) {
+                    const uuid = entry && typeof entry === 'object' ? entry.uuid : undefined;
+                    if (!uuid || (!state.preBaselineUUIDs.has(uuid) && !state.processedUUIDs.has(uuid))) {
+                        if (uuid) state.processedUUIDs.add(uuid);
+                        entries.push(entry);
+                    }
+                }
+            }
+
+            localOffset = nlIdx + 1;
+        }
+
+        state.cursor = startCursor + buf.length;
+        return entries;
+    }
+
+    function close() {
+        state.closed = true;
+    }
+
+    return {
+        initialiseBoundary,
+        tick,
+        close,
+        reopenAndRewalkBoundary,
+        get path() { return state.path; },
+        get unusable() { return state.unusable; },
+        get preBaselineUUIDs() { return state.preBaselineUUIDs; },
+        get boundaryEstablished() { return state.boundaryEstablished; },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kelceyp/caw-server",
-  "version": "1.0.280",
+  "version": "1.0.282",
   "description": "CAW server - REST API, MCP server and core features",
   "type": "module",
   "main": "dist/main.js",
@@ -19,7 +19,7 @@
     "build": "bash scripts/bun-build.sh",
     "build:client": "cd ../client && bun run build",
     "build:cli": "cd ../cli && bun run build && cp dist/cli.js ../server/dist/",
-    "build:all": "bun run clean && bun run generate:applyPojo && bun run build:client && bun run build && cp src/core/services/embedding-worker.js dist/embedding-worker.js && cp src/core/agents/pty-wrapper.mjs dist/pty-wrapper.mjs && cp src/core/agents/pty-deferred-teardown.mjs dist/pty-deferred-teardown.mjs && cp src/core/agents/pty-emit-result.mjs dist/pty-emit-result.mjs && cp src/core/agents/teardownReasons.mjs dist/teardownReasons.mjs && bun run build:cli",
+    "build:all": "bun run clean && bun run generate:applyPojo && bun run build:client && bun run build && cp src/core/services/embedding-worker.js dist/embedding-worker.js && cp src/core/agents/pty-wrapper.mjs dist/pty-wrapper.mjs && cp src/core/agents/pty-deferred-teardown.mjs dist/pty-deferred-teardown.mjs && cp src/core/agents/pty-emit-result.mjs dist/pty-emit-result.mjs && cp src/core/agents/teardownReasons.mjs dist/teardownReasons.mjs && cp src/core/agents/pty-non-interactive-setup.mjs dist/pty-non-interactive-setup.mjs && cp src/core/agents/transcript-tailer.mjs dist/transcript-tailer.mjs && cp src/core/agents/prompt-rejection-detector.mjs dist/prompt-rejection-detector.mjs && bun run build:cli",
     "dev": "STATIC_PATH=../client/src bun --define __BUILTIN_POSTHOG_KEY__=null run src/main.js",
     "start": "node dist/main.js",
     "test": "bun test --define __BUILTIN_POSTHOG_KEY__=null test/unit test/integration test/component test/cli test/investigation && (cd ../client && bun test)",