@tonyclaw/agent-inspector 3.0.46 → 3.0.48

package/src/proxy/identityProxy.ts

@@ -7,6 +7,10 @@ import {
   BROWSER_RUNTIME_SCHEMA_VERSION,
   type BrowserRuntimeDeployment,
 } from "../lib/browserRuntimeContract";
+import {
+  AGENT_INSPECTOR_BACKEND_HEADER,
+  type BackendImplementation,
+} from "../lib/backendImplementation";
 import {
   AGENT_INSPECTOR_BASE_PATH_META_NAME,
   AGENT_INSPECTOR_PUBLIC_BASE_PATH_HEADER,
@@ -39,6 +43,8 @@ const CSRF_HEADER = "x-agent-inspector-csrf";
 const DEFAULT_MAX_REQUEST_BYTES = 64 * 1024 * 1024;
 const DEFAULT_REQUEST_TIMEOUT_MS = 120_000;
 const ALIAS_CONTROL_MAX_REQUEST_BYTES = 8 * 1024;
+const INSTANCE_API_MAX_REQUEST_BYTES = 64 * 1024;
+const LOCAL_CONTROL_MAX_RESPONSE_BYTES = 1024 * 1024;
 
 export const IDENTITY_PROXY_CONTROL_NAMESPACE = "/.agent-inspector";
 export const IDENTITY_PROXY_ALIAS_CONTROL_PATH = `${IDENTITY_PROXY_CONTROL_NAMESPACE}/base-path-aliases`;
@@ -480,6 +486,8 @@ async function tryServeUiAsset(
 }
 
 export type IdentityProxyOptions = {
+  /** Backend child implementation supervised behind this protected ingress. */
+  backendImplementation?: BackendImplementation;
   /** Public port to listen on. Clients point at this. */
   listenPort: number;
   /** Interface exposed to clients. Defaults are chosen by the CLI. */
@@ -514,9 +522,12 @@ export type IdentityProxyOptions = {
   aliasRegistry?: BasePathAliasRegistry;
   /** Private lifecycle identity exposed only to the owning local instance manager. */
   managedInstance?: ManagedInstanceControlOptions;
+  /** Optional Node-supervisor instance API retained when the selected backend is Rust. */
+  instanceApiHandler?: (request: Request) => Promise<Response>;
 };
 
 export type ManagedInstanceControlOptions = {
+  backend?: BackendImplementation;
   name: string;
   instanceId: string;
   launchId: string;
@@ -900,6 +911,128 @@ function readAliasControlBody(req: http.IncomingMessage): Promise<AliasControlBo
   });
 }
 
