@averyyy/pi-coding-agent 0.80.10-piclient.1 → 0.81.1-piclient.1

package/dist/core/session-manager.js

@@ -1,4 +1,4 @@
-import { uuidv7 } from "@earendil-works/pi-agent-core";
+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 { readdir, stat } from "fs/promises";
@@ -253,6 +253,15 @@ export function getDefaultSessionDir(cwd, agentDir = getDefaultAgentDir()) {
     return sessionDir;
 }
 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;
+class SessionHeaderScanLimitError extends Error {
+    constructor(filePath) {
+        super(`Session header exceeds ${MAX_SESSION_HEADER_SCAN_BYTES}-byte scan limit: ${filePath}`);
+        this.name = "SessionHeaderScanLimitError";
+    }
+}
 function parseSessionEntryLine(line) {
     if (!line.trim())
         return null;
@@ -308,22 +317,70 @@ export function loadEntriesFromFile(filePath) {
     }
     return entries;
 }
+/**
+ * Inspect a physical line while searching for the first parsed session entry.
+ * Blank and malformed lines are skipped to match loadEntriesFromFile().
+ * Returns undefined to keep scanning, null for a parsed non-header entry, or the header.
+ */
+function parseSessionHeaderCandidate(line) {
+    if (!line.trim())
+        return undefined;
+    const entry = parseSessionEntryLine(line);
+    if (!entry)
+        return undefined;
+    if (entry.type !== "session" || typeof entry.id !== "string")
+        return null;
+    return entry;
+}
 function readSessionHeader(filePath) {
+    const fd = openSync(filePath, "r");
     try {
-        const fd = openSync(filePath, "r");
-        const buffer = Buffer.alloc(512);
-        const bytesRead = readSync(fd, buffer, 0, 512, 0);
-        closeSync(fd);
-        const firstLine = buffer.toString("utf8", 0, bytesRead).split("\n")[0];
-        if (!firstLine)
-            return null;
-        const header = JSON.parse(firstLine);
-        if (header.type !== "session" || typeof header.id !== "string") {
-            return null;
+        const decoder = new StringDecoder("utf8");
+        const buffer = Buffer.allocUnsafe(SESSION_HEADER_READ_BUFFER_SIZE);
+        const lineChunks = [];
+        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) {
+                lineChunks.push(decoder.end());
+                return parseSessionHeaderCandidate(lineChunks.join("")) ?? null;
+            }
+            scannedBytes += bytesRead;
+            const chunk = decoder.write(buffer.subarray(0, bytesRead));
+            let lineStart = 0;
+            let newlineIndex = chunk.indexOf("\n", lineStart);
+            while (newlineIndex !== -1) {
+                lineChunks.push(chunk.slice(lineStart, newlineIndex));
+                const header = parseSessionHeaderCandidate(lineChunks.join(""));
+                if (header !== undefined)
+                    return header;
+                lineChunks.length = 0;
+                lineStart = newlineIndex + 1;
+                newlineIndex = chunk.indexOf("\n", lineStart);
+            }
+            lineChunks.push(chunk.slice(lineStart));
         }
-        return header;
+        // Probe for EOF so a final header without a newline is allowed when it ends
+        // exactly at the scan limit. Any additional byte exceeds the bounded scan.
+        const probe = Buffer.allocUnsafe(1);
+        if (readSync(fd, probe, 0, probe.length, null) === 0) {
+            lineChunks.push(decoder.end());
+            return parseSessionHeaderCandidate(lineChunks.join("")) ?? null;
+        }
+        throw new SessionHeaderScanLimitError(filePath);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function readSessionHeaderForDiscovery(filePath) {
+    try {
+        return readSessionHeader(filePath);
     }
     catch {
+        // Discovery is best-effort: unreadable or oversized files are not sessions,
+        // and one corrupt file must not prevent other sessions from being found.
         return null;
     }
 }
@@ -342,7 +399,7 @@ export function findMostRecentSession(sessionDir, cwd) {
         const files = readdirSync(resolvedSessionDir)
             .filter((f) => f.endsWith(".jsonl"))
             .map((f) => join(resolvedSessionDir, f))
-            .map((path) => ({ path, header: readSessionHeader(path) }))
+            .map((path) => ({ path, header: readSessionHeaderForDiscovery(path) }))
             .filter((file) => file.header !== null &&
             (!resolvedCwd || sessionCwdMatches(getSessionHeaderCwd(file.header), resolvedCwd)))
             .map(({ path }) => ({ path, mtime: statSync(path).mtime }))
@@ -350,6 +407,7 @@ export function findMostRecentSession(sessionDir, cwd) {
         return files[0]?.path || null;
     }
     catch {
+        // Directory access and stat races make recent-session discovery unavailable.
         return null;
     }
 }
@@ -535,7 +593,7 @@ export class SessionManager {
     labelsById = new Map();
     labelTimestampsById = new Map();
     leafId = null;
-    constructor(cwd, sessionDir, sessionFile, persist, newSessionOptions) {
+    constructor(cwd, sessionDir, sessionFile, persist, newSessionOptions, preloadedFileEntries) {
         this.cwd = resolvePath(cwd);
         this.sessionDir = normalizePath(sessionDir);
         this.persist = persist;
@@ -543,7 +601,7 @@ export class SessionManager {
             mkdirSync(this.sessionDir, { recursive: true });
         }
         if (sessionFile) {
-            this.setSessionFile(sessionFile);
+            this._setSessionFile(sessionFile, preloadedFileEntries);
         }
         else {
             this.newSession(newSessionOptions);
@@ -551,9 +609,12 @@ export class SessionManager {
     }
     /** Switch to a different session file (used for resume and branching) */
     setSessionFile(sessionFile) {
+        this._setSessionFile(sessionFile);
+    }
+    _setSessionFile(sessionFile, preloadedFileEntries) {
         this.sessionFile = resolvePath(sessionFile);
         if (existsSync(this.sessionFile)) {
-            this.fileEntries = loadEntriesFromFile(this.sessionFile);
+            this.fileEntries = preloadedFileEntries ?? loadEntriesFromFile(this.sessionFile);
             // 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) {
@@ -790,7 +851,7 @@ export class SessionManager {
         return entry.id;
     }
     /** Append a compaction summary as child of current leaf, then advance leaf. Returns entry id. */
-    appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook) {
+    appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook, usage) {
         const entry = {
             type: "compaction",
             id: generateId(this.byId),
@@ -800,6 +861,7 @@ export class SessionManager {
             firstKeptEntryId,
             tokensBefore,
             details,
+            usage,
             fromHook,
         };
         this._appendEntry(entry);
@@ -1039,7 +1101,7 @@ export class SessionManager {
      * Same as branch(), but also appends a branch_summary entry that captures
      * context from the abandoned conversation path.
      */
-    branchWithSummary(branchFromId, summary, details, fromHook) {
+    branchWithSummary(branchFromId, summary, details, fromHook, usage) {
         if (branchFromId !== null && !this.byId.has(branchFromId)) {
             throw new Error(`Entry ${branchFromId} not found`);
         }
@@ -1052,6 +1114,7 @@ export class SessionManager {
             fromId: branchFromId ?? "root",
             summary,
             details,
+            usage,
             fromHook,
         };
         this._appendEntry(entry);
@@ -1173,13 +1236,26 @@ 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();
+        let header = null;
+        let preloadedFileEntries;
+        if (cwdOverride === undefined && existsSync(resolvedPath)) {
+            try {
+                header = readSessionHeader(resolvedPath);
+            }
+            catch (error) {
+                if (!(error instanceof SessionHeaderScanLimitError))
+                    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);
+                const firstEntry = preloadedFileEntries[0];
+                header = firstEntry?.type === "session" ? firstEntry : null;
+            }
+        }
+        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);
+        return new SessionManager(cwd, dir, resolvedPath, true, undefined, preloadedFileEntries);
     }
     /**
      * Continue the most recent session, or create new if none.