@tonyclaw/agent-inspector 3.0.29 → 3.0.31

package/src/proxy/sqliteLogIndex.ts

@@ -1,8 +1,9 @@
-import { mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { logger, resolveLogDir } from "./logger";
 import type { ApiFormat } from "./schemas";
 import type { LogIndexEntry, LogIndexSummary } from "./logIndex";
+import { ensurePrivateDirectorySync, securePrivateFileSync } from "./privateDataPath";
 
 type SqliteState =
   | { status: "ready"; db: unknown; path: string }
@@ -299,10 +300,19 @@ async function initializeSqliteState(): Promise<SqliteState> {
   }
 
   try {
-    await mkdir(dirname(path), { recursive: true });
+    if (!ensurePrivateDirectorySync(dirname(path))) {
+      return { status: "unavailable", path, reason: "SQLite index directory is not private" };
+    }
     const db = sqliteConstructor.constructor(path);
     execSql(db, "PRAGMA journal_mode = WAL");
     execSql(db, "PRAGMA synchronous = NORMAL");
+    if (!securePrivateFileSync(path, true)) {
+      callMethod(db, "close", []);
+      return { status: "unavailable", path, reason: "SQLite index file is not private" };
+    }
+    for (const sidecarPath of [`${path}-wal`, `${path}-shm`]) {
+      if (existsSync(sidecarPath)) void securePrivateFileSync(sidecarPath);
+    }
     if (!execSql(db, CREATE_SCHEMA_SQL)) {
       return { status: "unavailable", path, reason: "SQLite schema initialization failed" };
     }
@@ -326,6 +336,12 @@ async function getSqliteState(): Promise<SqliteState> {
   return await sqliteStatePromise;
 }
 
+/** Report only index availability; internal paths and failure reasons remain private. */
+export async function isSqliteLogIndexReady(): Promise<boolean> {
+  const state = await getSqliteState();
+  return state.status === "ready";
+}
+
 export function closeSqliteLogIndex(): void {
   if (activeDb !== null) {
     callMethod(activeDb, "close", []);

package/src/proxy/store.ts

@@ -10,7 +10,7 @@ import { open, unlink, rename } from "node:fs/promises";
 import { readdir as readdirCallback } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { Buffer } from "node:buffer";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import {
   appendLogEntry,
   resolveLogDir,
@@ -50,6 +50,11 @@ import {
   listArchivedSessionLogs,
   listArchivedSessionIds,
 } from "./sessionArchive";
+import {
+  ensurePrivateDirectorySync,
+  PRIVATE_FILE_MODE,
+  securePrivateFileSync,
+} from "./privateDataPath";
 import {
   clearSessionRegistry,
   getLogSessionId,
@@ -1383,7 +1388,13 @@ async function rewriteLogFileWithoutIds(
   ids: ReadonlySet<number>,
 ): Promise<RewriteLogFileResult> {
   const tempPath = tempRewritePath(filePath);
-  const writer = createWriteStream(tempPath, { encoding: "utf-8" });
+  if (!ensurePrivateDirectorySync(dirname(filePath))) {
+    return { rewritten: false, removedIds: new Set() };
+  }
+  const writer = createWriteStream(tempPath, {
+    encoding: "utf-8",
+    mode: PRIVATE_FILE_MODE,
+  });
   const removedIds = new Set<number>();
   let keptLineCount = 0;
   let writeOk = true;
@@ -1415,6 +1426,11 @@ async function rewriteLogFileWithoutIds(
     return { rewritten: false, removedIds: new Set() };
   }
 
+  if (!securePrivateFileSync(tempPath)) {
+    await removeTempFile(tempPath);
+    return { rewritten: false, removedIds: new Set() };
+  }
+
   if (removedIds.size === 0) {
     await removeTempFile(tempPath);
     return { rewritten: false, removedIds };

package/src/routes/__root.tsx

@@ -3,6 +3,7 @@ import { Outlet, createRootRoute, HeadContent, Scripts } from "@tanstack/react-r
 import { useEffect, type ReactNode } from "react";
 import { SWRConfig } from "swr";
 import faviconSvg from "../assets/favicon.svg?url";
+import { SafeErrorBoundary, SafeRouteError } from "../components/errors/SafeErrorBoundary";
 import appCss from "../index.css?url";
 import { installChunkLoadRecovery } from "../lib/chunkLoadRecovery";
 import { THEME_MODE_STORAGE_KEY } from "../lib/themeMode";
@@ -94,6 +95,7 @@ export const Route = createRootRoute({
     ],
   }),
   component: RootComponent,
+  errorComponent: RootRouteErrorComponent,
   notFoundComponent: RootNotFoundComponent,
 });
 
@@ -102,7 +104,22 @@ function RootComponent() {
 
   return (
     <RootDocument>
-      <Outlet />
+      <SafeErrorBoundary
+        scope="root-render"
+        title="Agent Inspector could not continue"
+        description="The application stopped this render safely. Retry or reload Inspector."
+        variant="page"
+      >
+        <Outlet />
+      </SafeErrorBoundary>
+    </RootDocument>
+  );
+}
+
+function RootRouteErrorComponent({ error, reset }: { error: Error; reset: () => void }) {
+  return (
+    <RootDocument>
+      <SafeRouteError error={error} reset={reset} scope="root-route" />
     </RootDocument>
   );
 }

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

@@ -1,21 +1,25 @@
 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;
-}
+import { DEFAULT_ALERT_SCAN_LIMIT, MAX_ALERT_SCAN_LIMIT } from "../../proxy/alerts";
+import { parseBoundedIntegerParameter } from "../../lib/resourceLimits";
 
 export const Route = createFileRoute("/api/alerts/summary")({
   server: {
     handlers: {
       GET: async ({ request }: { request: Request }) => {
         const url = new URL(request.url);
+        const scanLimitResult = parseBoundedIntegerParameter({
+          value: url.searchParams.get("scanLimit"),
+          parameter: "scanLimit",
+          fallback: DEFAULT_ALERT_SCAN_LIMIT,
+          minimum: 1,
+          maximum: MAX_ALERT_SCAN_LIMIT,
+          resource: "alerts-scan-size",
+        });
+        if (!scanLimitResult.ok) return scanLimitResult.response;
         return Response.json(
           await getInspectorAlertSummary({
-            scanLimit: parsePositiveInt(url.searchParams.get("scanLimit")),
+            scanLimit: scanLimitResult.value,
           }),
         );
       },

package/src/routes/api/alerts.ts

@@ -8,6 +8,13 @@ import {
   type AlertSource,
 } from "../../lib/alertContract";
 import { listInspectorAlerts } from "../../services/alerts";
+import {
+  DEFAULT_ALERT_LIMIT,
+  DEFAULT_ALERT_SCAN_LIMIT,
+  MAX_ALERT_LIMIT,
+  MAX_ALERT_SCAN_LIMIT,
+} from "../../proxy/alerts";
+import { parseBoundedIntegerParameter } from "../../lib/resourceLimits";
 
 type ParsedFilters = {
   severity?: AlertSeverity;
@@ -15,13 +22,6 @@ type ParsedFilters = {
   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"));
@@ -39,11 +39,29 @@ export const Route = createFileRoute("/api/alerts")({
     handlers: {
       GET: async ({ request }: { request: Request }) => {
         const url = new URL(request.url);
+        const limitResult = parseBoundedIntegerParameter({
+          value: url.searchParams.get("limit"),
+          parameter: "limit",
+          fallback: DEFAULT_ALERT_LIMIT,
+          minimum: 1,
+          maximum: MAX_ALERT_LIMIT,
+          resource: "alerts-page-size",
+        });
+        if (!limitResult.ok) return limitResult.response;
+        const scanLimitResult = parseBoundedIntegerParameter({
+          value: url.searchParams.get("scanLimit"),
+          parameter: "scanLimit",
+          fallback: DEFAULT_ALERT_SCAN_LIMIT,
+          minimum: 1,
+          maximum: MAX_ALERT_SCAN_LIMIT,
+          resource: "alerts-scan-size",
+        });
+        if (!scanLimitResult.ok) return scanLimitResult.response;
         return Response.json(
           await listInspectorAlerts({
             ...parseFilters(url),
-            limit: parsePositiveInt(url.searchParams.get("limit")),
-            scanLimit: parsePositiveInt(url.searchParams.get("scanLimit")),
+            limit: limitResult.value,
+            scanLimit: scanLimitResult.value,
           }),
         );
       },

package/src/routes/api/ecosystem.packages.$packageId.help.ts

@@ -1,16 +1,11 @@
 import { createFileRoute } from "@tanstack/react-router";
-import { startEcosystemTask } from "../../proxy/ecosystemTasks";
+import { handleEcosystemPackageExecution } from "../../proxy/ecosystemExecutionRoute";
 
 export const Route = createFileRoute("/api/ecosystem/packages/$packageId/help")({
   server: {
     handlers: {
-      POST: ({ params }: { params: { packageId: string } }) => {
-        const task = startEcosystemTask(params.packageId, "help");
-        if (task === null) {
-          return Response.json({ error: "Unknown ecosystem package" }, { status: 404 });
-        }
-        return Response.json({ task });
-      },
+      POST: ({ params, request }: { params: { packageId: string }; request: Request }) =>
+        handleEcosystemPackageExecution(request, params.packageId, "help"),
     },
   },
 });

package/src/routes/api/ecosystem.packages.$packageId.install.ts

@@ -1,16 +1,11 @@
 import { createFileRoute } from "@tanstack/react-router";
-import { startEcosystemTask } from "../../proxy/ecosystemTasks";
+import { handleEcosystemPackageExecution } from "../../proxy/ecosystemExecutionRoute";
 
 export const Route = createFileRoute("/api/ecosystem/packages/$packageId/install")({
   server: {
     handlers: {
-      POST: ({ params }: { params: { packageId: string } }) => {
-        const task = startEcosystemTask(params.packageId, "install");
-        if (task === null) {
-          return Response.json({ error: "Unknown ecosystem package" }, { status: 404 });
-        }
-        return Response.json({ task });
-      },
+      POST: ({ params, request }: { params: { packageId: string }; request: Request }) =>
+        handleEcosystemPackageExecution(request, params.packageId, "install"),
     },
   },
 });

package/src/routes/api/ecosystem.packages.$packageId.runner-presets.ts

@@ -1,19 +1,11 @@
 import { createFileRoute } from "@tanstack/react-router";
-import { startEcosystemTask } from "../../proxy/ecosystemTasks";
+import { handleEcosystemPackageExecution } from "../../proxy/ecosystemExecutionRoute";
 
 export const Route = createFileRoute("/api/ecosystem/packages/$packageId/runner-presets")({
   server: {
     handlers: {
-      POST: ({ params }: { params: { packageId: string } }) => {
-        const task = startEcosystemTask(params.packageId, "runner-presets");
-        if (task === null) {
-          return Response.json(
-            { error: "Runner presets are only available for Eval Harness" },
-            { status: 404 },
-          );
-        }
-        return Response.json({ task });
-      },
+      POST: ({ params, request }: { params: { packageId: string }; request: Request }) =>
+        handleEcosystemPackageExecution(request, params.packageId, "runner-presets"),
     },
   },
 });

package/src/routes/api/ecosystem.packages.$packageId.upgrade.ts

@@ -1,16 +1,11 @@
 import { createFileRoute } from "@tanstack/react-router";
-import { startEcosystemTask } from "../../proxy/ecosystemTasks";
+import { handleEcosystemPackageExecution } from "../../proxy/ecosystemExecutionRoute";
 
 export const Route = createFileRoute("/api/ecosystem/packages/$packageId/upgrade")({
   server: {
     handlers: {
-      POST: ({ params }: { params: { packageId: string } }) => {
-        const task = startEcosystemTask(params.packageId, "upgrade");
-        if (task === null) {
-          return Response.json({ error: "Unknown ecosystem package" }, { status: 404 });
-        }
-        return Response.json({ task });
-      },
+      POST: ({ params, request }: { params: { packageId: string }; request: Request }) =>
+        handleEcosystemPackageExecution(request, params.packageId, "upgrade"),
     },
   },
 });

package/src/routes/api/ecosystem.recipes.$recipeId.run.ts

@@ -1,16 +1,11 @@
 import { createFileRoute } from "@tanstack/react-router";
-import { startEcosystemRecipeTask } from "../../proxy/ecosystemTasks";
+import { handleEcosystemRecipeExecution } from "../../proxy/ecosystemExecutionRoute";
 
 export const Route = createFileRoute("/api/ecosystem/recipes/$recipeId/run")({
   server: {
     handlers: {
-      POST: ({ params }: { params: { recipeId: string } }) => {
-        const task = startEcosystemRecipeTask(params.recipeId);
-        if (task === null) {
-          return Response.json({ error: "Unknown ecosystem recipe" }, { status: 404 });
-        }
-        return Response.json({ task });
-      },
+      POST: ({ params, request }: { params: { recipeId: string }; request: Request }) =>
+        handleEcosystemRecipeExecution(request, params.recipeId),
     },
   },
 });

package/src/routes/api/health.ts

@@ -1,14 +1,21 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { logger } from "../../proxy/logger";
+import { getRuntimeReadiness } from "../../proxy/runtimeHealth";
+import { installRuntimeShutdownSignalHandlers } from "../../proxy/runtimeShutdown";
 
 // Trigger logger auto-initialization when this module loads
+installRuntimeShutdownSignalHandlers();
 logger.debug("Health endpoint loaded");
 
 export const Route = createFileRoute("/api/health")({
   server: {
     handlers: {
-      GET: () => {
-        return Response.json({ status: "ok" });
+      GET: async () => {
+        const readiness = await getRuntimeReadiness();
+        return Response.json(
+          { status: "ok", readiness: readiness.status },
+          { headers: { "cache-control": "no-store" } },
+        );
       },
     },
   },

package/src/routes/api/knowledge.project-context.ts

@@ -1,5 +1,6 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { searchOpenClaw } from "../../knowledge/openclawClient";
+import { MAX_SEARCH_PROJECT_CHARS, resourceLimitResponse } from "../../lib/resourceLimits";
 
 export const Route = createFileRoute("/api/knowledge/project-context")({
   server: {
@@ -10,6 +11,16 @@ export const Route = createFileRoute("/api/knowledge/project-context")({
         if (project === "") {
           return Response.json({ error: "Missing project search parameter" }, { status: 400 });
         }
+        if (project.length > MAX_SEARCH_PROJECT_CHARS) {
+          return resourceLimitResponse({
+            error: `Search project filters may contain at most ${String(MAX_SEARCH_PROJECT_CHARS)} characters.`,
+            code: "search-limit-exceeded",
+            status: 400,
+            resource: "knowledge-search-project",
+            limit: MAX_SEARCH_PROJECT_CHARS,
+            retryable: false,
+          });
+        }
         const response = await searchOpenClaw(`project context ${project}`, project);
         return Response.json({ project, ...response });
       },

package/src/routes/api/knowledge.search.ts

@@ -1,12 +1,32 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { z } from "zod";
 import { searchOpenClaw } from "../../knowledge/openclawClient";
+import { MAX_SEARCH_QUERY_CHARS, resourceLimitResponse } from "../../lib/resourceLimits";
 
 const SearchBodySchema = z.object({
-  query: z.string().min(1),
+  query: z.string().min(1).max(MAX_SEARCH_QUERY_CHARS),
   project: z.string().optional(),
 });
 
+function searchLimitResponse(): Response {
+  return resourceLimitResponse({
+    error: `Search queries may contain at most ${String(MAX_SEARCH_QUERY_CHARS)} characters.`,
+    code: "search-limit-exceeded",
+    status: 400,
+    resource: "knowledge-search-query",
+    limit: MAX_SEARCH_QUERY_CHARS,
+    retryable: false,
+  });
+}
+
+function bodySearchQuery(value: unknown): string | null {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+  const descriptor = Object.getOwnPropertyDescriptor(value, "query");
+  if (descriptor === undefined) return null;
+  const query: unknown = descriptor.value;
+  return typeof query === "string" ? query : null;
+}
+
 export const Route = createFileRoute("/api/knowledge/search")({
   server: {
     handlers: {
@@ -17,10 +37,21 @@ export const Route = createFileRoute("/api/knowledge/search")({
         if (query === "") {
           return Response.json({ error: "Missing q search parameter" }, { status: 400 });
         }
+        if (query.length > MAX_SEARCH_QUERY_CHARS) return searchLimitResponse();
         return Response.json(await searchOpenClaw(query, project));
       },
       POST: async ({ request }: { request: Request }) => {
-        const parsed = SearchBodySchema.safeParse(await request.json());
+        let body: unknown;
+        try {
+          body = await request.json();
+        } catch {
+          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+        }
+        const query = bodySearchQuery(body);
+        if (query !== null && query.length > MAX_SEARCH_QUERY_CHARS) {
+          return searchLimitResponse();
+        }
+        const parsed = SearchBodySchema.safeParse(body);
         if (!parsed.success) {
           return Response.json({ error: parsed.error.message }, { status: 400 });
         }

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

@@ -1,7 +1,12 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { LogBodyPartSchema } from "../../contracts";
-import { createLogBodyChunk } from "../../proxy/logBodyChunks";
+import {
+  createLogBodyChunk,
+  DEFAULT_LOG_BODY_CHUNK_BYTES,
+  MAX_LOG_BODY_CHUNK_BYTES,
+} from "../../proxy/logBodyChunks";
 import { getLogById } from "../../proxy/store";
+import { parseBoundedIntegerParameter } from "../../lib/resourceLimits";
 
 function parseIntegerParam(value: string | null, fallback: number): number {
   if (value === null) return fallback;
@@ -24,6 +29,15 @@ export const Route = createFileRoute("/api/logs/$id/body")({
         if (!partResult.success) {
           return Response.json({ error: "Invalid body part" }, { status: 400 });
         }
+        const limitResult = parseBoundedIntegerParameter({
+          value: url.searchParams.get("limit"),
+          parameter: "limit",
+          fallback: DEFAULT_LOG_BODY_CHUNK_BYTES,
+          minimum: 1,
+          maximum: MAX_LOG_BODY_CHUNK_BYTES,
+          resource: "log-body-page-bytes",
+        });
+        if (!limitResult.ok) return limitResult.response;
 
         const log = await getLogById(id);
         if (log === null) {
@@ -35,7 +49,7 @@ export const Route = createFileRoute("/api/logs/$id/body")({
             log,
             part: partResult.data,
             offset: parseIntegerParam(url.searchParams.get("offset"), 0),
-            limit: parseIntegerParam(url.searchParams.get("limit"), 0),
+            limit: limitResult.value,
           }),
         );
       },

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

@@ -1,32 +1,21 @@
-import { Buffer } from "node:buffer";
 import { createFileRoute } from "@tanstack/react-router";
 import { parseImportedLogFile, sessionNameFromImportFileName } from "../../proxy/logImporter";
+import { readBoundedLogImportUpload } from "../../proxy/logImportUpload";
 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 upload = await readBoundedLogImportUpload(request);
+        if (!upload.ok) {
+          return Response.json({ error: upload.message }, { status: upload.status });
         }
 
-        const sessionId = sessionNameFromImportFileName(upload.name);
+        const sessionId = sessionNameFromImportFileName(upload.fileName);
         const parsed = await parseImportedLogFile({
-          fileName: upload.name,
-          data: Buffer.from(await upload.arrayBuffer()),
+          fileName: upload.fileName,
+          data: upload.data,
         });
 
         if (!parsed.ok) {