@tonyclaw/agent-inspector 4.0.1 → 4.0.2

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

@@ -1,214 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { z } from "zod";
-import { LogIdSchema, parseLogId } from "../../../contracts";
-import {
-  clearPersistedLogStorage,
-  clearPersistedLogsByIds,
-  getLogStorageStats,
-  getReplayLogsForSource,
-  listLogsCursorPage,
-  listLogsPage,
-} from "../../../proxy/store";
-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({
-    ids: z.array(LogIdSchema).optional(),
-  })
-  .optional();
-
-function parseNonNegativeInt(value: string | null, fallback: number): number {
-  if (value === null) return fallback;
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed < 0) return fallback;
-  return parsed;
-}
-
-type OptionalPositiveIntResult = { ok: true; value: number | null } | { ok: false };
-type OptionalLogIdResult = { 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.isSafeInteger(parsed) || parsed < 1) return { ok: false };
-  return { ok: true, value: parsed };
-}
-
-function parseOptionalLogId(value: string | null): OptionalLogIdResult {
-  if (value === null) return { ok: true, value: null };
-  const parsed = parseLogId(value);
-  return parsed === null ? { ok: false } : { ok: true, value: parsed };
-}
-
-export const Route = createFileRoute("/api/logs")({
-  server: {
-    handlers: {
-      GET: async ({ request }: { request: Request }) => {
-        const url = new URL(request.url);
-        if (url.searchParams.get("stats") === "1") {
-          return Response.json(getLogStorageStats());
-        }
-        const replayOf = url.searchParams.get("replayOf");
-        if (replayOf !== null) {
-          const id = parseLogId(replayOf);
-          if (id === null) {
-            return Response.json({ error: "Invalid replayOf log ID" }, { status: 400 });
-          }
-          const logs = getReplayLogsForSource(id);
-          return Response.json({ logs, total: logs.length, offset: 0, limit: logs.length });
-        }
-        const sessionId = url.searchParams.get("sessionId") ?? undefined;
-        const model = url.searchParams.get("model") ?? undefined;
-        const clientPidResult = parseOptionalPositiveInt(url.searchParams.get("clientPid"));
-        if (!clientPidResult.ok) {
-          return Response.json({ error: "Invalid clientPid" }, { status: 400 });
-        }
-        const clientPid = clientPidResult.value ?? undefined;
-        const query = url.searchParams.get("q") ?? url.searchParams.get("search");
-        const offset = parseNonNegativeInt(url.searchParams.get("offset"), 0);
-        if (query !== null) {
-          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: limitResult.value,
-              scanLimit: scanLimitResult.value,
-            }),
-          );
-        }
-        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") {
-          const beforeLogId = parseOptionalLogId(url.searchParams.get("beforeLogId"));
-          const afterLogId = parseOptionalLogId(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,
-              clientPid,
-              limit,
-              includeBodies,
-              beforeLogId: beforeLogId.value ?? undefined,
-              afterLogId: afterLogId.value ?? undefined,
-              anchor,
-            }),
-          );
-        }
-
-        return Response.json(
-          await listLogsPage({ sessionId, model, clientPid, offset, limit, includeBodies }),
-        );
-      },
-      DELETE: async ({ request }: { request: Request }) => {
-        let body: z.infer<typeof DeleteLogsBodySchema> = undefined;
-        try {
-          const raw = await request.text();
-          if (raw !== "") {
-            const parsed: unknown = JSON.parse(raw);
-            const result = DeleteLogsBodySchema.safeParse(parsed);
-            if (!result.success) {
-              return Response.json(
-                { error: "Invalid request body", details: result.error.format() },
-                { status: 400 },
-              );
-            }
-            body = result.data;
-          }
-        } catch {
-          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
-        }
-
-        if (body?.ids !== undefined) {
-          if (body.ids.length === 0) {
-            return Response.json({
-              success: true,
-              cleared: 0,
-              logFilesRewritten: 0,
-              chunkFilesDeleted: 0,
-              sessionArchiveLogsDeleted: 0,
-            });
-          }
-          const result = await clearPersistedLogsByIds(body.ids);
-          return Response.json({
-            success: true,
-            cleared: result.cleared,
-            logFilesRewritten: result.logFilesRewritten,
-            chunkFilesDeleted: result.chunkFilesDeleted,
-            sessionArchiveLogsDeleted: result.sessionArchiveLogsDeleted,
-          });
-        }
-        const result = await clearPersistedLogStorage();
-        return Response.json({
-          success: true,
-          cleared: result.cleared,
-          logFilesDeleted: result.logFilesDeleted,
-          chunkFilesDeleted: result.chunkFilesDeleted,
-          sessionArchiveFilesDeleted: result.sessionArchiveFilesDeleted,
-        });
-      },
-    },
-  },
-});

