@letta-ai/dreams 0.0.1 → 0.0.4

package/dist/local/codex.js

@@ -0,0 +1,510 @@
+"use strict";
+/**
+ * Codex source adapter — discovery and harness detection ([LET-10314] / [LET-10317]).
+ *
+ * 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. Classification shares one path with discovery
+ * so status diagnostics and ingest agree. 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.classifyCodexRollout = classifyCodexRollout;
+exports.inspectCodexDiscovery = inspectCodexDiscovery;
+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$/;
+/** Broader candidate gate for diagnostics — drifted names still count as candidates. */
+const ROLLOUT_CANDIDATE_RE = /^rollout-.*\.jsonl$/i;
+const MAX_EXAMPLES = 5;
+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 readFirstRecordDetailed(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);
+        if (read === 0)
+            return { ok: false, reason: "empty" };
+        const head = buf.subarray(0, read);
+        const nl = head.indexOf(0x0a);
+        const lineBytes = nl === -1 ? head : head.subarray(0, nl);
+        const line = lineBytes.toString("utf8").trim();
+        if (line === "")
+            return { ok: false, reason: "empty" };
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+                return { ok: false, reason: "unsupported_metadata" };
+            }
+            return { ok: true, record: parsed };
+        }
+        catch {
+            return { ok: false, reason: "malformed_json" };
+        }
+    }
+    catch {
+        return { ok: false, reason: "unreadable" };
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+}
+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 };
+}
+function homeRelative(filePath, home = os.homedir()) {
+    const homeReal = (() => {
+        try {
+            return (0, config_1.canonicalize)(home);
+        }
+        catch {
+            return path.resolve(home);
+        }
+    })();
+    const fileReal = (() => {
+        try {
+            return (0, config_1.canonicalize)(filePath);
+        }
+        catch {
+            return path.resolve(filePath);
+        }
+    })();
+    if (fileReal === homeReal || fileReal.startsWith(homeReal + path.sep)) {
+        return path.join("~", path.relative(homeReal, fileReal));
+    }
+    return path.basename(filePath);
+}
+/**
+ * Classify one rollout candidate. Shared by discovery ingest and status
+ * diagnostics — a "supported" result is exactly what `discoverSessions` emits.
+ */
+function classifyCodexRollout(filePath, filenameId, options) {
+    const basename = path.basename(filePath);
+    const relative_path = homeRelative(filePath, options.home);
+    if (!validateCodexSessionId(filenameId)) {
+        return { kind: "unsupported", reason: "invalid_session_id", basename, relative_path };
+    }
+    let realPath;
+    try {
+        realPath = (0, config_1.canonicalize)(filePath);
+    }
+    catch {
+        return { kind: "unsupported", reason: "unreadable", basename, relative_path };
+    }
+    if (!underRoot(options.sessionsRootReal, realPath)) {
+        return { kind: "excluded", reason: "escaped_path", basename, relative_path };
+    }
+    const first = readFirstRecordDetailed(filePath);
+    if (!first.ok) {
+        return { kind: "unsupported", reason: first.reason, basename, relative_path };
+    }
+    const record = first.record;
+    if (record.type !== "session_meta") {
+        return { kind: "unsupported", reason: "unsupported_metadata", basename, relative_path };
+    }
+    const payload = record.payload;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return { kind: "unsupported", reason: "unsupported_metadata", basename, relative_path };
+    }
+    const meta = payload;
+    if (isSubagentMeta(meta)) {
+        return { kind: "excluded", reason: "subagent", basename, relative_path };
+    }
+    const sessionId = typeof meta.id === "string" ? meta.id : typeof meta.session_id === "string" ? meta.session_id : null;
+    if (!sessionId) {
+        return { kind: "unsupported", reason: "unsupported_metadata", basename, relative_path };
+    }
+    if (sessionId !== filenameId) {
+        return { kind: "unsupported", reason: "session_id_mismatch", basename, relative_path };
+    }
+    if (typeof meta.session_id === "string" && typeof meta.id === "string" && meta.session_id !== meta.id) {
+        return { kind: "unsupported", reason: "session_id_mismatch", basename, relative_path };
+    }
+    if (!validateCodexSessionId(sessionId)) {
+        return { kind: "unsupported", reason: "invalid_session_id", basename, relative_path };
+    }
+    let cwd = null;
+    if (typeof meta.cwd === "string") {
+        try {
+            cwd = (0, config_1.canonicalize)(meta.cwd);
+        }
+        catch {
+            cwd = null;
+        }
+    }
+    try {
+        const signals = statSignals(filePath);
+        return {
+            kind: "supported",
+            session: {
+                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 {
+        return { kind: "unsupported", reason: "unreadable", basename, relative_path };
+    }
+}
+function* walkRolloutCandidates(sessionsRootReal) {
+    let yearEntries;
+    try {
+        yearEntries = fs.readdirSync(sessionsRootReal, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const yearEntry of yearEntries) {
+        if (!yearEntry.isDirectory() || !/^\d{4}$/.test(yearEntry.name))
+            continue;
+        const yearDir = path.join(sessionsRootReal, yearEntry.name);
+        let monthEntries;
+        try {
+            monthEntries = fs.readdirSync(yearDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const monthEntry of monthEntries) {
+            if (!monthEntry.isDirectory() || !/^\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() || !/^\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;
+                    if (!ROLLOUT_CANDIDATE_RE.test(file.name))
+                        continue;
+                    const match = ROLLOUT_RE.exec(file.name);
+                    if (match) {
+                        yield { filePath: path.join(dayDir, file.name), filenameId: match[1], supportedName: true };
+                    }
+                    else {
+                        yield { filePath: path.join(dayDir, file.name), filenameId: null, supportedName: false };
+                    }
+                }
+            }
+        }
+    }
+}
+function actionableDriftMessage() {
+    return [
+        "Codex rollout files were found but none use a supported format.",
+        "Repair/upgrade with `npx @letta-ai/dreams@latest onboard --json`, then rerun `dreams sync status --source codex --json`.",
+        "If still unsupported, preserve a sample rollout basename and report the new format.",
+    ].join(" ");
+}
+/**
+ * Walk Codex rollout candidates and classify each. Never throws for bad files.
+ */
+function inspectCodexDiscovery(sessionsDir = codexSessionsDir(), home = os.homedir()) {
+    const harness = detectCodexHarness(home);
+    const by_reason = {};
+    const examples = [];
+    let candidates = 0;
+    let supported = 0;
+    let unsupported = 0;
+    let excluded_subagent = 0;
+    let excluded_other = 0;
+    if (!harness.present) {
+        return {
+            harness_present: false,
+            sessions_dir_present: false,
+            candidates: 0,
+            supported: 0,
+            unsupported: 0,
+            excluded_subagent: 0,
+            excluded_other: 0,
+            by_reason: {},
+            examples: [],
+            status: "absent",
+            message: "Codex was not detected under ~/.codex",
+        };
+    }
+    let sessionsRootReal;
+    let sessionsDirPresent = false;
+    try {
+        sessionsRootReal = (0, config_1.canonicalize)(sessionsDir);
+        sessionsDirPresent = fs.statSync(sessionsRootReal).isDirectory();
+    }
+    catch {
+        return {
+            harness_present: true,
+            sessions_dir_present: false,
+            candidates: 0,
+            supported: 0,
+            unsupported: 0,
+            excluded_subagent: 0,
+            excluded_other: 0,
+            by_reason: {},
+            examples: [],
+            status: "empty",
+            message: "Codex is present but no sessions directory was found",
+        };
+    }
+    if (!sessionsDirPresent) {
+        return {
+            harness_present: true,
+            sessions_dir_present: false,
+            candidates: 0,
+            supported: 0,
+            unsupported: 0,
+            excluded_subagent: 0,
+            excluded_other: 0,
+            by_reason: {},
+            examples: [],
+            status: "empty",
+            message: "Codex is present but no sessions directory was found",
+        };
+    }
+    for (const { filePath, filenameId, supportedName } of walkRolloutCandidates(sessionsRootReal)) {
+        candidates++;
+        const result = supportedName
+            ? classifyCodexRollout(filePath, filenameId, { sessionsRootReal, home })
+            : {
+                kind: "unsupported",
+                reason: "invalid_session_id",
+                basename: path.basename(filePath),
+                relative_path: homeRelative(filePath, home),
+            };
+        if (result.kind === "supported") {
+            supported++;
+            continue;
+        }
+        if (result.kind === "excluded") {
+            if (result.reason === "subagent")
+                excluded_subagent++;
+            else
+                excluded_other++;
+            continue;
+        }
+        unsupported++;
+        by_reason[result.reason] = (by_reason[result.reason] ?? 0) + 1;
+        if (examples.length < MAX_EXAMPLES) {
+            examples.push({
+                reason: result.reason,
+                basename: result.basename,
+                relative_path: result.relative_path,
+            });
+        }
+    }
+    let status = "ok";
+    let message = null;
+    if (candidates === 0) {
+        status = "empty";
+        message = "Codex is present but no rollout files were found";
+    }
+    else if (supported === 0 && unsupported > 0) {
+        status = "warning";
+        message = actionableDriftMessage();
+    }
+    else if (supported > 0 && unsupported > 0) {
+        status = "warning";
+        message =
+            "Some Codex rollout files use an unsupported format and were skipped. " +
+                "Rerun `dreams sync status --source codex --json` after upgrading Dreams; " +
+                "supported sessions continue to sync.";
+    }
+    return {
+        harness_present: true,
+        sessions_dir_present: true,
+        candidates,
+        supported,
+        unsupported,
+        excluded_subagent,
+        excluded_other,
+        by_reason,
+        examples,
+        status,
+        message,
+    };
+}
+/**
+ * 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;
+    }
+    for (const { filePath, filenameId, supportedName } of walkRolloutCandidates(rootReal)) {
+        if (!supportedName || filenameId === null)
+            continue;
+        const result = classifyCodexRollout(filePath, filenameId, { sessionsRootReal: rootReal });
+        if (result.kind === "supported")
+            sessions.push(result.session);
+    }
+    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(),
+};