@tonyclaw/agent-inspector 4.0.1 → 4.0.2

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

@@ -1,102 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { z } from "zod";
-import {
-  getProviders,
-  addProvider,
-  redactProvider,
-  redactProviders,
-} from "../../../proxy/providers";
-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";
-
-const ProviderInputSchema = z.object({
-  name: z.string().min(1, "Name is required"),
-  apiKey: z.string().min(1, "API key is required"),
-  format: z.enum(["anthropic", "openai"]).optional(),
-  anthropicBaseUrl: z.string().optional(),
-  openaiBaseUrl: z.string().optional(),
-  openaiResponsesBaseUrl: z.string().optional(),
-  models: ProviderModelsSchema.min(1, "At least one model is required"),
-  model: ProviderModelNameSchema.optional(),
-  authHeader: z.enum(["bearer", "x-api-key"]).optional().default("bearer"),
-  apiDocsUrl: z.string().optional(),
-  modelMetadataUrl: z.string().optional(),
-  modelMetadata: ProviderModelMetadataListSchema.optional(),
-  source: z.enum(["company", "personal"]).optional(),
-});
-
-export const Route = createFileRoute("/api/providers")({
-  server: {
-    handlers: {
-      GET: () => {
-        return Response.json(redactProviders(getProviders()));
-      },
-      POST: async ({ request }: { request: Request }) => {
-        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 = ProviderInputSchema.safeParse(body);
-        if (!parsed.success) {
-          return Response.json({ error: parsed.error.message }, { status: 400 });
-        }
-        for (const candidate of [
-          parsed.data.anthropicBaseUrl,
-          parsed.data.openaiBaseUrl,
-          parsed.data.openaiResponsesBaseUrl,
-        ]) {
-          if (candidate === undefined || candidate === "") continue;
-          const decision = evaluateUpstreamUrl(candidate, { allowLoopback: ALLOW_LOOPBACK });
-          if (!decision.allow) {
-            return Response.json({ error: decision.reason }, { status: 400 });
-          }
-        }
-        const newProvider = addProvider(
-          parsed.data.name,
-          parsed.data.apiKey,
-          parsed.data.format,
-          undefined, // baseUrl (legacy) — use format-specific URLs instead
-          parsed.data.models,
-          parsed.data.authHeader,
-          parsed.data.apiDocsUrl,
-          parsed.data.anthropicBaseUrl,
-          parsed.data.openaiBaseUrl,
-          parsed.data.source,
-          parsed.data.modelMetadataUrl,
-          parsed.data.modelMetadata,
-          parsed.data.openaiResponsesBaseUrl,
-        );
-        if (newProvider === null) {
-          return Response.json(
-            { error: "Secure provider storage is unavailable; provider was not created" },
-            { status: 503 },
-          );
-        }
-        return Response.json(redactProvider(newProvider), { status: 201 });
-      },
-    },
-  },
-});

package/src/backend/routes/api/runs.$runId.evidence.ts

@@ -1,55 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { EvidenceExportOptionsSchema } from "../../../lib/runContract";
-import { exportInspectorRunEvidence, readInspectorRunEvidence } from "../../../services/runs";
-
-type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
-
-async function readJsonBody(request: Request): Promise<JsonBodyResult> {
-  try {
-    const raw = await request.text();
-    if (raw.trim().length === 0) return { ok: true, value: undefined };
-    return { ok: true, value: JSON.parse(raw) };
-  } catch {
-    return { ok: false };
-  }
-}
-
-export const Route = createFileRoute("/api/runs/$runId/evidence")({
-  server: {
-    handlers: {
-      GET: ({ params }: { params: { runId: string } }) => {
-        const evidence = readInspectorRunEvidence(params.runId);
-        if (!evidence.ok) {
-          return Response.json({ error: evidence.message }, { status: evidence.status });
-        }
-
-        return Response.json(evidence.value);
-      },
-      POST: async ({ params, request }: { params: { runId: string }; request: Request }) => {
-        const body = await readJsonBody(request);
-        if (!body.ok) {
-          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
-        }
-
-        const parsed = EvidenceExportOptionsSchema.safeParse(body.value);
-        if (!parsed.success) {
-          return Response.json(
-            { error: "Invalid request body", details: parsed.error.format() },
-            { status: 400 },
-          );
-        }
-
-        const exported = await exportInspectorRunEvidence(
-          params.runId,
-          parsed.data,
-          new URL(request.url).origin,
-        );
-        if (!exported.ok) {
-          return Response.json({ error: exported.message }, { status: exported.status });
-        }
-
-        return Response.json(exported.value);
-      },
-    },
-  },
-});

