Files
pipelines/app/tool/capture/browser.mjs
T
alan ea428d3c98 Add generic capture kit and repo-owned test memory watchdog
app/tool/capture: one Chrome DevTools capture CLI over the full-app fixture
(serve build or URL, private headless Chrome or --cdp attach, label/key/xy
clicks via Flutter semantics, type, press, scroll, screenshots, filmed
clicks with a canvas contact sheet, cleanup on exit/signal), README recipes
and an example script. The fixture entry gains ?theme=light|dark.

app/tool/memwatch: run.sh/full.sh watchdog moved from /tmp (output dir
created if missing, exit status propagated) plus install.sh for the legacy
/tmp/memwatch shims. app/AGENTS.md points tests at full.sh and UI review at
the capture kit.
2026-11-01 21:22:08 +00:00

109 lines
4.8 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) {
const profile = await mkdtemp(join(tmpdir(), 'pipelines-capture-chrome-'));
const chrome = spawn(chromePath, [
'--headless=new', '--no-first-run', '--no-default-browser-check',
'--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, chromePath = process.env.CHROME_PATH ?? DEFAULT_CHROME } = {}) {
const { ws: endpoint, cleanup } = cdp ? await attach(cdp) : await launch(chromePath);
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));
},
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();
},
};
}