@phnx-labs/agents-cli 1.21.3 → 1.22.1

package/dist/lib/session/discover.js

@@ -34,6 +34,8 @@ import { mapBounded } from '../concurrency.js';
 import { getDB, getScanStampByPath, getScanStampsForPaths, getParserStatesForPaths, getDirLedgerForPaths, recordDirScans, recordScans, syncLabels, seedLabelsFromNames, syncTopics, upsertSessionsBatch, querySessions, countSessions, ftsSearch, tryClaimScan, releaseScan, cacheLinearProject, } from './db.js';
 import { buildRunNameMap } from './run-names.js';
 import { resolveLinearApiKey } from '../auto-dispatch-linear.js';
+import { ToolCallCollector, collectClaudeToolCalls, collectCodexToolCalls, } from './tool-calls.js';
+import { purgeMissingToolCallsInDirectory } from './tool-store.js';
 const HOME = os.homedir();
 // Versions can live under either repo: the user repo (current canonical
 // location, ~/.agents/.history/versions/) or the system repo (legacy / npm-shipped,
@@ -47,6 +49,73 @@ const HERMES_SESSIONS_DIR = path.join(HOME, '.hermes', 'sessions');
 /** How long OpenClaw channel/cron snapshots stay valid before we re-shell-out. */
 const OPENCLAW_TTL_MS = 60_000;
 const ACTIVE_APPEND_RESCAN_DEBOUNCE_MS = 5_000;
