@greppleai/grip 0.0.0-stage → 0.0.1

package/dist/core/session/stores/jsonl-session-store.js

@@ -0,0 +1,1140 @@
+import { randomUUID } from "node:crypto";
+import { appendFileSync, closeSync, createReadStream, existsSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, renameSync, rmSync, statSync, writeFileSync, } from "fs";
+import { readdir, stat } from "fs/promises";
+import { basename, dirname, join, resolve } from "path";
+import { createInterface } from "readline";
+import { getAgentDir as getDefaultAgentDir, getSessionsDir } from "../../../config.js";
+import { JsonlDecodeError as JsonlDecodeFailure, JsonlSessionError, } from "../jsonl-errors.js";
+import { InMemorySessionStore } from "./in-memory-session-store.js";
+function isMessageWithContent(message) {
+    return typeof message.role === "string" && "content" in message;
+}
+function extractTextContent(message) {
+    const content = message.content;
+    if (content == null) {
+        return "";
+    }
+    if (typeof content === "string") {
+        return content;
+    }
+    return content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join(" ");
+}
+function getMessageActivityTime(entry) {
+    const message = entry.message;
+    if (!isMessageWithContent(message))
+        return undefined;
+    if (message.role !== "user" && message.role !== "assistant")
+        return undefined;
+    const msgTimestamp = message.timestamp;
+    if (typeof msgTimestamp === "number") {
+        return msgTimestamp;
+    }
+    const t = new Date(entry.timestamp).getTime();
+    return Number.isNaN(t) ? undefined : t;
+}
+const SESSION_READ_BUFFER_SIZE = 1024 * 1024;
+const SESSION_HEADER_READ_BUFFER_SIZE = 4096;
+/** Bound synchronous header discovery while allowing large cwd and custom metadata fields. */
+const MAX_SESSION_HEADER_SCAN_BYTES = 1024 * 1024;
+const SAFE_ID_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/;
+function parseSessionEntryLine(line) {
+    if (!line.trim())
+        return null;
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+}
+function* readPhysicalRecords(filePath) {
+    const fd = openSync(filePath, "r");
+    const buffer = Buffer.allocUnsafe(SESSION_READ_BUFFER_SIZE);
+    let pending = Buffer.alloc(0);
+    let consumedBytes = 0;
+    let recordStart = 0;
+    let line = 1;
+    try {
+        while (true) {
+            const bytesRead = readSync(fd, buffer, 0, buffer.length, null);
+            if (bytesRead === 0)
+                break;
+            const chunk = buffer.subarray(0, bytesRead);
+            const data = pending.length === 0 ? chunk : Buffer.concat([pending, chunk]);
+            let start = 0;
+            let newline = data.indexOf(0x0a, start);
+            while (newline !== -1) {
+                yield { bytes: data.subarray(start, newline), line, start: recordStart, terminated: true };
+                line++;
+                start = newline + 1;
+                recordStart = consumedBytes + bytesRead - (data.length - start);
+                newline = data.indexOf(0x0a, start);
+            }
+            pending = Buffer.from(data.subarray(start));
+            consumedBytes += bytesRead;
+        }
+        if (pending.length > 0)
+            yield { bytes: pending, line, start: recordStart, terminated: false };
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+const jsonlEntryLocations = new WeakMap();
+export function getJsonlEntryLocations(entries) {
+    return jsonlEntryLocations.get(entries);
+}
+function decodePhysicalRecord(record) {
+    let bytes = record.bytes;
+    if (bytes.at(-1) === 0x0d)
+        bytes = bytes.subarray(0, bytes.length - 1);
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch (error) {
+        throw new JsonlDecodeFailure("utf8", "contains invalid UTF-8", error instanceof Error ? error : new Error(String(error)));
+    }
+}
+function parseJsonObject(record) {
+    let parsed;
+    try {
+        parsed = JSON.parse(decodePhysicalRecord(record));
+    }
+    catch (error) {
+        if (error instanceof JsonlDecodeFailure)
+            throw error;
+        throw new JsonlDecodeFailure("syntax", "is not valid JSON", error instanceof Error ? error : new Error(String(error)));
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new JsonlDecodeFailure("schema", "is not a JSON object");
+    }
+    return parsed;
+}
+function requireString(value, field) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new JsonlDecodeFailure("schema", `has invalid ${field}`);
+    }
+    return value;
+}
+function requireId(value, field) {
+    const id = requireString(value, field);
+    if (!SAFE_ID_PATTERN.test(id))
+        throw new JsonlDecodeFailure("schema", `has invalid ${field}`);
+    return id;
+}
+function requireTimestamp(value) {
+    const timestamp = requireString(value, "timestamp");
+    if (Number.isNaN(Date.parse(timestamp)))
+        throw new JsonlDecodeFailure("schema", "has invalid timestamp");
+    return timestamp;
+}
+const MESSAGE_ROLES = new Set([
+    "user",
+    "assistant",
+    "toolResult",
+    "bashExecution",
+    "custom",
+    "branchSummary",
+    "compactionSummary",
+    "hookMessage",
+]);
+function validatePersistedMessageRole(message, role) {
+    switch (role) {
+        case "toolResult":
+            requireString(message.toolCallId, "toolCallId");
+            requireString(message.toolName, "toolName");
+            if (typeof message.isError !== "boolean")
+                throw new JsonlDecodeFailure("schema", "has invalid isError");
+            break;
+        case "custom":
+        case "hookMessage":
+            requireString(message.customType, "customType");
+            if (typeof message.display !== "boolean")
+                throw new JsonlDecodeFailure("schema", "has invalid display");
+            break;
+        case "bashExecution":
+            requireString(message.command, "command");
+            if (typeof message.output !== "string")
+                throw new JsonlDecodeFailure("schema", "has invalid output");
+            if (typeof message.cancelled !== "boolean" || typeof message.truncated !== "boolean") {
+                throw new JsonlDecodeFailure("schema", "has invalid bash state");
+            }
+            break;
+        case "branchSummary":
+        case "compactionSummary":
+            requireString(message.summary, "summary");
+    }
+}
+function validatePersistedMessage(value) {
+    if (typeof value !== "object" || value === null)
+        throw new JsonlDecodeFailure("schema", "has invalid message");
+    const message = value;
+    const role = requireString(message.role, "message role");
+    if (!MESSAGE_ROLES.has(role))
+        throw new JsonlDecodeFailure("schema", `has unknown message role ${role}`);
+    if (typeof message.timestamp !== "number" || !Number.isFinite(message.timestamp)) {
+        throw new JsonlDecodeFailure("schema", "has invalid message timestamp");
+    }
+    if (message.content != null && typeof message.content !== "string" && !Array.isArray(message.content)) {
+        throw new JsonlDecodeFailure("schema", "has invalid message content");
+    }
+    validatePersistedMessageRole(message, role);
+}
+const SESSION_ENTRY_TYPES = new Set([
+    "message",
+    "thinking_level_change",
+    "model_change",
+    "compaction",
+    "branch_summary",
+    "custom",
+    "custom_message",
+    "label",
+    "session_info",
+]);
+function parseStrictHeader(record) {
+    const value = parseJsonObject(record);
+    if (value.type !== "session")
+        throw new JsonlDecodeFailure("schema", "is not a session header");
+    const version = value.version ?? 1;
+    if (version !== 1 && version !== 2 && version !== 3) {
+        throw new JsonlDecodeFailure("schema", "has unsupported session version");
+    }
+    requireId(value.id, "session id");
+    requireTimestamp(value.timestamp);
+    requireString(value.cwd, "cwd");
+    if (value.parentSession !== undefined && typeof value.parentSession !== "string") {
+        throw new JsonlDecodeFailure("schema", "has invalid parentSession");
+    }
+    return value;
+}
+function validateVersionedEntryLinks(value, version) {
+    if (version < 2)
+        return;
+    requireId(value.id, "entry id");
+    if (value.parentId !== null && (typeof value.parentId !== "string" || !SAFE_ID_PATTERN.test(value.parentId))) {
+        throw new JsonlDecodeFailure("schema", "has invalid parentId");
+    }
+}
+function validateCompactionEntry(value, version) {
+    requireString(value.summary, "summary");
+    if (version === 1) {
+        if (value.firstKeptEntryId === undefined && !Number.isInteger(value.firstKeptEntryIndex)) {
+            throw new JsonlDecodeFailure("schema", "has invalid compaction target");
+        }
+    }
+    else
+        requireId(value.firstKeptEntryId, "firstKeptEntryId");
+    if (typeof value.tokensBefore !== "number" || !Number.isFinite(value.tokensBefore)) {
+        throw new JsonlDecodeFailure("schema", "has invalid tokensBefore");
+    }
+}
+function validateCustomMessageEntry(value) {
+    requireString(value.customType, "customType");
+    if (value.content != null && typeof value.content !== "string" && !Array.isArray(value.content)) {
+        throw new JsonlDecodeFailure("schema", "has invalid content");
+    }
+    if (typeof value.display !== "boolean")
+        throw new JsonlDecodeFailure("schema", "has invalid display");
+}
+function parseStrictEntry(record, version) {
+    const value = parseJsonObject(record);
+    const type = requireString(value.type, "entry type");
+    if (!SESSION_ENTRY_TYPES.has(type)) {
+        throw new JsonlDecodeFailure("schema", `has unknown entry type ${type}`);
+    }
+    requireTimestamp(value.timestamp);
+    validateVersionedEntryLinks(value, version);
+    switch (type) {
+        case "message":
+            validatePersistedMessage(value.message);
+            break;
+        case "thinking_level_change":
+            requireString(value.thinkingLevel, "thinkingLevel");
+            break;
+        case "model_change":
+            requireString(value.provider, "provider");
+            requireString(value.modelId, "modelId");
+            break;
+        case "compaction":
+            validateCompactionEntry(value, version);
+            break;
+        case "branch_summary":
+            requireId(value.fromId, "fromId");
+            requireString(value.summary, "summary");
+            break;
+        case "custom":
+            requireString(value.customType, "customType");
+            break;
+        case "custom_message":
+            validateCustomMessageEntry(value);
+            if (typeof value.display !== "boolean")
+                throw new JsonlDecodeFailure("schema", "has invalid display");
+            break;
+        case "label":
+            requireId(value.targetId, "targetId");
+            if (value.label !== undefined && typeof value.label !== "string") {
+                throw new JsonlDecodeFailure("schema", "has invalid label");
+            }
+            break;
+        case "session_info":
+            if (value.name !== undefined && typeof value.name !== "string") {
+                throw new JsonlDecodeFailure("schema", "has invalid name");
+            }
+            break;
+    }
+    return value;
+}
+function invalidJsonl(filePath, record, failure, phase) {
+    const decodeFailure = failure instanceof JsonlDecodeFailure ? failure : new JsonlDecodeFailure("state", failure.message, failure);
+    return new JsonlSessionError({
+        code: "invalid_jsonl",
+        reference: filePath,
+        phase,
+        line: record.line,
+        byteOffset: record.start,
+        decodeKind: decodeFailure.decodeKind,
+        message: `Invalid JSONL session file ${filePath}: line ${record.line} ${failure.message}`,
+        cause: decodeFailure,
+    });
+}
+function jsonlStorageError(reference, phase, message, cause, outcome) {
+    if (cause instanceof JsonlSessionError && cause.phase === phase)
+        return cause;
+    return new JsonlSessionError({
+        code: cause instanceof JsonlSessionError ? cause.code : "storage",
+        reference,
+        phase,
+        line: cause instanceof JsonlSessionError ? cause.line : undefined,
+        byteOffset: cause instanceof JsonlSessionError ? cause.byteOffset : undefined,
+        decodeKind: cause instanceof JsonlSessionError ? cause.decodeKind : undefined,
+        message,
+        outcome: outcome ?? (cause instanceof JsonlSessionError ? cause.outcome : undefined),
+        cause,
+    });
+}
+export class SessionHeaderScanLimitError extends Error {
+    constructor(filePath) {
+        super(`Session header exceeds ${MAX_SESSION_HEADER_SCAN_BYTES}-byte scan limit: ${filePath}`);
+        this.name = "SessionHeaderScanLimitError";
+    }
+}
+/**
+ * Inspect a physical line while searching for the first parsed session entry.
+ * Blank lines are skipped; a malformed non-blank candidate quarantines the file.
+ */
+function parseSessionHeaderCandidate(line) {
+    if (!line.trim())
+        return undefined;
+    try {
+        const bytes = new TextEncoder().encode(line);
+        return parseStrictHeader({ bytes, line: 1, start: 0, terminated: true });
+    }
+    catch {
+        return null;
+    }
+}
+function parseSessionHeaderBytes(bytes) {
+    try {
+        return parseSessionHeaderCandidate(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    }
+    catch {
+        return null;
+    }
+}
+export function readSessionHeader(filePath) {
+    const fd = openSync(filePath, "r");
+    try {
+        const buffer = Buffer.allocUnsafe(SESSION_HEADER_READ_BUFFER_SIZE);
+        let pending = Buffer.alloc(0);
+        let scannedBytes = 0;
+        while (scannedBytes < MAX_SESSION_HEADER_SCAN_BYTES) {
+            const readLength = Math.min(buffer.length, MAX_SESSION_HEADER_SCAN_BYTES - scannedBytes);
+            const bytesRead = readSync(fd, buffer, 0, readLength, null);
+            if (bytesRead === 0)
+                return parseSessionHeaderBytes(pending) ?? null;
+            scannedBytes += bytesRead;
+            const data = pending.length === 0
+                ? buffer.subarray(0, bytesRead)
+                : Buffer.concat([pending, buffer.subarray(0, bytesRead)]);
+            let lineStart = 0;
+            let newlineIndex = data.indexOf(0x0a, lineStart);
+            while (newlineIndex !== -1) {
+                const header = parseSessionHeaderBytes(data.subarray(lineStart, newlineIndex));
+                if (header !== undefined)
+                    return header;
+                lineStart = newlineIndex + 1;
+                newlineIndex = data.indexOf(0x0a, lineStart);
+            }
+            pending = Buffer.from(data.subarray(lineStart));
+        }
+        const probe = Buffer.allocUnsafe(1);
+        if (readSync(fd, probe, 0, probe.length, null) === 0)
+            return parseSessionHeaderBytes(pending) ?? null;
+        throw new SessionHeaderScanLimitError(filePath);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function readSessionHeaderForDiscovery(filePath) {
+    try {
+        return readSessionHeader(filePath);
+    }
+    catch (error) {
+        if (error instanceof SessionHeaderScanLimitError)
+            return null;
+        throw error;
+    }
+}
+function getSessionHeaderCwd(header) {
+    const cwd = header.cwd;
+    return typeof cwd === "string" ? cwd : undefined;
+}
+function sessionCwdMatches(cwd, resolvedCwd) {
+    return cwd !== undefined && cwd !== "" && resolve(cwd) === resolvedCwd;
+}
+function recordSessionInfoEntry(result, entry) {
+    if (entry.type === "session_info")
+        result.name = entry.name?.trim() || undefined;
+    if (entry.type !== "message")
+        return;
+    result.messageCount++;
+    const activityTime = getMessageActivityTime(entry);
+    if (typeof activityTime === "number") {
+        result.lastActivityTime = Math.max(result.lastActivityTime ?? 0, activityTime);
+    }
+    const message = entry.message;
+    if (!isMessageWithContent(message))
+        return;
+    if (message.role !== "user" && message.role !== "assistant")
+        return;
+    const textContent = extractTextContent(message);
+    if (!textContent)
+        return;
+    result.allMessages.push(textContent);
+    if (!result.firstMessage && message.role === "user")
+        result.firstMessage = textContent;
+}
+async function scanSessionInfo(filePath) {
+    const result = {
+        messageCount: 0,
+        firstMessage: "",
+        allMessages: [],
+        name: undefined,
+        lastActivityTime: undefined,
+    };
+    const lines = createInterface({
+        input: createReadStream(filePath, { encoding: "utf8" }),
+        crlfDelay: Infinity,
+    });
+    for await (const line of lines) {
+        const entry = parseSessionEntryLine(line);
+        if (entry && entry.type !== "session")
+            recordSessionInfoEntry(result, entry);
+    }
+    return result;
+}
+function resolveSessionModifiedDate(header, lastActivityTime, fallback) {
+    if (typeof lastActivityTime === "number" && lastActivityTime > 0)
+        return new Date(lastActivityTime);
+    const headerTime = typeof header.timestamp === "string" ? new Date(header.timestamp).getTime() : NaN;
+    return Number.isNaN(headerTime) ? fallback : new Date(headerTime);
+}
+async function buildSessionInfo(filePath) {
+    try {
+        const stats = await stat(filePath);
+        const header = readSessionHeaderForDiscovery(filePath);
+        if (!header)
+            return null;
+        const scan = await scanSessionInfo(filePath);
+        const cwd = typeof header.cwd === "string" ? header.cwd : "";
+        return {
+            reference: filePath,
+            path: filePath,
+            id: header.id,
+            cwd,
+            name: scan.name,
+            parentSessionPath: header.parentSession,
+            created: new Date(header.timestamp),
+            modified: resolveSessionModifiedDate(header, scan.lastActivityTime, stats.mtime),
+            messageCount: scan.messageCount,
+            firstMessage: scan.firstMessage || "(no messages)",
+            allMessagesText: scan.allMessages.join(" "),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+const MAX_CONCURRENT_SESSION_INFO_LOADS = 10;
+export function getSessionDirForReference(reference) {
+    return resolve(reference, "..");
+}
+export function getDefaultSessionDirPath(cwd, agentDir = getDefaultAgentDir()) {
+    const resolvedCwd = resolve(cwd);
+    const safePath = `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+    return join(resolve(agentDir), "sessions", safePath);
+}
+export function getDefaultSessionDir(cwd, agentDir = getDefaultAgentDir()) {
+    const sessionDir = getDefaultSessionDirPath(cwd, agentDir);
+    ensureDir(sessionDir);
+    return sessionDir;
+}
+export function getSessionsRoot() {
+    return getSessionsDir();
+}
+export function prepareSessionReference(sessionDir, sessionId, timestamp) {
+    const fileTimestamp = timestamp.replace(/[:.]/g, "-");
+    return join(sessionDir, `${fileTimestamp}_${sessionId}.jsonl`);
+}
+export function exists(path) {
+    return existsSync(path);
+}
+export function ensureDir(path) {
+    if (!existsSync(path)) {
+        mkdirSync(path, { recursive: true });
+    }
+}
+function failCurrentSessionValidation(state, index, failure) {
+    const location = state.locations?.[index];
+    throw new JsonlSessionError({
+        code: "invalid_jsonl",
+        reference: state.filePath,
+        phase: state.phase,
+        line: location?.line ?? index + 1,
+        byteOffset: location?.byteOffset,
+        decodeKind: failure.decodeKind,
+        message: `Invalid JSONL session file ${state.filePath}: line ${location?.line ?? index + 1} ${failure.message}`,
+        cause: failure,
+    });
+}
+function validateCurrentSessionHeader(header, state) {
+    if (header?.type !== "session" || header.version !== 3) {
+        failCurrentSessionValidation(state, 0, new JsonlDecodeFailure("state", "does not have a current version-3 header"));
+    }
+    try {
+        const encodedHeader = new TextEncoder().encode(JSON.stringify(header));
+        parseStrictHeader({ bytes: encodedHeader, line: 1, start: 0, terminated: true });
+    }
+    catch (error) {
+        if (error instanceof JsonlDecodeFailure)
+            failCurrentSessionValidation(state, 0, error);
+        throw error;
+    }
+}
+function validateCurrentSessionEntrySchema(entry, index, state) {
+    if (!entry || entry.type === "session") {
+        failCurrentSessionValidation(state, index, new JsonlDecodeFailure("state", `has an unexpected session header at logical entry ${index + 1}`));
+    }
+    try {
+        const encodedEntry = new TextEncoder().encode(JSON.stringify(entry));
+        parseStrictEntry({ bytes: encodedEntry, line: index + 1, start: 0, terminated: true }, 3);
+    }
+    catch (error) {
+        if (error instanceof JsonlDecodeFailure)
+            failCurrentSessionValidation(state, index, error);
+        throw error;
+    }
+}
+function getCurrentSessionEntryTarget(entry) {
+    switch (entry.type) {
+        case "label":
+            return entry.targetId;
+        case "compaction":
+            return entry.firstKeptEntryId;
+        case "branch_summary":
+            return entry.fromId;
+        default:
+            return undefined;
+    }
+}
+function validateCurrentSessionEntryLinks(entry, index, state) {
+    if (state.entriesById.has(entry.id)) {
+        failCurrentSessionValidation(state, index, new JsonlDecodeFailure("state", `duplicates entry id ${entry.id}`));
+    }
+    if (entry.parentId !== null && !state.entriesById.has(entry.parentId)) {
+        failCurrentSessionValidation(state, index, new JsonlDecodeFailure("state", `references missing parent ${entry.parentId}`));
+    }
+    const targetId = getCurrentSessionEntryTarget(entry);
+    if (targetId !== undefined && !state.entriesById.has(targetId)) {
+        failCurrentSessionValidation(state, index, new JsonlDecodeFailure("state", `references missing target ${targetId}`));
+    }
+    state.entriesById.set(entry.id, entry);
+}
+export function validateCurrentSessionEntries(entries, filePath = "session", context = {}) {
+    const state = {
+        filePath,
+        phase: context.phase ?? "open",
+        locations: context.locations,
+        entriesById: new Map(),
+    };
+    validateCurrentSessionHeader(entries[0], state);
+    for (let index = 1; index < entries.length; index++) {
+        const entry = entries[index];
+        validateCurrentSessionEntrySchema(entry, index, state);
+        validateCurrentSessionEntryLinks(entry, index, state);
+    }
+}
+function repairTornJsonlRecord(context, record) {
+    publishJsonlContentAtomically(context.filePath, readFileSync(context.filePath).subarray(0, record.start), {
+        ...context.publicationOptions,
+        phase: "repair",
+    });
+}
+function isRepairableDecodeFailure(context, state, record, failure) {
+    return context.repair && state.header !== undefined && !record.terminated && failure instanceof JsonlDecodeFailure;
+}
+function isRepairableSyntaxFailure(context, state, record, failure) {
+    return (context.repair &&
+        state.header !== undefined &&
+        !record.terminated &&
+        failure instanceof JsonlDecodeFailure &&
+        failure.kind === "syntax");
+}
+function scanJsonlRecord(context, state, record) {
+    state.finalRecord = record;
+    let line;
+    try {
+        line = decodePhysicalRecord(record);
+    }
+    catch (error) {
+        const failure = error instanceof Error ? error : new Error(String(error));
+        if (isRepairableDecodeFailure(context, state, record, failure)) {
+            repairTornJsonlRecord(context, record);
+            return "stop";
+        }
+        throw invalidJsonl(context.filePath, record, failure, context.phase);
+    }
+    if (!line.trim())
+        return "continue";
+    try {
+        if (!state.header) {
+            state.header = parseStrictHeader(record);
+            state.headerRecord = record;
+            state.entries.push(state.header);
+        }
+        else {
+            state.entries.push(parseStrictEntry(record, state.header.version ?? 1));
+        }
+        state.locations.push({ line: record.line, byteOffset: record.start });
+        return "continue";
+    }
+    catch (error) {
+        const failure = error instanceof Error ? error : new Error(String(error));
+        if (isRepairableSyntaxFailure(context, state, record, failure)) {
+            repairTornJsonlRecord(context, record);
+            return "stop";
+        }
+        throw invalidJsonl(context.filePath, record, failure, context.phase);
+    }
+}
+function requireLoadedSessionHeader(context, state) {
+    if (state.header && state.headerRecord)
+        return state.header;
+    const failure = new JsonlDecodeFailure("schema", "does not contain a session header");
+    throw new JsonlSessionError({
+        code: "invalid_jsonl",
+        reference: context.filePath,
+        phase: context.phase,
+        line: state.finalRecord?.line ?? 1,
+        byteOffset: state.finalRecord?.start ?? 0,
+        decodeKind: failure.decodeKind,
+        message: `Session file is not a valid grip session: ${context.filePath}`,
+        cause: failure,
+    });
+}
+function repairMissingFinalNewline(context, state) {
+    if (!context.repair || state.finalRecord?.terminated !== false || state.entries.at(-1) === undefined)
+        return;
+    const original = readFileSync(context.filePath);
+    if (original.length === 0 || original.at(-1) === 0x0a)
+        return;
+    const repaired = Buffer.allocUnsafe(original.length + 1);
+    original.copy(repaired);
+    repaired[original.length] = 0x0a;
+    publishJsonlContentAtomically(context.filePath, repaired, {
+        ...context.publicationOptions,
+        phase: "repair",
+    });
+}
+function validateLoadedSessionEntries(context, state, header) {
+    if ((header.version ?? 1) < 2)
+        return;
+    const validationContext = { phase: context.phase, locations: state.locations };
+    if (header.version === 2) {
+        // Version 2 has current tree fields; validate via a non-mutating header projection.
+        validateCurrentSessionEntries([{ ...header, version: 3 }, ...state.entries.slice(1)], context.filePath, validationContext);
+        return;
+    }
+    validateCurrentSessionEntries(state.entries, context.filePath, validationContext);
+}
+function loadJsonlSession(filePath, publicationOptions = {}, repair = true, phase = "open") {
+    if (!existsSync(filePath))
+        return [];
+    if (lstatSync(filePath).size === 0)
+        return [];
+    const context = { filePath, publicationOptions, repair, phase };
+    const state = {
+        entries: [],
+        locations: [],
+        header: undefined,
+        headerRecord: undefined,
+        finalRecord: undefined,
+    };
+    for (const record of readPhysicalRecords(filePath)) {
+        if (scanJsonlRecord(context, state, record) === "stop")
+            break;
+    }
+    const header = requireLoadedSessionHeader(context, state);
+    repairMissingFinalNewline(context, state);
+    validateLoadedSessionEntries(context, state, header);
+    jsonlEntryLocations.set(state.entries, state.locations);
+    return state.entries;
+}
+export function load(filePath, publicationOptions = {}, repair = true, phase = "open") {
+    try {
+        return loadJsonlSession(filePath, publicationOptions, repair, phase);
+    }
+    catch (error) {
+        if (error instanceof JsonlSessionError)
+            throw error;
+        const cause = error instanceof Error ? error : new Error(String(error));
+        throw jsonlStorageError(filePath, phase, `Failed to ${phase} JSONL session ${filePath}: ${cause.message}`, cause);
+    }
+}
+function getNextAppendPosition(bytes) {
+    let line = 1;
+    for (const byte of bytes) {
+        if (byte === 0x0a)
+            line++;
+    }
+    return { line, byteOffset: bytes.length };
+}
+function serializeJsonlEntries(entries) {
+    return `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`;
+}
+export function append(filePath, entry) {
+    appendFileSync(filePath, `${JSON.stringify(entry)}\n`);
+}
+function isWindowsRenameSharingError(error) {
+    if (!(error instanceof Error) || !("code" in error))
+        return false;
+    const code = error.code;
+    return code === "EPERM" || code === "EACCES" || code === "EBUSY";
+}
+function renameWithRetry(source, destination, rename, platform) {
+    for (let attempt = 0; attempt < 5; attempt++) {
+        try {
+            rename(source, destination);
+            return;
+        }
+        catch (error) {
+            if (platform !== "win32" || !isWindowsRenameSharingError(error) || attempt === 4)
+                throw error;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10 * 2 ** attempt);
+        }
+    }
+}
+function assertJsonlDestinationReplaceable(filePath) {
+    try {
+        const destinationInfo = lstatSync(filePath);
+        if (!destinationInfo.isFile())
+            throw new Error(`Refusing to replace non-file session path: ${filePath}`);
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+}
+function allocateJsonlStagingPath(filePath) {
+    const parentDir = dirname(filePath);
+    ensureDir(parentDir);
+    for (let attempt = 0; attempt < 100; attempt++) {
+        const candidate = join(parentDir, `.${basename(filePath)}.tmp-${randomUUID()}`);
+        if (!existsSync(candidate))
+            return candidate;
+    }
+    throw new Error(`Failed to allocate staging path for session: ${filePath}`);
+}
+function stageJsonlContent(tempPath, filePath, content, options) {
+    try {
+        writeFileSync(tempPath, content);
+    }
+    catch (error) {
+        const cause = error instanceof Error ? error : new Error(String(error));
+        throw jsonlStorageError(filePath, options.phase ?? "replace", `Failed to stage JSONL session ${filePath}: ${cause.message}`, cause, "not_written");
+    }
+}
+function publishJsonlStagingPath(tempPath, filePath, options) {
+    try {
+        renameWithRetry(tempPath, filePath, options.rename ?? renameSync, options.platform ?? process.platform);
+    }
+    catch (error) {
+        const cause = error instanceof Error ? error : new Error(String(error));
+        throw jsonlStorageError(filePath, options.phase ?? "replace", `Failed to publish JSONL session ${filePath}: ${cause.message}`, cause, "unknown");
+    }
+}
+function removeUnpublishedJsonlStagingPath(tempPath, options) {
+    try {
+        (options.remove ?? ((path) => rmSync(path, { force: true })))(tempPath);
+    }
+    catch {
+        // Preserve the staging or rename failure; stale temps are undiscoverable.
+    }
+}
+function publishJsonlContentAtomicallyUnsafe(filePath, content, options = {}) {
+    assertJsonlDestinationReplaceable(filePath);
+    const tempPath = allocateJsonlStagingPath(filePath);
+    let published = false;
+    try {
+        stageJsonlContent(tempPath, filePath, content, options);
+        publishJsonlStagingPath(tempPath, filePath, options);
+        published = true;
+    }
+    finally {
+        if (!published)
+            removeUnpublishedJsonlStagingPath(tempPath, options);
+    }
+}
+function publishJsonlContentAtomically(filePath, content, options = {}) {
+    try {
+        publishJsonlContentAtomicallyUnsafe(filePath, content, options);
+    }
+    catch (error) {
+        if (error instanceof JsonlSessionError)
+            throw error;
+        const cause = error instanceof Error ? error : new Error(String(error));
+        throw jsonlStorageError(filePath, options.phase ?? "replace", `Failed to publish JSONL session ${filePath}: ${cause.message}`, cause, "not_written");
+    }
+}
+export function publishJsonlAtomically(filePath, entries, options = {}) {
+    publishJsonlContentAtomically(filePath, serializeJsonlEntries(entries), options);
+}
+export function rewrite(filePath, entries) {
+    publishJsonlAtomically(filePath, entries);
+}
+export function forkSession(sessionDir, header, sourceEntries) {
+    const reference = prepareSessionReference(sessionDir, header.id, header.timestamp);
+    publishJsonlAtomically(reference, [header, ...sourceEntries.filter((entry) => entry.type !== "session")], {
+        phase: "fork",
+    });
+    return reference;
+}
+export function findMostRecent(sessionDir, cwd) {
+    const resolvedCwd = cwd ? resolve(cwd) : undefined;
+    let names;
+    try {
+        names = readdirSync(sessionDir).filter((file) => file.endsWith(".jsonl"));
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    const files = [];
+    for (const name of names) {
+        const path = join(sessionDir, name);
+        try {
+            const header = readSessionHeaderForDiscovery(path);
+            if (!header)
+                continue;
+            if (resolvedCwd && !sessionCwdMatches(getSessionHeaderCwd(header), resolvedCwd))
+                continue;
+            files.push({ path, mtime: statSync(path).mtime });
+        }
+        catch {
+            // Quarantine a candidate that disappeared or became unreadable without hiding valid siblings.
+        }
+    }
+    files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    return files[0]?.path ?? null;
+}
+export async function list(dir, onProgress) {
+    const sessions = [];
+    if (!existsSync(dir)) {
+        return sessions;
+    }
+    const dirEntries = await readdir(dir);
+    const files = dirEntries.filter((file) => file.endsWith(".jsonl")).map((file) => join(dir, file));
+    let loaded = 0;
+    const results = await buildSessionInfosWithConcurrency(files, () => {
+        loaded++;
+        onProgress?.(loaded, files.length);
+    });
+    for (const info of results) {
+        if (info)
+            sessions.push(info);
+    }
+    return sessions;
+}
+export async function listAll(sessionsDir, onProgress) {
+    if (!existsSync(sessionsDir))
+        return [];
+    const entries = await readdir(sessionsDir, { withFileTypes: true });
+    const dirs = entries.filter((entry) => entry.isDirectory()).map((entry) => join(sessionsDir, entry.name));
+    let totalFiles = 0;
+    const dirFiles = [];
+    for (const dir of dirs) {
+        const files = (await readdir(dir)).filter((file) => file.endsWith(".jsonl"));
+        dirFiles.push(files.map((file) => join(dir, file)));
+        totalFiles += files.length;
+    }
+    let loaded = 0;
+    const sessions = [];
+    const results = await buildSessionInfosWithConcurrency(dirFiles.flat(), () => {
+        loaded++;
+        onProgress?.(loaded, totalFiles);
+    });
+    for (const info of results) {
+        if (info)
+            sessions.push(info);
+    }
+    return sessions;
+}
+async function buildSessionInfosWithConcurrency(files, onLoaded) {
+    const results = new Array(files.length).fill(null);
+    const inFlight = new Set();
+    let nextIndex = 0;
+    const startNext = () => {
+        const index = nextIndex++;
+        const file = files[index];
+        if (!file)
+            return;
+        let task;
+        task = buildSessionInfo(file)
+            .then((info) => {
+            results[index] = info;
+        })
+            .catch(() => {
+            results[index] = null;
+        })
+            .finally(() => {
+            inFlight.delete(task);
+            onLoaded();
+        });
+        inFlight.add(task);
+    };
+    while (nextIndex < files.length || inFlight.size > 0) {
+        while (nextIndex < files.length && inFlight.size < MAX_CONCURRENT_SESSION_INFO_LOADS) {
+            startNext();
+        }
+        if (inFlight.size > 0) {
+            await Promise.race(inFlight);
+        }
+    }
+    return results;
+}
+export class SessionAlreadyExistsError extends Error {
+    code = "already_exists";
+    reference;
+    path;
+    phase;
+    outcome = "not_written";
+    constructor(reference, sessionId, phase = "create") {
+        super(`Session already exists: ${sessionId}`);
+        this.name = "SessionAlreadyExistsError";
+        this.reference = reference;
+        this.path = reference;
+        this.phase = phase;
+    }
+}
+function isDefinitelyNotWritten(error) {
+    if (!(error instanceof Error) || !("code" in error))
+        return false;
+    return new Set(["ENOENT", "EACCES", "EPERM", "EISDIR", "ENOTDIR", "EINVAL", "EROFS"]).has(String(error.code));
+}
+function getFirstPublicationPhase(entries) {
+    const header = entries[0];
+    return header?.type === "session" && header.parentSession ? "fork" : "create";
+}
+const defaultWriteOperations = {
+    append: appendFileSync,
+    publish: publishJsonlAtomically,
+};
+export class JsonlSessionStore extends InMemorySessionStore {
+    reference;
+    flushed = false;
+    preloaded;
+    allowExistingEmptyFile = false;
+    writeOperations;
+    firstPublicationCoordinator;
+    writeFence;
+    nextAppendLine = 1;
+    nextAppendOffset = 0;
+    constructor(preloaded, writeOperations = defaultWriteOperations, firstPublicationCoordinator) {
+        super();
+        this.preloaded = preloaded ? { ...preloaded, reference: resolve(preloaded.reference) } : undefined;
+        this.writeOperations = writeOperations;
+        this.firstPublicationCoordinator = firstPublicationCoordinator;
+    }
+    isPersisted() {
+        return true;
+    }
+    getSessionReference() {
+        return this.reference;
+    }
+    setSessionReference(reference, options = {}) {
+        const resolvedReference = resolve(reference);
+        if (this.reference !== resolvedReference) {
+            this.writeFence = undefined;
+            this.allowExistingEmptyFile = false;
+        }
+        this.reference = resolvedReference;
+        if (options.allowExistingEmptyFile)
+            this.allowExistingEmptyFile = true;
+        this.flushed = false;
+    }
+    exists(path) {
+        return exists(path);
+    }
+    ensureDir(path) {
+        ensureDir(path);
+    }
+    load(filePath) {
+        if (!exists(filePath))
+            return [];
+        const info = lstatSync(filePath);
+        this.allowExistingEmptyFile = info.isFile() && info.size === 0;
+        this.flushed = true;
+        const resolvedFilePath = resolve(filePath);
+        if (!this.writeFence && this.preloaded?.reference === resolvedFilePath) {
+            const entries = this.preloaded.entries;
+            this.preloaded = undefined;
+            this.updateNextAppendPosition(resolvedFilePath);
+            return entries;
+        }
+        const entries = load(resolvedFilePath);
+        this.updateNextAppendPosition(resolvedFilePath);
+        this.writeFence = undefined;
+        this.preloaded = undefined;
+        return entries;
+    }
+    updateNextAppendPosition(filePath) {
+        const position = getNextAppendPosition(readFileSync(filePath));
+        this.nextAppendLine = position.line;
+        this.nextAppendOffset = position.byteOffset;
+    }
+    persistAppendedEntry(reference, prospectiveEntries, serializedEntry) {
+        try {
+            if (this.flushed)
+                this.writeOperations.append(reference, serializedEntry);
+            else
+                this.publishFirstSnapshot(prospectiveEntries);
+        }
+        catch (error) {
+            if (error instanceof SessionAlreadyExistsError)
+                throw error;
+            const cause = error instanceof Error ? error : new Error(String(error));
+            if (this.flushed && isDefinitelyNotWritten(error)) {
+                throw jsonlStorageError(reference, "append", cause.message, cause, "not_written");
+            }
+            this.writeFence = jsonlStorageError(reference, this.flushed ? "append" : getFirstPublicationPhase(prospectiveEntries), cause.message, cause, cause instanceof JsonlSessionError ? undefined : "unknown");
+            throw this.writeFence;
+        }
+    }
+    recordAppendedEntryPosition(wasFlushed, serializedEntry, prospectiveEntries) {
+        if (wasFlushed) {
+            this.nextAppendLine++;
+            this.nextAppendOffset += Buffer.byteLength(serializedEntry);
+            return;
+        }
+        const position = getNextAppendPosition(new TextEncoder().encode(serializeJsonlEntries(prospectiveEntries)));
+        this.nextAppendLine = position.line;
+        this.nextAppendOffset = position.byteOffset;
+    }
+    appendEntry(entry) {
+        if (!this.reference) {
+            super.appendEntry(entry);
+            return;
+        }
+        this.assertWritable();
+        const prospectiveEntries = [...this.getFileEntries(), entry];
+        const wasFlushed = this.flushed;
+        const appendPosition = wasFlushed
+            ? { line: this.nextAppendLine, byteOffset: this.nextAppendOffset }
+            : getNextAppendPosition(new TextEncoder().encode(serializeJsonlEntries(this.getFileEntries())));
+        const locations = [];
+        locations[prospectiveEntries.length - 1] = appendPosition;
+        validateCurrentSessionEntries(prospectiveEntries, this.reference, { phase: "append", locations });
+        const hasAssistantMessage = prospectiveEntries.some((fileEntry) => fileEntry.type === "message" && fileEntry.message.role === "assistant");
+        if (!hasAssistantMessage) {
+            super.appendEntry(entry);
+            this.flushed = false;
+            return;
+        }
+        if (!this.flushed)
+            serializeJsonlEntries(prospectiveEntries);
+        const serializedEntry = this.flushed ? `${JSON.stringify(entry)}\n` : undefined;
+        this.persistAppendedEntry(this.reference, prospectiveEntries, serializedEntry);
+        super.appendEntry(entry);
+        this.recordAppendedEntryPosition(wasFlushed, serializedEntry, prospectiveEntries);
+        this.flushed = true;
+        this.allowExistingEmptyFile = false;
+    }
+    assertWritable() {
+        if (this.writeFence) {
+            throw new JsonlSessionError({
+                code: "fenced",
+                reference: this.reference ?? "",
+                phase: "append",
+                message: `Session writes are fenced after a persistence failure: ${this.reference}`,
+                outcome: "unknown",
+                cause: this.writeFence,
+            });
+        }
+    }
+    publishFirstSnapshot(entries) {
+        if (!this.reference)
+            return;
+        const phase = getFirstPublicationPhase(entries);
+        const operation = () => this.writeOperations.publish(this.reference, entries, { phase });
+        if (this.firstPublicationCoordinator) {
+            this.firstPublicationCoordinator.publish(this.reference, entries, operation, {
+                allowExistingEmptyFile: this.allowExistingEmptyFile,
+                phase,
+            });
+        }
+        else {
+            operation();
+        }
+    }
+    saveSnapshot(options = {}) {
+        if (!this.reference)
+            return;
+        this.assertWritable();
+        serializeJsonlEntries(this.getFileEntries());
+        try {
+            if (this.flushed) {
+                this.writeOperations.publish(this.reference, this.getFileEntries(), {
+                    phase: options.phase ?? "replace",
+                });
+            }
+            else
+                this.publishFirstSnapshot(this.getFileEntries());
+        }
+        catch (error) {
+            if (error instanceof SessionAlreadyExistsError)
+                throw error;
+            const cause = error instanceof Error ? error : new Error(String(error));
+            this.writeFence = jsonlStorageError(this.reference, options.phase ?? (this.flushed ? "replace" : getFirstPublicationPhase(this.getFileEntries())), cause.message, cause, cause instanceof JsonlSessionError ? undefined : "unknown");
+            throw this.writeFence;
+        }
+        const position = getNextAppendPosition(new TextEncoder().encode(serializeJsonlEntries(this.getFileEntries())));
+        this.nextAppendLine = position.line;
+        this.nextAppendOffset = position.byteOffset;
+        this.flushed = true;
+        this.allowExistingEmptyFile = false;
+    }
+    commitSnapshot() {
+        if (!this.hasAssistantMessage()) {
+            this.flushed = false;
+            return;
+        }
+        this.saveSnapshot();
+    }
+}
+//# sourceMappingURL=jsonl-session-store.js.map