package/src/backend/routes/api/mcp.ts

@@ -1,25 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { handleMcpRequest } from "../../../mcp/server";
-
-/**
- * MCP HTTP Streamable transport endpoint. Mounted at `POST /api/mcp` on the
- * existing TanStack Start HTTP server — see
- * `openspec/changes/add-mcp-server/design.md` D1.
- *
- * All method/header routing is handled inside the SDK's
- * `WebStandardStreamableHTTPServerTransport` (it dispatches GET for SSE
- * stream, POST for client→server requests, DELETE for session close), so
- * the route simply forwards the request.
- */
-export const Route = createFileRoute("/api/mcp")({
-  server: {
-    handlers: {
-      // The SDK may issue either POST, GET, or DELETE. TanStack Start only
-      // requires us to declare the methods we accept; routing by method is
-      // handled inside the transport.
-      POST: ({ request }: { request: Request }) => handleMcpRequest(request),
-      GET: ({ request }: { request: Request }) => handleMcpRequest(request),
-      DELETE: ({ request }: { request: Request }) => handleMcpRequest(request),
-    },
-  },
-});

package/src/backend/routes/api/models.ts

@@ -1,10 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { getModels } from "../../../proxy/store";
-
-export const Route = createFileRoute("/api/models")({
-  server: {
-    handlers: {
-      GET: () => Response.json(getModels()),
-    },
-  },
-});

package/src/backend/routes/api/pi-agent.ts

@@ -1,29 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { PiAgentRequestSchema } from "../../../lib/piAgentContract";
-import { runPiAgent } from "../../../services/piAgent";
-
-export const Route = createFileRoute("/api/pi-agent")({
-  server: {
-    handlers: {
-      POST: async ({ request }: { request: Request }) => {
-        let body: unknown;
-        try {
-          body = await request.json();
-        } catch {
-          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
-        }
-
-        const parsed = PiAgentRequestSchema.safeParse(body);
-        if (!parsed.success) {
-          return Response.json(
-            { error: "Invalid Pi-agent request", details: parsed.error.format() },
-            { status: 400 },
-          );
-        }
-
-        const result = await runPiAgent(parsed.data);
-        return Response.json(result);
-      },
-    },
-  },
-});

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

