@tonyclaw/agent-inspector 3.0.29 → 3.0.31

package/src/proxy/evidenceExporter.ts

@@ -1,4 +1,5 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import assert from "node:assert/strict";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import {
   type EvidenceExportOptions,
@@ -10,6 +11,11 @@ import { getDataDir } from "./dataDir";
 import { analyzeEvidence } from "./evidenceAnalysis";
 import { getSessionInfo } from "./store";
 import { updateRunEvidence } from "./runStore";
+import {
+  ensurePrivateDirectorySync,
+  PRIVATE_FILE_MODE,
+  securePrivateFileSync,
+} from "./privateDataPath";
 
 type EvidenceDocument = EvidenceExportResult;
 
@@ -197,14 +203,22 @@ export async function exportRunEvidence(
   };
   const markdown = buildMarkdown(document);
 
-  mkdirSync(evidenceDir(run.id), { recursive: true });
-  writeFileSync(
-    evidence.jsonPath,
-    `${JSON.stringify({ ...document, evidence }, null, 2)}\n`,
-    "utf8",
-  );
-  writeFileSync(evidence.markdownPath, markdown, "utf8");
-  writeFileSync(evidence.htmlPath, buildHtml(markdown, run.title), "utf8");
+  assert(ensurePrivateDirectorySync(evidenceDir(run.id)), "Could not secure evidence directory");
+  writeFileSync(evidence.jsonPath, `${JSON.stringify({ ...document, evidence }, null, 2)}\n`, {
+    encoding: "utf8",
+    mode: PRIVATE_FILE_MODE,
+  });
+  writeFileSync(evidence.markdownPath, markdown, {
+    encoding: "utf8",
+    mode: PRIVATE_FILE_MODE,
+  });
+  writeFileSync(evidence.htmlPath, buildHtml(markdown, run.title), {
+    encoding: "utf8",
+    mode: PRIVATE_FILE_MODE,
+  });
+  for (const path of [evidence.jsonPath, evidence.markdownPath, evidence.htmlPath]) {
+    assert(securePrivateFileSync(path), `Could not secure evidence file ${path}`);
+  }
 
   const updatedRun = updateRunEvidence(run.id, evidence) ?? documentRun;
   return { ...document, run: updatedRun };

package/src/proxy/groupEvidenceExporter.ts

@@ -1,4 +1,5 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import assert from "node:assert/strict";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import {
   GroupEvidenceExportResultSchema,
@@ -16,6 +17,11 @@ import { getRun } from "./runStore";
 import { getSessionInfo } from "./store";
 import { updateGroupEvidence } from "./groupStore";
 import { readJsonFile } from "../lib/jsonFile";
+import {
+  ensurePrivateDirectorySync,
+  PRIVATE_FILE_MODE,
+  securePrivateFileSync,
+} from "./privateDataPath";
 
 type GroupEvidenceDocument = GroupEvidenceExportResult;
 
@@ -323,10 +329,25 @@ export async function exportGroupEvidence(
   };
   const markdown = buildMarkdown(document);
 
-  mkdirSync(groupEvidenceDir(group.id), { recursive: true });
-  writeFileSync(evidence.jsonPath, `${JSON.stringify(document, null, 2)}\n`, "utf8");
-  writeFileSync(evidence.markdownPath, markdown, "utf8");
-  writeFileSync(evidence.htmlPath, buildHtml(markdown, group.title), "utf8");
+  assert(
+    ensurePrivateDirectorySync(groupEvidenceDir(group.id)),
+    "Could not secure group evidence directory",
+  );
+  writeFileSync(evidence.jsonPath, `${JSON.stringify(document, null, 2)}\n`, {
+    encoding: "utf8",
+    mode: PRIVATE_FILE_MODE,
+  });
+  writeFileSync(evidence.markdownPath, markdown, {
+    encoding: "utf8",
+    mode: PRIVATE_FILE_MODE,
+  });
+  writeFileSync(evidence.htmlPath, buildHtml(markdown, group.title), {
+    encoding: "utf8",
+    mode: PRIVATE_FILE_MODE,
+  });
+  for (const path of [evidence.jsonPath, evidence.markdownPath, evidence.htmlPath]) {
+    assert(securePrivateFileSync(path), `Could not secure group evidence file ${path}`);
+  }
 
   const updatedGroup = updateGroupEvidence(group.id, evidence) ?? documentGroup;
   return { ...document, group: updatedGroup };

package/src/proxy/groupStore.ts

@@ -1,5 +1,6 @@
+import assert from "node:assert/strict";
 import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { z } from "zod";
 import {
@@ -20,6 +21,11 @@ import {
 } from "../lib/groupContract";
 import { getDataDir } from "./dataDir";
 import { readJsonFile } from "../lib/jsonFile";
+import {
+  ensurePrivateDirectorySync,
+  PRIVATE_FILE_MODE,
+  securePrivateFileSync,
+} from "./privateDataPath";
 
 const GroupsFileSchema = z.object({
   groups: z.array(InspectorGroupSchema),
@@ -77,8 +83,12 @@ function readGroups(): InspectorGroup[] {
 
 function writeGroups(groups: readonly InspectorGroup[]): void {
   const filePath = groupsFilePath();
-  mkdirSync(dirname(filePath), { recursive: true });
-  writeFileSync(filePath, `${JSON.stringify({ groups }, null, 2)}\n`, "utf8");
+  assert(ensurePrivateDirectorySync(dirname(filePath)), "Could not secure groups directory");
+  writeFileSync(filePath, `${JSON.stringify({ groups }, null, 2)}\n`, {
+    encoding: "utf8",
+    mode: PRIVATE_FILE_MODE,
+  });
+  assert(securePrivateFileSync(filePath), "Could not secure groups file");
 }
 
 function sortedGroups(groups: readonly InspectorGroup[]): InspectorGroup[] {

package/src/proxy/handler.ts

@@ -31,6 +31,7 @@ import { maskApiKey } from "../lib/mask";
 import { buildFileLogEntry, type FinalizeLogJob } from "./logFinalizer";
 import { enqueueFinalizeLogJob } from "./sessionRuntime";
 import { RawStreamCapture } from "./rawStreamCapture";
+import { acquireRuntimeRequest, type RuntimeRequestLease } from "./runtimeAdmission";
 import {
   buildUpstreamUrl,
   describeApiRoute,
@@ -202,35 +203,56 @@ function handleStreamingResponse(
 
     const totalStreamMs = Date.now() - startTime;
     const elapsedMs = totalStreamMs;
-    const rawStream = capture.snapshot();
-    switch (type) {
-      case "streaming":
-        scheduleLogFinalization({
-          type: "streaming",
-          log,
-          upstreamUrl,
-          elapsedMs,
-          responseStatus: upstreamRes.status,
-          rawStream,
-          collectStreamingChunks,
-          firstChunkMs,
-          totalStreamMs,
-        });
-        return;
-      case "stream-abort":
+    void capture
+      .finalize()
+      .then((rawStream) => {
+        switch (type) {
+          case "streaming":
+            scheduleLogFinalization({
+              type: "streaming",
+              log,
+              upstreamUrl,
+              elapsedMs,
+              responseStatus: upstreamRes.status,
+              rawStream,
+              collectStreamingChunks,
+              firstChunkMs,
+              totalStreamMs,
+            });
+            return;
+          case "stream-abort":
+            scheduleLogFinalization({
+              type: "stream-abort",
+              log,
+              upstreamUrl,
+              elapsedMs,
+              rawStream,
+              hasChunks: capture.hasChunks,
+              collectStreamingChunks,
+              firstChunkMs,
+              totalStreamMs,
+            });
+            return;
+        }
+      })
+      .catch((error: unknown) => {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(
+          `[handler] Raw stream finalization failed for log #${String(log.id)}:`,
+          message,
+        );
         scheduleLogFinalization({
           type: "stream-abort",
           log,
           upstreamUrl,
           elapsedMs,
-          rawStream,
+          rawStream: { type: "memory", rawStream: "" },
           hasChunks: capture.hasChunks,
           collectStreamingChunks,
           firstChunkMs,
           totalStreamMs,
         });
-        return;
-    }
+      });
   };
 
   const transform = new TransformStream<Uint8Array, Uint8Array>({
@@ -278,7 +300,7 @@ function handleStreamingResponse(
   });
 }
 
-export async function handleProxy(req: Request): Promise<Response> {
+async function handleAdmittedProxy(req: Request): Promise<Response> {
   const url = new URL(req.url);
   const parsed = parseRequestPath(req, url);
 
@@ -457,3 +479,64 @@ export async function handleProxy(req: Request): Promise<Response> {
 
   return handleStreamingResponse(upstreamRes, req, startTime, upstreamUrl, log, captureFullDetails);
 }
+
+function responseWithRuntimeLease(response: Response, lease: RuntimeRequestLease): Response {
+  if (response.body === null) {
+    lease.release();
+    return response;
+  }
+
+  const reader = response.body.getReader();
+  let released = false;
+  const release = (): void => {
+    if (released) return;
+    released = true;
+    lease.release();
+  };
+  const trackedBody = new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        const chunk = await reader.read();
+        if (chunk.done) {
+          controller.close();
+          release();
+          return;
+        }
+        controller.enqueue(chunk.value);
+      } catch (error) {
+        controller.error(error);
+        release();
+      }
+    },
+    async cancel(reason) {
+      try {
+        await reader.cancel(reason);
+      } finally {
+        release();
+      }
+    },
+  });
+
+  return new Response(trackedBody, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+  });
+}
+
+export async function handleProxy(req: Request): Promise<Response> {
+  const lease = acquireRuntimeRequest();
+  if (lease === null) {
+    return Response.json(
+      { error: "Agent Inspector is shutting down" },
+      { status: 503, headers: { "cache-control": "no-store", "retry-after": "5" } },
+    );
+  }
+
+  try {
+    return responseWithRuntimeLease(await handleAdmittedProxy(req), lease);
+  } catch (error) {
+    lease.release();
+    return await Promise.reject(error);
+  }
+}