Files
alan 6eb26b6d17 Bench desktop windows and chat, with an option to keep the GPU
interaction_bench.mjs gains 1280x800 scenarios (dragging, resizing, hiding
and floating chat windows, a probe window drag, chat scroll, typing, chat
switch, the terminal panel), key, drag and wheel steps, a per-scenario size
and --gpu, which keeps WebGL so raster time reads as on a desktop.
2026-11-11 01:41:44 +00:00

115 lines
5.3 KiB
JavaScript

// Headless Chrome over the DevTools protocol: launch a private instance (fresh
// profile, remote debugging on an OS-assigned port) or attach to a running one
// via `--cdp http://127.0.0.1:<port>`. Either way the kit works in its own page
// target, and close() removes everything it created.
import { spawn } from 'node:child_process';
import { mkdtemp, rm } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { setTimeout as delay } from 'node:timers/promises';
const CALL_TIMEOUT_MS = 30000;
const DEFAULT_CHROME ='/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
async function launch(chromePath, gpu) {
const profile = await mkdtemp(join(tmpdir(), 'pipelines-capture-chrome-'));
const chrome = spawn(chromePath, [
'--headless=new', '--no-first-run', '--no-default-browser-check',
// Without a GPU CanvasKit rasterises on the CPU; `gpu` keeps WebGL (Metal
// through ANGLE on a Mac) for benches that measure raster time.
...(gpu ? ['--use-angle=metal', '--enable-gpu-rasterization', '--ignore-gpu-blocklist'] : ['--disable-gpu']),
'--hide-scrollbars', '--mute-audio',
'--remote-debugging-port=0', `--user-data-dir=${profile}`, 'about:blank',
], { stdio: ['ignore', 'ignore', 'pipe'] });
let stderr = '';
chrome.stderr.on('data', (d) => { stderr += d; });
const exited = new Promise((done) => chrome.once('exit', done));
const cleanup = async () => {
if (chrome.exitCode === null && chrome.signalCode === null) {
chrome.kill('SIGTERM');
const timedOut = await Promise.race([exited.then(() => false), delay(3000, true)]);
if (timedOut) { chrome.kill('SIGKILL'); await exited; }
}
await rm(profile, { recursive: true, force: true }).catch(() => {});
};
for (let i = 0; i < 150; i++) {
const ws = stderr.match(/DevTools listening on (ws:\/\/\S+)/)?.[1];
if (ws) return { ws, cleanup };
if (chrome.exitCode !== null) break;
await delay(100);
}
await cleanup();
throw new Error(`Chrome did not start (${chromePath}): ${stderr.slice(-800)}`);
}
async function attach(cdp) {
const version = await (await fetch(new URL('/json/version', cdp))).json();
return { ws: version.webSocketDebuggerUrl, cleanup: async () => {} };
}
/**
* Opens a page target. Returns `{ send, on, close }`: `send(method, params)`
* talks to the page session; `on(method, fn)` subscribes to its events and
* returns the unsubscribe function; `newPage()` opens a scratch page.
*/
export async function openBrowser({ cdp, gpu = false, chromePath = process.env.CHROME_PATH ?? DEFAULT_CHROME } = {}) {
const { ws: endpoint, cleanup } = cdp ? await attach(cdp) : await launch(chromePath, gpu);
const ws = new WebSocket(endpoint);
try {
await new Promise((ok, fail) => { ws.onopen = ok; ws.onerror = () => fail(new Error(`Cannot open ${endpoint}`)); });
} catch (error) { await cleanup(); throw error; }
let nextId = 0;
const pending = new Map();
const listeners = new Map();
let sessionId;
ws.onmessage = (event) => {
const m = JSON.parse(event.data);
if (m.id && pending.has(m.id)) {
const { ok, fail, method } = pending.get(m.id);
pending.delete(m.id);
return m.error ? fail(new Error(`${method}: ${m.error.message}`)) : ok(m.result ?? {});
}
if (m.method && m.sessionId === sessionId) for (const fn of listeners.get(m.method) ?? []) fn(m.params);
};
// Every call is bounded: an unresponsive page (for example a navigation to a
// server that never answers) fails the step instead of hanging the kit.
const raw = (method, params = {}, session) => new Promise((ok, fail) => {
const id = ++nextId;
const timer = setTimeout(() => {
pending.delete(id);
fail(new Error(`${method}: no reply within ${CALL_TIMEOUT_MS} ms`));
}, CALL_TIMEOUT_MS);
const settle = (fn) => (value) => { clearTimeout(timer); fn(value); };
pending.set(id, { ok: settle(ok), fail: settle(fail), method });
ws.send(JSON.stringify({ id, method, params, ...(session ? { sessionId: session } : {}) }));
});
let targetId;
try {
({ targetId } = await raw('Target.createTarget', { url: 'about:blank' }));
({ sessionId } = await raw('Target.attachToTarget', { targetId, flatten: true }));
} catch (error) { ws.close(); await cleanup(); throw error; }
return {
send: (method, params) => raw(method, params, sessionId),
on: (method, fn) => {
listeners.set(method, [...(listeners.get(method) ?? []), fn]);
return () => listeners.set(method, listeners.get(method).filter((f) => f !== fn));
},
/** Every open page target (tabs a link opened included): `{ url, type }`. */
targets: async () => (await raw('Target.getTargets')).targetInfos
.filter((t) => t.type === 'page').map((t) => ({ url: t.url, type: t.type })),
newPage: async () => {
const page = await raw('Target.createTarget', { url: 'about:blank' });
const { sessionId: sid } = await raw('Target.attachToTarget', { targetId: page.targetId, flatten: true });
return {
send: (method, params) => raw(method, params, sid),
close: () => raw('Target.closeTarget', { targetId: page.targetId }).catch(() => {}),
};
},
close: async () => {
await raw('Target.closeTarget', { targetId }).catch(() => {});
ws.close();
await cleanup();
},
};
}