sidekick-shared 0.29.1 → 0.30.0

package/dist/esm/providers/codexCompressedReader.js

@@ -0,0 +1,184 @@
+/**
+ * Session reader for a compressed Codex rollout (`rollout-…jsonl.zst`).
+ *
+ * Codex compresses only rollouts it no longer writes, so the content is
+ * decompressed and parsed whole on the first read; later reads cost one
+ * stat and return nothing until the file changes (then the rollout is read
+ * again from the start, reported as `replaced`). Positions are offsets in
+ * the decompressed content. Live tailing stays with the `.jsonl` reader.
+ *
+ * Node-only: reads files.
+ *
+ * @module providers/codexCompressedReader
+ */
+import * as fs from 'fs';
+import { CodexRolloutParser } from '../parsers/codexParser';
+import { normalizeProviderUsage } from '../usageNormalization';
+import { readRolloutBuffer } from './compressedRollouts';
+/** Reads a `.jsonl.zst` rollout through a {@link CodexRolloutParser}. */
+export class CompressedCodexRolloutReader {
+    rolloutPath;
+    callbacks;
+    parser = new CodexRolloutParser({ includeSubagentActivity: true });
+    /** Offset after the last line parsed (the content is complete, so its end). */
+    position = 0;
+    /** Size and mtime of the compressed file the position refers to. */
+    source = null;
+    reset_ = null;
+    /** Position from `seekTo()` whose prefix still has to be parsed for context. */
+    pendingSeek = null;
+    constructor(rolloutPath, callbacks = {}) {
+        this.rolloutPath = rolloutPath;
+        this.callbacks = callbacks;
+    }
+    getSessionMeta() {
+        this.settleSeek();
+        return this.parser.getSessionMeta();
+    }
+    readNew() {
+        this.settleSeek();
+        this.reset_ = null;
+        return this.readFrom(true);
+    }
+    readAll() {
+        this.reset();
+        return this.readNew();
+    }
+    reset() {
+        this.parser.reset();
+        this.position = 0;
+        this.source = null;
+        this.reset_ = null;
+        this.pendingSeek = null;
+    }
+    exists() {
+        return fs.existsSync(this.rolloutPath);
+    }
+    flush() {
+        // Nothing is buffered: each read parses through the end of the content.
+    }
+    getPosition() {
+        return this.position;
+    }
+    seekTo(position) {
+        this.reset();
+        this.position = Math.max(0, position);
+        if (this.position > 0)
+            this.pendingSeek = this.position;
+    }
+    wasTruncated() {
+        return this.reset_ !== null;
+    }
+    lastReset() {
+        return this.reset_ ? { ...this.reset_ } : null;
+    }
+    getResumeState() {
+        this.settleSeek();
+        return this.parser.exportResumeState();
+    }
+    restoreResumeState(state) {
+        if (!this.parser.importResumeState(state))
+            return false;
+        this.pendingSeek = null;
+        this.propagateParserState();
+        return true;
+    }
+    /** Parses the content past `position`; `emit` false only rebuilds parser state. */
+    readFrom(emit, endPosition) {
+        let stat;
+        try {
+            stat = fs.statSync(this.rolloutPath);
+        }
+        catch {
+            return [];
+        }
+        const current = { size: stat.size, mtimeMs: stat.mtimeMs };
+        if (this.source &&
+            (this.source.size !== current.size || this.source.mtimeMs !== current.mtimeMs)) {
+            // Another file has the path: what was read no longer describes it.
+            this.reset_ = { reason: 'replaced', previousPosition: this.position };
+            this.parser.reset();
+            this.position = 0;
+        }
+        else if (this.source) {
+            return [];
+        }
+        const content = readRolloutBuffer(this.rolloutPath, {
+            onDiagnostic: this.callbacks.onDiagnostic,
+        });
+        if (!content)
+            return [];
+        this.source = current;
+        const end = Math.min(content.length, endPosition ?? content.length);
+        if (this.position > end) {
+            // The position sought lies past this content: start over.
+            this.reset_ = { reason: 'truncated', previousPosition: this.position };
+            this.parser.reset();
+            this.position = 0;
+        }
+        const events = [];
+        const text = content.toString('utf8', this.position, end);
+        for (const line of text.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const converted = this.parser.convertLine(JSON.parse(trimmed));
+                if (emit)
+                    events.push(...converted);
+            }
+            catch {
+                // Skip malformed lines.
+            }
+        }
+        this.position = end;
+        if (end < content.length)
+            this.source = null;
+        this.propagateParserState();
+        return events;
+    }
+    /** Rebuilds parser context for a pending `seekTo()` position. */
+    settleSeek() {
+        const position = this.pendingSeek;
+        if (position === null)
+            return;
+        this.pendingSeek = null;
+        this.parser.reset();
+        this.position = 0;
+        this.source = null;
+        this.readFrom(false, position);
+    }
+    /** Hands the parser's context window, rate limits, and last usage to the provider. */
+    propagateParserState() {
+        const { onContextWindowLimit, onRateLimits, onTokenUsage } = this.callbacks;
+        const window = this.parser.getModelContextWindow();
+        if (window && onContextWindowLimit) {
+            onContextWindowLimit(window, this.parser.getCurrentModel() ?? undefined);
+        }
+        const rateLimits = this.parser.getLastRateLimits();
+        if (rateLimits && onRateLimits)
+            onRateLimits(rateLimits);
+        const lastUsage = this.parser.getLastTokenUsage();
+        if (lastUsage && onTokenUsage) {
+            const normalized = normalizeProviderUsage({
+                semantics: 'openai',
+                provider: 'openai',
+                source: 'codex-reader-snapshot',
+                model: this.parser.getCurrentModel() || undefined,
+                inputTokens: lastUsage.input_tokens,
+                outputTokens: lastUsage.output_tokens,
+                cacheReadTokens: lastUsage.cached_input_tokens,
+                reasoningTokens: lastUsage.reasoning_output_tokens,
+            });
+            onTokenUsage({
+                inputTokens: normalized.uncachedInputTokens,
+                outputTokens: normalized.outputTokens,
+                cacheWriteTokens: normalized.cacheWriteTokens,
+                cacheReadTokens: normalized.cacheReadTokens,
+                reasoningTokens: normalized.reasoningTokens,
+                model: this.parser.getCurrentModel() || 'unknown',
+                timestamp: new Date(),
+            });
+        }
+    }
+}

