sidekick-shared 0.29.0 → 0.30.0

package/dist/providers/claudeCode.js

@@ -49,6 +49,7 @@ const string_decoder_1 = require("string_decoder");
 const sessionContext_1 = require("../context/sessionContext");
 const sessionStats_1 = require("../sessionStats");
 const jsonl_1 = require("../parsers/jsonl");
+const fileContinuity_1 = require("../fileContinuity");
 const claudeUsageDedupe_1 = require("../usage/claudeUsageDedupe");
 const diagnostics_1 = require("./diagnostics");
 const directoryListingCache_1 = require("./directoryListingCache");
@@ -146,7 +147,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_1.FileContinuity();
     decoder = new string_decoder_1.StringDecoder('utf8');
     /** Split lines of one response repeat its usage; count each response once. */
     usageDeduper;
@@ -155,7 +159,8 @@ class ClaudeCodeReader {
         this.usageDeduper = usageDeduper ?? new claudeUsageDedupe_1.ClaudeUsageDeduper();
         this.parser = new jsonl_1.JsonlParser({
             onEvent: (raw) => {
-                for (const event of (0, sessionEvent_1.extractSessionEvents)(raw)) {
+                // Mid-turn task notifications finish background subagents.
+                for (const event of (0, sessionEvent_1.extractSessionEvents)(raw, { includeTaskNotifications: true })) {
                     this.events.push(this.usageDeduper.apply((0, claudeUsageDedupe_1.normalizeClaudeUsage)(event)));
                 }
             },
@@ -166,37 +171,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 string_decoder_1.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)
@@ -206,10 +202,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 string_decoder_1.StringDecoder('utf8');
+        this.usageDeduper.reset();
+    }
     readAll() {
         this.reset();
         return this.readNew();
@@ -220,7 +237,8 @@ class ClaudeCodeReader {
         this.parser.reset();
         this.decoder = new string_decoder_1.StringDecoder('utf8');
         this.usageDeduper.reset();
-        this._wasTruncated = false;
+        this._lastReset = null;
+        this.continuity.forget();
     }
     exists() {
         return fs.existsSync(this.sessionPath);
@@ -240,9 +258,22 @@ class ClaudeCodeReader {
         this.committedPosition = position;
         this.parser.reset();
         this.decoder = new string_decoder_1.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() {
+        return this.usageDeduper.exportState();
+    }
+    restoreResumeState(state) {
+        return this.usageDeduper.importState(state);
     }
 }
 /**

package/dist/providers/codex.d.ts

@@ -4,7 +4,9 @@
  * Implements SessionProviderBase for monitoring Codex CLI sessions.
  * Codex stores sessions as JSONL rollout files in:
  *   ~/.codex/sessions/YYYY/MM/DD/rollout-<timestamp>-<uuid>.jsonl
- * with an optional SQLite index at ~/.codex/state.sqlite.
+ * with an optional SQLite index at ~/.codex/state.sqlite. Older rollouts are
+ * compressed in place to `….jsonl.zst`; those are read only with the
+ * `includeCompressedRollouts` option (see `providers/compressedRollouts`).
  *
  * Ported from sidekick-vscode/src/services/providers/CodexSessionProvider.ts
  */
@@ -15,6 +17,19 @@ import type { SubagentStats, TokenUsage } from '../types/sessionEvent';
 import type { CodexRateLimits } from '../types/codex';
 export { findCodexRolloutFile };
 export type { FindCodexRolloutFileOptions } from './codexRollouts';
+/** Options for {@link CodexProvider}; every field is optional and additive. */
+export interface CodexProviderOptions extends SessionProviderOptions {
+    /**
+     * Also discover and read compressed rollouts (`rollout-….jsonl.zst`,
+     * which Codex writes for older sessions). Listings, session lookups,
+     * labels, `createReader()` (a whole-file reader; live tailing stays
+     * `.jsonl`-only), search, and subagent stats then include them. Reading
+     * needs `zlib.zstdDecompressSync` (Node 22.15+); without it they are
+     * skipped and reported once through `onDiagnostic`. Default false, so
+     * session and history counts are unchanged.
+     */
+    includeCompressedRollouts?: boolean;
+}
 /**
  * Session provider for Codex CLI.
  *
@@ -33,7 +48,17 @@ export declare class CodexProvider implements SessionProviderBase {
     private lastTokenUsageData;
     /** Dated rollout-directory listings reused across async enumerations. */
     private readonly directoryCache;
-    constructor(options?: SessionProviderOptions);
+    /** See {@link CodexProviderOptions.includeCompressedRollouts}. */
+    private readonly compressedRequested;
+    private readonly onDiagnostic;
+    constructor(options?: CodexProviderOptions);
+    /**
+     * Whether compressed rollouts are discovered and read: requested, and the
+     * runtime can decompress them (otherwise reported once, on first use).
+     */
+    private get includeCompressed();
+    /** A stored rollout path as it exists now (its `.zst` when compressed and enabled). */
+    private resolveRollout;
     /** Lazy-initialize database connection. */
     private ensureDb;
     private ensureDbAsync;
@@ -70,11 +95,16 @@ export declare class CodexProvider implements SessionProviderBase {
     extractSessionLabel(sessionPath: string): string | null;
     extractSessionLabelsAsync(sessionPaths: readonly string[]): Promise<Map<string, string | null>>;
     createReader(sessionPath: string): SessionReader;
-    scanSubagents(_sessionDir: string, sessionId: string): SubagentStats[];
     /**
-     * Builds SubagentStats for a forked session by reading its rollout file.
+     * Every subagent below the session, any depth: spawned threads (the
+     * database's `threads.source`, else the newest rollouts' session_meta)
+     * and, on older schemas, forks (`forked_from_id`). Each carries its
+     * rollout (`filePath`), the parent's spawn call (`spawnToolUseId`),
+     * `agentNickname`, `agentPath`, `parentAgentId`, and `depth`; tool calls
+     * and tokens come from the child's own records, not the parent history a
+     * forked child embeds.
      */
-    private buildSubagentStats;
+    scanSubagents(_sessionDir: string, sessionId: string): SubagentStats[];
     searchInSession(sessionPath: string, query: string, maxResults: number): SearchHit[];
     getProjectsBaseDir(): string;
     getWatchRoots(): string[];