@letta-ai/dreams 0.0.1 → 0.0.3

package/dist/local/claude.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Claude Code source adapter — discovery, file identity, and byte reading.
+ * Claude Code source adapter — discovery and harness detection.
  *
  * Discovery rule (filesystem shape is authoritative for the pilot):
  *   - only DIRECT children of ~/.claude/projects/<encoded-project>/
@@ -11,7 +11,9 @@
  * `parentUuid` is intentionally NOT used — ordinary main-session records also
  * carry parent relationships.
  *
- * This module never normalizes transcripts; it only reads raw bytes.
+ * This module never normalizes transcripts; it only reads raw bytes for
+ * discovery. Generic scan byte primitives live in `transcript-bytes.ts`.
+ * Registration lives in `source-adapters.ts`.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -47,35 +49,63 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OversizedLineError = exports.IdentityChangedError = exports.CLAUDE_ADAPTER_VERSION = exports.CLAUDE_SOURCE_TYPE = void 0;
+exports.claudeSourceAdapter = exports.CLAUDE_DISPLAY_NAME = exports.CLAUDE_SOURCE_ID = exports.CLAUDE_ADAPTER_VERSION = exports.CLAUDE_SOURCE_TYPE = void 0;
 exports.claudeProjectsDir = claudeProjectsDir;
-exports.firstChunkFingerprint = firstChunkFingerprint;
-exports.prefixFingerprint = prefixFingerprint;
-exports.scanCompleteLinesVerified = scanCompleteLinesVerified;
+exports.validateClaudeSessionId = validateClaudeSessionId;
+exports.detectClaudeCodeHarness = detectClaudeCodeHarness;
 exports.discoverSessions = discoverSessions;
-const crypto = __importStar(require("node:crypto"));
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const config_1 = require("./config");
+const transcript_bytes_1 = require("./transcript-bytes");
 exports.CLAUDE_SOURCE_TYPE = "claude-code";
 exports.CLAUDE_ADAPTER_VERSION = "claude-code-1";
+exports.CLAUDE_SOURCE_ID = `src_${exports.CLAUDE_SOURCE_TYPE}`;
+exports.CLAUDE_DISPLAY_NAME = "Claude Code";
 const UUID_RE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
 const HEAD_READ_BYTES = 256 * 1024;
-const FIRST_CHUNK_BYTES = 4096;
 function claudeProjectsDir() {
     return path.join(os.homedir(), ".claude", "projects");
 }
