repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/canvas/__serial__/browser-sync.test.ts
Rawimport { type ChildProcess, spawn } from "node:child_process";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { delimiter, dirname, join } from "node:path";
import { fileURLToPath } from "node:url";
import { fauxAssistantMessage } from "@earendil-works/pi-ai";
import { expect, it } from "vitest";
import {
createPiSession,
type PiSession,
} from "../../../test/fixture/create-pi-session.ts";
import { findChromium, openCdp } from "../src/layout.ts";
import type { CanvasState } from "../src/store.ts";
async function until(
check: () => Promise<boolean>,
label: string,
): Promise<void> {
const deadline = Date.now() + 10000;
while (Date.now() < deadline) {
if (await check()) return;
await new Promise((resolve) => setTimeout(resolve, 40));
}
throw new Error(`Browser proof timed out: ${label}`);
}
async function stop(browser: ChildProcess): Promise<void> {
if (browser.exitCode !== null || browser.signalCode !== null) return;
await new Promise<void>((resolve) => {
const timer = setTimeout(() => {
browser.kill("SIGKILL");
}, 2000);
browser.once("exit", () => {
clearTimeout(timer);
resolve();
});
browser.kill("SIGTERM");
});
}
it.runIf(process.env["PI_CANVAS_NATIVE_TESTS"] === "1")(
"replays frozen-viewer agent commits with separate Undo and protects an unsent draft on resume",
async () => {
const executable = await findChromium();
const profile = await mkdtemp(join(tmpdir(), "pi-canvas-viewer-proof-"));
let pi: PiSession | undefined;
let browser: ChildProcess | undefined;
let cdp: Awaited<ReturnType<typeof openCdp>> | undefined;
try {
pi = await createPiSession({
extensionPaths: [
fileURLToPath(
new URL("../../../dist/canvas/index.ts", import.meta.url),
),
],
env: { PATH: "/canvas-test-no-executables", TERMUX_VERSION: undefined },
responses: Array.from({ length: 30 }, () => fauxAssistantMessage("")),
});
const session = pi;
let url = "";
const ctx = session.session.extensionRunner.createCommandContext();
ctx.ui.notify = (text) => {
const match = text.match(/http:\/\/127\.0\.0\.1:\d+\/#\S+/u);
if (match) url = match[0];
};
await session.extensions[0]!.commands.get("canvas")!.handler("open", ctx);
const headers = { Authorization: `Bearer ${new URL(url).hash.slice(1)}` };
const state = async (): Promise<CanvasState> =>
(
await fetch(new URL("/api/state", url), {
headers,
signal: AbortSignal.timeout(2000),
})
).json() as Promise<CanvasState>;
const scene = async (
elements: CanvasState["elements"],
revision: number,
) =>
fetch(new URL("/api/action", url), {
method: "POST",
headers: {
...headers,
Origin: new URL(url).origin,
"Content-Type": "application/json",
},
body: JSON.stringify({
kind: "scene",
clientId: "remote-proof",
sequence: revision + 1,
activity: "active",
revision,
elements,
}),
signal: AbortSignal.timeout(2000),
});
await scene(
[
{
id: "box",
type: "rectangle",
x: 400,
y: 220,
width: 100,
height: 80,
},
],
0,
);
browser = spawn(
executable,
[
"--headless=new",
"--remote-debugging-port=0",
`--user-data-dir=${profile}`,
"--no-first-run",
"--disable-gpu",
"about:blank",
],
{
stdio: ["ignore", "ignore", "pipe"],
env: {
...process.env,
PATH: [dirname(executable), process.env["PATH"]].join(delimiter),
},
},
);
const processHandle = browser;
const endpoint = await new Promise<string>((resolve, reject) => {
let text = "";
const timer = setTimeout(
() => reject(new Error("Viewer startup timed out")),
15000,
);
processHandle.once("error", reject);
processHandle.stderr!.on("data", (chunk: Buffer) => {
text = (text + chunk.toString()).slice(-8192);
const match = text.match(/DevTools listening on (ws:\/\/[^\s]+)/u);
if (match?.[1]) {
clearTimeout(timer);
resolve(match[1]);
}
});
});
const targetUrl = new URL(endpoint);
targetUrl.protocol = "http:";
targetUrl.pathname = "/json/new";
targetUrl.search = `?${encodeURIComponent(url)}`;
const target = (await (
await fetch(targetUrl, {
method: "PUT",
signal: AbortSignal.timeout(10000),
})
).json()) as { webSocketDebuggerUrl: string };
cdp = await openCdp(
target.webSocketDebuggerUrl,
AbortSignal.timeout(15000),
);
const client = cdp;
const evaluate = async <T>(expression: string): Promise<T> => {
const value = await client.call("Runtime.evaluate", {
expression,
awaitPromise: true,
returnByValue: true,
});
if (value["exceptionDetails"]) {
const details = value["exceptionDetails"] as {
text?: string;
exception?: { description?: string };
};
throw new Error(
`Browser proof script failed: ${details.exception?.description ?? details.text ?? "Unknown browser exception"}`,
);
}
return (value["result"] as { value: T }).value;
};
await client.call("Emulation.setFocusEmulationEnabled", {
enabled: true,
});
await until(
() =>
evaluate<boolean>(
"!!document.querySelector('canvas.static') && document.body.innerText.includes('Shared with Pi')",
),
"initial viewer",
);
await until(async () => {
const current = await state();
return current.elements[0]?.["version"] !== undefined;
}, "native initialization acknowledgement");
await evaluate(
"window.__renderedRevision=-1;const old=window.fetch;window.fetch=async function(i,o){const b=o?.body&&JSON.parse(o.body);const r=await old.call(this,i,o);if(b?.kind==='activity'&&b.activity==='settled'&&r.ok)window.__renderedRevision=b.revision;return r};true",
);
await client.call("Page.setWebLifecycleState", { state: "frozen" });
const draw = async (dx: number) => {
const current = await state();
return session.extensions[0]!.tools.get("canvas")!.definition.execute(
"background-draw",
{
action: "draw",
baseRevision: current.revision,
title: "Frozen viewer transaction",
moves: [{ ids: ["box"], dx, dy: 0 }],
},
undefined,
undefined,
session.session.extensionRunner.createToolContext(
"background-draw",
undefined,
),
);
};
await draw(20);
await draw(30);
const committed = await state();
expect(committed.elements[0]).toMatchObject({ x: 450, y: 220 });
await client.call("Page.setWebLifecycleState", { state: "active" });
await client.call("Emulation.setFocusEmulationEnabled", {
enabled: true,
});
await evaluate("window.dispatchEvent(new Event('focus')); true");
await until(
() =>
evaluate<boolean>(
`window.__renderedRevision >= ${committed.revision} && !document.querySelector('[aria-label="Undo"]').disabled`,
),
"catch-up native Undo",
);
// Native UI Undo changes the editor, then ordinary scene saving acknowledges it.
await evaluate(
"document.querySelector('[aria-label=\"Undo\"]').click(); true",
);
await until(
async () => (await state()).elements[0]?.x === 420,
"first agent Undo",
);
await evaluate(
"document.querySelector('[aria-label=\"Undo\"]').click(); true",
);
await until(
async () => (await state()).elements[0]?.x === 400,
"second agent Undo",
);
await evaluate(
"document.querySelector('[aria-label=\"Redo\"]').click(); true",
);
await until(
async () => (await state()).elements[0]?.x === 420,
"first agent Redo",
);
await evaluate(
"document.querySelector('[aria-label=\"Redo\"]').click(); true",
);
await until(
async () => (await state()).elements[0]?.x === 450,
"second agent Redo",
);
await evaluate(
"window.__heldSave = null; const original = window.fetch; window.fetch = function(i,o) { const b=o?.body&&JSON.parse(o.body); if(b?.kind==='scene') { window.__heldSave=b; return new Promise(()=>{}); } return original.call(this,i,o); }; true",
);
await client.call("Input.dispatchMouseEvent", {
type: "mouseMoved",
x: 450,
y: 260,
});
await client.call("Input.dispatchMouseEvent", {
type: "mousePressed",
x: 450,
y: 260,
button: "left",
clickCount: 1,
});
await client.call("Input.dispatchMouseEvent", {
type: "mouseMoved",
x: 470,
y: 280,
button: "left",
buttons: 1,
});
await client.call("Input.dispatchMouseEvent", {
type: "mouseReleased",
x: 470,
y: 280,
button: "left",
clickCount: 1,
});
await until(
() => evaluate<boolean>("!!window.__heldSave"),
"held local draft",
);
const held = await evaluate<CanvasState["elements"]>(
"window.__heldSave.elements",
);
expect(held.find((element) => element.id === "box")).toMatchObject({
x: 470,
y: 240,
});
await client.call("Page.setWebLifecycleState", { state: "frozen" });
const shared = await state();
await scene(
[
...shared.elements,
{
id: "foreign",
type: "rectangle",
x: 700,
y: 220,
width: 80,
height: 80,
},
],
shared.revision,
);
await client.call("Page.setWebLifecycleState", { state: "active" });
await client.call("Emulation.setFocusEmulationEnabled", {
enabled: true,
});
await evaluate("window.dispatchEvent(new Event('focus')); true");
await until(
() => evaluate<boolean>("!!document.querySelector('.conflict')"),
"dirty resync conflict",
);
await evaluate(
"(()=>{const original=URL.createObjectURL; URL.createObjectURL=function(blob){window.__download=blob;return original(blob)};document.querySelector('[data-testid=\"main-menu-trigger\"]').click();return true})()",
);
await evaluate(
"[...document.querySelectorAll('button')].find(b=>b.textContent.includes('Download drawing')).click();true",
);
const downloaded = await evaluate<{ elements: CanvasState["elements"] }>(
"(async()=>JSON.parse(await window.__download.text()))()",
);
expect(
downloaded.elements.find((element) => element.id === "box"),
).toMatchObject({ x: 470, y: 240 });
expect(
downloaded.elements.some((element) => element.id === "foreign"),
).toBe(false);
expect(
(await state()).elements.some((element) => element.id === "foreign"),
).toBe(true);
expect(session.errors).toEqual([]);
} finally {
cdp?.close();
if (browser) await stop(browser);
await pi?.dispose();
await rm(profile, {
recursive: true,
force: true,
maxRetries: 5,
retryDelay: 100,
});
}
},
90000,
);