@tonyclaw/agent-inspector 3.0.44 → 3.0.46

package/src/proxy/rawStreamCapture.ts

@@ -12,8 +12,28 @@ import {
 
 const DEFAULT_MEMORY_LIMIT_BYTES = 1024 * 1024;
 const FILE_WRITE_BATCH_BYTES = 64 * 1024;
+const DEFAULT_QUEUE_MAX_MESSAGES = 256;
+const DEFAULT_QUEUE_MAX_BYTES = 8 * 1024 * 1024;
+const DEFAULT_GLOBAL_QUEUE_MAX_MESSAGES = 4096;
+const DEFAULT_GLOBAL_QUEUE_MAX_BYTES = 64 * 1024 * 1024;
 const activeCaptures = new Set<RawStreamCapture>();
 
+export type RawStreamCaptureGapReason = "capacity-exceeded" | "pipeline-closed" | "write-failed";
+
+export type RawStreamCaptureStatus = {
+  incomplete: boolean;
+  droppedChunks: number;
+  droppedBytes: number;
+  reason: RawStreamCaptureGapReason | null;
+};
+
+export type RawStreamCaptureOptions = {
+  memoryLimitBytes?: number;
+  queueMaxMessages?: number;
+  queueMaxBytes?: number;
+  globalBudget?: RawStreamObservationBudget;
+};
+
 export type RawStreamSource =
   | {
       type: "memory";
@@ -32,6 +52,62 @@ function resolveMemoryLimitBytes(): number {
   return parsed;
 }
 
+function resolvePositiveIntegerEnv(name: string, fallback: number): number {
+  const raw = process.env[name];
+  if (raw === undefined || raw === "") return fallback;
+  const parsed = Number(raw);
+  if (!Number.isSafeInteger(parsed) || parsed < 1) return fallback;
+  return parsed;
+}
+
+function defaultQueueMaxMessages(): number {
+  return resolvePositiveIntegerEnv(
+    "AGENT_INSPECTOR_OBSERVATION_QUEUE_MESSAGES",
+    DEFAULT_QUEUE_MAX_MESSAGES,
+  );
+}
+
+function defaultQueueMaxBytes(): number {
+  return resolvePositiveIntegerEnv(
+    "AGENT_INSPECTOR_OBSERVATION_QUEUE_BYTES",
+    DEFAULT_QUEUE_MAX_BYTES,
+  );
+}
+
+export class RawStreamObservationBudget {
+  private messages = 0;
+  private bytes = 0;
+
+  constructor(
+    private readonly maxMessages: number,
+    private readonly maxBytes: number,
+  ) {}
+
+  tryAcquire(bytes: number): (() => void) | null {
+    if (this.messages + 1 > this.maxMessages || this.bytes + bytes > this.maxBytes) return null;
+    this.messages += 1;
+    this.bytes += bytes;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.messages -= 1;
+      this.bytes -= bytes;
+    };
+  }
+}
+
+const globalObservationBudget = new RawStreamObservationBudget(
+  resolvePositiveIntegerEnv(
+    "AGENT_INSPECTOR_OBSERVATION_GLOBAL_QUEUE_MESSAGES",
+    DEFAULT_GLOBAL_QUEUE_MAX_MESSAGES,
+  ),
+  resolvePositiveIntegerEnv(
+    "AGENT_INSPECTOR_OBSERVATION_GLOBAL_QUEUE_BYTES",
+    DEFAULT_GLOBAL_QUEUE_MAX_BYTES,
+  ),
+);
+
 function getRawStreamDir(): string {
   return join(getDataDir(), "raw-streams");
 }
@@ -42,6 +118,9 @@ function createRawStreamPath(): string {
 
 export class RawStreamCapture {
   private readonly memoryLimitBytes: number;
+  private readonly queueMaxMessages: number;
+  private readonly queueMaxBytes: number;
+  private readonly globalBudget: RawStreamObservationBudget;
   private chunks: string[] = [];
   private byteLength = 0;
   private filePath: string | null = null;
@@ -49,11 +128,22 @@ export class RawStreamCapture {
   private pendingFileChunks: string[] = [];
   private pendingFileBytes = 0;
   private operation = Promise.resolve();
+  private accepting = true;
   private closed = false;
   private sawChunk = false;
+  private queuedMessages = 0;
+  private queuedBytes = 0;
+  private incomplete = false;
+  private storageFailed = false;
+  private droppedChunks = 0;
+  private droppedBytes = 0;
+  private gapReason: RawStreamCaptureGapReason | null = null;
 
-  constructor(memoryLimitBytes: number = resolveMemoryLimitBytes()) {
-    this.memoryLimitBytes = memoryLimitBytes;
+  constructor(options: RawStreamCaptureOptions = {}) {
+    this.memoryLimitBytes = options.memoryLimitBytes ?? resolveMemoryLimitBytes();
+    this.queueMaxMessages = options.queueMaxMessages ?? defaultQueueMaxMessages();
+    this.queueMaxBytes = options.queueMaxBytes ?? defaultQueueMaxBytes();
+    this.globalBudget = options.globalBudget ?? globalObservationBudget;
     activeCaptures.add(this);
   }
 
@@ -61,6 +151,21 @@ export class RawStreamCapture {
     return this.sawChunk;
   }
 
+  get status(): RawStreamCaptureStatus {
+    return {
+      incomplete: this.incomplete,
+      droppedChunks: this.droppedChunks,
+      droppedBytes: this.droppedBytes,
+      reason: this.gapReason,
+    };
+  }
+
+  recordDroppedObservation(reason: RawStreamCaptureGapReason, observedBytes: number): void {
+    const safeObservedBytes =
+      Number.isSafeInteger(observedBytes) && observedBytes >= 0 ? observedBytes : 0;
+    this.recordGap(reason, safeObservedBytes, safeObservedBytes > 0);
+  }
+
   async append(text: string): Promise<void> {
     if (text === "") return;
     const next = this.operation.then(() => this.appendInternal(text));
@@ -68,7 +173,63 @@ export class RawStreamCapture {
     return next;
   }
 
+  /**
+   * Submit an observation without waiting for file I/O. Once capacity is exceeded, capture remains
+   * incomplete and all later chunks are counted as dropped so the persisted value is an honest
+   * prefix rather than a misleading stream with an unmarked hole.
+   */
+  tryAppend(text: string, observedBytes: number): boolean {
+    const safeObservedBytes =
+      Number.isSafeInteger(observedBytes) && observedBytes >= 0 ? observedBytes : 0;
+    const queuedBytes = Math.max(safeObservedBytes, Buffer.byteLength(text, "utf-8"));
+
+    if (!this.accepting || this.closed) {
+      this.recordGap("pipeline-closed", safeObservedBytes, safeObservedBytes > 0 || text !== "");
+      return false;
+    }
+    if (this.incomplete) {
+      this.recordGap("capacity-exceeded", safeObservedBytes, safeObservedBytes > 0 || text !== "");
+      return false;
+    }
+    if (text === "") return true;
+    if (
+      this.queuedMessages + 1 > this.queueMaxMessages ||
+      this.queuedBytes + queuedBytes > this.queueMaxBytes
+    ) {
+      this.recordGap("capacity-exceeded", safeObservedBytes, true);
+      return false;
+    }
+
+    const releaseGlobal = this.globalBudget.tryAcquire(queuedBytes);
+    if (releaseGlobal === null) {
+      this.recordGap("capacity-exceeded", safeObservedBytes, true);
+      return false;
+    }
+
+    this.queuedMessages += 1;
+    this.queuedBytes += queuedBytes;
+    this.operation = this.operation
+      .then(async () => {
+        if (this.storageFailed) {
+          this.recordGap("write-failed", safeObservedBytes, true);
+          return;
+        }
+        await this.appendInternal(text);
+      })
+      .catch(() => {
+        this.storageFailed = true;
+        this.recordGap("write-failed", safeObservedBytes, true);
+      })
+      .finally(() => {
+        this.queuedMessages -= 1;
+        this.queuedBytes -= queuedBytes;
+        releaseGlobal();
+      });
+    return true;
+  }
+
   async finalize(): Promise<RawStreamSource> {
+    this.accepting = false;
     const next = this.operation.then(() => this.finalizeInternal());
     this.operation = next.then(
       () => undefined,
@@ -100,14 +261,29 @@ export class RawStreamCapture {
     }
   }
 
+  private recordGap(
+    reason: RawStreamCaptureGapReason,
+    observedBytes: number,
+    countChunk: boolean,
+  ): void {
+    this.incomplete = true;
+    this.gapReason ??= reason;
+    if (countChunk) this.droppedChunks += 1;
+    this.droppedBytes += observedBytes;
+  }
+
   private async finalizeInternal(): Promise<RawStreamSource> {
     if (!this.closed) {
       this.closed = true;
       await this.flushFileBuffer();
       if (this.fileHandle !== null) {
-        await this.fileHandle.sync();
-        await this.fileHandle.close();
+        const handle = this.fileHandle;
         this.fileHandle = null;
+        try {
+          await handle.sync();
+        } finally {
+          await handle.close();
+        }
       }
     }
     if (this.filePath !== null) {
@@ -120,16 +296,21 @@ export class RawStreamCapture {
     const path = createRawStreamPath();
     assert(ensurePrivateDirectorySync(getRawStreamDir()), "Could not secure raw-stream directory");
     const handle = await open(path, "wx", PRIVATE_FILE_MODE);
-    const memoryText = this.chunks.join("");
-    if (memoryText.length > 0) await handle.write(memoryText, undefined, "utf-8");
-    if (!securePrivateFileSync(path)) {
-      await handle.close();
-      await unlink(path);
-      assert(false, "Could not secure raw-stream file");
+    let committed = false;
+    try {
+      const memoryText = this.chunks.join("");
+      if (memoryText.length > 0) await handle.write(memoryText, undefined, "utf-8");
+      assert(securePrivateFileSync(path), "Could not secure raw-stream file");
+      this.filePath = path;
+      this.fileHandle = handle;
+      this.chunks = [];
+      committed = true;
+    } finally {
+      if (!committed) {
+        await handle.close().catch(() => undefined);
+        await unlink(path).catch(() => undefined);
+      }
     }
-    this.filePath = path;
-    this.fileHandle = handle;
-    this.chunks = [];
   }
 
   private async flushFileBuffer(): Promise<void> {

package/src/proxy/runtimeAdmission.ts

@@ -1,3 +1,5 @@
+import { MAX_ACTIVE_PROXY_REQUESTS } from "../lib/resourceLimits";
+
 export type RuntimeRequestLease = {
   release: () => void;
 };
@@ -13,7 +15,7 @@ function notifyDrained(): void {
 }
 
 export function acquireRuntimeRequest(): RuntimeRequestLease | null {
-  if (!acceptingRequests) return null;
+  if (!acceptingRequests || activeRequests >= MAX_ACTIVE_PROXY_REQUESTS) return null;
   activeRequests += 1;
   let released = false;
   return {
@@ -41,8 +43,9 @@ export async function waitForRuntimeTrafficDrain(): Promise<void> {
 export function getRuntimeAdmissionState(): {
   acceptingRequests: boolean;
   activeRequests: number;
+  capacity: number;
 } {
-  return { acceptingRequests, activeRequests };
+  return { acceptingRequests, activeRequests, capacity: MAX_ACTIVE_PROXY_REQUESTS };
 }
 
 export function _resetRuntimeAdmissionForTests(): void {

package/src/proxy/runtimeHealth.ts

@@ -5,6 +5,9 @@ import { getDataDir } from "./dataDir";
 import { getFinalizerRuntimeHealth } from "./logFinalizer";
 import { ensurePrivateDirectorySync, PRIVATE_FILE_MODE } from "./privateDataPath";
 import { isSqliteLogIndexReady } from "./sqliteLogIndex";
+import { recoverCapturedLogStorage } from "./jsonlRecovery";
+import { resolveLogDir } from "./logger";
+import { loadIndex } from "./logIndex";
 
 const DEFAULT_CACHE_MS = 2_000;
 const DEFAULT_MIN_DISK_HEADROOM_BYTES = 256 * 1024 * 1024;
@@ -118,7 +121,17 @@ function checkQueue(): Promise<ReadinessCheckLevel> {
 }
 
 async function checkIndex(): Promise<ReadinessCheckLevel> {
-  return (await isSqliteLogIndexReady()) ? "ok" : "degraded";
+  const recovery = await recoverCapturedLogStorage(resolveLogDir());
+  if (recovery.level === "unavailable") return "unavailable";
+
+  try {
+    await loadIndex();
+  } catch {
+    return "unavailable";
+  }
+
+  const sqliteReady = await isSqliteLogIndexReady();
+  return recovery.level === "degraded" || !sqliteReady ? "degraded" : "ok";
 }
 
 function checkShutdown(): Promise<ReadinessCheckLevel> {

package/src/proxy/runtimeShutdown.ts

@@ -1,11 +1,25 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+import {
+  parseManagedInstanceShutdownMessage,
+  readManagedInstanceLaunch,
+} from "../lib/managedInstance";
 import { closeLogFinalizerWorkers, forceCloseLogFinalizerWorkers } from "./logFinalizer";
 import { flushIndex } from "./logIndex";
 import { flushApplicationLog, flushLogBuffer } from "./logger";
 import { flushAllRawStreamCaptures } from "./rawStreamCapture";
 import { setRuntimeShuttingDown } from "./runtimeHealth";
 import { stopRuntimeAdmission, waitForRuntimeTrafficDrain } from "./runtimeAdmission";
-import { createShutdownCoordinator, createShutdownSignalHandler } from "./shutdownCoordinator";
+import {
+  createShutdownCoordinator,
+  createShutdownSignalHandler,
+  type ShutdownResult,
+} from "./shutdownCoordinator";
 import { destroyAllSessionProcesses } from "./sessionProcess";
+import {
+  beginEcosystemTaskShutdown,
+  forceCloseEcosystemTasks,
+  waitForEcosystemTasksToClose,
+} from "./ecosystemTasks";
 import { flushSessionTasks } from "./sessionRuntime";
 import { closeSqliteLogIndex } from "./sqliteLogIndex";
 import { flushSessionArchiveWrites } from "./store";
@@ -36,6 +50,7 @@ async function flushPersistence(): Promise<void> {
 }
 
 async function closeResources(): Promise<void> {
+  await waitForEcosystemTasksToClose();
   await closeLogFinalizerWorkers();
   destroyAllSessionProcesses();
   closeSqliteLogIndex();
@@ -43,6 +58,7 @@ async function closeResources(): Promise<void> {
 }
 
 function forceCloseResources(): void {
+  forceCloseEcosystemTasks();
   forceCloseLogFinalizerWorkers();
   destroyAllSessionProcesses();
   closeSqliteLogIndex();
@@ -50,7 +66,10 @@ function forceCloseResources(): void {
 
 const runtimeShutdownCoordinator = createShutdownCoordinator(
   {
-    markShuttingDown: () => setRuntimeShuttingDown(true),
+    markShuttingDown: () => {
+      setRuntimeShuttingDown(true);
+      beginEcosystemTaskShutdown();
+    },
     stopAdmission: stopRuntimeAdmission,
     drainTraffic: waitForRuntimeTrafficDrain,
     drainFinalizers,
@@ -62,9 +81,72 @@ const runtimeShutdownCoordinator = createShutdownCoordinator(
 );
 
 let signalHandlersInstalled = false;
+let managedInstanceHandlersInstalled = false;
+
+export type ManagedRuntimeShutdownController = {
+  handleDisconnect: () => void;
+  handleMessage: (message: unknown) => void;
+};
+
+type ManagedRuntimeShutdownControllerOptions = {
+  controlToken: string;
+  shutdown: () => Promise<ShutdownResult>;
+  exit: (code: number) => void;
+};
+
+function managedControlTokensMatch(received: string, expected: string): boolean {
+  if (received.length === 0 || expected.length === 0) return false;
+  const receivedDigest = createHash("sha256").update(received).digest();
+  const expectedDigest = createHash("sha256").update(expected).digest();
+  return timingSafeEqual(receivedDigest, expectedDigest);
+}
+
+export function createManagedRuntimeShutdownController(
+  options: ManagedRuntimeShutdownControllerOptions,
+): ManagedRuntimeShutdownController {
+  let shutdownRequested = false;
+  const requestShutdown = (): void => {
+    if (shutdownRequested) return;
+    shutdownRequested = true;
+    void options.shutdown().then(
+      (result) => options.exit(result.forced ? 1 : 0),
+      () => options.exit(1),
+    );
+  };
+  return {
+    handleDisconnect: requestShutdown,
+    handleMessage: (message) => {
+      const parsed = parseManagedInstanceShutdownMessage(message);
+      if (
+        parsed === null ||
+        !managedControlTokensMatch(parsed.controlToken, options.controlToken)
+      ) {
+        return;
+      }
+      requestShutdown();
+    },
+  };
+}
+
+/** Install lifecycle cleanup for the private supervisor/runtime IPC channel. */
+export function installRuntimeManagedInstanceShutdownHandlers(): void {
+  if (managedInstanceHandlersInstalled) return;
+  const launchResult = readManagedInstanceLaunch(process.env);
+  if (launchResult.kind !== "managed") return;
+  managedInstanceHandlersInstalled = true;
+  const controller = createManagedRuntimeShutdownController({
+    controlToken: launchResult.launch.controlToken,
+    shutdown: async () => await runtimeShutdownCoordinator.shutdown("manual"),
+    exit: (code) => process.exit(code),
+  });
+  process.on("message", controller.handleMessage);
+  process.once("disconnect", controller.handleDisconnect);
+  if (process.connected === false) process.nextTick(controller.handleDisconnect);
+}
 
 /** Install once in the server runtime; the CLI supervisor owns its own public-ingress signals. */
 export function installRuntimeShutdownSignalHandlers(): void {
+  installRuntimeManagedInstanceShutdownHandlers();
   if (signalHandlersInstalled) return;
   signalHandlersInstalled = true;
   const handleSignal = createShutdownSignalHandler(runtimeShutdownCoordinator, (result) => {

package/src/proxy/schemas.ts

@@ -1,9 +1,15 @@
 import { z } from "zod";
 
-export { CapturedLogSchema, JsonValueSchema, StreamingChunkSchema } from "../contracts";
+export {
+  CaptureIncompleteReasonSchema,
+  CapturedLogSchema,
+  JsonValueSchema,
+  StreamingChunkSchema,
+} from "../contracts";
 export type {
   CapturedLog,
   ApiFormat,
+  CaptureIncompleteReason,
   JsonValue,
   StreamingChunk,
   TokenUsage,

package/src/proxy/sessionArchive.ts

@@ -40,6 +40,7 @@ ON CONFLICT(id) DO UPDATE SET
 `;
 
 let didLogUnavailable = false;
+let cachedArchiveMax: { root: string; maxId: number } | null = null;
 
 export function getSessionArchiveRoot(): string {
   return join(resolveLogDir(), SESSION_ARCHIVE_DIR);
@@ -236,23 +237,49 @@ async function openSessionArchiveDb(filePath: string, create: boolean): Promise<
   }
 }
 
-export async function archiveSessionLog(log: CapturedLog): Promise<boolean> {
-  const sessionId = log.sessionId;
-  if (sessionId === null || sessionId.trim().length === 0) return false;
+export async function archiveSessionLogs(logs: readonly CapturedLog[]): Promise<number> {
+  const bySession = new Map<string, CapturedLog[]>();
+  for (const log of logs) {
+    const sessionId = log.sessionId;
+    if (sessionId === null || sessionId.trim().length === 0) continue;
+    const existing = bySession.get(sessionId);
+    if (existing === undefined) bySession.set(sessionId, [log]);
+    else existing.push(log);
+  }
 
-  const db = await openSessionArchiveDb(getSessionArchivePath(sessionId), true);
-  if (db === null) return false;
+  let archivedCount = 0;
+  for (const [sessionId, sessionLogs] of bySession) {
+    const db = await openSessionArchiveDb(getSessionArchivePath(sessionId), true);
+    if (db === null || !execSql(db, "BEGIN IMMEDIATE")) {
+      if (db !== null) closeDatabase(db);
+      continue;
+    }
 
-  try {
-    return runPrepared(db, UPSERT_SQL, [
-      log.id,
-      sessionId,
-      JSON.stringify(log),
-      new Date().toISOString(),
-    ]);
-  } finally {
-    closeDatabase(db);
+    let committed = false;
+    try {
+      const updatedAt = new Date().toISOString();
+      const archived = sessionLogs.every((log) =>
+        runPrepared(db, UPSERT_SQL, [log.id, sessionId, JSON.stringify(log), updatedAt]),
+      );
+      if (archived && execSql(db, "COMMIT")) {
+        committed = true;
+        archivedCount += sessionLogs.length;
+        if (cachedArchiveMax?.root === getSessionArchiveRoot()) {
+          for (const log of sessionLogs) {
+            cachedArchiveMax.maxId = Math.max(cachedArchiveMax.maxId, log.id);
+          }
+        }
+      }
+    } finally {
+      if (!committed) void execSql(db, "ROLLBACK");
+      closeDatabase(db);
+    }
   }
+  return archivedCount;
+}
+
+export async function archiveSessionLog(log: CapturedLog): Promise<boolean> {
+  return (await archiveSessionLogs([log])) === 1;
 }
 
 function readString(row: unknown, name: string): string | null {
@@ -343,6 +370,36 @@ async function listArchiveDatabasePaths(): Promise<string[]> {
   }
 }
 
+/**
+ * Return the highest ID retained by an authoritative session archive. The global SQLite index is a
+ * rebuildable projection and must never influence ID allocation, while archive IDs must remain
+ * reserved even after their corresponding global JSONL records have aged out.
+ */
+export async function getSessionArchiveMaxLogId(): Promise<number> {
+  const root = getSessionArchiveRoot();
+  if (cachedArchiveMax?.root === root) return cachedArchiveMax.maxId;
+
+  let maxId = 0;
+  const archivePaths = await listArchiveDatabasePaths();
+  for (const archivePath of archivePaths) {
+    const db = await openSessionArchiveDb(archivePath, false);
+    if (db === null) continue;
+
+    try {
+      const rows = allPrepared(db, "SELECT MAX(id) AS max_id FROM session_logs");
+      const archiveMax = readNumber(rows[0], "max_id");
+      if (archiveMax !== null && Number.isSafeInteger(archiveMax) && archiveMax >= 0) {
+        maxId = Math.max(maxId, archiveMax);
+      }
+    } finally {
+      closeDatabase(db);
+    }
+  }
+
+  cachedArchiveMax = { root, maxId };
+  return maxId;
+}
+
 export async function findArchivedLogById(id: number): Promise<CapturedLog | null> {
   const archivePaths = await listArchiveDatabasePaths();
   for (const archivePath of archivePaths) {
@@ -405,6 +462,8 @@ export async function deleteArchivedLogsByIds(ids: ReadonlySet<number>): Promise
     }
   }
 
+  if (removedIds.size > 0) cachedArchiveMax = null;
+
   return removedIds;
 }
 
@@ -415,9 +474,14 @@ export async function clearSessionArchives(): Promise<number> {
   const archivePaths = await listArchiveDatabasePaths();
   try {
     await rm(root, { recursive: true, force: true });
+    cachedArchiveMax = null;
     return archivePaths.length;
   } catch (err) {
     logger.warn("[sessionArchive] Failed to clear session archives:", String(err));
     return 0;
   }
 }
+
+export function _resetSessionArchiveCacheForTests(): void {
+  cachedArchiveMax = null;
+}

package/src/proxy/sessionInfo.ts

@@ -1,5 +1,6 @@
 import type { SessionInfo, SessionLogSummary, SessionTokenUsage } from "../lib/sessionInfoContract";
-import { getConfiguredBasePath, withBasePath } from "../lib/basePath";
+import { withBasePath } from "../lib/basePath";
+import { getPublicBasePath } from "../lib/publicBasePathContext";
 import { getSessionPath } from "../lib/sessionUrl";
 import type { CapturedLog } from "./schemas";
 import type { SessionSnapshot } from "./sessionSupervisor";
@@ -106,14 +107,14 @@ function buildAbsoluteUrl(baseUrl: string, path: string): string {
 
 function buildApiPath(sessionId: string): string {
   return buildRelativePath(
-    withBasePath("/api/sessions", getConfiguredBasePath(process.env)),
+    withBasePath("/api/sessions", getPublicBasePath()),
     new URLSearchParams({ sessionId }),
   );
 }
 
 function buildCompactLogsPath(sessionId: string): string {
   return buildRelativePath(
-    withBasePath("/api/logs", getConfiguredBasePath(process.env)),
+    withBasePath("/api/logs", getPublicBasePath()),
     new URLSearchParams({ compact: "1", sessionId }),
   );
 }
@@ -211,7 +212,7 @@ export function buildSessionInfo(input: BuildSessionInfoInput): SessionInfo {
   const queuedTasks = input.snapshot?.queuedTasks ?? 0;
   const runningTasks = input.snapshot?.runningTasks ?? 0;
   const lastTaskError = normalizeString(input.snapshot?.lastTaskError);
-  const inspectorPath = getSessionPath(input.sessionId, getConfiguredBasePath(process.env));
+  const inspectorPath = getSessionPath(input.sessionId, getPublicBasePath());
   const apiPath = buildApiPath(input.sessionId);
   const compactLogsPath = buildCompactLogsPath(input.sessionId);
   const latestLogs = summaries.slice(0, latestLogLimit).map((summary, index) => ({