@ashx-j/lunr 0.2.21 → 0.2.22

package/dist/core/session-manager.js

@@ -1,6 +1,6 @@
 import { uuidv7 } from "@ashx-j/lunr-agent";
-import { randomUUID } from "crypto";
-import { appendFileSync, closeSync, createReadStream, existsSync, mkdirSync, openSync, readdirSync, readSync, statSync, writeFileSync, } from "fs";
+import { createHash, randomUUID } from "crypto";
+import { appendFileSync, closeSync, createReadStream, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, statSync, writeFileSync, } from "fs";
 import { readdir, stat } from "fs/promises";
 import { join, resolve } from "path";
 import { createInterface } from "readline";
@@ -8,6 +8,7 @@ import { StringDecoder } from "string_decoder";
 import { getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
 import { normalizePath, resolvePath } from "../utils/paths.js";
 import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "./messages.js";
+import { canonicalSessionPath, SessionOwnership, SessionOwnershipError, writeSessionJson, } from "./session-ownership.js";
 export const CURRENT_SESSION_VERSION = 3;
 function createSessionId() {
     return uuidv7();
@@ -535,6 +536,92 @@ export class SessionManager {
     labelsById = new Map();
     labelTimestampsById = new Map();
     leafId = null;
+    ownership;
+    readOnly = false;
+    disposed = false;
+    permissionMode;
+    getPermissionMode() {
+        return this.permissionMode;
+    }
+    setPermissionMode(mode) {
+        this.assertWritable();
+        this.permissionMode = mode;
+        this.saveLeaf();
+    }
+    assertWritable() {
+        if (this.readOnly || this.disposed)
+            throw new SessionOwnershipError(this.sessionFile ?? "in-memory", "Session is read-only or released.");
+        if (this.persist) {
+            this.ownership?.assert();
+            if (this.ownership &&
+                this.sessionFile &&
+                canonicalSessionPath(this.sessionFile) !== this.ownership.owner.file) {
+                throw new SessionOwnershipError(this.sessionFile, "Session ownership does not match the write target.");
+            }
+        }
+    }
+    getOwnership() {
+        return this.ownership;
+    }
+    copyInMemory() {
+        const copy = SessionManager.inMemory(this.cwd);
+        copy.sessionId = this.sessionId;
+        copy.fileEntries = structuredClone(this.fileEntries);
+        copy._buildIndex();
+        copy.leafId = this.leafId;
+        return copy;
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        if (!this.readOnly)
+            this.saveLeaf();
+        this.ownership?.release();
+        this.disposed = true;
+    }
+    flush() {
+        this.assertWritable();
+        if (!this.persist)
+            return;
+        this._rewriteFile();
+        this.flushed = true;
+        this.saveLeaf();
+    }
+    claim(file) {
+        this.assertWritable();
+        const canonical = canonicalSessionPath(file);
+        if (this.ownership?.owner.file === canonical)
+            return;
+        const next = new SessionOwnership(canonical);
+        this.saveLeaf();
+        this.ownership?.release();
+        this.ownership = next;
+    }
+    saveLeaf() {
+        if (!this.persist || !this.sessionFile || !this.flushed)
+            return;
+        this.assertWritable();
+        writeSessionJson(`${this.sessionFile}.leaf.json`, {
+            id: this.sessionId,
+            leafId: this.leafId,
+            permissionMode: this.permissionMode,
+            revision: createHash("sha256").update(readFileSync(this.sessionFile)).digest("hex"),
+        });
+    }
+    restoreLeaf() {
+        if (!this.sessionFile)
+            return;
+        try {
+            const saved = JSON.parse(readFileSync(`${this.sessionFile}.leaf.json`, "utf8"));
+            if (saved.id === this.sessionId && ["manual", "yolo", "plan", "auto"].includes(saved.permissionMode))
+                this.permissionMode = saved.permissionMode;
+            if (saved.id === this.sessionId &&
+                (saved.leafId === null || this.byId.has(saved.leafId)) &&
+                saved.revision === createHash("sha256").update(readFileSync(this.sessionFile)).digest("hex"))
+                this.leafId = saved.leafId;
+        }
+        catch { }
+    }
     constructor(cwd, sessionDir, sessionFile, persist, newSessionOptions) {
         this.cwd = resolvePath(cwd);
         this.sessionDir = normalizePath(sessionDir);
@@ -542,15 +629,37 @@ export class SessionManager {
         if (persist && this.sessionDir && !existsSync(this.sessionDir)) {
             mkdirSync(this.sessionDir, { recursive: true });
         }
-        if (sessionFile) {
-            this.setSessionFile(sessionFile);
+        try {
+            if (sessionFile)
+                this.loadSessionFile(sessionFile);
+            else
+                this.newSession(newSessionOptions);
+            this.ownership?.bindSession(this.sessionId);
         }
-        else {
-            this.newSession(newSessionOptions);
+        catch (error) {
+            this.ownership?.release();
+            throw error;
         }
     }
     /** Switch to a different session file (used for resume and branching) */
     setSessionFile(sessionFile) {
+        this.assertWritable();
+        if (this.sessionFile && canonicalSessionPath(sessionFile) === canonicalSessionPath(this.sessionFile)) {
+            this.loadSessionFile(sessionFile);
+            return;
+        }
+        const next = new SessionManager(this.cwd, this.sessionDir, sessionFile, this.persist);
+        try {
+            this.dispose();
+        }
+        catch (error) {
+            next.dispose();
+            throw error;
+        }
+        Object.assign(this, next);
+    }
+    loadSessionFile(sessionFile) {
+        this.claim(sessionFile);
         this.sessionFile = resolvePath(sessionFile);
         if (existsSync(this.sessionFile)) {
             this.fileEntries = loadEntriesFromFile(this.sessionFile);
@@ -561,7 +670,7 @@ export class SessionManager {
                 if (statSync(explicitPath).size > 0) {
                     throw new Error(`Session file is not a valid pi session: ${explicitPath}`);
                 }
-                this.newSession();
+                this.initializeSession();
                 this.sessionFile = explicitPath;
                 this._rewriteFile();
                 this.flushed = true;
@@ -573,20 +682,31 @@ export class SessionManager {
                 this._rewriteFile();
             }
             this._buildIndex();
+            this.restoreLeaf();
             this.flushed = true;
         }
         else {
             const explicitPath = this.sessionFile;
-            this.newSession();
+            this.initializeSession();
             this.sessionFile = explicitPath; // preserve explicit path from --session flag
         }
     }
     newSession(options) {
+        this.assertWritable();
+        const id = options?.id ?? createSessionId();
+        assertValidSessionId(id);
+        const timestamp = new Date().toISOString();
+        if (this.persist)
+            this.claim(join(this.getSessionDir(), `${timestamp.replace(/[:.]/g, "-")}_${id}.jsonl`));
+        this.initializeSession({ ...options, id }, timestamp);
+        this.ownership?.bindSession(this.sessionId);
+        return this.sessionFile;
+    }
+    initializeSession(options, timestamp = new Date().toISOString()) {
         if (options?.id !== undefined) {
             assertValidSessionId(options.id);
         }
         this.sessionId = options?.id ?? createSessionId();
-        const timestamp = new Date().toISOString();
         const header = {
             type: "session",
             version: CURRENT_SESSION_VERSION,
@@ -601,6 +721,7 @@ export class SessionManager {
         this.labelTimestampsById.clear();
         this.leafId = null;
         this.flushed = false;
+        this.permissionMode = undefined;
         if (this.persist) {
             const fileTimestamp = timestamp.replace(/[:.]/g, "-");
             this.sessionFile = join(this.getSessionDir(), `${fileTimestamp}_${this.sessionId}.jsonl`);
@@ -630,6 +751,7 @@ export class SessionManager {
         }
     }
     _rewriteFile() {
+        this.assertWritable();
         if (!this.persist || !this.sessionFile)
             return;
         const fd = openSync(this.sessionFile, "w");
@@ -661,6 +783,7 @@ export class SessionManager {
         return this.sessionFile;
     }
     _persist(entry) {
+        this.assertWritable();
         if (!this.persist || !this.sessionFile)
             return;
         const hasAssistant = this.fileEntries.some((e) => e.type === "message" && e.message.role === "assistant");
@@ -691,6 +814,7 @@ export class SessionManager {
         }
     }
     _appendEntry(entry) {
+        this.assertWritable();
         this.fileEntries.push(entry);
         this.byId.set(entry.id, entry);
         this.leafId = entry.id;
@@ -970,10 +1094,12 @@ export class SessionManager {
      * are not modified or deleted.
      */
     branch(branchFromId) {
+        this.assertWritable();
         if (!this.byId.has(branchFromId)) {
             throw new Error(`Entry ${branchFromId} not found`);
         }
         this.leafId = branchFromId;
+        this.flush();
     }
     /**
      * Reset the leaf pointer to null (before any entries).
@@ -981,7 +1107,9 @@ export class SessionManager {
      * Use this when navigating to re-edit the first user message.
      */
     resetLeaf() {
+        this.assertWritable();
         this.leafId = null;
+        this.flush();
     }
     /**
      * Start a new branch with a summary of the abandoned path.
@@ -989,6 +1117,7 @@ export class SessionManager {
      * context from the abandoned conversation path.
      */
     branchWithSummary(branchFromId, summary, details, fromHook) {
+        this.assertWritable();
         if (branchFromId !== null && !this.byId.has(branchFromId)) {
             throw new Error(`Entry ${branchFromId} not found`);
         }
@@ -1012,6 +1141,7 @@ export class SessionManager {
      * Returns the new session file path, or undefined if not persisting.
      */
     createBranchedSession(leafId) {
+        this.assertWritable();
         const previousSessionFile = this.sessionFile;
         const path = this.getBranch(leafId);
         if (path.length === 0) {
@@ -1066,8 +1196,10 @@ export class SessionManager {
                 labelEntries.push(labelEntry);
                 parentId = labelEntry.id;
             }
+            this.claim(newSessionFile);
             this.fileEntries = [header, ...pathWithoutLabels, ...labelEntries];
             this.sessionId = newSessionId;
+            this.ownership?.bindSession(this.sessionId);
             this.sessionFile = newSessionFile;
             this._buildIndex();
             // Only write the file now if it contains an assistant message.
@@ -1122,13 +1254,36 @@ export class SessionManager {
      */
     static open(path, sessionDir, cwdOverride) {
         const resolvedPath = resolvePath(path);
-        // Extract cwd from session header if possible, otherwise use process.cwd()
-        const entries = loadEntriesFromFile(resolvedPath);
-        const header = entries.find((e) => e.type === "session");
-        const cwd = cwdOverride ?? header?.cwd ?? process.cwd();
-        // If no sessionDir provided, derive from file's parent directory
         const dir = sessionDir ? normalizePath(sessionDir) : resolve(resolvedPath, "..");
-        return new SessionManager(cwd, dir, resolvedPath, true);
+        const manager = new SessionManager(cwdOverride ?? process.cwd(), dir, resolvedPath, true);
+        manager.cwd = resolvePath(cwdOverride ?? manager.getHeader()?.cwd ?? process.cwd());
+        return manager;
+    }
+    static forkBranch(path, leafId, sessionDir) {
+        const manager = SessionManager.openReadOnly(path);
+        manager.readOnly = false;
+        manager.persist = true;
+        if (sessionDir)
+            manager.sessionDir = sessionDir;
+        manager.createBranchedSession(leafId);
+        return manager;
+    }
+    static openReadOnly(path) {
+        const file = canonicalSessionPath(path);
+        const entries = loadEntriesFromFile(file);
+        migrateToCurrentVersion(entries);
+        const header = entries.find((entry) => entry.type === "session");
+        if (!header)
+            throw new Error(`Invalid session: ${file}`);
+        const manager = SessionManager.inMemory(header.cwd);
+        manager.sessionFile = file;
+        manager.sessionDir = resolve(file, "..");
+        manager.sessionId = header.id;
+        manager.fileEntries = entries;
+        manager._buildIndex();
+        manager.restoreLeaf();
+        manager.readOnly = true;
+        return manager;
     }
     /**
      * Continue the most recent session, or create new if none.
@@ -1187,14 +1342,21 @@ export class SessionManager {
             cwd: resolvedTargetCwd,
             parentSession: resolvedSourcePath,
         };
-        writeFileSync(newSessionFile, `${JSON.stringify(newHeader)}\n`, { flag: "wx" });
-        // Copy all non-header entries from source
-        for (const entry of sourceEntries) {
-            if (entry.type !== "session") {
-                appendFileSync(newSessionFile, `${JSON.stringify(entry)}\n`);
-            }
+        const manager = new SessionManager(resolvedTargetCwd, dir, newSessionFile, true);
+        try {
+            manager.fileEntries = [newHeader, ...sourceEntries.filter((entry) => entry.type !== "session")];
+            manager.sessionId = newSessionId;
+            manager.ownership?.bindSession(newSessionId);
+            manager._buildIndex();
+            const snapshot = SessionManager.openReadOnly(sourcePath);
+            manager.leafId = snapshot.getLeafId();
+            manager.flush();
+            return manager;
+        }
+        catch (error) {
+            manager.dispose();
+            throw error;
         }
-        return new SessionManager(resolvedTargetCwd, dir, newSessionFile, true);
     }
     /**
      * List all sessions for a directory.