The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
import { createHash } from "node:crypto";
import { access, readdir } from "node:fs/promises";
import { tmpdir } from "node:os";
import { describe, expect, it, vi } from "vitest";
import { captureRunnerApiResponse } from "./runner-api-response.js";
import { acquireRunnerApiResponseSlot, runnerApiCompanyCaptureMaxBytes, RUNNER_API_RESPONSE_MAX_BYTES } from "./runner-api-response-limits.js";
const controller = () => new AbortController();
describe("streamed API response capture", () => {
it("rejects an oversized Content-Length before reading or reserving disk", async () => {
let cancelled = false;
let reserved = false;
const abort = controller();
const response = new Response(new ReadableStream({ cancel() { cancelled = true; } }), { headers: { "content-length": String(RUNNER_API_RESPONSE_MAX_BYTES + 1) } });
await expect(captureRunnerApiResponse(response, 24 * 1024, abort, 1000, undefined, {
beforeSpill: async () => { reserved = true; },
})).rejects.toMatchObject({ code: "api_response_too_large" });
expect(cancelled).toBe(true);
expect(abort.signal.aborted).toBe(true);
expect(reserved).toBe(false);
});
it.each([undefined, "1"])("counts streamed bytes with Content-Length %s and removes partial files", async contentLength => {
const before = new Set(await readdir(tmpdir()));
let cancelled = false;
let reserved = 0;
const response = new Response(new ReadableStream({
pull(target) { target.enqueue(Buffer.alloc(4096)); },
cancel() { cancelled = true; },
}), { headers: contentLength ? { "content-length": contentLength } : {} });
await expect(captureRunnerApiResponse(response, 4096, controller(), 1000, undefined, {
maxBytes: 16 * 1024,
beforeSpill: async () => { reserved++; },
})).rejects.toMatchObject({ code: "api_response_too_large" });
expect(cancelled).toBe(true);
expect(reserved).toBe(1);
expect((await readdir(tmpdir())).filter(name => name.startsWith("paperclip-api-response-") && !before.has(name))).toEqual([]);
});
it("accepts exactly the capture limit", async () => {
const captured = await captureRunnerApiResponse(new Response(Buffer.alloc(8192)), 4096, controller(), 1000, undefined, { maxBytes: 8192 });
try { expect(captured.byteSize).toBe(8192); }
finally { await captured.dispose(); }
});
it("stops an active endless stream at the total deadline", async () => {
let cancelled = false;
const response = new Response(new ReadableStream({
async pull(target) {
await new Promise(resolve => setTimeout(resolve, 5));
if (!cancelled) target.enqueue(Buffer.alloc(4096));
},
cancel() { cancelled = true; },
}));
await expect(captureRunnerApiResponse(response, 4096, controller(), 1000, undefined, { deadlineMs: 30 })).rejects.toMatchObject({ code: "api_response_timeout" });
expect(cancelled).toBe(true);
});
it("spills a chunked response and reads only requested bytes, preserving its digest", async () => {
const chunk = Buffer.alloc(64 * 1024, 65);
const digest = createHash("sha256");
let emitted = 0;
const response = new Response(new ReadableStream({
pull(target) {
if (emitted++ === 200) return target.close();
digest.update(chunk);
target.enqueue(chunk);
},
}));
const captured = await captureRunnerApiResponse(response, 24 * 1024, controller(), 1000);
expect(Buffer.isBuffer(captured.body)).toBe(false);
if (Buffer.isBuffer(captured.body)) throw new Error("Expected a file");
const path = captured.body.path;
try {
expect(captured.body).toMatchObject({ byteSize: 200 * chunk.length, sha256: digest.digest("hex") });
expect(await captured.read(11 * 1024 * 1024, 4)).toEqual(Buffer.from("AAAA"));
expect(await captured.read(captured.byteSize, 4)).toHaveLength(0);
} finally { await captured.dispose(); }
await expect(access(path)).rejects.toThrow();
});
it("keeps small bodies inline", async () => {
const captured = await captureRunnerApiResponse(new Response("small"), 24 * 1024, controller(), 1000);
try { expect(captured.body).toEqual(Buffer.from("small")); }
finally { await captured.dispose(); }
});
it("stops a long capture when its run loses authority", async () => {
let checks = 0;
let cancelled = false;
const response = new Response(new ReadableStream({
pull(target) { target.enqueue(Buffer.alloc(64 * 1024)); },
cancel() { cancelled = true; },
}));
await expect(captureRunnerApiResponse(response, 24 * 1024, controller(), 1000, async () => {
if (++checks === 2) throw new Error("run stopped");
})).rejects.toThrow("run stopped");
expect(cancelled).toBe(true);
expect(checks).toBe(2);
});
it("allows active downloads longer than the idle timeout", async () => {
let chunks = 0;
const response = new Response(new ReadableStream({
async pull(target) {
await new Promise(resolve => setTimeout(resolve, 20));
if (chunks++ === 5) target.close();
else target.enqueue(Buffer.from("a"));
},
}));
const captured = await captureRunnerApiResponse(response, 24 * 1024, controller(), 100);
try { expect(captured.body).toEqual(Buffer.from("aaaaa")); }
finally { await captured.dispose(); }
});
it("cancels stalled bodies and aborts the HTTP request", async () => {
let cancelled = false;
const response = new Response(new ReadableStream({ cancel() { cancelled = true; } }));
const abort = controller();
await expect(captureRunnerApiResponse(response, 24 * 1024, abort, 10)).rejects.toThrow("timed out");
expect(cancelled).toBe(true);
expect(abort.signal.aborted).toBe(true);
});
});
describe("large response concurrency", () => {
it("only accepts finite positive operator quotas, never unlimited settings", () => {
try {
for (const value of ["0", "-1", "Infinity", "NaN", "1", "9007199254740992"]) {
vi.stubEnv("PAPERCLIP_RUNNER_API_COMPANY_CAPTURE_MAX_BYTES", value);
expect(runnerApiCompanyCaptureMaxBytes()).toBe(20 * RUNNER_API_RESPONSE_MAX_BYTES);
}
vi.stubEnv("PAPERCLIP_RUNNER_API_COMPANY_CAPTURE_MAX_BYTES", String(2 * RUNNER_API_RESPONSE_MAX_BYTES));
expect(runnerApiCompanyCaptureMaxBytes()).toBe(2 * RUNNER_API_RESPONSE_MAX_BYTES);
} finally { vi.unstubAllEnvs(); }
});
it("limits each company and the server and releases slots idempotently", () => {
const releases: Array<() => void> = [];
try {
releases.push(acquireRunnerApiResponseSlot("a"), acquireRunnerApiResponseSlot("a"));
expect(() => acquireRunnerApiResponseSlot("a")).toThrow("busy");
releases.push(acquireRunnerApiResponseSlot("b"), acquireRunnerApiResponseSlot("b"));
expect(() => acquireRunnerApiResponseSlot("c")).toThrow("busy");
releases[0](); releases[0]();
releases.push(acquireRunnerApiResponseSlot("c"));
expect(() => acquireRunnerApiResponseSlot("d")).toThrow("busy");
} finally { for (const release of releases) release(); }
acquireRunnerApiResponseSlot("a")();
});
});