@tonyclaw/agent-inspector 2.1.3 → 2.1.4

package/src/proxy/store.ts

@@ -26,17 +26,20 @@ import {
   flushIndex,
   getNextLogId,
   getCurrentLogFile,
+  listFilteredIndexEntries,
   listIndexEntries,
   rebuildIndex,
   type LogIndexEntry,
   type LogIndexSummary,
 } from "./logIndex";
 import { writeChunks } from "./chunkStorage";
+import { closeSqliteLogIndex } from "./sqliteLogIndex";
 import type { SessionInfo, SessionLogSummary } from "../lib/sessionInfoContract";
 import { buildSessionInfo, buildSessionLogSummary } from "./sessionInfo";
 import type { CapturedLog } from "./schemas";
 import { CapturedLogSchema } from "./schemas";
 import { apiFormatForPath } from "./formats/registry";
+import type { ImportedLogDraft } from "./logImporter";
 import {
   clearSessionRegistry,
   getLogSessionId,
@@ -237,8 +240,8 @@ export function compactLogForList(log: CapturedLog): CapturedLog {
     rawHeaders: undefined,
     headers: undefined,
     streamingChunks: undefined,
-    rawRequestBodyBytes: textByteLength(log.rawRequestBody),
-    responseTextBytes: textByteLength(log.responseText),
+    rawRequestBodyBytes: log.rawRequestBodyBytes ?? textByteLength(log.rawRequestBody),
+    responseTextBytes: log.responseTextBytes ?? textByteLength(log.responseText),
     bodyContentMode: "compact",
   };
 }
@@ -327,6 +330,23 @@ export async function addTestLogEntry(entry: Omit<CapturedLog, "id">): Promise<C
   return log;
 }
 
