@tonyclaw/agent-inspector 2.0.42 → 2.1.0

package/src/proxy/store.ts

@@ -21,6 +21,7 @@ import {
 import { getChunksDir } from "./chunkStorage";
 import {
   addToIndex,
+  createLogIndexEntryMetadata,
   findInIndex,
   flushIndex,
   getNextLogId,
@@ -28,6 +29,7 @@ import {
   listIndexEntries,
   rebuildIndex,
   type LogIndexEntry,
+  type LogIndexSummary,
 } from "./logIndex";
 import { writeChunks } from "./chunkStorage";
 import type { SessionInfo, SessionLogSummary } from "../lib/sessionInfoContract";
@@ -92,6 +94,26 @@ export type ListLogsPageResult = {
   limit: number;
 };
 
+export type ListLogsCursorPageOptions = {
+  sessionId?: string;
+  model?: string;
+  limit: number;
+  includeBodies?: boolean;
+  beforeLogId?: number;
+  afterLogId?: number;
+  anchor?: "newest" | "oldest";
+};
+
+export type ListLogsCursorPageResult = {
+  logs: CapturedLog[];
+  total: number;
+  limit: number;
+  hasOlder: boolean;
+  hasNewer: boolean;
+  oldestLogId: number | null;
+  newestLogId: number | null;
+};
+
 export type GetSessionInfoOptions = {
   baseUrl: string;
   includeHistory?: boolean;
@@ -100,6 +122,74 @@ export type GetSessionInfoOptions = {
 
 // Memory cache: id -> CapturedLog (recent logs only, FIFO eviction)
 const memoryCache: Map<number, CapturedLog> = new Map();
+const MAX_CURSOR_PAGE_INDEXES = 16;
+
+type LogCursorPageIndex = {
+  key: string;
+  sessionId?: string;
+  model?: string;
+  ids: number[];
+  logsById: Map<number, CapturedLog>;
+  entriesById: Map<number, LogIndexEntry>;
+};
+
+const logCursorPageIndexes: Map<string, LogCursorPageIndex> = new Map();
+let logCursorPageIndexBuildCount = 0;
+
+function cursorPageIndexKey(
+  options: Pick<ListLogsCursorPageOptions, "sessionId" | "model">,
+): string {
+  return JSON.stringify({
+    sessionId: options.sessionId ?? null,
+    model: options.model ?? null,
+  });
+}
+
+function matchesCursorIndexFilters(log: CapturedLog, index: LogCursorPageIndex): boolean {
+  if (index.sessionId !== undefined && getLogSessionId(log) !== index.sessionId) return false;
+  if (index.model !== undefined && log.model !== index.model) return false;
+  return true;
+}
+
+function insertSortedLogId(ids: number[], id: number): void {
+  if (ids.includes(id)) return;
+  const insertionIndex = ids.findIndex((candidate) => candidate > id);
+  if (insertionIndex === -1) {
+    ids.push(id);
+    return;
+  }
+  ids.splice(insertionIndex, 0, id);
+}
+
+function upsertLogCursorPageIndexes(log: CapturedLog): void {
+  for (const index of logCursorPageIndexes.values()) {
+    if (!matchesCursorIndexFilters(log, index)) {
+      if (index.logsById.delete(log.id)) {
+        index.ids = index.ids.filter((id) => id !== log.id);
+      }
+      index.entriesById.delete(log.id);
+      continue;
+    }
+    index.logsById.set(log.id, log);
+    insertSortedLogId(index.ids, log.id);
+  }
+}
+
+function removeLogsFromCursorPageIndexes(ids: ReadonlySet<number>): void {
+  if (ids.size === 0) return;
+  for (const index of logCursorPageIndexes.values()) {
+    for (const id of ids) {
+      index.logsById.delete(id);
+      index.entriesById.delete(id);
+    }
+    index.ids = index.ids.filter((id) => !ids.has(id));
+  }
+}
+
+function clearLogCursorPageIndexes(): void {
+  logCursorPageIndexes.clear();
+  logCursorPageIndexBuildCount = 0;
+}
 
 function evictOldestIfNeeded(): void {
   while (memoryCache.size > MAX_MEMORY_CACHE) {
@@ -125,11 +215,13 @@ function addToCache(log: CapturedLog): void {
     memoryCache.delete(cachedLog.id);
   }
   memoryCache.set(cachedLog.id, cachedLog);
+  upsertLogCursorPageIndexes(cachedLog);
   evictOldestIfNeeded();
 }
 
 function removeFromCache(id: number): void {
   memoryCache.delete(id);
+  removeLogsFromCursorPageIndexes(new Set([id]));
 }
 
 function textByteLength(value: string | null): number | null {
@@ -151,6 +243,45 @@ export function compactLogForList(log: CapturedLog): CapturedLog {
   };
 }
 
+function compactLogFromIndexSummary(summary: LogIndexSummary): CapturedLog {
+  return normalizeLog({
+    id: summary.id,
+    timestamp: summary.timestamp,
+    method: summary.method,
+    path: summary.path,
+    model: summary.model,
+    sessionId: summary.sessionId,
+    rawRequestBody: null,
+    responseStatus: summary.responseStatus,
+    responseText: null,
+    inputTokens: summary.inputTokens,
+    outputTokens: summary.outputTokens,
+    cacheCreationInputTokens: summary.cacheCreationInputTokens,
+    cacheReadInputTokens: summary.cacheReadInputTokens,
+    elapsedMs: summary.elapsedMs,
+    firstChunkMs: summary.firstChunkMs,
+    totalStreamMs: summary.totalStreamMs,
+    tokensPerSecond: summary.tokensPerSecond,
+    streaming: summary.streaming,
+    userAgent: summary.userAgent,
+    origin: summary.origin,
+    apiFormat: summary.apiFormat,
+    isTest: summary.isTest,
+    replayOfLogId: summary.replayOfLogId,
+    providerName: summary.providerName,
+    clientPort: summary.clientPort,
+    clientPid: summary.clientPid,
+    clientCwd: summary.clientCwd,
+    clientProjectFolder: summary.clientProjectFolder,
+    streamingChunksPath: summary.streamingChunksPath,
+    rawRequestBodyBytes: summary.rawRequestBodyBytes,
+    responseTextBytes: summary.responseTextBytes,
+    bodyContentMode: "compact",
+    warnings: summary.warnings,
+    error: summary.error,
+  });
+}
+
 function prepareLogForList(log: CapturedLog, includeBodies: boolean): CapturedLog {
   return includeBodies ? log : compactLogForList(log);
 }
@@ -187,7 +318,7 @@ export async function addTestLogEntry(entry: Omit<CapturedLog, "id">): Promise<C
   await runWithLogWriteLock(async () => {
     const logFile = getCurrentLogFile();
     appendLogEntry(log);
-    await addToIndex(id, logFile, -1, -1);
+    await addToIndex(id, logFile, -1, -1, createLogIndexEntryMetadata(log));
   });
 
   addToCache(log);
@@ -258,7 +389,7 @@ export async function createLog(
   await runWithLogWriteLock(async () => {
     const logFile = getCurrentLogFile();
     appendLogEntry(log);
-    await addToIndex(id, logFile, -1, -1); // line numbers not tracked precisely
+    await addToIndex(id, logFile, -1, -1, createLogIndexEntryMetadata(log));
   });
 
   // Add to memory cache
@@ -522,6 +653,234 @@ export async function listLogsPage(options: ListLogsPageOptions): Promise<ListLo
   };
 }
 
+function matchesCursorWindow(id: number, options: ListLogsCursorPageOptions): boolean {
+  if (options.beforeLogId !== undefined && id >= options.beforeLogId) return false;
+  if (options.afterLogId !== undefined && id <= options.afterLogId) return false;
+  return true;
+}
+
+function selectCursorPageLogs(
+  ids: readonly number[],
+  options: ListLogsCursorPageOptions,
+): number[] {
+  const matchingWindow = ids.filter((id) => matchesCursorWindow(id, options));
+  if (options.afterLogId !== undefined || options.anchor === "oldest") {
+    return matchingWindow.slice(0, options.limit);
+  }
+  return matchingWindow.slice(Math.max(0, matchingWindow.length - options.limit));
+}
+
+function rememberLogCursorPageIndex(index: LogCursorPageIndex): LogCursorPageIndex {
+  if (logCursorPageIndexes.has(index.key)) {
+    logCursorPageIndexes.delete(index.key);
+  }
+  logCursorPageIndexes.set(index.key, index);
+  while (logCursorPageIndexes.size > MAX_CURSOR_PAGE_INDEXES) {
+    const oldestKey = logCursorPageIndexes.keys().next().value;
+    if (oldestKey === undefined) break;
+    logCursorPageIndexes.delete(oldestKey);
+  }
+  return index;
+}
+
+function hasNullableStringField(entry: LogIndexEntry, field: "sessionId" | "model"): boolean {
+  const desc = Object.getOwnPropertyDescriptor(entry, field);
+  if (desc === undefined) return false;
+  return typeof desc.value === "string" || desc.value === null;
+}
+
+function hasLogIndexFilterMetadata(entry: LogIndexEntry): boolean {
+  return hasNullableStringField(entry, "sessionId") && hasNullableStringField(entry, "model");
+}
+
+function hasLogIndexSummary(entry: LogIndexEntry): boolean {
+  return entry.summary !== undefined;
+}
+
+function matchesLogIndexEntryFilters(
+  entry: LogIndexEntry,
+  sessionId: string | undefined,
+  model: string | undefined,
+): boolean {
+  if (sessionId !== undefined && entry.sessionId !== sessionId) return false;
+  if (model !== undefined && entry.model !== model) return false;
+  return true;
+}
+
+async function buildLogCursorPageIndexFromLogIndex(
+  options: Pick<ListLogsCursorPageOptions, "sessionId" | "model">,
+  allowRebuild: boolean,
+): Promise<LogCursorPageIndex | null> {
+  let entries = await listIndexEntries();
+  if (entries.length === 0 && allowRebuild) {
+    await rebuildIndex();
+    entries = await listIndexEntries();
+  }
+
+  if (entries.some((entry) => !hasLogIndexFilterMetadata(entry))) {
+    if (!allowRebuild) return null;
+    await rebuildIndex();
+    return await buildLogCursorPageIndexFromLogIndex(options, false);
+  }
+
+  const matchingEntries = entries.filter((entry) =>
+    matchesLogIndexEntryFilters(entry, options.sessionId, options.model),
+  );
+
+  if (matchingEntries.some((entry) => !hasLogIndexSummary(entry))) {
+    if (!allowRebuild) return null;
+    await rebuildIndex();
+    return await buildLogCursorPageIndexFromLogIndex(options, false);
+  }
+
+  if (matchingEntries.some((entry) => !hasUsableIndexOffset(entry) && !memoryCache.has(entry.id))) {
+    if (!allowRebuild) return null;
+    await rebuildIndex();
+    return await buildLogCursorPageIndexFromLogIndex(options, false);
+  }
+
+  const idsById = new Set<number>();
+  const entriesById = new Map<number, LogIndexEntry>();
+  for (const entry of matchingEntries) {
+    idsById.add(entry.id);
+    entriesById.set(entry.id, entry);
+  }
+
+  const logsById = new Map<number, CapturedLog>();
+  for (const log of memoryCache.values()) {
+    if (!matchesLogFilters(log, options.sessionId, options.model)) continue;
+    idsById.add(log.id);
+    logsById.set(log.id, log);
+  }
+
+  return {
+    key: cursorPageIndexKey(options),
+    sessionId: options.sessionId,
+    model: options.model,
+    ids: [...idsById].sort((left, right) => left - right),
+    logsById,
+    entriesById,
+  };
+}
+
+async function buildLogCursorPageIndex(
+  options: Pick<ListLogsCursorPageOptions, "sessionId" | "model">,
+): Promise<LogCursorPageIndex> {
+  logCursorPageIndexBuildCount += 1;
+  const indexed = await buildLogCursorPageIndexFromLogIndex(options, true);
+  if (indexed !== null) return indexed;
+
+  const key = cursorPageIndexKey(options);
+  const logsById = new Map<number, CapturedLog>();
+
+  const visitLog = (log: CapturedLog): void => {
+    if (!matchesLogFilters(log, options.sessionId, options.model)) return;
+    logsById.set(log.id, log);
+  };
+
+  await visitPersistedLogs((log) => {
+    observeSessionLog(log);
+    visitLog(log);
+  });
+
+  for (const log of memoryCache.values()) {
+    visitLog(log);
+  }
+
+  return {
+    key,
+    sessionId: options.sessionId,
+    model: options.model,
+    ids: [...logsById.keys()].sort((left, right) => left - right),
+    logsById,
+    entriesById: new Map<number, LogIndexEntry>(),
+  };
+}
+
+async function getLogCursorPageIndex(
+  options: Pick<ListLogsCursorPageOptions, "sessionId" | "model">,
+): Promise<LogCursorPageIndex> {
+  const key = cursorPageIndexKey(options);
+  const cached = logCursorPageIndexes.get(key);
+  if (cached !== undefined) {
+    logCursorPageIndexes.delete(key);
+    logCursorPageIndexes.set(key, cached);
+    return cached;
+  }
+  return rememberLogCursorPageIndex(await buildLogCursorPageIndex(options));
+}
+
+async function hydrateCursorPageLogs(
+  index: LogCursorPageIndex,
+  pageIds: readonly number[],
+): Promise<CapturedLog[]> {
+  const logs: CapturedLog[] = [];
+  for (const id of pageIds) {
+    const cached = index.logsById.get(id);
+    if (cached !== undefined) {
+      logs.push(cached);
+      continue;
+    }
+
+    const log = await getLogById(id);
+    if (log === null) continue;
+    index.logsById.set(id, log);
+    logs.push(log);
+  }
+  return logs;
+}
+
+async function hydrateCompactCursorPageLogs(
+  index: LogCursorPageIndex,
+  pageIds: readonly number[],
+): Promise<CapturedLog[]> {
+  const logs: CapturedLog[] = [];
+  for (const id of pageIds) {
+    const cached = index.logsById.get(id);
+    if (cached !== undefined) {
+      logs.push(compactLogForList(cached));
+      continue;
+    }
+
+    const entry = index.entriesById.get(id);
+    if (entry !== undefined && entry.summary !== undefined) {
+      logs.push(compactLogFromIndexSummary(entry.summary));
+      continue;
+    }
+
+    const log = await getLogById(id);
+    if (log === null) continue;
+    index.logsById.set(id, log);
+    logs.push(compactLogForList(log));
+  }
+  return logs;
+}
+
+export async function listLogsCursorPage(
+  options: ListLogsCursorPageOptions,
+): Promise<ListLogsCursorPageResult> {
+  const includeBodies = options.includeBodies !== false;
+  const index = await getLogCursorPageIndex(options);
+  const pageIds = selectCursorPageLogs(index.ids, options);
+  const pageLogs = includeBodies
+    ? await hydrateCursorPageLogs(index, pageIds)
+    : await hydrateCompactCursorPageLogs(index, pageIds);
+  const oldestLogId = pageIds[0] ?? null;
+  const newestLogId = pageIds.at(-1) ?? null;
+  const oldestIndex = oldestLogId === null ? -1 : index.ids.indexOf(oldestLogId);
+  const newestIndex = newestLogId === null ? -1 : index.ids.indexOf(newestLogId);
+
+  return {
+    logs: pageLogs.map((log) => prepareLogForList(log, includeBodies)),
+    total: index.ids.length,
+    limit: options.limit,
+    hasOlder: oldestIndex > 0,
+    hasNewer: newestIndex >= 0 && newestIndex < index.ids.length - 1,
+    oldestLogId,
+    newestLogId,
+  };
+}
+
 function findSessionSnapshot(sessionId: string): SessionSnapshot | null {
   for (const snapshot of getSessionSnapshots()) {
     if (snapshot.id === sessionId) return snapshot;
@@ -539,7 +898,12 @@ async function collectSessionLogSummaries(
     summariesById.set(log.id, buildSessionLogSummary(log));
   };
 
-  if (includeHistory) {
+  const indexedSummaries = await collectIndexedSessionLogSummaries(sessionId);
+  for (const summary of indexedSummaries) {
+    summariesById.set(summary.id, summary);
+  }
+
+  if (includeHistory && summariesById.size === 0) {
     await visitPersistedLogs((log) => {
       observeSessionLog(log);
       observeMatchingLog(log);
@@ -553,6 +917,30 @@ async function collectSessionLogSummaries(
   return [...summariesById.values()];
 }
 
+async function collectIndexedSessionLogSummaries(sessionId: string): Promise<SessionLogSummary[]> {
+  let entries = await listIndexEntries();
+  if (entries.length === 0) return [];
+
+  const needsMetadataRebuild = entries.some((entry) => !hasLogIndexFilterMetadata(entry));
+  const needsSummaryRebuild = entries.some((entry) => {
+    if (!matchesLogIndexEntryFilters(entry, sessionId, undefined)) return false;
+    return !hasLogIndexSummary(entry);
+  });
+
+  if (needsMetadataRebuild || needsSummaryRebuild) {
+    await rebuildIndex();
+    entries = await listIndexEntries();
+  }
+
+  const summaries: SessionLogSummary[] = [];
+  for (const entry of entries) {
+    if (!matchesLogIndexEntryFilters(entry, sessionId, undefined)) continue;
+    if (entry.summary === undefined) continue;
+    summaries.push(buildSessionLogSummary(compactLogFromIndexSummary(entry.summary)));
+  }
+  return summaries;
+}
+
 async function includeSnapshotLastLogSummary(
   sessionId: string,
   snapshot: SessionSnapshot | null,
@@ -678,6 +1066,7 @@ export async function loadLogsIntoMemory(): Promise<void> {
   }
 
   rebuildSessionRegistry(memoryCache.values());
+  clearLogCursorPageIndexes();
 }
 
 function rememberRecentCompletedLog(
@@ -706,6 +1095,7 @@ function findSmallestLogId(logsById: ReadonlyMap<number, CapturedLog>): number |
 export function clearAllLogs(): { cleared: number } {
   const count = memoryCache.size;
   memoryCache.clear();
+  clearLogCursorPageIndexes();
   clearSessionRegistry();
   return { cleared: count };
 }
@@ -967,6 +1357,7 @@ export async function clearPersistedLogsByIds(
     ]);
 
     await rebuildIndex();
+    clearLogCursorPageIndexes();
 
     const clearedIds = new Set<number>(rewriteResult.removedIds);
     if (result.cleared > 0) {
@@ -996,10 +1387,21 @@ export function clearLogsByIds(ids: readonly number[]): { cleared: number } {
   for (const id of unique) {
     removeFromCache(id);
   }
+  removeLogsFromCursorPageIndexes(unique);
   rebuildSessionRegistry(memoryCache.values());
   return { cleared: unique.size };
 }
 
+export function _getLogCursorPageIndexStatsForTests(): {
+  indexCount: number;
+  buildCount: number;
+} {
+  return {
+    indexCount: logCursorPageIndexes.size,
+    buildCount: logCursorPageIndexBuildCount,
+  };
+}
+
 // SSE event system for real-time log updates
 type LogUpdateHandler = (log: CapturedLog) => void;
 const sseHandlers: Set<LogUpdateHandler> = new Set();

package/src/routes/api/logs.ts

@@ -5,6 +5,7 @@ import {
   clearPersistedLogsByIds,
   getLogStorageStats,
   getReplayLogsForSource,
+  listLogsCursorPage,
   listLogsPage,
 } from "../../proxy/store";
 import {
@@ -33,6 +34,15 @@ function parsePositiveInt(value: string | null, fallback: number): number {
   return parsed;
 }
 
+type OptionalPositiveIntResult = { ok: true; value: number | null } | { ok: false };
+
+function parseOptionalPositiveInt(value: string | null): OptionalPositiveIntResult {
+  if (value === null) return { ok: true, value: null };
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) return { ok: false };
+  return { ok: true, value: parsed };
+}
+
 export const Route = createFileRoute("/api/logs")({
   server: {
     handlers: {
@@ -67,6 +77,32 @@ export const Route = createFileRoute("/api/logs")({
         const limit = parsePositiveInt(url.searchParams.get("limit"), 50);
         const includeBodies = url.searchParams.get("compact") !== "1";
 
+        if (url.searchParams.get("cursor") === "1" || url.searchParams.get("cursor") === "true") {
+          const beforeLogId = parseOptionalPositiveInt(url.searchParams.get("beforeLogId"));
+          const afterLogId = parseOptionalPositiveInt(url.searchParams.get("afterLogId"));
+          if (!beforeLogId.ok || !afterLogId.ok) {
+            return Response.json({ error: "Invalid cursor log ID" }, { status: 400 });
+          }
+          if (beforeLogId.value !== null && afterLogId.value !== null) {
+            return Response.json(
+              { error: "Use beforeLogId or afterLogId, not both" },
+              { status: 400 },
+            );
+          }
+          const anchor = url.searchParams.get("anchor") === "oldest" ? "oldest" : "newest";
+          return Response.json(
+            await listLogsCursorPage({
+              sessionId,
+              model,
+              limit,
+              includeBodies,
+              beforeLogId: beforeLogId.value ?? undefined,
+              afterLogId: afterLogId.value ?? undefined,
+              anchor,
+            }),
+          );
+        }
+
         return Response.json(
           await listLogsPage({ sessionId, model, offset, limit, includeBodies }),
         );