146 lines
4.3 KiB
TypeScript
146 lines
4.3 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import { test } from "node:test";
|
|
import {
|
|
parseScriptAssignmentPayload,
|
|
runScriptSandbox,
|
|
ScriptRequestBudget,
|
|
validateScriptIpcEnvelope,
|
|
} from "./script-runtime.ts";
|
|
|
|
function run(
|
|
source: string,
|
|
overrides: Partial<Parameters<typeof runScriptSandbox>[0]> = {},
|
|
) {
|
|
const abort = new AbortController();
|
|
return runScriptSandbox({
|
|
source,
|
|
args: undefined,
|
|
cwd: process.cwd(),
|
|
signal: abort.signal,
|
|
onAssign: async (role, prompt) => ({
|
|
ok: true,
|
|
output: `${role}:${prompt}`,
|
|
}),
|
|
onStage: () => {},
|
|
...overrides,
|
|
});
|
|
}
|
|
|
|
test("script sandbox exposes only stage, assign, parallel, and immutable args", async () => {
|
|
const stages: string[] = [];
|
|
const result = await run(
|
|
`
|
|
stage("Audit");
|
|
const replies = await parallel([
|
|
() => assign("review", "one"),
|
|
() => assign("review", "two"),
|
|
], { concurrency: 99 });
|
|
return {
|
|
replies: replies.map((reply) => reply.output),
|
|
processType: typeof process,
|
|
requireType: typeof require,
|
|
fetchType: typeof fetch,
|
|
nestedArgsFrozen: Object.isFrozen(args.nested),
|
|
};
|
|
`,
|
|
{
|
|
args: { nested: { value: "immutable" } },
|
|
onStage: (title) => stages.push(title),
|
|
},
|
|
);
|
|
assert.deepEqual(result, {
|
|
replies: ["review:one", "review:two"],
|
|
processType: "undefined",
|
|
requireType: "undefined",
|
|
fetchType: "undefined",
|
|
nestedArgsFrozen: true,
|
|
});
|
|
assert.deepEqual(stages, ["Audit"]);
|
|
});
|
|
|
|
test("script sandbox rejects unawaited assignments and synchronous loops", async () => {
|
|
let calls = 0;
|
|
await assert.rejects(
|
|
run(`assign("review", "orphan"); return "done";`, {
|
|
onAssign: async () => {
|
|
calls++;
|
|
return { ok: true, output: "unexpected" };
|
|
},
|
|
}),
|
|
/unawaited assign/,
|
|
);
|
|
assert.equal(calls, 0);
|
|
await assert.rejects(run(`while (true) {}`), /timed out/);
|
|
});
|
|
|
|
test("script cancellation aborts active assignments and terminates execution", async () => {
|
|
const controller = new AbortController();
|
|
let startedResolve: (() => void) | undefined;
|
|
const started = new Promise<void>((resolve) => {
|
|
startedResolve = resolve;
|
|
});
|
|
let requestAborted = false;
|
|
const pending = run(`return await assign("review", "pending");`, {
|
|
signal: controller.signal,
|
|
onAssign: async (_role, _prompt, signal) => {
|
|
startedResolve?.();
|
|
await new Promise<void>((resolve) => {
|
|
signal.addEventListener(
|
|
"abort",
|
|
() => {
|
|
requestAborted = true;
|
|
resolve();
|
|
},
|
|
{ once: true },
|
|
);
|
|
});
|
|
return { ok: false, output: "", error: "Assignment was aborted" };
|
|
},
|
|
});
|
|
await started;
|
|
controller.abort(new Error("cancel fixture"));
|
|
await assert.rejects(pending, /Script was aborted/);
|
|
assert.equal(requestAborted, true);
|
|
});
|
|
|
|
test("script IPC rejects unauthenticated, malformed, oversized, duplicate, and over-budget requests", () => {
|
|
assert.throws(
|
|
() => validateScriptIpcEnvelope({ token: "wrong", kind: "assign" }, "right"),
|
|
/invalid IPC message/,
|
|
);
|
|
assert.throws(() => parseScriptAssignmentPayload("{"), /malformed assignment JSON/);
|
|
assert.throws(
|
|
() => parseScriptAssignmentPayload("x".repeat(512 * 1024 + 1)),
|
|
/oversized assignment request/,
|
|
);
|
|
assert.throws(
|
|
() => parseScriptAssignmentPayload(JSON.stringify({ id: 1, role: "", prompt: "x" })),
|
|
/invalid assignment request/,
|
|
);
|
|
const duplicate = new ScriptRequestBudget();
|
|
duplicate.accept(1);
|
|
assert.throws(() => duplicate.accept(1), /duplicate assignment request/);
|
|
const budget = new ScriptRequestBudget();
|
|
for (let id = 1; id <= 32; id++) budget.accept(id);
|
|
assert.throws(() => budget.accept(33), /request budget/);
|
|
});
|
|
|
|
test("script stage updates and total runtime are bounded", async () => {
|
|
await assert.rejects(
|
|
run(`for (let index = 0; index < 65; index++) stage("flood-" + index);`),
|
|
/stage update budget/,
|
|
);
|
|
await assert.rejects(
|
|
run(`while (true) { await Promise.resolve(); }`, { runtimeTimeoutMs: 20 }),
|
|
/wall-clock time limit/,
|
|
);
|
|
});
|
|
|
|
test("script source and args are bounded", async () => {
|
|
await assert.rejects(run("x".repeat(512 * 1024 + 1)), /source exceeds/);
|
|
await assert.rejects(
|
|
run("return null", { args: "x".repeat(256 * 1024 + 1) }),
|
|
/args exceed/,
|
|
);
|
|
});
|