+type LocalControlBodyResult =
+  | { ok: true; body: Buffer }
+  | { ok: false; status: number; error: string };
+
+function readLocalControlBody(
+  req: http.IncomingMessage,
+  maxBytes: number,
+  timeoutMs: number,
+): Promise<LocalControlBodyResult> {
+  return new Promise((resolve) => {
+    const chunks: Buffer[] = [];
+    let receivedBytes = 0;
+    let settled = false;
+    const timer = setTimeout(() => {
+      finish({ ok: false, status: 408, error: "Instance request body timed out" });
+      req.resume();
+    }, timeoutMs);
+    const finish = (result: LocalControlBodyResult): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+    req.on("data", (chunk: unknown) => {
+      if (settled) return;
+      const buffer = toBuffer(chunk);
+      receivedBytes += buffer.byteLength;
+      if (receivedBytes > maxBytes) {
+        finish({
+          ok: false,
+          status: 413,
+          error: `Instance request body exceeds ${String(maxBytes)} bytes`,
+        });
+        req.resume();
+        return;
+      }
+      chunks.push(buffer);
+    });
+    req.on("end", () => finish({ ok: true, body: Buffer.concat(chunks) }));
+    req.on("aborted", () =>
+      finish({ ok: false, status: 400, error: "Client aborted instance request body" }),
+    );
+    req.on("error", () =>
+      finish({ ok: false, status: 400, error: "Instance request body failed" }),
+    );
+  });
+}
+
+function writeLocalControlError(
+  res: http.ServerResponse,
+  status: number,
+  error: string,
+  allowedUiOrigin: string | null,
+): void {
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store",
+    ...uiCorsHeaders(allowedUiOrigin),
+  });
+  res.end(JSON.stringify({ error }));
+}
+
+async function handleLocalInstanceApi(
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+  handler: (request: Request) => Promise<Response>,
+  upstreamPath: string,
+  requestPublicOrigin: string,
+  allowedUiOrigin: string | null,
+  maxRequestBytes: number,
+  requestTimeoutMs: number,
+): Promise<void> {
+  const body = await readLocalControlBody(
+    req,
+    Math.min(maxRequestBytes, INSTANCE_API_MAX_REQUEST_BYTES),
+    requestTimeoutMs,
+  );
+  if (!body.ok) {
+    writeLocalControlError(res, body.status, body.error, allowedUiOrigin);
+    return;
+  }
+  const method = (req.method ?? "GET").toUpperCase();
+  const headers = new Headers();
+  const contentType = firstHeader(req.headers["content-type"]);
+  if (contentType !== undefined) headers.set("content-type", contentType);
+  const request = new Request(new URL(upstreamPath, requestPublicOrigin), {
+    method,
+    headers,
+    body: method === "GET" || method === "HEAD" ? undefined : body.body.toString("utf8"),
+  });
+  let response: Response;
+  try {
+    response = await handler(request);
+  } catch {
+    writeLocalControlError(res, 503, "Instance supervisor request failed", allowedUiOrigin);
+    return;
+  }
+  const responseBody = Buffer.from(await response.arrayBuffer());
+  if (responseBody.byteLength > LOCAL_CONTROL_MAX_RESPONSE_BYTES) {
+    writeLocalControlError(
+      res,
+      502,
+      "Instance supervisor response exceeded its resource limit",
+      allowedUiOrigin,
+    );
+    return;
+  }
+  const responseHeaders: Record<string, string> = {
+    ...uiCorsHeaders(allowedUiOrigin),
+    "content-length": String(responseBody.byteLength),
+  };
+  response.headers.forEach((value, name) => {
+    const lowerName = name.toLowerCase();
+    if (!REQUEST_HOP_BY_HOP.has(lowerName) && lowerName !== "content-length") {
+      responseHeaders[lowerName] = value;
+    }
+  });
+  responseHeaders["cache-control"] = "no-store";
+  res.writeHead(response.status, responseHeaders);
+  res.end(responseBody);
+}
+
 function isUnknownRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1070,6 +1203,7 @@ function handleManagedInstanceControlRequest(
     }
     writeManagedInstanceControlResponse(res, 200, {
       schemaVersion: 1,
+      backend: managedInstance.backend ?? "typescript",
       name: managedInstance.name,
       instanceId: managedInstance.instanceId,
       launchId: managedInstance.launchId,
@@ -1483,6 +1617,19 @@ async function handleRequest(
     options.requestTimeoutMs,
     DEFAULT_REQUEST_TIMEOUT_MS,
   );
+  if (options.instanceApiHandler !== undefined && isInstanceManagementPath(upstreamPathname)) {
+    await handleLocalInstanceApi(
+      req,
+      res,
+      options.instanceApiHandler,
+      upstreamPath,
+      requestPublicOrigin,
+      allowedUiOrigin,
+      maxRequestBytes,
+      requestTimeoutMs,
+    );
+    return;
+  }
   const proxyReq = http.request(
     {
       hostname: options.upstreamHost,
@@ -1554,6 +1701,7 @@ async function handleRequest(
       for (const [name, value] of Object.entries(BASE_SECURITY_HEADERS)) {
         outHeaders[name] = value;
       }
+      outHeaders[AGENT_INSPECTOR_BACKEND_HEADER] = options.backendImplementation ?? "typescript";
       if (allowedUiOrigin !== null && isUiControlPath(upstreamPathname)) {
         outHeaders["access-control-allow-origin"] = allowedUiOrigin;
         outHeaders["access-control-expose-headers"] = "Content-Disposition";

package/src/proxy/sessionArchive.ts

@@ -278,10 +278,6 @@ export async function archiveSessionLogs(logs: readonly CapturedLog[]): Promise<
   return archivedCount;
 }
 
-export async function archiveSessionLog(log: CapturedLog): Promise<boolean> {
-  return (await archiveSessionLogs([log])) === 1;
-}
-
 function readString(row: unknown, name: string): string | null {
   const value = readProperty(row, name);
   return typeof value === "string" ? value : null;
@@ -481,7 +477,3 @@ export async function clearSessionArchives(): Promise<number> {
     return 0;
   }
 }
-
-export function _resetSessionArchiveCacheForTests(): void {
-  cachedArchiveMax = null;
-}

package/src/proxy/sqliteLogIndex.ts

@@ -605,46 +605,6 @@ export async function syncSqliteLogIndexEntries(
   }
 }
 
-export async function findSqliteLogIndexEntry(id: number): Promise<LogIndexEntry | null> {
-  const state = await getSqliteState();
-  if (state.status !== "ready") return null;
-  const row = getPrepared(state.db, "SELECT * FROM log_index WHERE id = ?", [id]);
-  return entryFromRow(row);
-}
-
-export async function listSqliteLogIndexEntries({
-  sessionId,
-  model,
-}: {
-  sessionId?: string;
-  model?: string;
-} = {}): Promise<LogIndexEntry[] | null> {
-  const state = await getSqliteState();
-  if (state.status !== "ready") return null;
-
-  const clauses: string[] = [];
-  const params: unknown[] = [];
-  if (sessionId !== undefined) {
-    clauses.push("session_id = ?");
-    params.push(sessionId);
-  }
-  if (model !== undefined) {
-    clauses.push("model = ?");
-    params.push(model);
-  }
-
-  const where = clauses.length === 0 ? "" : ` WHERE ${clauses.join(" AND ")}`;
-  const rows = allPrepared(state.db, `SELECT * FROM log_index${where} ORDER BY id ASC`, params);
-  if (rows === null) return null;
-
-  const entries: LogIndexEntry[] = [];
-  for (const row of rows) {
-    const entry = entryFromRow(row);
-    if (entry !== null) entries.push(entry);
-  }
-  return entries;
-}
-
 export async function replaceSqliteLogIndexEntries(
   entries: readonly LogIndexEntry[],
 ): Promise<boolean> {