+/** One JSONL record may not force an unbounded string allocation. */
+export const SESSION_JSONL_LINE_MAX_BYTES = 1024 * 1024;
+/**
+ * Stream one appended JSONL range, applying only newline-terminated records.
+ * Memory is bounded to one record. An ordinary unterminated tail remains for the
+ * next scan. Once a record exceeds the cap, its consumed offset and a one-bit
+ * dropping state advance together so later scans never reread the growing tail.
+ */
+async function applyJsonlAppend(filePath, fromOffset, wasDroppingOversizedLine, apply) {
+    let pending = Buffer.alloc(0);
+    let droppingOversizedLine = wasDroppingOversizedLine;
+    let bytesBeforeChunk = 0;
+    let consumedBytes = 0;
+    let skippedOversizedLine = false;
+    const stream = fs.createReadStream(filePath, { start: fromOffset });
+    try {
+        for await (const rawChunk of stream) {
+            const chunk = typeof rawChunk === 'string' ? Buffer.from(rawChunk, 'utf-8') : rawChunk;
+            let cursor = 0;
+            for (;;) {
+                const newline = chunk.indexOf(0x0a, cursor);
+                if (newline === -1) {
+                    if (!droppingOversizedLine) {
+                        const tail = chunk.subarray(cursor);
+                        if (pending.length + tail.length > SESSION_JSONL_LINE_MAX_BYTES) {
+                            pending = Buffer.alloc(0);
+                            droppingOversizedLine = true;
+                            skippedOversizedLine = true;
+                        }
+                        else if (tail.length > 0) {
+                            pending = pending.length > 0 ? Buffer.concat([pending, tail]) : Buffer.from(tail);
+                        }
+                    }
+                    if (droppingOversizedLine)
+                        consumedBytes = bytesBeforeChunk + chunk.length;
+                    break;
+                }
+                if (!droppingOversizedLine) {
+                    const segment = chunk.subarray(cursor, newline);
+                    if (pending.length + segment.length <= SESSION_JSONL_LINE_MAX_BYTES) {
+                        const line = (pending.length > 0 ? Buffer.concat([pending, segment]) : segment).toString('utf-8');
+                        if (line.trim()) {
+                            try {
+                                apply(JSON.parse(line));
+                            }
+                            catch {
+                                // One malformed line never aborts the session scan.
+                            }
+                        }
+                    }
+                    else {
+                        skippedOversizedLine = true;
+                    }
+                }
+                pending = Buffer.alloc(0);
+                droppingOversizedLine = false;
+                consumedBytes = bytesBeforeChunk + newline + 1;
+                cursor = newline + 1;
+            }
+            bytesBeforeChunk += chunk.length;
+        }
+    }
+    finally {
+        stream.destroy();
+    }
+    return { consumedBytes, droppingOversizedLine, skippedOversizedLine };
+}
 /**
  * How recently a file must have been scanned to be treated as "hot" — a
  * candidate for an in-place append even when its parent dir's mtime hasn't
@@ -102,8 +171,17 @@ export async function discoverSessions(options) {
             releaseScan(process.pid);
         }
     }
-    const sessions = querySessions(buildQueryOptions(options, agents, { includeLimit: true }));
-    await resolveLinearProjects(sessions);
+    return queryIndexedSessions(options, {
+        skipExistenceCheck: options?.skipExistenceCheck ?? false,
+    });
+}
+/** Read the current SQLite snapshot without scanning or parsing transcript files. */
+export async function queryIndexedSessions(options, indexedOptions = {}) {
+    getDB();
+    const agents = options?.agent ? [options.agent] : SESSION_AGENTS;
+    const sessions = querySessions(buildQueryOptions({ ...options, skipExistenceCheck: indexedOptions.skipExistenceCheck ?? true }, agents, { includeLimit: true }));
+    if (indexedOptions.resolveLinear !== false)
+        await resolveLinearProjects(sessions);
     for (const s of sessions)
         s.machine = machineForSessionFile(s.filePath, s.agent);
     return scopeToManaged(sessions, agents, options);
@@ -156,7 +234,7 @@ async function resolveLinearProjects(sessions) {
  * An agent with no managed versions is left alone entirely — someone who has never
  * run `agents add` sees exactly what they saw before.
  */
-function scopeToManaged(sessions, agents, options) {
+export function scopeToManaged(sessions, agents, options) {
     if (options?.includeUnmanaged)
         return sessions;
     if (!anyManagedVersions())
@@ -306,11 +384,12 @@ function buildQueryOptions(options, agents, opts) {
         project: projectQuery,
         sinceMs,
         untilMs: Number.isFinite(untilMs) ? untilMs : undefined,
-        limit: opts.includeLimit ? (options?.limit ?? 50) : undefined,
+        limit: opts.includeLimit && !options?.unbounded ? (options?.limit ?? 50) : undefined,
         excludeTeamOrigin: options?.excludeTeamOrigin,
         onlyTeamOrigin: options?.onlyTeamOrigin,
         origin: options?.origin,
         sortBy: options?.sortBy,
+        skipExistenceCheck: options?.skipExistenceCheck,
         skill: options?.skill,
         plugin: options?.plugin,
     };
@@ -582,6 +661,7 @@ export function collectChangedFilesInLeafDirs(leafDirs, ext) {
                     continue;
                 toCompare.push({ filePath, fileMtimeMs: stat.mtimeMs, fileSize: stat.size });
             }
+            purgeMissingToolCallsInDirectory(getDB(), dirPath, files);
             if (!disabled)
                 dirScansToRecord.push({ dirPath, dirMtimeMs, entryCount });
         }
@@ -789,7 +869,13 @@ async function scanRoutineArchivesIncremental(agent, onProgress) {
         try {
             const result = await readRoutineArchiveMeta(agent, filePath);
             if (result)
-                entries.push({ meta: result.meta, content: result.content, scan });
+                entries.push({
+                    meta: result.meta,
+                    content: result.content,
+                    scan,
+                    toolCalls: result.toolCalls,
+                    toolIndexMode: result.toolIndexMode,
+                });
             else
                 touched.push({ filePath, scan });
         }
@@ -964,6 +1050,8 @@ async function scanClaudeIncremental(onProgress) {
                         scan,
                         parserState: result.parserState,
                         contentText: result.contentText,
+                        toolCalls: result.toolCalls,
+                        toolIndexMode: result.toolIndexMode,
                     });
                 }
                 else {
@@ -993,7 +1081,7 @@ async function scanClaudeIncremental(onProgress) {
  */
 async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account, label) {
     const prior = parsePriorClaudeState(priorRow);
-    const { scan, newState, mode } = await scanClaudeSessionResumable(filePath, prior, scanStamp.fileMtimeMs, scanStamp.fileSize, priorRow?.fileMtimeMs);
+    const { scan, newState, toolCalls, mode } = await scanClaudeSessionResumable(filePath, prior, scanStamp.fileMtimeMs, scanStamp.fileSize, priorRow?.fileMtimeMs);
     if (mode === 'incremental')
         claudeIncrementalScanCount++;
     else
@@ -1078,6 +1166,8 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account,
         // doc, cached so the resume can hydrate userTexts without re-reading the file.
         parserState: JSON.stringify(newState),
         contentText: newState.contentText,
+        toolCalls,
+        toolIndexMode: mode === 'full' ? 'replace' : 'append',
     };
 }
 // ---------------------------------------------------------------------------
@@ -1215,6 +1305,8 @@ async function scanCodexIncremental(onProgress) {
                     scan,
                     parserState: result.parserState,
                     contentText: result.contentText,
+                    toolCalls: result.toolCalls,
+                    toolIndexMode: result.toolIndexMode,
                 });
             }
             else {
@@ -1317,6 +1409,8 @@ export async function readCodexMeta(filePath, resolveAccount, currentVersion, sc
     let scan;
     let newState;
     let newOffset = 0;
+    let toolCalls;
+    let toolIndexMode = 'replace';
     if (scanStamp) {
         const prior = parsePriorCodexState(priorRow);
         const result = await scanCodexSessionResumable(filePath, prior, scanStamp.fileMtimeMs, scanStamp.fileSize, priorRow?.fileMtimeMs);
@@ -1327,6 +1421,8 @@ export async function readCodexMeta(filePath, resolveAccount, currentVersion, sc
         scan = result.scan;
         newState = result.newState;
         newOffset = result.newOffset;
+        toolCalls = result.toolCalls;
+        toolIndexMode = result.mode === 'full' ? 'replace' : 'append';
     }
     else {
         scan = await scanCodexSession(filePath);
@@ -1373,6 +1469,8 @@ export async function readCodexMeta(filePath, resolveAccount, currentVersion, sc
         // doc for the resume's hydrate. Absent when no stamp was supplied.
         parserState: newState ? JSON.stringify(newState) : undefined,
         contentText: newState?.contentText,
+        toolCalls,
+        toolIndexMode,
     };
 }
 /**
@@ -2453,6 +2551,7 @@ export function initClaudeParseState() {
         plan: undefined,
         checklistEvents: [],
         recentDirectoriesTouched: [],
+        toolCollector: new ToolCallCollector(),
         skillEvents: [],
         slashCommandEvents: [],
     };
@@ -2491,6 +2590,7 @@ function foldDerivedToolState(state, event) {
  * malformed-line skip happens in the caller, as before).
  */
 export function applyClaudeLine(state, parsed) {
+    collectClaudeToolCalls(state.toolCollector, parsed);
     // entrypoint ships on the first envelope event (attachment/user/assistant)
     // and is the clean structural signal for "was this a team spawn?"
     if (!state.entrypoint && typeof parsed.entrypoint === 'string') {
@@ -2726,15 +2826,16 @@ const SEEN_IDS_RECENT_CAP = 256;
  * `offset` bytes consumed. Round-trips through {@link hydrateClaudeParseState}
  * so incremental replay equals a full parse.
  */
-export function serializeClaudeParserState(state, offset) {
+export function serializeClaudeParserState(state, offset, jsonlDroppingOversizedLine = false) {
     const allIds = [...state.seenAssistantIds];
     const seenIdsRecent = allIds.length > SEEN_IDS_RECENT_CAP
         ? allIds.slice(allIds.length - SEEN_IDS_RECENT_CAP)
         : allIds;
     const ticket = detectTicket(state.userTexts.join('\n') || undefined, state.gitBranch);
     return {
-        v: 1,
+        v: 2,
         offset,
+        jsonlDroppingOversizedLine: jsonlDroppingOversizedLine || undefined,
         timestamp: state.timestamp,
         cwd: state.cwd,
         gitBranch: state.gitBranch,
@@ -2770,6 +2871,7 @@ export function serializeClaudeParserState(state, offset) {
         contentText: state.userTexts.length > 0 ? state.userTexts.join('\n') : undefined,
         checklistEvents: state.checklistEvents,
         recentDirectoriesTouched: state.recentDirectoriesTouched,
+        toolCalls: state.toolCollector.snapshot(),
         skillEvents: state.skillEvents,
         slashCommandEvents: state.slashCommandEvents,
     };
@@ -2828,6 +2930,7 @@ export function hydrateClaudeParseState(prior) {
         plan: prior.plan,
         checklistEvents: prior.checklistEvents ?? [],
         recentDirectoriesTouched: prior.recentDirectoriesTouched ?? [],
+        toolCollector: new ToolCallCollector(prior.toolCalls),
         skillEvents: prior.skillEvents ?? [],
         slashCommandEvents: prior.slashCommandEvents ?? [],
     };
@@ -2853,45 +2956,20 @@ export async function scanClaudeSessionIncremental(filePath, fromOffset, prior)
     // have no dedup, unlike assistant `seenAssistantIds`). A record written
     // non-atomically — bytes first, then '\n' in a second write — is exactly this
     // case. So we slice at the last '\n' ourselves: everything up to and including
-    // it is a run of complete lines we apply and commit; any tail after it
-    // (syntactically broken OR complete-but-not-yet-terminated) is a still-being-
-    // written record we DEFER to the next pass, once its '\n' lands.
-    const chunks = [];
-    const stream = fs.createReadStream(filePath, { start: fromOffset });
-    try {
-        for await (const chunk of stream) {
-            chunks.push(typeof chunk === 'string' ? Buffer.from(chunk, 'utf-8') : chunk);
-        }
-    }
-    finally {
-        stream.destroy();
-    }
-    const appended = Buffer.concat(chunks);
-    // Bytes up to AND INCLUDING the last '\n' are the committed, complete-line run.
-    const lastNl = appended.lastIndexOf(0x0a);
-    const consumedBytes = lastNl === -1 ? 0 : lastNl + 1;
-    if (consumedBytes > 0) {
-        // split('\n') on the committed run: the element after the final '\n' is ''
-        // (skipped by the trim guard). A stray '\r' from CRLF is tolerated by the
-        // JSON.parse below exactly as the full parse tolerates it.
-        for (const line of appended.subarray(0, consumedBytes).toString('utf-8').split('\n')) {
-            if (!line.trim())
-                continue;
-            let parsed;
-            try {
-                parsed = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            applyClaudeLine(state, parsed);
-        }
-    }
-    const newOffset = fromOffset + consumedBytes;
+    // it is a run of complete lines we apply and commit. An ordinary tail after
+    // it is deferred until its '\n' lands; after a tail exceeds 1 MiB, its offset
+    // advances with a persisted discard-until-newline bit.
+    const append = await applyJsonlAppend(filePath, fromOffset, prior.jsonlDroppingOversizedLine === true, (parsed) => applyClaudeLine(state, parsed));
+    if (append.skippedOversizedLine)
+        state.toolCollector.recordIndexLimit();
+    const newOffset = fromOffset + append.consumedBytes;
+    const scan = finalizeClaudeScan(state);
+    const toolCalls = state.toolCollector.drainChanged();
     return {
-        scan: finalizeClaudeScan(state),
-        newState: serializeClaudeParserState(state, newOffset),
+        scan,
+        newState: serializeClaudeParserState(state, newOffset, append.droppingOversizedLine),
         newOffset,
+        toolCalls,
     };
 }
 /** Serialized zero-value continuation: a fresh accumulator at offset 0, used to drive a FULL parse from the start through the same resumable path. */
@@ -2986,7 +3064,7 @@ function parsePriorClaudeState(row) {
         return null;
     try {
         const parsed = JSON.parse(row.parserState);
-        if (parsed?.v !== 1 || typeof parsed.offset !== 'number')
+        if (parsed?.v !== 2 || typeof parsed.offset !== 'number' || parsed.toolCalls?.v !== 1)
             return null;
         return parsed;
     }
@@ -3031,6 +3109,7 @@ export function initCodexParseState() {
         spawnedTeam: undefined,
         checklistEvents: [],
         recentDirectoriesTouched: [],
+        toolCollector: new ToolCallCollector(),
         skillEvents: [],
         slashCommandEvents: [],
     };
@@ -3042,6 +3121,7 @@ export function initCodexParseState() {
  * malformed-line skip happens in the caller, as before).
  */
 export function applyCodexLine(state, parsed) {
+    collectCodexToolCalls(state.toolCollector, parsed);
     // PR signal, structurally: a Codex `function_call` whose command is
     // `gh pr create`, then the pull URL from a `function_call_output`.
     if (parsed.type === 'response_item') {
@@ -3214,11 +3294,12 @@ async function scanCodexSession(filePath) {
  * bytes consumed. Round-trips through {@link hydrateCodexParseState} so
  * incremental replay equals a full parse.
  */
-export function serializeCodexParserState(state, offset) {
+export function serializeCodexParserState(state, offset, jsonlDroppingOversizedLine = false) {
     const ticket = detectTicket(state.userTexts.join('\n') || undefined, state.gitBranch);
     return {
-        v: 1,
+        v: 2,
         offset,
+        jsonlDroppingOversizedLine: jsonlDroppingOversizedLine || undefined,
         sessionId: state.sessionId,
         timestamp: state.timestamp,
         cwd: state.cwd,
@@ -3245,6 +3326,7 @@ export function serializeCodexParserState(state, offset) {
         contentText: state.userTexts.length > 0 ? state.userTexts.join('\n') : undefined,
         checklistEvents: state.checklistEvents,
         recentDirectoriesTouched: state.recentDirectoriesTouched,
+        toolCalls: state.toolCollector.snapshot(),
     };
 }
 /**
@@ -3280,6 +3362,7 @@ export function hydrateCodexParseState(prior) {
         spawnedTeam: prior.spawnedTeam,
         checklistEvents: prior.checklistEvents ?? [],
         recentDirectoriesTouched: prior.recentDirectoriesTouched ?? [],
+        toolCollector: new ToolCallCollector(prior.toolCalls),
         // Not persisted in CodexParserState (always empty for Codex today — see
         // CodexParseState.skillEvents) — a resume starts fresh rather than
         // round-tripping an always-empty array through the continuation blob.
@@ -3294,47 +3377,25 @@ export function hydrateCodexParseState(prior) {
  *
  * Same trailing-line discipline as {@link scanClaudeSessionIncremental}: apply
  * ONLY the run of newline-terminated lines (slice at the last `'\n'`), and set
- * `newOffset = fromOffset + consumedBytes`. Any tail after the last `'\n'` —
- * syntactically broken OR a complete-but-not-yet-terminated record — is DEFERRED
- * to the next pass once its `'\n'` lands. Codex `messageCount` is additive with
+ * `newOffset = fromOffset + consumedBytes`. An ordinary tail after the last
+ * `'\n'` is deferred; an oversized one advances under a persisted discard bit.
+ * Codex `messageCount` is additive with
  * NO dedup, so re-reading a still-unterminated complete line would double-count
  * it; deferring prevents that (the bug class prix-cloud caught for Claude).
  */
 export async function scanCodexSessionIncremental(filePath, fromOffset, prior) {
     const state = hydrateCodexParseState(prior);
-    const chunks = [];
-    const stream = fs.createReadStream(filePath, { start: fromOffset });
-    try {
-        for await (const chunk of stream) {
-            chunks.push(typeof chunk === 'string' ? Buffer.from(chunk, 'utf-8') : chunk);
-        }
-    }
-    finally {
-        stream.destroy();
-    }
-    const appended = Buffer.concat(chunks);
-    // Bytes up to AND INCLUDING the last '\n' are the committed, complete-line run.
-    const lastNl = appended.lastIndexOf(0x0a);
-    const consumedBytes = lastNl === -1 ? 0 : lastNl + 1;
-    if (consumedBytes > 0) {
-        for (const line of appended.subarray(0, consumedBytes).toString('utf-8').split('\n')) {
-            if (!line.trim())
-                continue;
-            let parsed;
-            try {
-                parsed = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            applyCodexLine(state, parsed);
-        }
-    }
-    const newOffset = fromOffset + consumedBytes;
+    const append = await applyJsonlAppend(filePath, fromOffset, prior.jsonlDroppingOversizedLine === true, (parsed) => applyCodexLine(state, parsed));
+    if (append.skippedOversizedLine)
+        state.toolCollector.recordIndexLimit();
+    const newOffset = fromOffset + append.consumedBytes;
+    const scan = finalizeCodexScan(state);
+    const toolCalls = state.toolCollector.drainChanged();
     return {
-        scan: finalizeCodexScan(state),
-        newState: serializeCodexParserState(state, newOffset),
+        scan,
+        newState: serializeCodexParserState(state, newOffset, append.droppingOversizedLine),
         newOffset,
+        toolCalls,
     };
 }
 /** Serialized zero-value continuation: a fresh accumulator at offset 0, used to drive a FULL parse from the start through the same resumable path. */
@@ -3423,7 +3484,7 @@ function parsePriorCodexState(row) {
         return null;
     try {
         const parsed = JSON.parse(row.parserState);
-        if (parsed?.v !== 1 || typeof parsed.offset !== 'number')
+        if (parsed?.v !== 2 || typeof parsed.offset !== 'number' || parsed.toolCalls?.v !== 1)
             return null;
         return parsed;
     }

package/dist/lib/session/parse.d.ts

@@ -12,7 +12,14 @@ import type { SessionAgentId, SessionEvent } from './types.js';
  * Node's ~512MB string ceiling with a healthy margin.
  */
 export declare const SESSION_FILE_MAX_BYTES = 200000000;
-export declare function sanitizeForTerminal(s: string): string;
+/**
+ * Strip terminal control sequences that a malicious session file could use to
+ * hijack the user's terminal (clipboard via OSC 52, scrollback wipe, alt-screen
+ * takeover, cursor moves, etc.). Allowed through: tab (0x09), newline (0x0a),
+ * carriage return (0x0d). Everything else in the C0/C1 range and every CSI/OSC
+ * escape is dropped.
+ */
+export { sanitizeForTerminal } from '../redact.js';
 /** In-place sanitize every user-visible string field on a list of events. */
 export declare function sanitizeEvents(events: SessionEvent[]): void;
 /**