@tonyclaw/agent-inspector 3.0.28 → 3.0.30

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

@@ -1,85 +1,163 @@
 import { createFileRoute } from "@tanstack/react-router";
-import { compactLogForList, onLogUpdate, getLogSessionId, listLogsPage } from "../../proxy/store";
+import {
+  compactLogForList,
+  onLogUpdate,
+  getLogSessionId,
+  listLogsCursorPage,
+} from "../../proxy/store";
 import { type CapturedLog } from "../../contracts";
+import {
+  createCapacityLimiter,
+  MAX_SSE_CLIENTS,
+  resourceLimitResponse,
+  type CapacityLimiter,
+} from "../../lib/resourceLimits";
 
 const INITIAL_STREAM_LOG_LIMIT = 100;
+const UPDATE_COALESCE_MS = 50;
+const MAX_BUFFERED_UPDATE_EVENTS = 16;
+const sseClientLimiter = createCapacityLimiter(MAX_SSE_CLIENTS);
 
-export const Route = createFileRoute("/api/logs/stream")({
-  server: {
-    handlers: {
-      GET: ({ request }: { request: Request }) => {
-        const url = new URL(request.url);
-        const sessionId = url.searchParams.get("sessionId") ?? undefined;
-        const model = url.searchParams.get("model") ?? undefined;
-        const includeBodies = url.searchParams.get("compact") !== "1";
+export function streamIncludesBodies(url: URL): boolean {
+  return url.searchParams.get("compact") === "0";
+}
 
-        let controllerRef: ReadableStreamDefaultController<Uint8Array> | null = null;
-        let cleanedUp = false;
+export function parseLastEventLogId(value: string | null): number | undefined {
+  if (value === null || !/^\d+$/.test(value)) return undefined;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
 
-        const unsubscribe = onLogUpdate((log: CapturedLog) => {
-          if (controllerRef === null) return;
-          // Filter by session/model if specified
-          if (sessionId !== undefined && getLogSessionId(log) !== sessionId) return;
-          if (model !== undefined && log.model !== model) return;
-          try {
-            const payloadLog = includeBodies ? log : compactLogForList(log);
-            const data = `data: ${JSON.stringify({ type: "update", log: payloadLog })}\n\n`;
-            controllerRef.enqueue(new TextEncoder().encode(data));
-          } catch {
-            cleanup();
-          }
-        });
+function encodeSse(value: unknown, id?: number): Uint8Array {
+  const idLine = id === undefined ? "" : `id: ${String(id)}\n`;
+  return new TextEncoder().encode(`${idLine}data: ${JSON.stringify(value)}\n\n`);
+}
 
-        const cleanup = (): void => {
-          if (cleanedUp) return;
-          cleanedUp = true;
-          clearInterval(heartbeat);
-          unsubscribe();
-          controllerRef = null;
-          request.signal.removeEventListener("abort", cleanup);
-        };
+export function createLogsStreamResponse(
+  request: Request,
+  clientLimiter: CapacityLimiter = sseClientLimiter,
+): Response {
+  const lease = clientLimiter.tryAcquire();
+  if (lease === null) {
+    return resourceLimitResponse({
+      error: `SSE client capacity reached. At most ${String(clientLimiter.capacity)} live clients are allowed; retry after a connection closes.`,
+      code: "sse-capacity-exceeded",
+      status: 503,
+      resource: "sse-clients",
+      limit: clientLimiter.capacity,
+      retryable: true,
+      retryAfterSeconds: 1,
+    });
+  }
+  const url = new URL(request.url);
+  const sessionId = url.searchParams.get("sessionId") ?? undefined;
+  const model = url.searchParams.get("model") ?? undefined;
+  const includeBodies = streamIncludesBodies(url);
+  const lastEventLogId = parseLastEventLogId(request.headers.get("last-event-id"));
 
-        // Send heartbeat comment every 30s to keep connection alive
-        const heartbeat = setInterval(() => {
-          if (controllerRef !== null) {
-            try {
-              controllerRef.enqueue(new TextEncoder().encode(": heartbeat\n\n"));
-            } catch {
-              cleanup();
-            }
-          }
-        }, 30000);
+  let controllerRef: ReadableStreamDefaultController<Uint8Array> | null = null;
+  let cleanedUp = false;
+  let updateTimer: ReturnType<typeof setTimeout> | null = null;
+  const pendingUpdates = new Map<number, CapturedLog>();
 
-        request.signal.addEventListener("abort", cleanup, { once: true });
+  const flushPendingUpdates = (): void => {
+    updateTimer = null;
+    const controller = controllerRef;
+    if (controller === null) return;
+    if (controller.desiredSize !== null && controller.desiredSize <= -MAX_BUFFERED_UPDATE_EVENTS) {
+      controller.close();
+      cleanup();
+      return;
+    }
+    for (const log of pendingUpdates.values()) {
+      if (
+        controller.desiredSize !== null &&
+        controller.desiredSize <= -MAX_BUFFERED_UPDATE_EVENTS
+      ) {
+        controller.close();
+        cleanup();
+        return;
+      }
+      const payloadLog = includeBodies ? log : compactLogForList(log);
+      controller.enqueue(encodeSse({ type: "update", log: payloadLog }, log.id));
+    }
+    pendingUpdates.clear();
+  };
 
-        const stream = new ReadableStream<Uint8Array>({
-          async start(controller) {
-            controllerRef = controller;
-            // Send initial batch of logs immediately
-            const result = await listLogsPage({
-              sessionId,
-              model,
-              offset: 0,
-              limit: INITIAL_STREAM_LOG_LIMIT,
-              includeBodies,
-            });
-            const logs = result.logs;
-            const initData = `data: ${JSON.stringify({ type: "init", logs })}\n\n`;
-            controller.enqueue(new TextEncoder().encode(initData));
-          },
-          cancel() {
-            cleanup();
-          },
-        });
+  const unsubscribe = onLogUpdate((log: CapturedLog) => {
+    if (controllerRef === null) return;
+    // Filter by session/model if specified
+    if (sessionId !== undefined && getLogSessionId(log) !== sessionId) return;
+    if (model !== undefined && log.model !== model) return;
+    pendingUpdates.set(log.id, log);
+    if (updateTimer === null) updateTimer = setTimeout(flushPendingUpdates, UPDATE_COALESCE_MS);
+  });
+
+  const cleanup = (): void => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    clearInterval(heartbeat);
+    if (updateTimer !== null) clearTimeout(updateTimer);
+    updateTimer = null;
+    pendingUpdates.clear();
+    unsubscribe();
+    lease.release();
+    controllerRef = null;
+    request.signal.removeEventListener("abort", cleanup);
+  };
+
+  // Send heartbeat comment every 30s to keep connection alive
+  const heartbeat = setInterval(() => {
+    if (controllerRef !== null) {
+      try {
+        controllerRef.enqueue(new TextEncoder().encode(": heartbeat\n\n"));
+      } catch {
+        cleanup();
+      }
+    }
+  }, 30000);
+
+  request.signal.addEventListener("abort", cleanup, { once: true });
 
-        return new Response(stream, {
-          headers: {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            Connection: "keep-alive",
-          },
+  const stream = new ReadableStream<Uint8Array>({
+    async start(controller) {
+      controllerRef = controller;
+      try {
+        const result = await listLogsCursorPage({
+          sessionId,
+          model,
+          limit: INITIAL_STREAM_LOG_LIMIT,
+          includeBodies,
+          afterLogId: lastEventLogId,
+          anchor: lastEventLogId === undefined ? "newest" : undefined,
         });
-      },
+        if (cleanedUp) return;
+        const logs = result.logs;
+        const newestLogId = logs.at(-1)?.id;
+        controller.enqueue(encodeSse({ type: "init", logs }, newestLogId));
+      } catch (error) {
+        cleanup();
+        controller.error(error);
+      }
+    },
+    cancel() {
+      cleanup();
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    },
+  });
+}
+
+export const Route = createFileRoute("/api/logs/stream")({
+  server: {
+    handlers: {
+      GET: ({ request }: { request: Request }) => createLogsStreamResponse(request),
     },
   },
 });

package/src/routes/api/logs.ts

@@ -11,8 +11,16 @@ import {
 import {
   LOG_SEARCH_DEFAULT_LIMIT,
   LOG_SEARCH_DEFAULT_SCAN_LIMIT,
+  LOG_SEARCH_MAX_LIMIT,
+  LOG_SEARCH_MAX_SCAN_LIMIT,
   searchLogsPage,
 } from "../../proxy/logSearch";
+import {
+  MAX_REST_LOG_PAGE_SIZE,
+  MAX_SEARCH_QUERY_CHARS,
+  parseBoundedIntegerParameter,
+  resourceLimitResponse,
+} from "../../lib/resourceLimits";
 
 export const DeleteLogsBodySchema = z
   .object({
@@ -27,13 +35,6 @@ function parseNonNegativeInt(value: string | null, fallback: number): number {
   return parsed;
 }
 
-function parsePositiveInt(value: string | null, fallback: number): number {
-  if (value === null) return fallback;
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed < 1) return fallback;
-  return parsed;
-}
-
 type OptionalPositiveIntResult = { ok: true; value: number | null } | { ok: false };
 
 function parseOptionalPositiveInt(value: string | null): OptionalPositiveIntResult {
@@ -70,16 +71,56 @@ export const Route = createFileRoute("/api/logs")({
         const query = url.searchParams.get("q") ?? url.searchParams.get("search");
         const offset = parseNonNegativeInt(url.searchParams.get("offset"), 0);
         if (query !== null) {
-          const limit = parsePositiveInt(url.searchParams.get("limit"), LOG_SEARCH_DEFAULT_LIMIT);
-          const scanLimit = parsePositiveInt(
-            url.searchParams.get("scanLimit"),
-            LOG_SEARCH_DEFAULT_SCAN_LIMIT,
-          );
+          if (query.length > MAX_SEARCH_QUERY_CHARS) {
+            return resourceLimitResponse({
+              error: `Search queries may contain at most ${String(MAX_SEARCH_QUERY_CHARS)} characters.`,
+              code: "search-limit-exceeded",
+              status: 400,
+              resource: "log-search-query",
+              limit: MAX_SEARCH_QUERY_CHARS,
+              retryable: false,
+            });
+          }
+          const limitResult = parseBoundedIntegerParameter({
+            value: url.searchParams.get("limit"),
+            parameter: "limit",
+            fallback: LOG_SEARCH_DEFAULT_LIMIT,
+            minimum: 1,
+            maximum: LOG_SEARCH_MAX_LIMIT,
+            resource: "log-search-page-size",
+          });
+          if (!limitResult.ok) return limitResult.response;
+          const scanLimitResult = parseBoundedIntegerParameter({
+            value: url.searchParams.get("scanLimit"),
+            parameter: "scanLimit",
+            fallback: LOG_SEARCH_DEFAULT_SCAN_LIMIT,
+            minimum: 1,
+            maximum: LOG_SEARCH_MAX_SCAN_LIMIT,
+            resource: "log-search-scan-size",
+          });
+          if (!scanLimitResult.ok) return scanLimitResult.response;
           return Response.json(
-            await searchLogsPage({ query, sessionId, model, clientPid, offset, limit, scanLimit }),
+            await searchLogsPage({
+              query,
+              sessionId,
+              model,
+              clientPid,
+              offset,
+              limit: limitResult.value,
+              scanLimit: scanLimitResult.value,
+            }),
           );
         }
-        const limit = parsePositiveInt(url.searchParams.get("limit"), 50);
+        const limitResult = parseBoundedIntegerParameter({
+          value: url.searchParams.get("limit"),
+          parameter: "limit",
+          fallback: 50,
+          minimum: 1,
+          maximum: MAX_REST_LOG_PAGE_SIZE,
+          resource: "logs-page-size",
+        });
+        if (!limitResult.ok) return limitResult.response;
+        const limit = limitResult.value;
         const includeBodies = url.searchParams.get("compact") !== "1";
 
         if (url.searchParams.get("cursor") === "1" || url.searchParams.get("cursor") === "true") {

package/src/routes/api/providers.$providerId.model-metadata.ts

@@ -1,6 +1,7 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { z } from "zod";
 import { getProvider, updateProvider } from "../../proxy/providers";
+import { toRedactedProviderDto } from "../../lib/providerContract";
 import {
   applyBuiltinProviderModelMetadata,
   applyProviderModelRegistry,
@@ -8,6 +9,7 @@ import {
   ProviderModelRegistrySchema,
 } from "../../lib/providerModelMetadata";
 import { safeFetch } from "../../lib/safeFetch";
+import { MAX_PROVIDER_MODELS, resourceLimitResponse } from "../../lib/resourceLimits";
 
 const RefreshModelMetadataInputSchema = z.object({
   url: z.string().optional(),
@@ -61,10 +63,13 @@ export const Route = createFileRoute("/api/providers/$providerId/model-metadata"
             modelMetadata: result.modelMetadata,
           });
           if (updated === null) {
-            return Response.json({ error: "Provider not found" }, { status: 404 });
+            return Response.json(
+              { error: "Secure provider storage is unavailable; metadata was not updated" },
+              { status: 503 },
+            );
           }
           return Response.json({
-            provider: updated,
+            provider: toRedactedProviderDto(updated),
             imported: result.imported,
             matchedModels: result.matchedModels,
             missingModels: result.missingModels,
@@ -114,6 +119,16 @@ export const Route = createFileRoute("/api/providers/$providerId/model-metadata"
 
         const registry = ProviderModelRegistrySchema.safeParse(registryJson);
         if (!registry.success) {
+          if (registry.error.issues.some((issue) => issue.code === "too_big")) {
+            return resourceLimitResponse({
+              error: `Provider metadata model collections may contain at most ${String(MAX_PROVIDER_MODELS)} entries.`,
+              code: "provider-model-limit-exceeded",
+              status: 413,
+              resource: "provider-model-metadata",
+              limit: MAX_PROVIDER_MODELS,
+              retryable: false,
+            });
+          }
           return Response.json({ error: registry.error.message }, { status: 400 });
         }
 
@@ -128,11 +143,14 @@ export const Route = createFileRoute("/api/providers/$providerId/model-metadata"
           modelMetadataUrl: sourceUrl,
         });
         if (updated === null) {
-          return Response.json({ error: "Provider not found" }, { status: 404 });
+          return Response.json(
+            { error: "Secure provider storage is unavailable; metadata was not updated" },
+            { status: 503 },
+          );
         }
 
         return Response.json({
-          provider: updated,
+          provider: toRedactedProviderDto(updated),
           imported: result.imported,
           matchedModels: result.matchedModels,
           missingModels: result.missingModels,

package/src/routes/api/providers.$providerId.ts

@@ -6,8 +6,14 @@ import {
   deleteProvider,
   redactProvider,
 } from "../../proxy/providers";
-import { ProviderModelMetadataSchema } from "../../lib/providerContract";
+import {
+  getProviderModelLimitViolation,
+  ProviderModelMetadataListSchema,
+  ProviderModelNameSchema,
+  ProviderModelsSchema,
+} from "../../lib/providerContract";
 import { evaluateUpstreamUrl } from "../../lib/ssrfGuard";
+import { resourceLimitResponse } from "../../lib/resourceLimits";
 
 const ALLOW_LOOPBACK = process.env["AGENT_INSPECTOR_ALLOW_LOOPBACK"] === "1";
 
@@ -16,15 +22,15 @@ const ProviderUpdateSchema = z.object({
   apiKey: z.string().min(1, "API key is required").optional(),
   format: z.enum(["anthropic", "openai"]).optional(),
   baseUrl: z.string().min(1, "Base URL is required").optional(),
-  model: z.string().optional(),
-  models: z.array(z.string()).optional(),
+  model: ProviderModelNameSchema.optional(),
+  models: ProviderModelsSchema.optional(),
   authHeader: z.enum(["bearer", "x-api-key"]).optional(),
   anthropicBaseUrl: z.string().optional(),
   openaiBaseUrl: z.string().optional(),
   openaiResponsesBaseUrl: z.string().optional(),
   apiDocsUrl: z.string().optional(),
   modelMetadataUrl: z.string().optional(),
-  modelMetadata: z.array(ProviderModelMetadataSchema).optional(),
+  modelMetadata: ProviderModelMetadataListSchema.optional(),
   source: z.enum(["company", "personal"]).optional(),
 });
 
@@ -40,7 +46,26 @@ export const Route = createFileRoute("/api/providers/$providerId")({
         return Response.json(redactProvider(provider));
       },
       PUT: async ({ params, request }: { params: { providerId: string }; request: Request }) => {
-        const parsed = ProviderUpdateSchema.safeParse(await request.json());
+        let body: unknown;
+        try {
+          body = await request.json();
+        } catch {
+          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+        }
+
+        const violation = getProviderModelLimitViolation(body);
+        if (violation !== null) {
+          return resourceLimitResponse({
+            error: `Provider model collections may contain at most ${String(violation.limit)} entries.`,
+            code: "provider-model-limit-exceeded",
+            status: 413,
+            resource: violation.resource,
+            limit: violation.limit,
+            retryable: false,
+          });
+        }
+
+        const parsed = ProviderUpdateSchema.safeParse(body);
         if (!parsed.success) {
           return Response.json({ error: parsed.error.message }, { status: 400 });
         }
@@ -56,9 +81,15 @@ export const Route = createFileRoute("/api/providers/$providerId")({
             return Response.json({ error: decision.reason }, { status: 400 });
           }
         }
+        const providerExists = getProviders().some((provider) => provider.id === params.providerId);
         const updated = updateProvider(params.providerId, parsed.data);
         if (!updated) {
-          return Response.json({ error: "Provider not found" }, { status: 404 });
+          return providerExists
+            ? Response.json(
+                { error: "Secure provider storage is unavailable; provider was not updated" },
+                { status: 503 },
+              )
+            : Response.json({ error: "Provider not found" }, { status: 404 });
         }
         return Response.json(redactProvider(updated));
       },

package/src/routes/api/providers.export.ts

@@ -1,25 +1,43 @@
 import { createFileRoute } from "@tanstack/react-router";
+import { z } from "zod";
 import { exportProviders, exportProvidersWithKeys } from "../../proxy/providers";
 
+const SecretExportRequestSchema = z.object({
+  confirmation: z.literal("EXPORT_PROVIDER_KEYS"),
+});
+
+function exportResponse(json: string, filename: string): Response {
+  return new Response(json, {
+    headers: {
+      "Content-Type": "application/json",
+      "Content-Disposition": `attachment; filename="${filename}"`,
+      "Cache-Control": "no-store",
+    },
+  });
+}
+
 export const Route = createFileRoute("/api/providers/export")({
   server: {
     handlers: {
-      GET: ({ request }: { request: Request }) => {
-        const url = new URL(request.url);
-        const includeKeys = url.searchParams.get("includeKeys") === "true";
-
-        const json = includeKeys ? exportProvidersWithKeys() : exportProviders();
-
-        const filename = includeKeys
-          ? `agent-inspector-providers-${Date.now()}.json`
-          : `agent-inspector-providers-safe-${Date.now()}.json`;
-
-        return new Response(json, {
-          headers: {
-            "Content-Type": "application/json",
-            "Content-Disposition": `attachment; filename="${filename}"`,
-          },
-        });
+      GET: () => {
+        return exportResponse(
+          exportProviders(),
+          `agent-inspector-providers-safe-${Date.now()}.json`,
+        );
+      },
+      POST: async ({ request }: { request: Request }) => {
+        const body: unknown = await request.json().catch(() => null);
+        const parsed = SecretExportRequestSchema.safeParse(body);
+        if (!parsed.success) {
+          return Response.json(
+            { error: "Plaintext key export requires explicit confirmation" },
+            { status: 400, headers: { "Cache-Control": "no-store" } },
+          );
+        }
+        return exportResponse(
+          exportProvidersWithKeys(),
+          `agent-inspector-providers-sensitive-${Date.now()}.json`,
+        );
       },
     },
   },

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

@@ -1,8 +1,11 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { z } from "zod";
+import { randomUUID } from "node:crypto";
+import { ProviderScanImportRequestSchema } from "../../lib/providerImportContract";
+import { consumeProviderScan } from "../../proxy/providerScanStore";
 import { importProviders } from "../../proxy/providers";
 
-const ImportRequestSchema = z.union([z.string(), z.object({ providers: z.unknown() })]);
+const ProviderFileImportSchema = z.union([z.string(), z.object({ providers: z.unknown() })]);
 
 export const Route = createFileRoute("/api/providers/import")({
   server: {
@@ -13,12 +16,46 @@ export const Route = createFileRoute("/api/providers/import")({
           let jsonContent: string;
           try {
             const parsedBody: unknown = JSON.parse(rawBody);
-            jsonContent = typeof parsedBody === "string" ? parsedBody : JSON.stringify(parsedBody);
+            const scanRequest = ProviderScanImportRequestSchema.safeParse(parsedBody);
+            if (scanRequest.success) {
+              const selected = consumeProviderScan(
+                scanRequest.data.scanId,
+                scanRequest.data.selectionIds,
+              );
+              if (selected === null) {
+                return Response.json(
+                  { error: "Provider scan expired or selection is invalid" },
+                  { status: 410, headers: { "cache-control": "no-store" } },
+                );
+              }
+              const now = new Date().toISOString();
+              jsonContent = JSON.stringify({
+                providers: selected.map((provider) => ({
+                  id: randomUUID(),
+                  name: provider.name,
+                  apiKey: provider.apiKey,
+                  format: provider.format,
+                  anthropicBaseUrl: provider.anthropicBaseUrl,
+                  openaiBaseUrl: provider.openaiBaseUrl,
+                  openaiResponsesBaseUrl: provider.openaiResponsesBaseUrl,
+                  models: provider.models,
+                  createdAt: now,
+                  updatedAt: now,
+                })),
+              });
+            } else {
+              const fileImport = ProviderFileImportSchema.safeParse(parsedBody);
+              jsonContent = fileImport.success
+                ? typeof fileImport.data === "string"
+                  ? fileImport.data
+                  : JSON.stringify(fileImport.data)
+                : rawBody;
+            }
           } catch {
             jsonContent = rawBody;
           }
 
-          if (!jsonContent || jsonContent.trim() === "") {
+          if (jsonContent.trim() === "") {
             return Response.json({ error: "No JSON content provided" }, { status: 400 });
           }
 
@@ -35,11 +72,8 @@ export const Route = createFileRoute("/api/providers/import")({
                   ? `Import completed with ${result.errors.length} error(s)`
                   : "No providers imported",
           });
-        } catch (err) {
-          return Response.json(
-            { error: `Failed to import: ${err instanceof Error ? err.message : String(err)}` },
-            { status: 400 },
-          );
+        } catch {
+          return Response.json({ error: "Provider import failed" }, { status: 400 });
         }
       },
     },

package/src/routes/api/providers.scan.ts

@@ -1,21 +1,26 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { scanExternalProviders } from "../../proxy/providerImporters";
+import { createProviderScan } from "../../proxy/providerScanStore";
 
 export const Route = createFileRoute("/api/providers/scan")({
   server: {
     handlers: {
-      GET: () => {
+      POST: () => {
         try {
           const result = scanExternalProviders();
-          return Response.json({
-            providers: result.providers,
-            warnings: result.warnings,
-          });
-        } catch (err) {
+          const scan = createProviderScan(result.providers);
           return Response.json(
-            { error: `Scan failed: ${err instanceof Error ? err.message : String(err)}` },
-            { status: 500 },
+            {
+              scanId: scan.scanId,
+              providers: scan.providers,
+              warnings: result.warnings,
+            },
+            {
+              headers: { "cache-control": "no-store" },
+            },
           );
+        } catch {
+          return Response.json({ error: "Provider scan failed" }, { status: 500 });
         }
       },
     },