package/src/backend/routes/api/runs.$runId.ts

@@ -1,50 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { UpdateInspectorRunInputSchema } from "../../../lib/runContract";
-import { getInspectorRun, updateInspectorRun } from "../../../services/runs";
-
-type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
-
-async function readJsonBody(request: Request): Promise<JsonBodyResult> {
-  try {
-    const raw = await request.text();
-    if (raw.trim().length === 0) return { ok: true, value: {} };
-    return { ok: true, value: JSON.parse(raw) };
-  } catch {
-    return { ok: false };
-  }
-}
-
-export const Route = createFileRoute("/api/runs/$runId")({
-  server: {
-    handlers: {
-      GET: ({ params }: { params: { runId: string } }) => {
-        const run = getInspectorRun(params.runId);
-        if (!run.ok) {
-          return Response.json({ error: run.message }, { status: run.status });
-        }
-        return Response.json(run.value);
-      },
-      PATCH: async ({ params, request }: { params: { runId: string }; request: Request }) => {
-        const body = await readJsonBody(request);
-        if (!body.ok) {
-          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
-        }
-
-        const parsed = UpdateInspectorRunInputSchema.safeParse(body.value);
-        if (!parsed.success) {
-          return Response.json(
-            { error: "Invalid request body", details: parsed.error.format() },
-            { status: 400 },
-          );
-        }
-
-        const updated = updateInspectorRun(params.runId, parsed.data);
-        if (!updated.ok) {
-          return Response.json({ error: updated.message }, { status: updated.status });
-        }
-
-        return Response.json(updated.value);
-      },
-    },
-  },
-});

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

@@ -1,62 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { CreateInspectorRunInputSchema } from "../../../lib/runContract";
-import {
-  RECENT_FAILURES_DEFAULT_LIMIT,
-  createInspectorRun,
-  listInspectorRecentFailures,
-  listInspectorRuns,
-} from "../../../services/runs";
-import { RECENT_FAILURES_MAX_LIMIT } from "../../../proxy/runFailures";
-import { parseBoundedIntegerParameter } from "../../../lib/resourceLimits";
-
-type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
-
-async function readJsonBody(request: Request): Promise<JsonBodyResult> {
-  try {
-    const raw = await request.text();
-    if (raw.trim().length === 0) return { ok: true, value: undefined };
-    return { ok: true, value: JSON.parse(raw) };
-  } catch {
-    return { ok: false };
-  }
-}
-
-export const Route = createFileRoute("/api/runs")({
-  server: {
-    handlers: {
-      GET: ({ request }: { request: Request }) => {
-        const url = new URL(request.url);
-        if (url.searchParams.get("failures") === "1") {
-          const limitResult = parseBoundedIntegerParameter({
-            value: url.searchParams.get("limit"),
-            parameter: "limit",
-            fallback: RECENT_FAILURES_DEFAULT_LIMIT,
-            minimum: 1,
-            maximum: RECENT_FAILURES_MAX_LIMIT,
-            resource: "recent-failures-page-size",
-          });
-          if (!limitResult.ok) return limitResult.response;
-          return Response.json(listInspectorRecentFailures(limitResult.value));
-        }
-
-        return Response.json(listInspectorRuns());
-      },
-      POST: async ({ request }: { request: Request }) => {
-        const body = await readJsonBody(request);
-        if (!body.ok) {
-          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
-        }
-
-        const parsed = CreateInspectorRunInputSchema.safeParse(body.value);
-        if (!parsed.success) {
-          return Response.json(
-            { error: "Invalid request body", details: parsed.error.format() },
-            { status: 400 },
-          );
-        }
-
-        return Response.json(createInspectorRun(parsed.data), { status: 201 });
-      },
-    },
-  },
-});

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

