@senpiper/sp-agent 0.1.6 → 0.1.9

package/node_modules/@senpiper/pi-coding-agent/dist/core/session-manager.js

@@ -1,6 +1,6 @@
 import { uuidv7 } from "@earendil-works/pi-ai";
 import { randomUUID } from "crypto";
-import { appendFileSync, closeSync, createReadStream, existsSync, mkdirSync, openSync, readdirSync, readSync, statSync, writeFileSync, } from "fs";
+import { appendFileSync, closeSync, copyFileSync, createReadStream, existsSync, mkdirSync, openSync, readdirSync, 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 { APP_NAME, getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
 import { normalizePath, resolvePath } from "../utils/paths.js";
 import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "./messages.js";
+import { getSessionWriterLeaseProvider, } from "./session-writer-lease.js";
 export const CURRENT_SESSION_VERSION = 3;
 function createSessionId() {
     return uuidv7();
@@ -274,7 +275,17 @@ function parseSessionEntryLine(line) {
     }
 }
 /** Exported for testing */
-export function loadEntriesFromFile(filePath) {
+export function loadEntriesFromFile(filePath, repair = true, ownedLease) {
+    const lease = repair && !ownedLease && existsSync(filePath) ? getSessionWriterLeaseProvider()?.acquire(filePath) : undefined;
+    try {
+        ownedLease?.assertOwned();
+        return readEntriesFromFile(filePath, repair);
+    }
+    finally {
+        lease?.release();
+    }
+}
+function readEntriesFromFile(filePath, repair) {
     const resolvedFilePath = normalizePath(filePath);
     if (!existsSync(resolvedFilePath))
         return [];
@@ -315,7 +326,7 @@ export function loadEntriesFromFile(filePath) {
     if (header.type !== "session" || typeof header.id !== "string") {
         return [];
     }
-    if (pending)
+    if (pending && repair)
         appendFileSync(resolvedFilePath, "\n");
     return entries;
 }
@@ -584,6 +595,43 @@ async function listSessionsFromDir(dir, onProgress, progressOffset = 0, progress
  * handles compaction summaries and follows the path from root to current leaf.
  */
 export class SessionManager {
+    writerLeaseProvider = getSessionWriterLeaseProvider();
+    writerLease;
+    closed = false;
+    writesReserved = false;
+    /** Block new mutations while a host performs an exclusive lifecycle transaction. */
+    reserveWrites() {
+        this.assertWriterOwned();
+        this.writesReserved = true;
+        return () => {
+            this.writesReserved = false;
+        };
+    }
+    /** Permanently disable this writer before releasing its lifetime reservation. */
+    dispose() {
+        this.closed = true;
+        this.writerLease?.release();
+        this.writerLease = undefined;
+    }
+    assertWriterOwned() {
+        if (this.closed)
+            throw new Error("Session writer is closed.");
+        if (this.writesReserved)
+            throw new Error("Session writes are reserved by the host.");
+        this.writerLease?.assertOwned();
+    }
+    usesWriterLeaseProvider(provider) {
+        return !this.persist || (this.writerLeaseProvider === provider && this.writerLease !== undefined);
+    }
+    changeWriterFile(path) {
+        this.assertWriterOwned();
+        if (this.persist && path !== this.sessionFile) {
+            const lease = this.writerLeaseProvider?.acquire(path);
+            this.writerLease?.release();
+            this.writerLease = lease;
+        }
+        this.sessionFile = path;
+    }
     sessionId = "";
     sessionFile;
     sessionDir;
@@ -595,18 +643,27 @@ export class SessionManager {
     labelsById = new Map();
     labelTimestampsById = new Map();
     leafId = null;
-    constructor(cwd, sessionDir, sessionFile, persist, newSessionOptions, preloadedFileEntries) {
+    constructor(cwd, sessionDir, sessionFile, persist, newSessionOptions, preloadedFileEntries, lease) {
+        this.writerLease = lease;
+        if (lease)
+            this.sessionFile = sessionFile;
         this.cwd = resolvePath(cwd);
         this.sessionDir = normalizePath(sessionDir);
         this.persist = persist;
         if (persist && this.sessionDir && !existsSync(this.sessionDir)) {
             mkdirSync(this.sessionDir, { recursive: true });
         }
-        if (sessionFile) {
-            this._setSessionFile(sessionFile, preloadedFileEntries);
+        try {
+            if (sessionFile) {
+                this._setSessionFile(sessionFile, preloadedFileEntries);
+            }
+            else {
+                this.newSession(newSessionOptions);
+            }
         }
-        else {
-            this.newSession(newSessionOptions);
+        catch (error) {
+            this.dispose();
+            throw error;
         }
     }
     /** Switch to a different session file (used for resume and branching) */
@@ -614,17 +671,18 @@ export class SessionManager {
         this._setSessionFile(sessionFile);
     }
     _setSessionFile(sessionFile, preloadedFileEntries) {
-        this.sessionFile = resolvePath(sessionFile);
-        if (existsSync(this.sessionFile)) {
-            this.fileEntries = preloadedFileEntries ?? loadEntriesFromFile(this.sessionFile);
+        const path = resolvePath(sessionFile);
+        this.changeWriterFile(path);
+        if (existsSync(path)) {
+            this.fileEntries = preloadedFileEntries ?? loadEntriesFromFile(path, true, this.writerLease);
             // If file was empty, initialize it with a valid session header. If it was
             // non-empty but did not parse as a pi session, fail without modifying it.
             if (this.fileEntries.length === 0) {
-                const explicitPath = this.sessionFile;
+                const explicitPath = path;
                 if (statSync(explicitPath).size > 0) {
                     throw new Error(`Session file is not a valid ${APP_NAME} session: ${explicitPath}`);
                 }
-                this.newSession();
+                this.initializeSession();
                 this.sessionFile = explicitPath;
                 this._rewriteFile();
                 this.flushed = true;
@@ -640,16 +698,25 @@ export class SessionManager {
         }
         else {
             const explicitPath = this.sessionFile;
-            this.newSession();
+            this.initializeSession();
             this.sessionFile = explicitPath; // preserve explicit path from --session flag
         }
     }
     newSession(options) {
+        this.assertWriterOwned();
+        return this.initializeSession(options, true);
+    }
+    initializeSession(options, chooseFile = false) {
         if (options?.id !== undefined) {
             assertValidSessionId(options.id);
         }
-        this.sessionId = options?.id ?? createSessionId();
+        const sessionId = options?.id ?? createSessionId();
         const timestamp = new Date().toISOString();
+        if (this.persist && chooseFile) {
+            const fileTimestamp = timestamp.replace(/[:.]/g, "-");
+            this.changeWriterFile(join(this.getSessionDir(), `${fileTimestamp}_${sessionId}.jsonl`));
+        }
+        this.sessionId = sessionId;
         const header = {
             type: "session",
             version: CURRENT_SESSION_VERSION,
@@ -664,10 +731,6 @@ export class SessionManager {
         this.labelTimestampsById.clear();
         this.leafId = null;
         this.flushed = false;
-        if (this.persist) {
-            const fileTimestamp = timestamp.replace(/[:.]/g, "-");
-            this.sessionFile = join(this.getSessionDir(), `${fileTimestamp}_${this.sessionId}.jsonl`);
-        }
         return this.sessionFile;
     }
     _buildIndex() {
@@ -693,6 +756,7 @@ export class SessionManager {
         }
     }
     _rewriteFile() {
+        this.assertWriterOwned();
         if (!this.persist || !this.sessionFile)
             return;
         const fd = openSync(this.sessionFile, "w");
@@ -724,6 +788,7 @@ export class SessionManager {
         return this.sessionFile;
     }
     _persist(entry) {
+        this.assertWriterOwned();
         if (!this.persist || !this.sessionFile)
             return;
         const hasAssistant = this.fileEntries.some((e) => e.type === "message" && e.message.role === "assistant");
@@ -754,6 +819,7 @@ export class SessionManager {
         }
     }
     _appendEntry(entry) {
+        this.assertWriterOwned();
         this.fileEntries.push(entry);
         this.byId.set(entry.id, entry);
         this.leafId = entry.id;
@@ -1034,6 +1100,7 @@ export class SessionManager {
      * are not modified or deleted.
      */
     branch(branchFromId) {
+        this.assertWriterOwned();
         if (!this.byId.has(branchFromId)) {
             throw new Error(`Entry ${branchFromId} not found`);
         }
@@ -1045,6 +1112,7 @@ export class SessionManager {
      * Use this when navigating to re-edit the first user message.
      */
     resetLeaf() {
+        this.assertWriterOwned();
         this.leafId = null;
     }
     /**
@@ -1053,6 +1121,7 @@ export class SessionManager {
      * context from the abandoned conversation path.
      */
     branchWithSummary(branchFromId, summary, details, fromHook, usage) {
+        this.assertWriterOwned();
         if (branchFromId !== null && !this.byId.has(branchFromId)) {
             throw new Error(`Entry ${branchFromId} not found`);
         }
@@ -1078,6 +1147,7 @@ export class SessionManager {
      * Returns the new session file path, or undefined if not persisting.
      */
     createBranchedSession(leafId) {
+        this.assertWriterOwned();
         const previousSessionFile = this.sessionFile;
         const path = this.getBranch(leafId);
         if (path.length === 0) {
@@ -1132,6 +1202,7 @@ export class SessionManager {
                 labelEntries.push(labelEntry);
                 parentId = labelEntry.id;
             }
+            this.changeWriterFile(newSessionFile);
             this.fileEntries = [header, ...pathWithoutLabels, ...labelEntries];
             this.sessionId = newSessionId;
             this.sessionFile = newSessionFile;
@@ -1186,8 +1257,20 @@ export class SessionManager {
      * @param sessionDir Optional session directory for /new or /branch. If omitted, derives from file's parent.
      * @param cwdOverride Optional cwd override instead of the session header cwd.
      */
-    static open(path, sessionDir, cwdOverride) {
+    static open(path, sessionDir, cwdOverride, options) {
+        if (options?.readOnly)
+            return SessionManager.openReadonly(path, cwdOverride);
         const resolvedPath = resolvePath(path);
+        const lease = getSessionWriterLeaseProvider()?.acquire(resolvedPath);
+        try {
+            return SessionManager.openAcquired(resolvedPath, sessionDir, cwdOverride, lease);
+        }
+        catch (error) {
+            lease?.release();
+            throw error;
+        }
+    }
+    static openAcquired(resolvedPath, sessionDir, cwdOverride, lease) {
         let header = null;
         let preloadedFileEntries;
         if (cwdOverride === undefined && existsSync(resolvedPath)) {
@@ -1199,7 +1282,7 @@ export class SessionManager {
                     throw error;
                 // The bounded scan is only a discovery optimization. A full load remains
                 // authoritative for legacy files with very large headers or prefixes.
-                preloadedFileEntries = loadEntriesFromFile(resolvedPath);
+                preloadedFileEntries = loadEntriesFromFile(resolvedPath, true, lease);
                 const firstEntry = preloadedFileEntries[0];
                 header = firstEntry?.type === "session" ? firstEntry : null;
             }
@@ -1207,7 +1290,55 @@ export class SessionManager {
         const cwd = cwdOverride ?? (header ? getSessionHeaderCwd(header) : undefined) ?? 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, undefined, preloadedFileEntries);
+        return new SessionManager(cwd, dir, resolvedPath, true, undefined, preloadedFileEntries, lease);
+    }
+    /** Read a snapshot without file repair, migration writes, or a writer lease. */
+    static openReadonly(path, cwdOverride) {
+        const entries = loadEntriesFromFile(path, false);
+        const header = entries[0];
+        if (!header || header.type !== "session")
+            throw new Error("Invalid session header.");
+        const manager = SessionManager.inMemory(cwdOverride ?? header.cwd);
+        manager.fileEntries = entries;
+        migrateToCurrentVersion(entries);
+        manager.sessionId = header.id;
+        manager.sessionFile = resolvePath(path);
+        manager._buildIndex();
+        return manager;
+    }
+    /** Reserve the import destination before copying, and retain that lease in the returned writer. */
+    static importJsonl(source, destination, sessionDir, cwdOverride) {
+        const path = resolvePath(destination);
+        const lease = getSessionWriterLeaseProvider()?.acquire(path);
+        try {
+            if (resolvePath(source) !== path)
+                copyFileSync(source, path);
+            return SessionManager.openAcquired(path, sessionDir, cwdOverride, lease);
+        }
+        catch (error) {
+            lease?.release();
+            throw error;
+        }
+    }
+    /** Copy this writer's snapshot into an independent leased branch writer. */
+    forkBranch(leafId) {
+        this.assertWriterOwned();
+        const manager = new SessionManager(this.cwd, this.sessionDir, undefined, this.persist);
+        try {
+            manager.fileEntries = this.fileEntries.slice();
+            manager._buildIndex();
+            manager.createBranchedSession(leafId);
+            const header = manager.getHeader();
+            if (header)
+                header.parentSession = this.sessionFile;
+            if (manager.flushed)
+                manager._rewriteFile();
+            return manager;
+        }
+        catch (error) {
+            manager.dispose();
+            throw error;
+        }
     }
     /**
      * Continue the most recent session, or create new if none.
@@ -1237,7 +1368,7 @@ export class SessionManager {
     static forkFrom(sourcePath, targetCwd, sessionDir, options) {
         const resolvedSourcePath = resolvePath(sourcePath);
         const resolvedTargetCwd = resolvePath(targetCwd);
-        const sourceEntries = loadEntriesFromFile(resolvedSourcePath);
+        const sourceEntries = loadEntriesFromFile(resolvedSourcePath, false);
         if (sourceEntries.length === 0) {
             throw new Error(`Cannot fork: source session file is empty or invalid: ${resolvedSourcePath}`);
         }
@@ -1266,14 +1397,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 lease = getSessionWriterLeaseProvider()?.acquire(newSessionFile);
+        try {
+            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`);
+                }
             }
+            return new SessionManager(resolvedTargetCwd, dir, newSessionFile, true, undefined, undefined, lease);
+        }
+        catch (error) {
+            lease?.release();
+            throw error;
         }
-        return new SessionManager(resolvedTargetCwd, dir, newSessionFile, true);
     }
     /**
      * List all sessions for a directory.