@tonyclaw/agent-inspector 3.0.44 → 3.0.46

package/src/proxy/sqliteLogIndex.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { logger, resolveLogDir } from "./logger";
-import type { ApiFormat } from "./schemas";
+import type { ApiFormat, CaptureIncompleteReason } from "./schemas";
 import type { LogIndexEntry, LogIndexSummary } from "./logIndex";
 import { ensurePrivateDirectorySync, securePrivateFileSync } from "./privateDataPath";
 
@@ -47,6 +47,10 @@ CREATE TABLE IF NOT EXISTS log_index (
   streaming_chunks_path TEXT,
   raw_request_body_bytes INTEGER,
   response_text_bytes INTEGER,
+  capture_incomplete INTEGER NOT NULL DEFAULT 0,
+  dropped_chunks INTEGER NOT NULL DEFAULT 0,
+  dropped_bytes INTEGER NOT NULL DEFAULT 0,
+  capture_incomplete_reason TEXT,
   warnings_json TEXT,
   error TEXT
 );
@@ -89,10 +93,14 @@ INSERT INTO log_index (
   streaming_chunks_path,
   raw_request_body_bytes,
   response_text_bytes,
+  capture_incomplete,
+  dropped_chunks,
+  dropped_bytes,
+  capture_incomplete_reason,
   warnings_json,
   error
 ) VALUES (
-  ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+  ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
 )
 ON CONFLICT(id) DO UPDATE SET
   file = excluded.file,
@@ -126,6 +134,10 @@ ON CONFLICT(id) DO UPDATE SET
   streaming_chunks_path = excluded.streaming_chunks_path,
   raw_request_body_bytes = excluded.raw_request_body_bytes,
   response_text_bytes = excluded.response_text_bytes,