@@ -1,173 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { z } from "zod";
-import { getProvider, updateProvider } from "../../../proxy/providers";
-import { toRedactedProviderDto } from "../../../lib/providerContract";
-import {
-  applyBuiltinProviderModelMetadata,
-  applyProviderModelRegistry,
-  BUILTIN_MODEL_METADATA_SOURCE_URL,
-  ProviderModelRegistrySchema,
-} from "../../../lib/providerModelMetadata";
-import { safeFetch } from "../../../lib/safeFetch";
-import {
-  DEFAULT_RUNTIME_BUDGET_POLICY,
-  MAX_PROVIDER_MODELS,
-  resourceLimitResponse,
-} from "../../../lib/resourceLimits";
-
-const RefreshModelMetadataInputSchema = z.object({
-  url: z.string().optional(),
-});
-
-function normalizeRefreshUrl(value: string | undefined): string | null {
-  if (value === undefined) return null;
-  const trimmed = value.trim();
-  return trimmed === "" ? null : trimmed;
-}
-
-function isHttpUrl(value: string): boolean {
-  try {
-    const parsed = new URL(value);
-    return parsed.protocol === "http:" || parsed.protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-
-async function readRegistryJson(response: Response): Promise<unknown | null> {
-  try {
-    return JSON.parse(await response.text());
-  } catch {
-    return null;
-  }
-}
-
-export const Route = createFileRoute("/api/providers/$providerId/model-metadata")({
-  server: {
-    handlers: {
-      POST: async ({ params, request }: { params: { providerId: string }; request: Request }) => {
-        const provider = getProvider(params.providerId);
-        if (provider === undefined) {
-          return Response.json({ error: "Provider not found" }, { status: 404 });
-        }
-
-        const parsed = RefreshModelMetadataInputSchema.safeParse(await request.json());
-        if (!parsed.success) {
-          return Response.json({ error: parsed.error.message }, { status: 400 });
-        }
-
-        const sourceUrl = normalizeRefreshUrl(
-          parsed.data.url ??
-            provider.modelMetadataUrl ??
-            process.env["AGENT_INSPECTOR_MODEL_METADATA_URL"],
-        );
-        if (sourceUrl === null) {
-          const result = applyBuiltinProviderModelMetadata(provider, new Date().toISOString());
-          const updated = updateProvider(provider.id, {
-            modelMetadata: result.modelMetadata,
-          });
-          if (updated === null) {
-            return Response.json(
-              { error: "Secure provider storage is unavailable; metadata was not updated" },
-              { status: 503 },
-            );
-          }
-          return Response.json({
-            provider: toRedactedProviderDto(updated),
-            imported: result.imported,
-            matchedModels: result.matchedModels,
-            missingModels: result.missingModels,
-            sourceUrl: BUILTIN_MODEL_METADATA_SOURCE_URL,
-          });
-        }
-        if (!isHttpUrl(sourceUrl)) {
-          return Response.json(
-            { error: "Model metadata URL must be an http(s) URL." },
-            { status: 400 },
-          );
-        }
-
-        let response: Response;
-        try {
-          const fetchResult = await safeFetch(
-            sourceUrl,
-            {
-              headers: { Accept: "application/json" },
-            },
-            {
-              deadlineMs: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.metadataDeadlineMs,
-              responseBytes: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.metadataResponseBytes,
-            },
-          );
-          if (!fetchResult.ok) {
-            return Response.json(
-              { error: `Model metadata URL blocked: ${fetchResult.reason}` },
-              { status: 400 },
-            );
-          }
-          response = fetchResult.response;
-        } catch (err) {
-          return Response.json(
-            { error: `Failed to fetch model metadata: ${String(err)}` },
-            { status: 502 },
-          );
-        }
-
-        if (!response.ok) {
-          return Response.json(
-            { error: `Model metadata fetch failed with HTTP ${String(response.status)}` },
-            { status: 502 },
-          );
-        }
-
-        const registryJson = await readRegistryJson(response);
-        if (registryJson === null) {
-          return Response.json(
-            { error: "Model metadata response is not valid JSON." },
-            { status: 400 },
-          );
-        }
-
-        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 });
-        }
-
-        const result = applyProviderModelRegistry(
-          provider,
-          registry.data,
-          sourceUrl,
-          new Date().toISOString(),
-        );
-        const updated = updateProvider(provider.id, {
-          modelMetadata: result.modelMetadata,
-          modelMetadataUrl: sourceUrl,
-        });
-        if (updated === null) {
-          return Response.json(
-            { error: "Secure provider storage is unavailable; metadata was not updated" },
-            { status: 503 },
-          );
-        }
-
-        return Response.json({
-          provider: toRedactedProviderDto(updated),
-          imported: result.imported,
-          matchedModels: result.matchedModels,
-          missingModels: result.missingModels,
-          sourceUrl,
-        });
-      },
-    },
-  },
-});