fix(agent): enforce combined dispatch capture bound

Signed-off-by: Prekshi Vyas <prekshiv@nvidia.com>

Author: prekshivyas

src/lib/actions/sandbox/agent/passthrough-dispatch.test.ts

@@ -12,7 +12,7 @@ import {
   runAgentDispatch,
   SILENT_AGENT_DISPATCH_EXIT_CODE,
 } from "./passthrough-dispatch";
-import type { SandboxExecSignalSource } from "../exec";
+import { computeExitCode, type SandboxExecSignalSource } from "../exec";
 
 function dispatchHarness() {
   const childEvents = new EventEmitter();
@@ -79,9 +79,36 @@ describe("runAgentDispatch", () => {
 
     const result = await pending;
     expect(harness.child.kill).toHaveBeenCalledWith("SIGTERM");
-    expect(result.error).toEqual(new Error("agent stdout exceeded the 4-byte capture limit"));
+    expect(result.error).toEqual(
+      new Error("agent output exceeded the 4-byte combined capture limit"),
+    );
+    expect(computeExitCode(result)).toEqual({
+      code: 1,
+      errorMessage: "agent output exceeded the 4-byte combined capture limit",
+    });
     expect(result.stdout).toBe("");
   });
+
+  it("enforces one capture bound across stdout and stderr", async () => {
+    const harness = dispatchHarness();
+    const pending = runAgentDispatch(
+      "openshell",
+      ["sandbox", "exec", "--name", "alpha", "--", "openclaw", "agent"],
+      { maxBufferBytes: 6, stdinIsTty: false },
+      { signalSource: harness.signalSource, spawnChild: () => harness.child },
+    );
+
+    harness.stdout.emit("data", "1234");
+    harness.stderr.emit("data", "567");
+
+    const result = await pending;
+    expect(harness.child.kill).toHaveBeenCalledWith("SIGTERM");
+    expect(result.error).toEqual(
+      new Error("agent output exceeded the 6-byte combined capture limit"),
+    );
+    expect(result.stdout).toBe("1234");
+    expect(result.stderr).toBe("");
+  });
 });
 
 describe("isSilentAgentDispatch", () => {

src/lib/actions/sandbox/agent/passthrough-dispatch.ts

@@ -84,6 +84,11 @@ type AgentDispatchReadable = {
   on(event: "data", listener: (chunk: Buffer | string) => void): unknown;
 };
 
+type AgentDispatchCaptureBudget = {
+  bytes: number;
+  overflowed: boolean;
+};
+
 export type AgentDispatchChild = SandboxExecChild & {
   stderr: AgentDispatchReadable | null;
   stdout: AgentDispatchReadable | null;
@@ -116,26 +121,25 @@ const defaultAgentDispatchSpawner: AgentDispatchSpawner = (binary, args, stdio)
 
 function captureAgentDispatchStream(
   stream: AgentDispatchReadable | null,
-  streamName: "stderr" | "stdout",
   child: AgentDispatchChild,
   chunks: Buffer[],
   maxBufferBytes: number,
+  budget: AgentDispatchCaptureBudget,
   setOverflowError: (error: Error) => void,
 ): void {
-  let size = 0;
-  let overflowed = false;
   stream?.on("data", (chunk) => {
-    if (overflowed) return;
+    if (budget.overflowed) return;
     const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-    size += data.byteLength;
-    if (size > maxBufferBytes) {
-      overflowed = true;
+    const nextSize = budget.bytes + data.byteLength;
+    if (nextSize > maxBufferBytes) {
+      budget.overflowed = true;
       setOverflowError(
-        new Error(`agent ${streamName} exceeded the ${maxBufferBytes}-byte capture limit`),
+        new Error(`agent output exceeded the ${maxBufferBytes}-byte combined capture limit`),
       );
       if (child.exitCode === null && child.signalCode === null) child.kill("SIGTERM");
       return;
     }
+    budget.bytes = nextSize;
     chunks.push(data);
   });
 }
@@ -155,6 +159,7 @@ export async function runAgentDispatch(
 ): Promise<AgentDispatchResult> {
   const stderrChunks: Buffer[] = [];
   const stdoutChunks: Buffer[] = [];
+  const captureBudget: AgentDispatchCaptureBudget = { bytes: 0, overflowed: false };
   let overflowError: Error | undefined;
   const maxBufferBytes = options.maxBufferBytes ?? DEFAULT_AGENT_DISPATCH_MAX_BUFFER_BYTES;
   const spawnChild = deps.spawnChild ?? defaultAgentDispatchSpawner;
@@ -173,18 +178,18 @@ export async function runAgentDispatch(
       };
       captureAgentDispatchStream(
         child.stdout,
-        "stdout",
         child,
         stdoutChunks,
         maxBufferBytes,
+        captureBudget,
         setOverflowError,
       );
       captureAgentDispatchStream(
         child.stderr,
-        "stderr",
         child,
         stderrChunks,
         maxBufferBytes,
+        captureBudget,
         setOverflowError,
       );
       return child;

src/lib/actions/sandbox/agent/passthrough.test.ts

@@ -35,15 +35,12 @@ const isTerminalAgentMock = vi.hoisted(() =>
   vi.fn((agent: { runtime?: { kind?: string } }) => agent.runtime?.kind === "terminal"),
 );
 
-vi.mock("../exec", () => ({
+vi.mock("../exec", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../exec")>()),
   execSandbox: execMock,
   buildOpenshellExecArgs: vi.fn((_sb: string, cmd: readonly string[]) => cmd),
   wrapExecCommandWithRuntimeEnv: vi.fn((cmd: readonly string[]) => cmd),
   wrapOpenClawAgentCommandWithRuntimeEnv: vi.fn((cmd: readonly string[]) => cmd),
-  computeExitCode: vi.fn((result: { signal?: NodeJS.Signals | null; status: number | null }) => ({
-    code: result.status ?? (result.signal === "SIGTERM" ? 143 : 1),
-    errorMessage: null,
-  })),
 }));
 vi.mock("../gateway-state", () => ({ ensureLiveSandboxOrExit: ensureLiveMock }));
 vi.mock("../../../state/registry", () => ({ getSandbox: getSandboxMock }));

src/lib/core/process-exit.test.ts

@@ -9,14 +9,16 @@ describe("spawnExitCode", () => {
     ["zero status", { status: 0 }, 0],
     ["nonzero status", { status: 42 }, 42],
     ["status before signal", { status: 7, signal: "SIGTERM" }, 7],
+    ["SIGINT", { status: null, signal: "SIGINT" }, 130],
     ["SIGTERM", { status: null, signal: "SIGTERM" }, 143],
     ["SIGKILL", { status: null, signal: "SIGKILL" }, 137],
     ["missing signal", { status: null }, 1],
     ["null signal", { status: null, signal: null }, 1],
     ["unknown signal", { status: null, signal: "SIGBOGUS" as NodeJS.Signals }, 1],
-  ] satisfies Array<
-    [string, Parameters<typeof spawnExitCode>[0], number]
-  >)("normalizes %s (#5936)", (_label, result, expected) => {
-    expect(spawnExitCode(result)).toBe(expected);
-  });
+  ] satisfies Array<[string, Parameters<typeof spawnExitCode>[0], number]>)(
+    "normalizes %s (#5936)",
+    (_label, result, expected) => {
+      expect(spawnExitCode(result)).toBe(expected);
+    },
+  );
 });