sidekick-shared 0.29.1 → 0.30.0

package/dist/esm/promptHistory.js

@@ -24,11 +24,11 @@
  * answering call brings model or usage (`metadataStatus` says how settled).
  */
 import { createHash } from 'crypto';
-import * as fs from 'fs';
 import * as path from 'path';
 import { HUMAN_CODEX_SOURCES, humanPromptText } from './humanPrompt';
 import { listClaudeSessionFilesAsync } from './providers/claudeListing';
 import { listCodexSessionFilesAsync } from './providers/codexRollouts';
+import { canReadCompressedRollouts, openRolloutReadHandle, statRolloutContent, } from './providers/compressedRollouts';
 import { DirectoryListingCache } from './providers/directoryListingCache';
 import { realpathOrNull, resolveWorkspaceRoots } from './workspaceRoots';
 import { fileHeadOf, HEAD_BYTES, headMatches } from './fileHead';
@@ -105,7 +105,9 @@ export async function collectPromptHistory(options) {
         return finish();
     const sinceMs = options.since ? options.since.getTime() : null;
     const providers = options.providers ?? ALL_PROVIDERS;
-    const candidates = rotate(await listCandidates(providers, listingRoots, sinceMs), previousNext);
+    const candidates = rotate(await listCandidates(providers, listingRoots, sinceMs, {
+        includeCompressedRollouts: options.includeCompressedRollouts,
+    }), previousNext);
     const moved = movedSessionKeys(previous, candidates);
     const context = {
         roots,
@@ -141,7 +143,8 @@ export async function collectPromptHistory(options) {
         }
         let stat;
         try {
-            stat = await fs.promises.stat(candidate.filePath);
+            // A compressed rollout's size is its decompressed content's.
+            stat = await statRolloutContent(candidate.filePath);
         }
         catch {
             continue;
@@ -246,7 +249,7 @@ export async function collectPromptHistory(options) {
  */
 export async function readPromptOrdinalMarks(provider, sessionId, filePath) {
     const marks = [];
-    const stat = await fs.promises.stat(filePath);
+    const stat = await statRolloutContent(filePath);
     const unbounded = Number.MAX_SAFE_INTEGER;
     const context = {
         roots: [],
@@ -435,19 +438,24 @@ function scopedCwd(cwd, roots, realpaths) {
     return null;
 }
 /** @internal */
-export async function listCandidates(providers, listingRoots, sinceMs) {
+export async function listCandidates(providers, listingRoots, sinceMs, options = {}) {
     const byPath = new Map();
     const listOptions = sinceMs !== null ? { since: sinceMs } : {};
     for (const provider of [...new Set(providers)]) {
         if (!ALL_PROVIDERS.includes(provider))
             continue;
         // Listings are only candidate supersets; scope is re-checked per prompt.
-        const list = provider === 'claude-code' ? listClaudeSessionFilesAsync : listCodexSessionFilesAsync;
         const cache = new DirectoryListingCache();
         for (const root of listingRoots) {
             let files;
             try {
-                files = await list(root, listOptions, cache);
+                files =
+                    provider === 'claude-code'
+                        ? await listClaudeSessionFilesAsync(root, listOptions, cache)
+                        : await listCodexSessionFilesAsync(root, {
+                            ...listOptions,
+                            includeCompressed: options.includeCompressedRollouts === true && canReadCompressedRollouts(),
+                        }, cache);
             }
             catch {
                 files = [];
@@ -469,11 +477,11 @@ export async function listCandidates(providers, listingRoots, sinceMs) {
         compareStrings(left.sessionId, right.sessionId) ||
         compareStrings(left.key, right.key));
 }
-/** True when the file's first bytes still match a recorded head. */
+/** True when the file's first bytes (a compressed rollout's content) still match a recorded head. */
 async function fileStartsWith(filePath, head) {
     let handle;
     try {
-        handle = await fs.promises.open(filePath, 'r');
+        ({ handle } = await openRolloutReadHandle(filePath));
         return headMatches(head, await readAt(handle, 0, Math.min(HEAD_BYTES, head.bytes)));
     }
     catch {
@@ -546,8 +554,11 @@ async function verifyFile(handle, size, session) {
     return { head: fileHeadOf(head), bytesRead };
 }
 /** @internal */
-export async function scanFile(candidate, stat, prior, budget, context) {
-    const handle = await fs.promises.open(candidate.filePath, 'r');
+export async function scanFile(candidate, fileStat, prior, budget, context) {
+    // A compressed rollout is scanned over its decompressed content.
+    const opened = await openRolloutReadHandle(candidate.filePath);
+    const handle = opened.handle;
+    const stat = opened.size === null ? fileStat : { size: opened.size, mtimeMs: fileStat.mtimeMs };
     try {
         let bytesRead = 0;
         const verified = await verifyFile(handle, stat.size, prior);

package/dist/esm/providers/claudeCode.js

@@ -13,6 +13,7 @@ import { StringDecoder } from 'string_decoder';
 import { readSessionContextSnapshot } from '../context/sessionContext';
 import { readSessionFileStats } from '../sessionStats';
 import { JsonlParser } from '../parsers/jsonl';
+import { FileContinuity } from '../fileContinuity';
 import { ClaudeUsageDeduper, normalizeClaudeUsage, } from '../usage/claudeUsageDedupe';
 import { ProviderDiagnosticTracker } from './diagnostics';
 import { DirectoryListingCache, splitWatchedPath } from './directoryListingCache';
@@ -110,7 +111,10 @@ class ClaudeCodeReader {
     /** Cursor after the last complete line, safe to persist across restarts. */
     committedPosition = 0;
     events = [];
-    _wasTruncated = false;
+    /** Why the last `readNew()` started over from offset 0, if it did. */
+    _lastReset = null;
+    /** Whether the file is still the one the positions refer to. */
+    continuity = new FileContinuity();
     decoder = new StringDecoder('utf8');
     /** Split lines of one response repeat its usage; count each response once. */
     usageDeduper;
@@ -131,37 +135,28 @@ class ClaudeCodeReader {
     }
     readNew() {
         this.events = [];
-        this._wasTruncated = false;
+        this._lastReset = null;
+        let fd = null;
         try {
-            if (!fs.existsSync(this.sessionPath)) {
-                return [];
-            }
-            const stats = fs.statSync(this.sessionPath);
+            // Open first and stat the descriptor: the size and identity checked
+            // are those of the file actually read, even if the path is replaced.
+            fd = fs.openSync(this.sessionPath, 'r');
+            const stats = fs.fstatSync(fd);
+            const reason = this.continuity.check(fd, stats, this.filePosition, this.committedPosition);
+            // Truncated, rewritten, or replaced: what was read no longer describes
+            // the file, so start over from its beginning.
+            if (reason !== null)
+                this.restart(reason);
+            this.continuity.adopt(stats);
             const currentSize = stats.size;
-            // Handle truncation
-            if (currentSize < this.filePosition) {
-                this._wasTruncated = true;
-                this.filePosition = 0;
-                this.committedPosition = 0;
-                this.parser.reset();
-                this.decoder = new StringDecoder('utf8');
-                this.usageDeduper.reset();
-            }
             // No new content
             if (currentSize <= this.filePosition) {
-                return [];
+                return this.events;
             }
             // Read new bytes from last position
-            const fd = fs.openSync(this.sessionPath, 'r');
             const bufferSize = currentSize - this.filePosition;
             const buffer = Buffer.alloc(bufferSize);
-            let bytesRead = 0;
-            try {
-                bytesRead = fs.readSync(fd, buffer, 0, bufferSize, this.filePosition);
-            }
-            finally {
-                fs.closeSync(fd);
-            }
+            const bytesRead = fs.readSync(fd, buffer, 0, bufferSize, this.filePosition);
             const bytes = buffer.subarray(0, bytesRead);
             const newline = bytes.lastIndexOf(0x0a);
             if (newline >= 0)
@@ -171,10 +166,31 @@ class ClaudeCodeReader {
             this.filePosition += bytesRead;
         }
         catch (error) {
-            console.error(`ClaudeCodeReader: error reading ${this.sessionPath}: ${error}`);
+            if (error?.code !== 'ENOENT') {
+                console.error(`ClaudeCodeReader: error reading ${this.sessionPath}: ${error}`);
+            }
+        }
+        finally {
+            if (fd !== null) {
+                try {
+                    fs.closeSync(fd);
+                }
+                catch {
+                    // Ignore close errors.
+                }
+            }
         }
         return this.events;
     }
+    /** Starts over from offset 0 of a file that was truncated, rewritten, or replaced. */
+    restart(reason) {
+        this._lastReset = { reason, previousPosition: this.committedPosition };
+        this.filePosition = 0;
+        this.committedPosition = 0;
+        this.parser.reset();
+        this.decoder = new StringDecoder('utf8');
+        this.usageDeduper.reset();
+    }
     readAll() {
         this.reset();
         return this.readNew();
@@ -185,7 +201,8 @@ class ClaudeCodeReader {
         this.parser.reset();
         this.decoder = new StringDecoder('utf8');
         this.usageDeduper.reset();
-        this._wasTruncated = false;
+        this._lastReset = null;
+        this.continuity.forget();
     }
     exists() {
         return fs.existsSync(this.sessionPath);
@@ -205,9 +222,15 @@ class ClaudeCodeReader {
         this.committedPosition = position;
         this.parser.reset();
         this.decoder = new StringDecoder('utf8');
+        // The position comes from elsewhere (a snapshot): adopt the file the next
+        // read finds rather than compare it with one read before.
+        this.continuity.forget();
     }
     wasTruncated() {
-        return this._wasTruncated;
+        return this._lastReset !== null;
+    }
+    lastReset() {
+        return this._lastReset ? { ...this._lastReset } : null;
     }
     /** The usage deduper's recent message ids, so a resumed reader does not recount a split response. */
     getResumeState() {