@letta-ai/dreams 0.0.1 → 0.0.4

package/dist/local/claude-hooks.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Claude Code live-sync hook helpers — merge Dreams SessionStart/Stop into
+ * ~/.claude/settings.json without clobbering unrelated handlers.
+ *
+ * SessionStart → `dreams wake` (housekeeping + pending drain)
+ * Stop → `dreams sync` (live turn, stdin session hint)
+ */
+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.CLAUDE_HOOK_MARKER = void 0;
+exports.claudeSettingsPath = claudeSettingsPath;
+exports.buildClaudeHookCommandPosix = buildClaudeHookCommandPosix;
+exports.buildClaudeHookCommandPowerShell = buildClaudeHookCommandPowerShell;
+exports.buildClaudeHookCommand = buildClaudeHookCommand;
+exports.mergeClaudeSettingsJson = mergeClaudeSettingsJson;
+exports.planClaudeHooksInstall = planClaudeHooksInstall;
+exports.installClaudeHooks = installClaudeHooks;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+exports.CLAUDE_HOOK_MARKER = "dreams-sync-hook";
+function claudeSettingsPath(home = os.homedir()) {
+    return path.join(home, ".claude", "settings.json");
+}
+/** POSIX bash command for Claude Code command hooks. */
+function buildClaudeHookCommandPosix(cliPath, mode) {
+    return `"${cliPath}" ${mode} >/dev/null 2>&1 || true # ${exports.CLAUDE_HOOK_MARKER}`;
+}
+/** PowerShell command for Claude Code command hooks on Windows. */
+function buildClaudeHookCommandPowerShell(cliPath, mode) {
+    const quoted = cliPath.replace(/'/g, "''");
+    return `& '${quoted}' ${mode} *> $null; exit 0 # ${exports.CLAUDE_HOOK_MARKER}`;
+}
+function buildClaudeHookCommand(cliPath, mode, platform = process.platform) {
+    return platform === "win32"
+        ? buildClaudeHookCommandPowerShell(cliPath, mode)
+        : buildClaudeHookCommandPosix(cliPath, mode);
+}
+function isDreamsClaudeHandler(command) {
+    if (typeof command !== "string")
+        return false;
+    // Prefer the marker; also recognize older Dreams sync-only handlers by cli+sync.
+    return (command.includes(exports.CLAUDE_HOOK_MARKER) ||
+        (/\bsync\b/.test(command) && (command.includes("dreams") || command.includes(">/dev/null") || command.includes("*> $null"))));
+}
+function upsertEventHandler(matchers, command, platform) {
+    const next = matchers.map((matcher) => ({ ...matcher, hooks: [...(matcher.hooks ?? [])] }));
+    let updated = false;
+    for (const matcher of next) {
+        const hooks = matcher.hooks ?? [];
+        for (let i = 0; i < hooks.length; i++) {
+            if (isDreamsClaudeHandler(hooks[i]?.command)) {
+                const handler = { ...hooks[i], type: "command", command };
+                if (platform === "win32")
+                    handler.shell = "powershell";
+                else
+                    delete handler.shell;
+                hooks[i] = handler;
+                updated = true;
+            }
+        }
+        matcher.hooks = hooks;
+    }
+    if (updated)
+        return next;
+    const handler = { type: "command", command };
+    if (platform === "win32")
+        handler.shell = "powershell";
+    return [...next, { hooks: [handler] }];
+}
+/**
+ * Merge Dreams Claude handlers into settings.json.
+ * SessionStart uses wake; Stop uses sync.
+ */
+function mergeClaudeSettingsJson(existingRaw, cliPath, platform = process.platform) {
+    const wakeCmd = buildClaudeHookCommand(cliPath, "wake", platform);
+    const syncCmd = buildClaudeHookCommand(cliPath, "sync", platform);
+    let doc = {};
+    if (existingRaw !== null && existingRaw.trim() !== "") {
+        const parsed = JSON.parse(existingRaw);
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error("claude settings.json must be a JSON object");
+        }
+        doc = { ...parsed };
+    }
+    const hooksValue = doc.hooks;
+    const hooks = hooksValue && typeof hooksValue === "object" && !Array.isArray(hooksValue)
+        ? { ...hooksValue }
+        : {};
+    const sessionStart = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+    const stop = Array.isArray(hooks.Stop) ? hooks.Stop : [];
+    hooks.SessionStart = upsertEventHandler(sessionStart, wakeCmd, platform);
+    hooks.Stop = upsertEventHandler(stop, syncCmd, platform);
+    doc.hooks = hooks;
+    return `${JSON.stringify(doc, null, 2)}\n`;
+}
+function planClaudeHooksInstall(options) {
+    const home = options.home ?? os.homedir();
+    const platform = options.platform ?? process.platform;
+    const settingsPath = claudeSettingsPath(home);
+    let existing = null;
+    try {
+        existing = fs.readFileSync(settingsPath, "utf8");
+    }
+    catch {
+        existing = null;
+    }
+    const next = mergeClaudeSettingsJson(existing, options.cliPath, platform);
+    return {
+        settings_path: settingsPath,
+        changed: existing !== next,
+        session_start_command: buildClaudeHookCommand(options.cliPath, "wake", platform),
+        stop_command: buildClaudeHookCommand(options.cliPath, "sync", platform),
+        next_contents: next,
+    };
+}
+function installClaudeHooks(options) {
+    const plan = planClaudeHooksInstall(options);
+    if (plan.changed) {
+        fs.mkdirSync(path.dirname(plan.settings_path), { recursive: true });
+        const temporary = `${plan.settings_path}.tmp-${process.pid}-${Math.random().toString(16).slice(2)}`;
+        try {
+            fs.writeFileSync(temporary, plan.next_contents, { encoding: "utf8" });
+            fs.renameSync(temporary, plan.settings_path);
+        }
+        finally {
+            try {
+                fs.rmSync(temporary, { force: true });
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    return plan;
+}

package/dist/local/claude.js

@@ -1,17 +1,22 @@
 "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>/
  *   - filename must be a UUID-like `<sessionId>.jsonl`
- *   - the transcript's own `sessionId` must agree with the filename
+ *   - a complete head record's `sessionId` must agree with the filename
+ *   - `cwd` is taken from the first head record that carries a string `cwd`
+ *     for that session (modern Claude transcripts often open with mode /
+ *     ai-title / etc. before the first cwd-bearing record)
  *   - never recurse; the `subagents/` directory is excluded outright
- *   - `isSidechain: true` records are a secondary signal to exclude sidechains
+ *   - `isSidechain: true` on any matching head record excludes the file
  * `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,203 +52,142 @@ 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";
-    }
-}
-exports.IdentityChangedError = IdentityChangedError;
-function fingerprint(bytes) {
-    return crypto.createHash("sha256").update(bytes).digest("hex");
-}
-/** Read the file head and return the first COMPLETE JSONL record, or null. */
-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; // no complete first line yet
-        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 validateClaudeSessionId(value) {
+    return UUID_RE.test(value);
 }
 /**
- * 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.)
+ * Deterministic harness-owned filesystem facts only. Never opens transcript
+ * files or walks session contents. Paths stay private to this adapter.
  */
-function firstChunkFingerprint(filePath) {
-    let fd;
+function detectClaudeCodeHarness(home = os.homedir()) {
+    const claudeDir = path.join(home, ".claude");
+    const evidence = [];
     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);
+        if (!fs.statSync(claudeDir).isDirectory()) {
+            return { present: false, evidence };
+        }
     }
     catch {
-        return "";
-    }
-    finally {
-        if (fd !== undefined)
-            fs.closeSync(fd);
+        return { present: false, evidence };
     }
-}
-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");
+    evidence.push(claudeDir);
+    const projectsDir = path.join(home, ".claude", "projects");
     try {
-        const digest = crypto.createHash("sha256");
-        hashRange(fd, length, digest, onProgress);
-        return digest.digest("hex");
+        if (fs.statSync(projectsDir).isDirectory())
+            evidence.push(projectsDir);
     }
-    finally {
-        fs.closeSync(fd);
+    catch {
+        // projects/ is optional evidence; ~/.claude alone is enough.
     }
-}
-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";
+    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 };
 }
-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.
+ * Read up to HEAD_READ_BYTES and derive session identity + cwd from complete
+ * JSONL records in that window. Modern Claude Code transcripts often open with
+ * metadata lines (mode, ai-title, …) that omit `cwd`; the first cwd-bearing
+ * record may appear several lines later (still well within the head window).
+ *
+ * Returns null when the head has no complete line, no matching sessionId, a
+ * mismatched sessionId, or is unreadable / malformed beyond recovery.
  */
-function scanCompleteLinesVerified(realPath, start, expectedInode, maxLineBytes, onLine, onProgress) {
+function readHeadSessionFacts(filePath, expectedSessionId) {
     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;
+        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 null;
+        const head = buf.subarray(0, read);
+        // Only complete lines — a trailing partial record in the head is ignored.
+        const text = head.toString("utf8");
+        const lines = text.split("\n");
+        // If the buffer did not end on a newline, the final split piece is partial.
+        const completeLines = head[head.length - 1] === 0x0a ? lines : lines.slice(0, -1);
+        if (completeLines.length === 0)
+            return null;
+        let sawMatchingSession = false;
+        let isSidechain = false;
+        let cwd = null;
+        for (const raw of completeLines) {
+            const line = raw.trim();
+            if (line === "")
+                continue;
+            let record;
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+                    continue;
+                record = parsed;
             }
-            carry = Buffer.from(combined.subarray(consumed));
-            carryStart = combinedStart + consumed;
-            if (carry.length > maxLineBytes) {
-                throw new OversizedLineError(realPath, carryStart, carry.length, maxLineBytes);
+            catch {
+                continue;
+            }
+            const sessionId = typeof record.sessionId === "string" ? record.sessionId : null;
+            if (sessionId !== null) {
+                if (sessionId !== expectedSessionId) {
+                    return null; // filename must agree with every sessionId in the head
+                }
+                sawMatchingSession = true;
+                if (record.isSidechain === true)
+                    isSidechain = true;
+            }
+            // First cwd-bearing record wins. Modern transcripts put cwd on a later
+            // user/assistant line; some preamble lines omit sessionId entirely.
+            if (cwd === null && typeof record.cwd === "string" && record.cwd.length > 0) {
+                try {
+                    cwd = (0, config_1.canonicalize)(record.cwd);
+                }
+                catch {
+                    cwd = null;
+                }
             }
         }
-        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") : "",
-        };
+        if (!sawMatchingSession)
+            return null;
+        return { sessionId: expectedSessionId, cwd, isSidechain };
+    }
+    catch {
+        return null;
     }
     finally {
-        if (fd !== undefined)
-            fs.closeSync(fd);
+        if (fd !== undefined) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                // ignore
+            }
+        }
     }
 }
 function statSignals(filePath) {
@@ -256,6 +200,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 = [];
@@ -288,28 +235,35 @@ function discoverSessions(projectsDir = claudeProjectsDir()) {
             if (!UUID_RE.test(base))
                 continue;
             const filePath = path.join(projectDir, file.name);
-            const record = readFirstRecord(filePath);
-            if (!record)
+            const facts = readHeadSessionFacts(filePath, base);
+            if (!facts)
                 continue;
-            if (record.isSidechain === true)
+            if (facts.isSidechain)
                 continue;
-            const sessionId = typeof record.sessionId === "string" ? record.sessionId : null;
-            if (sessionId !== base)
-                continue; // filename must agree with the transcript
             const signals = statSignals(filePath);
             sessions.push({
                 path: filePath,
                 real_path: (0, config_1.canonicalize)(filePath),
-                session_id: sessionId,
-                cwd: typeof record.cwd === "string" ? (0, config_1.canonicalize)(record.cwd) : null,
+                session_id: facts.sessionId,
+                cwd: facts.cwd,
                 size: signals.size,
                 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(),
+};