Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/firefox-bidi/__serial__/codemode.test.ts

Raw
import { 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);
	});
});