@@ -1,46 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { appendBasePathToOrigin } from "../../../lib/basePath";
-import {
-  BROWSER_RUNTIME_SCHEMA_VERSION,
-  type BrowserRuntimeDeployment,
-} from "../../../lib/browserRuntimeContract";
-import { getPublicBasePath, getPublicOrigin } from "../../../lib/publicBasePathContext";
-
-type RuntimeEnvironment = Readonly<Record<string, string | undefined>>;
-
-export const AGENT_INSPECTOR_BACKEND_ONLY_ENV = "AGENT_INSPECTOR_BACKEND_ONLY";
-
-export function runtimeDiscoveryDocument(
-  env: RuntimeEnvironment = process.env,
-): BrowserRuntimeDeployment {
-  const basePath = getPublicBasePath(env);
-  const baseUrl = appendBasePathToOrigin(getPublicOrigin(), "/", basePath);
-
-  return {
-    schemaVersion: BROWSER_RUNTIME_SCHEMA_VERSION,
-    deploymentMode: env[AGENT_INSPECTOR_BACKEND_ONLY_ENV] === "1" ? "backend-only" : "composed",
-    ui: { basePath: basePath.length === 0 ? "/" : basePath },
-    control: { baseUrl },
-    agent: { baseUrl },
-    capabilities: {
-      rest: true,
-      sse: true,
-      proxy: true,
-      mcp: true,
-    },
-  };
-}
-
-export function runtimeDiscoveryResponse(env: RuntimeEnvironment = process.env): Response {
-  return Response.json(runtimeDiscoveryDocument(env), {
-    headers: { "cache-control": "no-store" },
-  });
-}
-
-export const Route = createFileRoute("/api/runtime")({
-  server: {
-    handlers: {
-      GET: () => runtimeDiscoveryResponse(),
-    },
-  },
-});

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

@@ -1,51 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { getSessionInfo, getSessionSnapshots, listSessions } from "../../../proxy/store";
-import {
-  SESSION_INFO_DEFAULT_LATEST_LOG_LIMIT,
-  SESSION_INFO_MAX_LATEST_LOG_LIMIT,
-} from "../../../proxy/sessionInfo";
-import { parseBoundedIntegerParameter } from "../../../lib/resourceLimits";
-
-function parseBooleanFlag(value: string | null): boolean {
-  return value === "1" || value === "true";
-}
-
-export const Route = createFileRoute("/api/sessions")({
-  server: {
-    handlers: {
-      GET: async ({ request }: { request: Request }) => {
-        const url = new URL(request.url);
-        const sessionId = url.searchParams.get("sessionId");
-        if (sessionId !== null) {
-          if (sessionId.length === 0) {
-            return Response.json({ error: "sessionId is required" }, { status: 400 });
-          }
-          const limitResult = parseBoundedIntegerParameter({
-            value: url.searchParams.get("limit"),
-            parameter: "limit",
-            fallback: SESSION_INFO_DEFAULT_LATEST_LOG_LIMIT,
-            minimum: 1,
-            maximum: SESSION_INFO_MAX_LATEST_LOG_LIMIT,
-            resource: "session-log-page-size",
-          });
-          if (!limitResult.ok) return limitResult.response;
-          const info = await getSessionInfo(sessionId, {
-            baseUrl: url.origin,
-            includeHistory: parseBooleanFlag(url.searchParams.get("includeHistory")),
-            latestLogLimit: limitResult.value,
-          });
-          if (info === null) {
-            return Response.json({ error: "Session not found" }, { status: 404 });
-          }
-          return Response.json(info);
-        }
-
-        const details = url.searchParams.get("details");
-        if (details === "true" || details === "1") {
-          return Response.json(getSessionSnapshots());
-        }
-        return Response.json(await listSessions());
-      },
-    },
-  },
-});

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