-/** Thrown when a file's identity changes between discovery and read (TOCTOU / swap). */
-class IdentityChangedError extends Error {
-    constructor(filePath) {
-        super(`file identity changed under read: ${filePath}`);
-        this.name = "IdentityChangedError";
-    }
+function validateClaudeSessionId(value) {
+    return UUID_RE.test(value);
 }
-exports.IdentityChangedError = IdentityChangedError;
-function fingerprint(bytes) {
-    return crypto.createHash("sha256").update(bytes).digest("hex");
+/**
+ * Deterministic harness-owned filesystem facts only. Never opens transcript
+ * files or walks session contents. Paths stay private to this adapter.
+ */
+function detectClaudeCodeHarness(home = os.homedir()) {
+    const claudeDir = path.join(home, ".claude");
+    const evidence = [];
+    try {
+        if (!fs.statSync(claudeDir).isDirectory()) {
+            return { present: false, evidence };
+        }
+    }
+    catch {
+        return { present: false, evidence };
+    }
+    evidence.push(claudeDir);
+    const projectsDir = path.join(home, ".claude", "projects");
+    try {
+        if (fs.statSync(projectsDir).isDirectory())
+            evidence.push(projectsDir);
+    }
+    catch {
+        // projects/ is optional evidence; ~/.claude alone is enough.
+    }
+    for (const name of ["settings.json", "settings.local.json", "CLAUDE.md"]) {
+        const candidate = path.join(claudeDir, name);
+        try {
+            if (fs.statSync(candidate).isFile())
+                evidence.push(candidate);
+        }
+        catch {
+            // ignore
+        }
+    }
+    return { present: true, evidence };
 }
 /** Read the file head and return the first COMPLETE JSONL record, or null. */
 function readFirstRecord(filePath) {
@@ -101,151 +131,6 @@ function readFirstRecord(filePath) {
             fs.closeSync(fd);
     }
 }
-/**
- * Fingerprint the transcript's FIRST LINE (which carries the stable sessionId).
- * This is invariant under appends — new bytes go after the first line — but
- * changes when the file is replaced by a different session, so it is a reliable
- * replacement signal. (Hashing a fixed-size prefix would wrongly change on every
- * append for files shorter than that prefix.)
- */
-function firstChunkFingerprint(filePath) {
-    let fd;
-    try {
-        fd = fs.openSync(filePath, "r");
-        const buf = Buffer.alloc(FIRST_CHUNK_BYTES);
-        const read = fs.readSync(fd, buf, 0, FIRST_CHUNK_BYTES, 0);
-        const head = buf.subarray(0, read);
-        const nl = head.indexOf(0x0a);
-        const firstLine = nl === -1 ? head : head.subarray(0, nl + 1);
-        return fingerprint(firstLine);
-    }
-    catch {
-        return "";
-    }
-    finally {
-        if (fd !== undefined)
-            fs.closeSync(fd);
-    }
-}
-const IO_CHUNK_BYTES = 64 * 1024;
-function normalizedMtime(stat) {
-    return Number.isFinite(stat.mtimeMs) ? Math.floor(stat.mtimeMs) : null;
-}
-function inodeOf(stat) {
-    return stat.ino ? String(stat.ino) : null;
-}
-function hashRange(fd, end, digest, onProgress) {
-    let position = 0;
-    while (position < end) {
-        const buf = Buffer.allocUnsafe(Math.min(IO_CHUNK_BYTES, end - position));
-        const read = fs.readSync(fd, buf, 0, buf.length, position);
-        if (read === 0)
-            throw new IdentityChangedError("opened transcript");
-        digest.update(buf.subarray(0, read));
-        position += read;
-        onProgress?.();
-    }
-}
-/** SHA-256 of [0, length), read with bounded memory. */
-function prefixFingerprint(filePath, length, onProgress) {
-    if (length <= 0)
-        return "";
-    const fd = fs.openSync(filePath, "r");
-    try {
-        const digest = crypto.createHash("sha256");
-        hashRange(fd, length, digest, onProgress);
-        return digest.digest("hex");
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}
-class OversizedLineError extends Error {
-    filePath;
-    startOffset;
-    byteLength;
-    maxBytes;
-    constructor(filePath, startOffset, byteLength, maxBytes) {
-        super(`JSONL record at byte ${startOffset} in ${filePath} is ${byteLength} bytes; maximum is ${maxBytes}`);
-        this.filePath = filePath;
-        this.startOffset = startOffset;
-        this.byteLength = byteLength;
-        this.maxBytes = maxBytes;
-        this.name = "OversizedLineError";
-    }
-}
-exports.OversizedLineError = OversizedLineError;
-/**
- * Read complete JSONL records from one opened handle using bounded memory.
- * The covered-prefix hash is computed from that same handle, and a final fstat
- * rejects files that changed while being scanned.
- */
-function scanCompleteLinesVerified(realPath, start, expectedInode, maxLineBytes, onLine, onProgress) {
-    let fd;
-    try {
-        fd = fs.openSync(realPath, "r");
-        const initial = fs.fstatSync(fd);
-        const inode = inodeOf(initial);
-        if (expectedInode !== null && inode !== null && inode !== expectedInode)
-            throw new IdentityChangedError(realPath);
-        if (start > initial.size)
-            throw new IdentityChangedError(realPath);
-        const digest = crypto.createHash("sha256");
-        hashRange(fd, start, digest, onProgress);
-        let readPosition = start;
-        let carry = Buffer.alloc(0);
-        let carryStart = start;
-        let completeThrough = start;
-        while (readPosition < initial.size) {
-            const chunk = Buffer.allocUnsafe(Math.min(IO_CHUNK_BYTES, initial.size - readPosition));
-            const read = fs.readSync(fd, chunk, 0, chunk.length, readPosition);
-            if (read === 0)
-                break;
-            readPosition += read;
-            onProgress?.();
-            const combined = carry.length === 0 ? chunk.subarray(0, read) : Buffer.concat([carry, chunk.subarray(0, read)]);
-            const combinedStart = carryStart;
-            let consumed = 0;
-            while (consumed < combined.length) {
-                const newline = combined.indexOf(0x0a, consumed);
-                if (newline === -1)
-                    break;
-                const end = newline + 1;
-                const byteLength = end - consumed;
-                const lineStart = combinedStart + consumed;
-                if (byteLength > maxLineBytes)
-                    throw new OversizedLineError(realPath, lineStart, byteLength, maxLineBytes);
-                const bytes = combined.subarray(consumed, end);
-                digest.update(bytes);
-                completeThrough = combinedStart + end;
-                onLine({ bytes, start_offset: lineStart, end_offset: completeThrough });
-                consumed = end;
-            }
-            carry = Buffer.from(combined.subarray(consumed));
-            carryStart = combinedStart + consumed;
-            if (carry.length > maxLineBytes) {
-                throw new OversizedLineError(realPath, carryStart, carry.length, maxLineBytes);
-            }
-        }
-        const final = fs.fstatSync(fd);
-        if (inodeOf(final) !== inode ||
-            final.size !== initial.size ||
-            normalizedMtime(final) !== normalizedMtime(initial)) {
-            throw new IdentityChangedError(realPath);
-        }
-        return {
-            size: initial.size,
-            inode,
-            mtime_ms: normalizedMtime(initial),
-            complete_through_offset: completeThrough,
-            prefix_fp: completeThrough > 0 ? digest.digest("hex") : "",
-        };
-    }
-    finally {
-        if (fd !== undefined)
-            fs.closeSync(fd);
-    }
-}
 function statSignals(filePath) {
     const stat = fs.statSync(filePath);
     const inode = stat.ino ? String(stat.ino) : null;
@@ -256,6 +141,9 @@ function statSignals(filePath) {
 /**
  * Enumerate valid top-level Claude Code session files. Malformed, sidechain,
  * name-mismatched, and not-yet-complete files are skipped rather than failing.
+ *
+ * Optional `projectsDir` is Claude-private (tests / direct callers). The
+ * `SourceAdapter.discoverSessions` method does not expose this path override.
  */
 function discoverSessions(projectsDir = claudeProjectsDir()) {
     const sessions = [];
@@ -306,10 +194,20 @@ function discoverSessions(projectsDir = claudeProjectsDir()) {
                 inode: signals.inode,
                 birthtime_ms: signals.birthtime_ms,
                 mtime_ms: signals.mtime_ms,
-                first_chunk_fp: firstChunkFingerprint(filePath),
+                first_chunk_fp: (0, transcript_bytes_1.firstChunkFingerprint)(filePath),
             });
         }
     }
     sessions.sort((a, b) => a.path.localeCompare(b.path));
     return sessions;
 }
+exports.claudeSourceAdapter = {
+    sourceType: exports.CLAUDE_SOURCE_TYPE,
+    sourceKey: exports.CLAUDE_SOURCE_TYPE,
+    sourceId: exports.CLAUDE_SOURCE_ID,
+    adapterVersion: exports.CLAUDE_ADAPTER_VERSION,
+    displayName: exports.CLAUDE_DISPLAY_NAME,
+    validateSessionId: validateClaudeSessionId,
+    discoverSessions: () => discoverSessions(),
+    detect: () => detectClaudeCodeHarness(),
+};

package/dist/local/codex.js

@@ -0,0 +1,313 @@
+"use strict";
+/**
+ * Codex source adapter — discovery and harness detection ([LET-10314]).
+ *
+ * On-disk layout (fail closed when unrecognized):
+ *   ~/.codex/sessions/YYYY/MM/DD/rollout-<timestamp>-<sessionId>.jsonl
+ *
+ * Identity chain (upstream openai/codex@fb6aad9ae341; ThreadId is UUIDv7 Display string):
+ * - Filename suffix = `conversation_id` / ThreadId
+ *   (`codex-rs/rollout/src/recorder.rs` `precompute_log_file_info`)
+ * - First JSONL item is RolloutLine{type:session_meta,payload:SessionMetaLine}
+ *   (`codex-rs/protocol/src/protocol.rs` RolloutItem + RolloutLine)
+ * - `payload.id` and `payload.session_id` are the same ThreadId uuid
+ *   (`SessionMeta { session_id: id.into(), id: thread_id, ... }`)
+ * - Hook stdin `session_id` is `ThreadId.to_string()` from `sess.session_id()`
+ *   (`codex-rs/hooks/src/events/session_start.rs`,
+ *    `codex-rs/core/src/hook_runtime.rs`,
+ *    `codex-rs/hooks/schema/generated/session-start.command.input.schema.json`)
+ * Pin: https://github.com/openai/codex/tree/fb6aad9ae34116128e537696c24e35fe6548e1c2
+ *
+ * Subagent rollouts are skipped. Paths stay private to this module.
+ * Registration lives in `source-adapters.ts` (not the default).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexSourceAdapter = exports.CODEX_DISPLAY_NAME = exports.CODEX_SOURCE_ID = exports.CODEX_ADAPTER_VERSION = exports.CODEX_SOURCE_TYPE = void 0;
+exports.codexSessionsDir = codexSessionsDir;
+exports.validateCodexSessionId = validateCodexSessionId;
+exports.detectCodexHarness = detectCodexHarness;
+exports.discoverSessions = discoverSessions;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const config_1 = require("./config");
+const transcript_bytes_1 = require("./transcript-bytes");
+exports.CODEX_SOURCE_TYPE = "codex";
+exports.CODEX_ADAPTER_VERSION = "codex-1";
+exports.CODEX_SOURCE_ID = `src_${exports.CODEX_SOURCE_TYPE}`;
+exports.CODEX_DISPLAY_NAME = "Codex";
+/** Opaque safe identifiers (not UUID-bound; not permanently tied to thr_). */
+const SESSION_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+const HEAD_READ_BYTES = 256 * 1024;
+/** Timestamp uses hyphens instead of colons: YYYY-MM-DDTHH-MM-SS. */
+const ROLLOUT_RE = /^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-([A-Za-z0-9][A-Za-z0-9_-]{0,127})\.jsonl$/;
+function codexSessionsDir() {
+    return path.join(os.homedir(), ".codex", "sessions");
+}
+function validateCodexSessionId(value) {
+    return SESSION_ID_RE.test(value);
+}
+/**
+ * Deterministic harness-owned filesystem facts only. Never opens transcript
+ * files or walks session contents.
+ */
+function detectCodexHarness(home = os.homedir()) {
+    const codexDir = path.join(home, ".codex");
+    const evidence = [];
+    try {
+        if (!fs.statSync(codexDir).isDirectory()) {
+            return { present: false, evidence };
+        }
+    }
+    catch {
+        return { present: false, evidence };
+    }
+    evidence.push(codexDir);
+    const sessionsDir = path.join(codexDir, "sessions");
+    try {
+        if (fs.statSync(sessionsDir).isDirectory())
+            evidence.push(sessionsDir);
+    }
+    catch {
+        // optional
+    }
+    for (const name of ["config.toml", "hooks.json"]) {
+        const candidate = path.join(codexDir, name);
+        try {
+            if (fs.statSync(candidate).isFile())
+                evidence.push(candidate);
+        }
+        catch {
+            // ignore
+        }
+    }
+    return { present: true, evidence };
+}
+function readFirstRecord(filePath) {
+    let fd;
+    try {
+        fd = fs.openSync(filePath, "r");
+        const buf = Buffer.alloc(HEAD_READ_BYTES);
+        const read = fs.readSync(fd, buf, 0, HEAD_READ_BYTES, 0);
+        const head = buf.subarray(0, read);
+        const nl = head.indexOf(0x0a);
+        if (nl === -1)
+            return null;
+        const line = head.subarray(0, nl).toString("utf8").trim();
+        if (line === "")
+            return null;
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
+function isSubagentMeta(payload) {
+    if (typeof payload.parent_thread_id === "string" && payload.parent_thread_id.length > 0)
+        return true;
+    const source = payload.source;
+    if (source && typeof source === "object" && !Array.isArray(source) && "subagent" in source)
+        return true;
+    return false;
+}
+function underRoot(rootReal, candidateReal) {
+    const prefix = rootReal.endsWith(path.sep) ? rootReal : rootReal + path.sep;
+    return candidateReal === rootReal || candidateReal.startsWith(prefix);
+}
+function statSignals(filePath) {
+    const stat = fs.statSync(filePath);
+    const inode = stat.ino ? String(stat.ino) : null;
+    const birthtime = Number.isFinite(stat.birthtimeMs) && stat.birthtimeMs > 0 ? Math.floor(stat.birthtimeMs) : null;
+    const mtime = Number.isFinite(stat.mtimeMs) ? Math.floor(stat.mtimeMs) : null;
+    return { size: stat.size, inode, birthtime_ms: birthtime, mtime_ms: mtime };
+}
+/**
+ * Enumerate top-level Codex rollout files. Malformed, truncated, escaped,
+ * identity-mismatched, and subagent files are skipped (fail closed).
+ *
+ * Optional `sessionsDir` is Codex-private (tests / direct callers).
+ */
+function discoverSessions(sessionsDir = codexSessionsDir()) {
+    const sessions = [];
+    let rootReal;
+    try {
+        rootReal = (0, config_1.canonicalize)(sessionsDir);
+        if (!fs.statSync(rootReal).isDirectory())
+            return sessions;
+    }
+    catch {
+        return sessions;
+    }
+    let yearEntries;
+    try {
+        yearEntries = fs.readdirSync(rootReal, { withFileTypes: true });
+    }
+    catch {
+        return sessions;
+    }
+    for (const yearEntry of yearEntries) {
+        if (!yearEntry.isDirectory())
+            continue;
+        if (!/^\d{4}$/.test(yearEntry.name))
+            continue;
+        const yearDir = path.join(rootReal, yearEntry.name);
+        let monthEntries;
+        try {
+            monthEntries = fs.readdirSync(yearDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const monthEntry of monthEntries) {
+            if (!monthEntry.isDirectory())
+                continue;
+            if (!/^\d{2}$/.test(monthEntry.name))
+                continue;
+            const monthDir = path.join(yearDir, monthEntry.name);
+            let dayEntries;
+            try {
+                dayEntries = fs.readdirSync(monthDir, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const dayEntry of dayEntries) {
+                if (!dayEntry.isDirectory())
+                    continue;
+                if (!/^\d{2}$/.test(dayEntry.name))
+                    continue;
+                const dayDir = path.join(monthDir, dayEntry.name);
+                let files;
+                try {
+                    files = fs.readdirSync(dayDir, { withFileTypes: true });
+                }
+                catch {
+                    continue;
+                }
+                for (const file of files) {
+                    if (!file.isFile())
+                        continue;
+                    const match = ROLLOUT_RE.exec(file.name);
+                    if (!match)
+                        continue;
+                    const filenameId = match[1];
+                    if (!validateCodexSessionId(filenameId))
+                        continue;
+                    const filePath = path.join(dayDir, file.name);
+                    try {
+                        let realPath;
+                        try {
+                            realPath = (0, config_1.canonicalize)(filePath);
+                        }
+                        catch {
+                            continue;
+                        }
+                        if (!underRoot(rootReal, realPath))
+                            continue;
+                        const record = readFirstRecord(filePath);
+                        if (!record)
+                            continue;
+                        if (record.type !== "session_meta")
+                            continue;
+                        const payload = record.payload;
+                        if (!payload || typeof payload !== "object" || Array.isArray(payload))
+                            continue;
+                        const meta = payload;
+                        if (isSubagentMeta(meta))
+                            continue;
+                        // Prefer payload.id; accept payload.session_id when present (same ThreadId).
+                        const sessionId = typeof meta.id === "string"
+                            ? meta.id
+                            : typeof meta.session_id === "string"
+                                ? meta.session_id
+                                : null;
+                        if (!sessionId || sessionId !== filenameId)
+                            continue;
+                        if (typeof meta.session_id === "string" &&
+                            typeof meta.id === "string" &&
+                            meta.session_id !== meta.id) {
+                            continue;
+                        }
+                        if (!validateCodexSessionId(sessionId))
+                            continue;
+                        let cwd = null;
+                        if (typeof meta.cwd === "string") {
+                            try {
+                                cwd = (0, config_1.canonicalize)(meta.cwd);
+                            }
+                            catch {
+                                // Unresolvable cwd → discover but deny-by-default at policy gate.
+                                cwd = null;
+                            }
+                        }
+                        const signals = statSignals(filePath);
+                        sessions.push({
+                            path: filePath,
+                            real_path: realPath,
+                            session_id: sessionId,
+                            cwd,
+                            size: signals.size,
+                            inode: signals.inode,
+                            birthtime_ms: signals.birthtime_ms,
+                            mtime_ms: signals.mtime_ms,
+                            first_chunk_fp: (0, transcript_bytes_1.firstChunkFingerprint)(filePath),
+                        });
+                    }
+                    catch {
+                        // Fail closed for this candidate only — never abort the whole pass.
+                        continue;
+                    }
+                }
+            }
+        }
+    }
+    sessions.sort((a, b) => a.path.localeCompare(b.path));
+    return sessions;
+}
+exports.codexSourceAdapter = {
+    sourceType: exports.CODEX_SOURCE_TYPE,
+    sourceKey: exports.CODEX_SOURCE_TYPE,
+    sourceId: exports.CODEX_SOURCE_ID,
+    adapterVersion: exports.CODEX_ADAPTER_VERSION,
+    displayName: exports.CODEX_DISPLAY_NAME,
+    validateSessionId: validateCodexSessionId,
+    discoverSessions: () => discoverSessions(),
+    detect: () => detectCodexHarness(),
+};