package/dist/esm/providers/codexDatabase.js

@@ -5,7 +5,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { execFile, execFileSync } from 'child_process';
-import { codexSpawnParentFromSource as spawnParentFromSource } from '../parsers/codexRolloutOrigin';
+import { codexRolloutOrigin, codexSpawnParentFromSource as spawnParentFromSource, } from '../parsers/codexRolloutOrigin';
 /**
  * Ids per inlined `IN (…)` query. Values are passed inside a single argv
  * element to sqlite3, so an unbounded list would hit E2BIG on large stores.
@@ -13,6 +13,17 @@ import { codexSpawnParentFromSource as spawnParentFromSource } from '../parsers/
 const SQL_ID_CHUNK_SIZE = 400;
 /** Parent thread id of a spawned subagent's `source`; one rule shared with rollout parsing. */
 export { spawnParentFromSource };
+/** Default levels {@link CodexDatabase.getSpawnedDescendantThreads} follows. */
+export const DEFAULT_SUBAGENT_TREE_MAX_DEPTH = 8;
+/**
+ * Whether a thread row is a subagent's rather than a session a person
+ * started: `thread_source: 'subagent'`, or a `{ subagent: … }` source.
+ */
+export function isCodexSubagentThread(thread) {
+    if (thread.thread_source === 'subagent')
+        return true;
+    return codexRolloutOrigin({ source: thread.source }).isSubagent;
+}
 export class CodexDatabase {
     dbPath;
     sqlite3Available = null;
@@ -141,8 +152,12 @@ export class CodexDatabase {
                 threadCwd.startsWith(normalized + path.sep));
         });
     }