@@ -1,56 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { getLogStorageStats } from "../../../proxy/store";
-import {
-  getLastStorageLifecycleGcResult,
-  getStorageLifecycleInventory,
-  resolveStorageLifecycleQuotaPolicy,
-  runStorageLifecycleGc,
-  type StorageLifecycleGcResult,
-} from "../../../proxy/storageLifecycle";
-
-function summarizeGcResult(result: StorageLifecycleGcResult | null) {
-  if (result === null) return null;
-  return {
-    checkedAt: result.checkedAt,
-    filesDeleted: result.filesDeleted,
-    bytesDeleted: result.bytesDeleted,
-    errors: result.errors.length,
-    beforeTotalBytes: result.before.totalBytes,
-    afterTotalBytes: result.after.totalBytes,
-  };
-}
-
-function getStorageResponse() {
-  const logStats = getLogStorageStats();
-  const inventory = getStorageLifecycleInventory();
-  const policy = resolveStorageLifecycleQuotaPolicy();
-  const reclaimableBytes = inventory.artifacts
-    .filter(
-      (artifact) =>
-        artifact.cleanupBehavior === "retention-gc" ||
-        artifact.cleanupBehavior === "orphan-reclaim",
-    )
-    .reduce((sum, artifact) => sum + artifact.bytes, 0);
-
-  return {
-    memoryCount: logStats.memoryCount,
-    inventory,
-    policy,
-    reclaimableBytes,
-    lastGc: summarizeGcResult(getLastStorageLifecycleGcResult()),
-  };
-}
-
-export const Route = createFileRoute("/api/storage")({
-  server: {
-    handlers: {
-      GET: () => {
-        return Response.json(getStorageResponse(), { headers: { "cache-control": "no-store" } });
-      },
-      POST: () => {
-        runStorageLifecycleGc();
-        return Response.json(getStorageResponse(), { headers: { "cache-control": "no-store" } });
-      },
-    },
-  },
-});

package/src/backend/routes/livez.ts

@@ -1,13 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-
-export function livenessResponse(): Response {
-  return Response.json({ status: "ok" }, { headers: { "cache-control": "no-store" } });
-}
-
-export const Route = createFileRoute("/livez")({
-  server: {
-    handlers: {
-      GET: livenessResponse,
-    },
-  },
-});

package/src/backend/routes/metrics.ts

@@ -1,14 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { getLogsStreamMetrics } from "./api/logs.stream";
-import { getSafeOperationalMetrics } from "../../proxy/runtimeMetrics";
-
-export const Route = createFileRoute("/metrics")({
-  server: {
-    handlers: {
-      GET: async () => {
-        const metrics = await getSafeOperationalMetrics(getLogsStreamMetrics());
-        return Response.json(metrics, { headers: { "cache-control": "no-store" } });
-      },
-    },
-  },
-});

package/src/backend/routes/proxy/$.ts

@@ -1,15 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { handleProxy } from "../../../proxy/handler";
-
-export const Route = createFileRoute("/proxy/$")({
-  server: {
-    handlers: {
-      GET: ({ request }: { request: Request }) => handleProxy(request),
-      POST: ({ request }: { request: Request }) => handleProxy(request),
-      PUT: ({ request }: { request: Request }) => handleProxy(request),
-      DELETE: ({ request }: { request: Request }) => handleProxy(request),
-      PATCH: ({ request }: { request: Request }) => handleProxy(request),
-      OPTIONS: ({ request }: { request: Request }) => handleProxy(request),
-    },
-  },
-});

package/src/backend/routes/readyz.ts

@@ -1,18 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { getRuntimeReadiness } from "../../proxy/runtimeHealth";
-
-export async function readinessResponse(): Promise<Response> {
-  const readiness = await getRuntimeReadiness();
-  return Response.json(readiness, {
-    status: readiness.status === "unavailable" ? 503 : 200,
-    headers: { "cache-control": "no-store" },
-  });
-}
-
-export const Route = createFileRoute("/readyz")({
-  server: {
-    handlers: {
-      GET: readinessResponse,
-    },
-  },
-});

package/src/backend/start.ts

@@ -1,10 +0,0 @@
-import { createMiddleware, createStart } from "@tanstack/react-start";
-
-const publicBasePathMiddleware = createMiddleware().server(async ({ next, request }) => {
-  const { runWithRequestPublicBasePath } = await import("../lib/publicBasePathContext");
-  return runWithRequestPublicBasePath(request, () => next());
-});
-
-export const startInstance = createStart(() => ({
-  requestMiddleware: [publicBasePathMiddleware],
-}));