+  capture_incomplete = excluded.capture_incomplete,
+  dropped_chunks = excluded.dropped_chunks,
+  dropped_bytes = excluded.dropped_bytes,
+  capture_incomplete_reason = excluded.capture_incomplete_reason,
   warnings_json = excluded.warnings_json,
   error = excluded.error
 `;
@@ -215,6 +227,30 @@ function execSql(db: unknown, sql: string): boolean {
   return result !== undefined;
 }
 
+const REQUIRED_SCHEMA_COLUMNS = [
+  { name: "capture_incomplete", definition: "INTEGER NOT NULL DEFAULT 0" },
+  { name: "dropped_chunks", definition: "INTEGER NOT NULL DEFAULT 0" },
+  { name: "dropped_bytes", definition: "INTEGER NOT NULL DEFAULT 0" },
+  { name: "capture_incomplete_reason", definition: "TEXT" },
+];
+
+function ensureSchemaColumns(db: unknown): boolean {
+  const rows = allPrepared(db, "PRAGMA table_info(log_index)");
+  if (rows === null) return false;
+  const existing = new Set<string>();
+  for (const row of rows) {
+    const name = readProperty(row, "name");
+    if (typeof name === "string") existing.add(name);
+  }
+  for (const column of REQUIRED_SCHEMA_COLUMNS) {
+    if (existing.has(column.name)) continue;
+    if (!execSql(db, `ALTER TABLE log_index ADD COLUMN ${column.name} ${column.definition}`)) {
+      return false;
+    }
+  }
+  return true;
+}
+
 function sqliteConstructorFromModule(
   moduleValue: unknown,
   exportName: "default" | "Database",
@@ -316,6 +352,9 @@ async function initializeSqliteState(): Promise<SqliteState> {
     if (!execSql(db, CREATE_SCHEMA_SQL)) {
       return { status: "unavailable", path, reason: "SQLite schema initialization failed" };
     }
+    if (!ensureSchemaColumns(db)) {
+      return { status: "unavailable", path, reason: "SQLite schema migration failed" };
+    }
     activeDb = db;
     return { status: "ready", db, path };
   } catch (err) {
@@ -394,6 +433,10 @@ function entryParams(entry: LogIndexEntry): readonly unknown[] {
     summary?.streamingChunksPath ?? null,
     summary?.rawRequestBodyBytes ?? null,
     summary?.responseTextBytes ?? null,
+    boolToInt(summary?.captureIncomplete ?? false),
+    summary?.droppedChunks ?? 0,
+    summary?.droppedBytes ?? 0,
+    summary?.captureIncompleteReason ?? null,
     warningJson(summary?.warnings),
     summary?.error ?? null,
   ];
@@ -428,6 +471,22 @@ function readApiFormat(row: unknown): ApiFormat {
   }
 }
 
+function readCaptureIncompleteReason(row: unknown): CaptureIncompleteReason | null {
+  const value = readString(row, "capture_incomplete_reason");
+  switch (value) {
+    case "capacity-exceeded":
+    case "pipeline-closed":
+    case "write-failed":
+    case "finalize-failed":
+    case "upstream-stream-error":
+    case "shutdown":
+      return value;
+    case null:
+    default:
+      return null;
+  }
+}
+
 function readWarnings(row: unknown): string[] | undefined {
   const value = readString(row, "warnings_json");
   if (value === null) return undefined;
@@ -481,6 +540,10 @@ function summaryFromRow(row: unknown, id: number): LogIndexSummary {
     streamingChunksPath: readString(row, "streaming_chunks_path"),
     rawRequestBodyBytes: readNumber(row, "raw_request_body_bytes"),
     responseTextBytes: readNumber(row, "response_text_bytes"),
+    captureIncomplete: readBoolean(row, "capture_incomplete"),
+    droppedChunks: readNumber(row, "dropped_chunks") ?? 0,
+    droppedBytes: readNumber(row, "dropped_bytes") ?? 0,
+    captureIncompleteReason: readCaptureIncompleteReason(row),
     warnings: readWarnings(row),
     error: readString(row, "error"),
   };

package/src/proxy/store.ts

@@ -29,6 +29,7 @@ import {
   listFilteredIndexEntries,
   listIndexEntries,
   rebuildIndex,
+  updateLogIndexEntryMetadata,
   type LogIndexEntry,
   type LogIndexSummary,
 } from "./logIndex";
@@ -42,7 +43,7 @@ import { CapturedLogSchema } from "./schemas";
 import { apiFormatForPath } from "./formats/registry";
 import type { ImportedLogDraft } from "./logImporter";
 import {
-  archiveSessionLog,
+  archiveSessionLogs,
   clearSessionArchives,
   deleteArchivedLogsByIds,
   findArchivedLogById,
@@ -55,6 +56,7 @@ import {
   PRIVATE_FILE_MODE,
   securePrivateFileSync,
 } from "./privateDataPath";
+import { recoverCapturedLogStorage } from "./jsonlRecovery";
 import {
   clearSessionRegistry,
   getLogSessionId,
@@ -162,6 +164,43 @@ type LogCursorPageIndex = {
 const logCursorPageIndexes: Map<string, LogCursorPageIndex> = new Map();
 let logCursorPageIndexBuildCount = 0;
 let sessionArchiveQueue: Promise<void> = Promise.resolve();
+const SESSION_ARCHIVE_BATCH_SIZE = 128;
+const SESSION_ARCHIVE_FLUSH_DELAY_MS = 10;
+let sessionArchiveBuffer: CapturedLog[] = [];
+let sessionArchiveFlushTimeout: ReturnType<typeof setTimeout> | null = null;
+
+function drainSessionArchiveBuffer(): CapturedLog[] {
+  const logs = sessionArchiveBuffer;
+  sessionArchiveBuffer = [];
+  return logs;
+}
+
+function queueSessionArchiveFlush(): void {
+  const logs = drainSessionArchiveBuffer();
+  if (logs.length === 0) return;
+  sessionArchiveQueue = sessionArchiveQueue
+    .catch(() => undefined)
+    .then(async () => {
+      await archiveSessionLogs(logs);
+    })
+    .catch((err: unknown) => {
+      logger.warn("[store] Failed to archive session logs:", String(err));
+    });
+}
+
+function cancelSessionArchiveFlushTimer(): void {
+  if (sessionArchiveFlushTimeout === null) return;
+  clearTimeout(sessionArchiveFlushTimeout);
+  sessionArchiveFlushTimeout = null;
+}
+
+function scheduleSessionArchiveFlush(): void {
+  if (sessionArchiveFlushTimeout !== null) return;
+  sessionArchiveFlushTimeout = setTimeout(() => {
+    sessionArchiveFlushTimeout = null;
+    queueSessionArchiveFlush();
+  }, SESSION_ARCHIVE_FLUSH_DELAY_MS);
+}
 
 function cursorPageIndexKey(
   options: Pick<ListLogsCursorPageOptions, "sessionId" | "model" | "clientPid">,
@@ -233,8 +272,29 @@ function normalizeLog(log: CapturedLog): CapturedLog {
   const sessionId = getLogSessionId(log);
   const pathFormat = apiFormatForPath(log.path);
   const apiFormat = pathFormat === "unknown" ? log.apiFormat : pathFormat;
-  if (sessionId === log.sessionId && apiFormat === log.apiFormat) return log;
-  return { ...log, sessionId, apiFormat };
+  const captureIncomplete = log.captureIncomplete ?? false;
+  const droppedChunks = log.droppedChunks ?? 0;
+  const droppedBytes = log.droppedBytes ?? 0;
+  const captureIncompleteReason = log.captureIncompleteReason ?? null;
+  if (
+    sessionId === log.sessionId &&
+    apiFormat === log.apiFormat &&
+    log.captureIncomplete !== undefined &&
+    log.droppedChunks !== undefined &&
+    log.droppedBytes !== undefined &&
+    log.captureIncompleteReason !== undefined
+  ) {
+    return log;
+  }
+  return {
+    ...log,
+    sessionId,
+    apiFormat,
+    captureIncomplete,
+    droppedChunks,
+    droppedBytes,
+    captureIncompleteReason,
+  };
 }
 
 function addToCache(log: CapturedLog): void {
@@ -249,19 +309,20 @@ function addToCache(log: CapturedLog): void {
 }
 
 function archiveLogSnapshot(log: CapturedLog): void {
-  const archivedLog = normalizeLog(log);
-  sessionArchiveQueue = sessionArchiveQueue
-    .catch(() => undefined)
-    .then(async () => {
-      await archiveSessionLog(archivedLog);
-    })
-    .catch((err: unknown) => {
-      logger.warn("[store] Failed to archive session log:", String(err));
-    });
+  sessionArchiveBuffer.push(normalizeLog(log));
+  if (sessionArchiveBuffer.length >= SESSION_ARCHIVE_BATCH_SIZE) {
+    cancelSessionArchiveFlushTimer();
+    queueSessionArchiveFlush();
+  } else if (sessionArchiveBuffer.length === 1) {
+    scheduleSessionArchiveFlush();
+  }
 }
 
 export async function flushSessionArchiveWrites(): Promise<void> {
+  cancelSessionArchiveFlushTimer();
+  if (sessionArchiveBuffer.length > 0) queueSessionArchiveFlush();
   await sessionArchiveQueue;
+  if (sessionArchiveBuffer.length > 0) await flushSessionArchiveWrites();
 }
 
 function removeFromCache(id: number): void {
@@ -317,6 +378,10 @@ function compactLogFromIndexSummary(summary: LogIndexSummary): CapturedLog {
     rawRequestBodyBytes: summary.rawRequestBodyBytes,
     responseTextBytes: summary.responseTextBytes,
     bodyContentMode: "compact",
+    captureIncomplete: summary.captureIncomplete,
+    droppedChunks: summary.droppedChunks,
+    droppedBytes: summary.droppedBytes,
+    captureIncompleteReason: summary.captureIncompleteReason,
     warnings: summary.warnings,
     error: summary.error,
   });
@@ -441,6 +506,10 @@ export async function createLog(
     clientCwd: clientInfo?.cwd ?? null,
     clientProjectFolder: clientInfo?.projectFolder ?? null,
     streamingChunksPath: null,
+    captureIncomplete: false,
+    droppedChunks: 0,
+    droppedBytes: 0,
+    captureIncompleteReason: null,
   });
 
   // Write to disk and update index
@@ -466,6 +535,12 @@ export function finalizeLogUpdate(log: CapturedLog): void {
   emitLogUpdate(log);
 }
 
+/** Persist the terminal cache/session state and refresh both JSON and SQLite index summaries. */
+export async function persistFinalizedLogUpdate(log: CapturedLog): Promise<void> {
+  finalizeLogUpdate(log);
+  await updateLogIndexEntryMetadata(log);
+}
+
 async function getArchivedLogByIdForStore(id: number): Promise<CapturedLog | null> {
   await flushSessionArchiveWrites();
   const archivedLog = await findArchivedLogById(id);
@@ -543,24 +618,31 @@ async function scanLogFileForId(filePath: string, id: number): Promise<CapturedL
     crlfDelay: Infinity,
   });
 
+  let lineNumber = 0;
   for await (const line of fileStream) {
+    lineNumber += 1;
     if (line.trim() === "") continue;
+    let parsed: unknown;
     try {
-      const parsed: unknown = JSON.parse(line);
-      if (typeof parsed === "object" && parsed !== null) {
-        const desc = Object.getOwnPropertyDescriptor(parsed, "id");
-        if (desc !== undefined && typeof desc.value === "number" && desc.value === id) {
-          const result = CapturedLogSchema.safeParse(parsed);
-          if (result.success) {
-            lastMatch = normalizeLog(result.data);
-            if (result.data.responseStatus !== null) {
-              return lastMatch;
-            }
-          }
-        }
+      parsed = JSON.parse(line);
+    } catch (error) {
+      return await Promise.reject(
+        new Error(
+          `Malformed JSONL record in ${filePath} at line ${String(lineNumber)}: ${String(error)}`,
+        ),
+      );
+    }
+    const result = CapturedLogSchema.safeParse(parsed);
+    if (!result.success) {
+      return await Promise.reject(
+        new Error(`Invalid captured-log record in ${filePath} at line ${String(lineNumber)}`),
+      );
+    }
+    if (result.data.id === id) {
+      lastMatch = normalizeLog(result.data);
+      if (result.data.responseStatus !== null) {
+        return lastMatch;
       }
-    } catch {
-      // Skip malformed lines
     }
   }
 
@@ -597,6 +679,13 @@ async function visitPersistedLogs(visitor: PersistedLogVisitor): Promise<void> {
   const logDir = resolveLogDir();
   if (!existsSync(logDir)) return;
 
+  const recovery = await recoverCapturedLogStorage(logDir);
+  if (recovery.level === "unavailable") {
+    return await Promise.reject(
+      new Error(recovery.diagnostic ?? "Captured-log recovery blocked persisted-log reads"),
+    );
+  }
+
   try {
     const entries = await readdirCallback(logDir);
     const files = entries.filter((file) => file.endsWith(".jsonl")).sort();
@@ -605,6 +694,9 @@ async function visitPersistedLogs(visitor: PersistedLogVisitor): Promise<void> {
     }
   } catch (err) {
     logger.error("[store] Failed to list persisted logs:", String(err));
+    return await Promise.reject(
+      err instanceof Error ? err : new Error(`Failed to list persisted logs: ${String(err)}`),
+    );
   }
 }
 
@@ -620,21 +712,36 @@ async function visitPersistedLogFile(
       crlfDelay: Infinity,
     });
 
+    let lineNumber = 0;
     for await (const line of fileStream) {
+      lineNumber += 1;
       if (line.trim() === "") continue;
+      let parsed: unknown;
       try {
-        const parsed: unknown = JSON.parse(line);
-        const result = CapturedLogSchema.safeParse(parsed);
-        if (result.success) {
-          const log = normalizeLog(result.data);
-          visitor(log);
-        }
-      } catch {
-        // Skip malformed lines.
+        parsed = JSON.parse(line);
+      } catch (error) {
+        return await Promise.reject(
+          new Error(
+            `Malformed JSONL record in ${filePath} at line ${String(lineNumber)}: ${String(error)}`,
+          ),
+        );
       }
+      const result = CapturedLogSchema.safeParse(parsed);
+      if (!result.success) {
+        return await Promise.reject(
+          new Error(`Invalid captured-log record in ${filePath} at line ${String(lineNumber)}`),
+        );
+      }
+      const log = normalizeLog(result.data);
+      visitor(log);
     }
   } catch (err) {
     logger.error("[store] Failed to read persisted log file:", filePath, String(err));
+    return await Promise.reject(
+      err instanceof Error
+        ? err
+        : new Error(`Failed to read persisted log file ${filePath}: ${String(err)}`),
+    );
   }
 }
 

package/src/proxy/uiAssetServer.ts

@@ -0,0 +1,106 @@
+import { Buffer } from "node:buffer";
+import { readFile } from "node:fs/promises";
+import { extname, relative, resolve, sep } from "node:path";
+
+const CONTENT_TYPES: Readonly<Record<string, string>> = {
+  ".css": "text/css; charset=utf-8",
+  ".html": "text/html; charset=utf-8",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+};
+
+export type UiAsset = {
+  body: Buffer;
+  cacheControl: string;
+  contentType: string;
+  document: boolean;
+};
+
+function safeDecodedPath(pathname: string): string | null {
+  let decoded: string;
+  try {
+    decoded = decodeURIComponent(pathname);
+  } catch {
+    return null;
+  }
+  if (decoded.includes("\\") || decoded.includes("\0")) return null;
+  if (decoded.split("/").some((segment) => segment === "." || segment === "..")) return null;
+  return decoded;
+}
+
+function isInsideDirectory(path: string, directory: string): boolean {
+  const child = relative(directory, path);
+  return child === "" || (!child.startsWith("..") && !child.startsWith(sep));
+}
+
+function assetPath(uiDirectory: string, pathname: string): string | null {
+  const decoded = safeDecodedPath(pathname);
+  if (decoded === null) return null;
+  const target = resolve(uiDirectory, `.${decoded}`);
+  return isInsideDirectory(target, resolve(uiDirectory)) ? target : null;
+}
+
+async function readAsset(path: string): Promise<Buffer | null> {
+  try {
+    return await readFile(path);
+  } catch {
+    return null;
+  }
+}
+
+function contentTypeFor(path: string): string {
+  return CONTENT_TYPES[extname(path).toLowerCase()] ?? "application/octet-stream";
+}
+
+function isBackendNamespace(pathname: string): boolean {
+  return (
+    pathname === "/api" ||
+    pathname.startsWith("/api/") ||
+    pathname === "/proxy" ||
+    pathname.startsWith("/proxy/") ||
+    pathname === "/livez" ||
+    pathname === "/readyz"
+  );
+}
+
+function shouldUseDocumentFallback(pathname: string): boolean {
+  if (pathname === "/" || pathname.length === 0) return true;
+  const lastSegment = pathname.split("/").at(-1) ?? "";
+  return !lastSegment.includes(".");
+}
+
+export async function loadUiAsset(uiDirectory: string, pathname: string): Promise<UiAsset | null> {
+  if (isBackendNamespace(pathname)) return null;
+  const requestedPath = assetPath(uiDirectory, pathname);
+  if (requestedPath === null) return null;
+  const requestedBody = await readAsset(requestedPath);
+  if (requestedBody !== null) {
+    return {
+      body: requestedBody,
+      cacheControl: pathname.startsWith("/assets/")
+        ? "public, max-age=31536000, immutable"
+        : "no-cache",
+      contentType: contentTypeFor(requestedPath),
+      document: extname(requestedPath).toLowerCase() === ".html",
+    };
+  }
+  if (!shouldUseDocumentFallback(pathname)) return null;
+  const indexPath = resolve(uiDirectory, "index.html");
+  const indexBody = await readAsset(indexPath);
+  if (indexBody === null) return null;
+  return {
+    body: indexBody,
+    cacheControl: "no-store",
+    contentType: CONTENT_TYPES[".html"] ?? "text/html; charset=utf-8",
+    document: true,
+  };
+}

package/src/proxy/upstream.ts

@@ -55,8 +55,9 @@ export function selectUpstreamBase(route: ApiRoute, provider: ProviderConfig | n
   if (formatSpecificUrl !== undefined && formatSpecificUrl !== "") {
     return formatSpecificUrl;
   }
-  if (provider.baseUrl !== undefined && provider.baseUrl !== "") {
-    return provider.baseUrl;
+  const legacyBaseUrl = selectLegacyBaseUrl(route, provider);
+  if (legacyBaseUrl !== undefined) {
+    return legacyBaseUrl;
   }
 
   // Legacy records may only contain format. Keep this fallback for compatibility,
@@ -68,6 +69,22 @@ function nonEmptyUrl(value: string | undefined): string | undefined {
   return value !== undefined && value !== "" ? value : undefined;
 }
 
+function hasFormatSpecificUrlFields(provider: ProviderConfig): boolean {
+  return (
+    provider.anthropicBaseUrl !== undefined ||
+    provider.openaiBaseUrl !== undefined ||
+    provider.openaiResponsesBaseUrl !== undefined
+  );
+}
+
+function selectLegacyBaseUrl(route: ApiRoute, provider: ProviderConfig): string | undefined {
+  if (hasFormatSpecificUrlFields(provider)) return undefined;
+  const baseUrl = nonEmptyUrl(provider.baseUrl);
+  if (baseUrl === undefined) return undefined;
+  if (route.isOpenAI) return provider.format === "openai" ? baseUrl : undefined;
+  return provider.format === "anthropic" ? baseUrl : undefined;
+}
+
 function selectFormatSpecificUrl(route: ApiRoute, provider: ProviderConfig): string | undefined {
   if (!route.isOpenAI) return provider.anthropicBaseUrl;
   if (route.isResponses) {
@@ -76,6 +93,16 @@ function selectFormatSpecificUrl(route: ApiRoute, provider: ProviderConfig): str
   return provider.openaiBaseUrl;
 }
 
+/**
+ * Whether a model-matched Provider explicitly supports the protocol selected by the request path.
+ * Empty current-schema fields are deliberate opt-outs. Only a legacy record with no protocol URL
+ * fields may use baseUrl, and then only for the protocol declared by provider.format.
+ */
+export function providerSupportsApiRoute(route: ApiRoute, provider: ProviderConfig): boolean {
+  if (nonEmptyUrl(selectFormatSpecificUrl(route, provider)) !== undefined) return true;
+  return selectLegacyBaseUrl(route, provider) !== undefined;
+}
+
 export function setUpstreamHost(headers: Headers, upstreamBase: string): void {
   try {
     headers.set(HEADER_HOST, new URL(upstreamBase).host);