+export async function importCapturedLogs(
+  entries: readonly ImportedLogDraft[],
+  sessionId: string,
+): Promise<CapturedLog[]> {
+  const imported: CapturedLog[] = [];
+  for (const entry of entries) {
+    const log = await addTestLogEntry({
+      ...entry,
+      sessionId,
+      isTest: false,
+      replayOfLogId: null,
+    });
+    imported.push(log);
+  }
+  return imported;
+}
+
 type ClientInfo = SessionClientInfo;
 
 export async function createLog(
@@ -711,10 +731,10 @@ async function buildLogCursorPageIndexFromLogIndex(
   options: Pick<ListLogsCursorPageOptions, "sessionId" | "model">,
   allowRebuild: boolean,
 ): Promise<LogCursorPageIndex | null> {
-  let entries = await listIndexEntries();
+  let entries = await listFilteredIndexEntries(options);
   if (entries.length === 0 && allowRebuild) {
     await rebuildIndex();
-    entries = await listIndexEntries();
+    entries = await listFilteredIndexEntries(options);
   }
 
   if (entries.some((entry) => !hasLogIndexFilterMetadata(entry))) {
@@ -918,7 +938,7 @@ async function collectSessionLogSummaries(
 }
 
 async function collectIndexedSessionLogSummaries(sessionId: string): Promise<SessionLogSummary[]> {
-  let entries = await listIndexEntries();
+  let entries = await listFilteredIndexEntries({ sessionId });
   if (entries.length === 0) return [];
 
   const needsMetadataRebuild = entries.some((entry) => !hasLogIndexFilterMetadata(entry));
@@ -929,7 +949,7 @@ async function collectIndexedSessionLogSummaries(sessionId: string): Promise<Ses
 
   if (needsMetadataRebuild || needsSummaryRebuild) {
     await rebuildIndex();
-    entries = await listIndexEntries();
+    entries = await listFilteredIndexEntries({ sessionId });
   }
 
   const summaries: SessionLogSummary[] = [];
@@ -1097,6 +1117,7 @@ export function clearAllLogs(): { cleared: number } {
   memoryCache.clear();
   clearLogCursorPageIndexes();
   clearSessionRegistry();
+  closeSqliteLogIndex();
   return { cleared: count };
 }
 
@@ -1135,7 +1156,11 @@ export async function clearPersistedLogStorage(): Promise<ClearPersistedLogStora
     const [logFilesDeleted, chunkFilesDeleted] = await Promise.all([
       deleteMatchingFiles(
         resolveLogDir(),
-        (fileName) => fileName.endsWith(".jsonl") || fileName === "logs.idx",
+        (fileName) =>
+          fileName.endsWith(".jsonl") ||
+          fileName === "logs.idx" ||
+          fileName === "inspector.sqlite" ||
+          fileName.startsWith("inspector.sqlite-"),
       ),
       deleteMatchingFiles(
         getChunksDir(),

package/src/routes/api/alerts.summary.ts

@@ -0,0 +1,24 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { getInspectorAlertSummary } from "../../services/alerts";
+
+function parsePositiveInt(value: string | null): number | undefined {
+  if (value === null) return undefined;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) return undefined;
+  return parsed;
+}
+
+export const Route = createFileRoute("/api/alerts/summary")({
+  server: {
+    handlers: {
+      GET: async ({ request }: { request: Request }) => {
+        const url = new URL(request.url);
+        return Response.json(
+          await getInspectorAlertSummary({
+            scanLimit: parsePositiveInt(url.searchParams.get("scanLimit")),
+          }),
+        );
+      },
+    },
+  },
+});

package/src/routes/api/alerts.ts

@@ -0,0 +1,52 @@
+import { createFileRoute } from "@tanstack/react-router";
+import {
+  AlertCategorySchema,
+  AlertSeveritySchema,
+  AlertSourceSchema,
+  type AlertCategory,
+  type AlertSeverity,
+  type AlertSource,
+} from "../../lib/alertContract";
+import { listInspectorAlerts } from "../../services/alerts";
+
+type ParsedFilters = {
+  severity?: AlertSeverity;
+  category?: AlertCategory;
+  source?: AlertSource;
+};
+
+function parsePositiveInt(value: string | null): number | undefined {
+  if (value === null) return undefined;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) return undefined;
+  return parsed;
+}
+
+function parseFilters(url: URL): ParsedFilters {
+  const severityResult = AlertSeveritySchema.safeParse(url.searchParams.get("severity"));
+  const categoryResult = AlertCategorySchema.safeParse(url.searchParams.get("category"));
+  const sourceResult = AlertSourceSchema.safeParse(url.searchParams.get("source"));
+
+  return {
+    severity: severityResult.success ? severityResult.data : undefined,
+    category: categoryResult.success ? categoryResult.data : undefined,
+    source: sourceResult.success ? sourceResult.data : undefined,
+  };
+}
+
+export const Route = createFileRoute("/api/alerts")({
+  server: {
+    handlers: {
+      GET: async ({ request }: { request: Request }) => {
+        const url = new URL(request.url);
+        return Response.json(
+          await listInspectorAlerts({
+            ...parseFilters(url),
+            limit: parsePositiveInt(url.searchParams.get("limit")),
+            scanLimit: parsePositiveInt(url.searchParams.get("scanLimit")),
+          }),
+        );
+      },
+    },
+  },
+});

package/src/routes/api/logs.$id.body.ts

@@ -0,0 +1,44 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { LogBodyPartSchema } from "../../contracts";
+import { createLogBodyChunk } from "../../proxy/logBodyChunks";
+import { getLogById } from "../../proxy/store";
+
+function parseIntegerParam(value: string | null, fallback: number): number {
+  if (value === null) return fallback;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) return fallback;
+  return parsed;
+}
+
+export const Route = createFileRoute("/api/logs/$id/body")({
+  server: {
+    handlers: {
+      GET: async ({ params, request }: { params: { id: string }; request: Request }) => {
+        const id = Number(params.id);
+        if (!Number.isInteger(id) || id <= 0) {
+          return Response.json({ error: "Invalid log ID" }, { status: 400 });
+        }
+
+        const url = new URL(request.url);
+        const partResult = LogBodyPartSchema.safeParse(url.searchParams.get("part"));
+        if (!partResult.success) {
+          return Response.json({ error: "Invalid body part" }, { status: 400 });
+        }
+
+        const log = await getLogById(id);
+        if (log === null) {
+          return Response.json({ error: "Log not found" }, { status: 404 });
+        }
+
+        return Response.json(
+          createLogBodyChunk({
+            log,
+            part: partResult.data,
+            offset: parseIntegerParam(url.searchParams.get("offset"), 0),
+            limit: parseIntegerParam(url.searchParams.get("limit"), 0),
+          }),
+        );
+      },
+    },
+  },
+});

package/src/routes/api/logs.import.ts

@@ -0,0 +1,50 @@
+import { Buffer } from "node:buffer";
+import { createFileRoute } from "@tanstack/react-router";
+import { parseImportedLogFile, sessionNameFromImportFileName } from "../../proxy/logImporter";
+import { compactLogForList, importCapturedLogs } from "../../proxy/store";
+
+function isUploadedFile(value: FormDataEntryValue | null): value is File {
+  return value instanceof File;
+}
+
+export const Route = createFileRoute("/api/logs/import")({
+  server: {
+    handlers: {
+      POST: async ({ request }: { request: Request }) => {
+        let formData: FormData;
+        try {
+          formData = await request.formData();
+        } catch {
+          return Response.json({ error: "Expected multipart form data" }, { status: 400 });
+        }
+
+        const upload = formData.get("file");
+        if (!isUploadedFile(upload)) {
+          return Response.json({ error: "Missing import file" }, { status: 400 });
+        }
+
+        const sessionId = sessionNameFromImportFileName(upload.name);
+        const parsed = await parseImportedLogFile({
+          fileName: upload.name,
+          data: Buffer.from(await upload.arrayBuffer()),
+        });
+
+        if (!parsed.ok) {
+          return Response.json(
+            { error: parsed.message, warnings: parsed.warnings },
+            { status: 400 },
+          );
+        }
+
+        const imported = await importCapturedLogs(parsed.logs, sessionId);
+        return Response.json({
+          sessionId,
+          imported: imported.length,
+          skipped: parsed.skipped,
+          warnings: parsed.warnings,
+          logs: imported.map((log) => compactLogForList(log)),
+        });
+      },
+    },
+  },
+});

package/src/services/alerts.ts

@@ -0,0 +1,12 @@
+import type { AlertListResponse, AlertSummary } from "../lib/alertContract";
+import { getAlertSummary, listAlerts, type ListAlertsOptions } from "../proxy/alerts";
+
+export function listInspectorAlerts(options: ListAlertsOptions): Promise<AlertListResponse> {
+  return listAlerts(options);
+}
+
+export function getInspectorAlertSummary(
+  options: Pick<ListAlertsOptions, "scanLimit">,
+): Promise<AlertSummary> {
+  return getAlertSummary(options);
+}