+    /**
+     * The workspace's most recently updated thread that a person started:
+     * subagent threads (which share their parent's cwd) are skipped.
+     */
     getMostRecentThread(cwd) {
-        return this.getThreadsByCwd(cwd)[0] ?? null;
+        return this.getThreadsByCwd(cwd).find((thread) => !isCodexSubagentThread(thread)) ?? null;
     }
     getAllDistinctCwds() {
         return this.query('SELECT cwd, COUNT(*) as count, MAX(updated_at) as lastUpdated FROM threads GROUP BY cwd ORDER BY lastUpdated DESC');
@@ -195,6 +210,36 @@ export class CodexDatabase {
         const rows = this.query('SELECT * FROM threads WHERE source LIKE ? ORDER BY created_at ASC', [`%${parentId}%`]);
         return rows.filter((row) => spawnParentFromSource(row.source) === parentId);
     }
+    /**
+     * Every subagent thread below a session, level by level (one query per
+     * level, in chunks of ids), oldest first within a level: its children,
+     * their children, and so on up to `maxDepth` levels.
+     */
+    getSpawnedDescendantThreads(rootId, maxDepth = DEFAULT_SUBAGENT_TREE_MAX_DEPTH) {
+        if (!this.getThreadColumns().has('source'))
+            return [];
+        const found = [];
+        const seen = new Set([rootId]);
+        let level = [rootId];
+        for (let depth = 1; depth <= maxDepth && level.length > 0; depth++) {
+            const parents = new Set(level);
+            const next = [];
+            for (let i = 0; i < level.length; i += SQL_ID_CHUNK_SIZE) {
+                const chunk = level.slice(i, i + SQL_ID_CHUNK_SIZE);
+                const rows = this.query(`SELECT * FROM threads WHERE ${chunk.map(() => 'source LIKE ?').join(' OR ')} ORDER BY created_at ASC`, chunk.map((id) => `%${id}%`));
+                for (const row of rows) {
+                    const parentId = spawnParentFromSource(row.source);
+                    if (!parentId || !parents.has(parentId) || seen.has(row.id))
+                        continue;
+                    seen.add(row.id);
+                    found.push({ thread: row, parentId, depth });
+                    next.push(row.id);
+                }
+            }
+            level = next;
+        }
+        return found;
+    }
     /** Get the database file's mtime (ms epoch). Returns 0 if unavailable. */
     getDbMtime() {
         try {

package/dist/esm/providers/codexRollouts.js

@@ -9,15 +9,19 @@ import * as path from 'path';
 import { getCodexSessionsDirs } from '../codexPaths';
 import { DirectoryListingCache } from './directoryListingCache';
 import { walkRolloutFiles, walkRolloutFilesAsync } from './rolloutWalker';
+import { isCompressedRolloutPath, readRolloutFirstLines, readRolloutHead, } from './compressedRollouts';
 /** Every directory across the monitored homes that may hold rollouts, archived ones included. */
 export function getSessionsDirs() {
     return getCodexSessionsDirs();
 }
 /**
  * Read the first N complete lines from a file using chunked reads.
- * Handles arbitrarily long lines (Codex session_meta can be 10KB+).
+ * Handles arbitrarily long lines (Codex session_meta can be 10KB+), and
+ * compressed rollouts (`.jsonl.zst`, decompressed when the runtime can).
  */
 export function readFirstLines(filePath, maxLines, maxBytes = 256 * 1024) {
+    if (isCompressedRolloutPath(filePath))
+        return readRolloutFirstLines(filePath, maxLines, maxBytes);
     const lines = [];
     let fd;
     try {
@@ -81,6 +85,14 @@ export async function readFirstLineAsync(rolloutPath) {
     // `instructions` and can far exceed a single chunk.
     const maxBytes = 256 * 1024;
     const chunkSize = 64 * 1024;
+    if (isCompressedRolloutPath(rolloutPath)) {
+        // Compressed rollouts are complete: their first line is final.
+        const head = readRolloutHead(rolloutPath, maxBytes);
+        if (head.length === 0)
+            return { line: null, complete: false };
+        const firstLine = head.toString('utf8').split('\n', 1)[0]?.trim();
+        return { line: firstLine || null, complete: true };
+    }
     let handle = null;
     try {
         handle = await fs.promises.open(rolloutPath, 'r');
@@ -198,6 +210,7 @@ export async function listCodexSessionFilesAsync(workspacePath, options = {}, ca
         cache,
         revalidateRecent: options.revalidateRecent,
         stats: options.stats,
+        includeCompressed: options.includeCompressed,
     });
     for (const file of files) {
         if (options.limit !== undefined && results.length >= options.limit)
@@ -234,5 +247,10 @@ export function findCodexRolloutFile(sessionId, options = {}) {
         ? getCodexSessionsDirs([options.codexHome])
         : getSessionsDirs();
     // Name-only filter, one walk across the homes, newest modification first.
-    return walkRolloutFiles(sessionsDirs, { sessionId: normalizedId })[0]?.path ?? null;
+    const matches = walkRolloutFiles(sessionsDirs, {
+        sessionId: normalizedId,
+        includeCompressed: options.includeCompressed,
+    });
+    // A live `.jsonl` wins over a compressed copy found in another home.
+    return (matches.find((file) => !isCompressedRolloutPath(file.path)) ?? matches[0])?.path ?? null;
 }