repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/firefox-bidi/__serial__/codemode.test.ts
Rawimport { EventEmitter } from "node:events";
import { readFile } from "node:fs/promises";
import { PassThrough } from "node:stream";
import { fauxAssistantMessage, fauxToolCall } from "@earendil-works/pi-ai";
import { createCodemodeExtension } from "@earendil-works/pi-coding-agent";
import { Type } from "typebox";
import { Value } from "typebox/value";
import { afterEach, describe, expect, it, vi } from "vitest";
import {
createPiSession,
type PiSession,
} from "../../../test/fixture/create-pi-session.ts";
import firefoxExtension from "../index.ts";
const { spawnMock } = vi.hoisted(() => ({ spawnMock: vi.fn() }));
vi.mock("node:child_process", async (original) => ({
...(await original<typeof import("node:child_process")>()),
spawn: spawnMock,
}));
const png =
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=";
let fixture: PiSession | undefined;
let captured: unknown;
let nativeError = false;
let held: (() => void) | undefined;
class Socket {
static OPEN = 1;
static sent: string[] = [];
readyState = 1;
onopen?: () => void;
onclose?: () => void;
onmessage?: (message: { data: string }) => void;
constructor(_url: string) {
queueMicrotask(() => this.onopen?.());
}
close() {
this.readyState = 3;
this.onclose?.();
}
send(text: string) {
const frame = JSON.parse(text);
Socket.sent.push(frame.method);
if (frame.method === "Held.command") {
held?.();
return;
}
const reply =
frame.method === "Bad.command"
? {
id: frame.id,
type: "error",
error: "unknown command",
message: "deliberate protocol failure",
}
: {
id: frame.id,
type: "success",
result:
frame.method === "session.new"
? {
sessionId: "fixture-session",
capabilities: { browserName: "fixture" },
}
: frame.method === "browsingContext.captureScreenshot"
? { data: png }
: {
value: frame.method.startsWith("Large.")
? "x".repeat(80_000)
: frame.method,
},
};
queueMicrotask(() => this.onmessage?.({ data: JSON.stringify(reply) }));
}
}
afterEach(async () => {
await fixture?.dispose();
fixture = undefined;
vi.restoreAllMocks();
vi.unstubAllGlobals();
});
async function start() {
captured = undefined;
nativeError = false;
held = undefined;
Socket.sent = [];
spawnMock.mockReset().mockImplementation(() => {
const emitter = new EventEmitter();
const child = Object.assign(emitter, {
exitCode: null as number | null,
signalCode: null as string | null,
stdout: new PassThrough(),
stderr: new PassThrough(),
kill() {
this.exitCode = 0;
emitter.emit("exit", 0);
return true;
},
});
queueMicrotask(() =>
child.stderr.write("WebDriver BiDi listening on ws://127.0.0.1:9999\n"),
);
return child;
});
vi.stubGlobal("WebSocket", Socket);
fixture = await createPiSession({
extensionFactories: [
firefoxExtension,
createCodemodeExtension(),
(pi) => {
pi.registerTool({
name: "capture",
label: "Capture fixture",
description: "Capture test data",
exposure: "codemode",
parameters: Type.Object({ value: Type.Unknown() }),
async execute(_id, { value }) {
captured = value;
return { content: [], details: {} };
},
});
},
],
userSettings: { defaultTools: ["+codemode"] },
env: { FIREFOX_BIN: process.execPath },
});
for (const key of ["TMPDIR", "TMP", "TEMP"]) process.env[key] = fixture.cwd;
fixture.session.subscribe((event) => {
if (
event.type === "tool_execution_end" &&
event.toolName === "firefox_bidi"
)
nativeError = event.isError;
});
expect(fixture.errors).toEqual([]);
}
async function execute(code: string): Promise<Record<string, any>> {
if (!fixture) throw new Error("Missing fixture");
fixture.setResponses([
fauxAssistantMessage(fauxToolCall("codemode", { code }), {
stopReason: "toolUse",
}),
fauxAssistantMessage("DONE"),
]);
await fixture.session.prompt(
"Exercise fake process and fake BiDi socket only.",
);
const result = fixture.session.messages.findLast(
(message) =>
message.role === "toolResult" && message.toolName === "codemode",
);
if (result?.role !== "toolResult") throw new Error("Missing codemode result");
expect(result.isError, JSON.stringify(result.content)).toBe(false);
expect(captured, JSON.stringify(result.content)).toBeDefined();
return captured as Record<string, any>;
}
describe("Firefox structured codemode contract", () => {
it("returns session metadata and filterable raw replies without text parsing", async () => {
await start();
const data = await execute(
'const r=await tools.firefox_bidi({frames:[{method:"session.new",params:{capabilities:{}}},{method:"script.evaluate"}]}); await tools.capture({value:{reply:r,selected:r.responses.filter(x=>x.result.value).map(x=>x.result.value)}});',
);
expect(data["selected"]).toEqual(["script.evaluate"]);
expect(data["reply"]).toMatchObject({
outcome: "ok",
session: { sessionId: "fixture-session" },
});
const schema =
fixture!.extensions[0]!.tools.get("firefox_bidi")!.definition
.outputSchema!;
expect(Value.Check(schema, data["reply"])).toBe(true);
});
it("reports protocol errors as partial data while preserving later valid replies", async () => {
await start();
const data = await execute(
'const r=await tools.firefox_bidi({frames:[{method:"Bad.command"},{method:"Later.valid"}]}); await tools.capture({value:r});',
);
expect(data["outcome"]).toBe("partial");
expect(data["responses"][0]).toMatchObject({
type: "error",
message: "deliberate protocol failure",
});
expect(data["responses"][1]).toMatchObject({
type: "success",
result: { value: "Later.valid" },
});
expect(nativeError).toBe(true);
});
it("retains all omitted replies in quota-accounted full-payload recovery", async () => {
await start();
const data = await execute(
'const r=await tools.firefox_bidi({frames:[{method:"Large.first"},{method:"Large.second"},{method:"Later.third"}]}); await tools.capture({value:r});',
);
expect(data).toMatchObject({
outcome: "ok",
truncated: true,
responseCount: 3,
});
expect(JSON.stringify(data).length).toBeLessThan(4096);
const full = JSON.parse(
await readFile(String(data["payloadSpool"]), "utf8"),
);
expect(full.responses[0].result.value).toHaveLength(80_000);
expect(full.responses[1].result.value).toHaveLength(80_000);
expect(full.responses[2].result.value).toBe("Later.third");
});
it("preserves raw screenshot bytes for codemode image consumers", async () => {
await start();
const data = await execute(
'const r=await tools.firefox_bidi({frames:[{method:"browsingContext.captureScreenshot",params:{context:"fixture"}}]}); await tools.capture({value:{data:r.responses[0].result.data}});',
);
expect(data["data"]).toBe(png);
});
it("aborts a held frame and tears down only its owned fake process", async () => {
await start();
let entered!: () => void;
const started = new Promise<void>((resolve) => {
entered = resolve;
});
held = entered;
fixture!.setResponses([
fauxAssistantMessage(
fauxToolCall("codemode", {
code: 'return await tools.firefox_bidi({frames:[{method:"Held.command"},{method:"Never.sent"}]});',
}),
{ stopReason: "toolUse" },
),
fauxAssistantMessage("DONE"),
]);
const running = fixture!.session.prompt("Cancel controlled BiDi request.");
await Promise.race([
started,
running.then(() => {
throw new Error("Frame never entered");
}),
]);
await fixture!.session.abort();
await running;
expect(Socket.sent).not.toContain("Never.sent");
const child = spawnMock.mock.results[0]!.value;
await fixture!.dispose();
fixture = undefined;
expect(child.exitCode).toBe(0);
});
});