1 +import test from 'node:test';
2 +import assert from 'node:assert/strict';
3 +import { createServer } from 'node:http';
4 +import { createHash, randomBytes } from 'node:crypto';
5 +import { mkdtemp, readFile, stat, writeFile, rm } from 'node:fs/promises';
6 +import { existsSync } from 'node:fs';
7 +import { tmpdir } from 'node:os';
8 +import { dirname, join, resolve } from 'node:path';
9 +import { fileURLToPath } from 'node:url';
10 +import { spawn } from 'node:child_process';
12 +const __dirname = dirname(fileURLToPath(import.meta.url));
13 +const SCRIPT = resolve(__dirname, 'cdp.mjs');
14 +const TARGET_ID = 'ABCDEF1234567890ABCDEF1234567890';
15 +const TARGET_PREFIX = TARGET_ID.slice(0, 8);
16 +const PNG_1X1 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII=';
18 +function encodeFrame(text) {
19 + const payload = Buffer.from(text);
20 + if (payload.length < 126) return Buffer.concat([Buffer.from([0x81, payload.length]), payload]);
21 + if (payload.length <= 0xffff) {
22 + const head = Buffer.alloc(4);
25 + head.writeUInt16BE(payload.length, 2);
26 + return Buffer.concat([head, payload]);
28 + const head = Buffer.alloc(10);
31 + head.writeBigUInt64BE(BigInt(payload.length), 2);
32 + return Buffer.concat([head, payload]);
35 +function decodeFrames(buffer) {
36 + const messages = [];
38 + while (offset + 2 <= buffer.length) {
39 + const b1 = buffer[offset];
40 + const b2 = buffer[offset + 1];
41 + let len = b2 & 0x7f;
44 + if (offset + 4 > buffer.length) break;
45 + len = buffer.readUInt16BE(offset + 2);
47 + } else if (len === 127) {
48 + if (offset + 10 > buffer.length) break;
49 + len = Number(buffer.readBigUInt64BE(offset + 2));
52 + const masked = (b2 & 0x80) !== 0;
53 + const maskOffset = offset + header;
54 + const payloadOffset = maskOffset + (masked ? 4 : 0);
55 + const end = payloadOffset + len;
56 + if (end > buffer.length) break;
57 + const payload = Buffer.from(buffer.subarray(payloadOffset, end));
59 + const mask = buffer.subarray(maskOffset, payloadOffset);
60 + for (let i = 0; i < payload.length; i++) payload[i] ^= mask[i % 4];
62 + if ((b1 & 0x0f) === 0x1) messages.push(payload.toString('utf8'));
65 + return { messages, rest: buffer.subarray(offset) };
68 +async function startFakeCdpServer() {
73 + loadMoreRemaining: 2,
76 + const sockets = new Set();
78 + const server = createServer();
79 + server.on('upgrade', (req, socket) => {
80 + sockets.add(socket);
81 + socket.on('close', () => sockets.delete(socket));
82 + const accept = createHash('sha1')
83 + .update(req.headers['sec-websocket-key'] + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
86 + 'HTTP/1.1 101 Switching Protocols',
87 + 'Upgrade: websocket',
88 + 'Connection: Upgrade',
89 + `Sec-WebSocket-Accept: ${accept}`,
94 + let buf = Buffer.alloc(0);
95 + socket.on('data', chunk => {
96 + buf = Buffer.concat([buf, chunk]);
97 + const decoded = decodeFrames(buf);
99 + for (const message of decoded.messages) {
100 + const req = JSON.parse(message);
101 + handleRequest(socket, req, state);
106 + await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
107 + const { port } = server.address();
108 + const path = `/devtools/browser/${randomBytes(4).toString('hex')}`;
113 + wsUrl: `ws://127.0.0.1:${port}${path}`,
115 + for (const socket of sockets) socket.destroy();
116 + await new Promise(resolve => server.close(resolve));
121 +function send(socket, payload) {
122 + socket.write(encodeFrame(JSON.stringify(payload)));
125 +function runtimeValue(expression, state) {
126 + if (expression === 'document.title') return 'Fake Title';
127 + if (expression === 'document.readyState') return 'complete';
128 + if (expression === 'window.devicePixelRatio') return 2;
129 + if (expression === 'document.documentElement.outerHTML') return '<html><body><button id="go">Go</button><div class="card">Card</div></body></html>';
130 + if (expression.includes('document.querySelector(".card")?.outerHTML')) return '<div class="card">Card</div>';
131 + if (expression.includes("performance.getEntriesByType('resource')")) {
132 + return JSON.stringify([{ name: 'https://example.test/app.js', type: 'script', duration: 12, size: 2048 }]);
134 + if (expression.includes('document.querySelector("#go")') && expression.includes('return { ok: true, tag: el.tagName')) {
135 + return { ok: true, tag: 'BUTTON', text: 'Go' };
137 + if (expression.includes('document.querySelector("#more")') && expression.includes('exists: true')) {
138 + if (state.loadMoreRemaining > 0) {
139 + state.loadMoreRemaining--;
140 + return { exists: true, clicked: true };
142 + return { exists: false, clicked: false };
147 +function handleRequest(socket, req, state) {
148 + state.methods.push(req.method);
150 + const sid = req.sessionId;
151 + switch (req.method) {
152 + case 'Target.getTargets':
153 + return send(socket, { id, result: { targetInfos: [
154 + { targetId: TARGET_ID, type: 'page', title: 'Fake Page', url: 'https://example.test/' },
155 + { targetId: 'CHROME0000000000000000000000000000', type: 'page', title: 'Chrome', url: 'chrome://inspect' },
157 + case 'Target.attachToTarget':
159 + return send(socket, { id, result: { sessionId: 'session-1' } });
160 + case 'Accessibility.getFullAXTree':
161 + return send(socket, { id, sessionId: sid, result: { nodes: [
162 + { nodeId: '1', role: { value: 'RootWebArea' }, name: { value: 'Fake Page' }, childIds: ['2', '3'] },
163 + { nodeId: '2', parentId: '1', role: { value: 'button' }, name: { value: 'Go' } },
164 + { nodeId: '3', parentId: '1', role: { value: 'InlineTextBox' }, name: { value: 'hidden text' } },
166 + case 'Runtime.enable':
167 + case 'Page.enable':
168 + return send(socket, { id, sessionId: sid, result: {} });
169 + case 'Runtime.evaluate':
170 + return send(socket, { id, sessionId: sid, result: { result: { value: runtimeValue(req.params.expression, state) } } });
171 + case 'Page.getLayoutMetrics':
172 + return send(socket, { id, sessionId: sid, result: { visualViewport: { clientWidth: 1600 }, cssVisualViewport: { clientWidth: 800 } } });
173 + case 'Emulation.getDeviceMetricsOverride':
174 + return send(socket, { id, sessionId: sid, result: { deviceScaleFactor: 2 } });
175 + case 'Page.captureScreenshot':
176 + return send(socket, { id, sessionId: sid, result: { data: PNG_1X1 } });
177 + case 'Page.navigate':
178 + send(socket, { id, sessionId: sid, result: { loaderId: 'loader-1' } });
179 + setTimeout(() => send(socket, { method: 'Page.loadEventFired', sessionId: sid, params: { timestamp: Date.now() / 1000 } }), 5);
181 + case 'Input.dispatchMouseEvent':
182 + state.mouseEvents.push(req.params.type);
183 + return send(socket, { id, sessionId: sid, result: {} });
184 + case 'Input.insertText':
185 + state.typed.push(req.params.text);
186 + return send(socket, { id, sessionId: sid, result: {} });
187 + case 'DOM.getDocument':
188 + return send(socket, { id, sessionId: sid, result: { root: { nodeId: 1, nodeName: '#document' } } });
190 + return send(socket, { id, sessionId: sid, result: {} });
194 +function runCdp(args, env, options = {}) {
195 + return new Promise((resolve, reject) => {
196 + const child = spawn(process.execPath, [SCRIPT, ...args], {
197 + env: { ...process.env, ...env },
199 + stdio: ['ignore', 'pipe', 'pipe'],
204 + child.stdout.setEncoding('utf8');
205 + child.stderr.setEncoding('utf8');
206 + child.stdout.on('data', chunk => { stdout += chunk; });
207 + child.stderr.on('data', chunk => { stderr += chunk; });
208 + child.on('error', reject);
209 + child.on('close', code => resolve({ code, stdout, stderr }));
213 +async function expectOk(args, env) {
214 + const result = await runCdp(args, env);
215 + assert.equal(result.code, 0, `${args.join(' ')}\nstdout=${result.stdout}\nstderr=${result.stderr}`);
216 + return result.stdout.trimEnd();
219 +test('cdp CLI integration covers list + all page commands + daemon lifecycle', async () => {
220 + const server = await startFakeCdpServer();
221 + const stateDir = await mkdtemp(join(tmpdir(), 'pi-chrome-cdp-test-'));
223 + PI_CHROME_CDP_WS_URL: server.wsUrl,
224 + PI_CHROME_CDP_STATE_DIR: stateDir,
225 + PI_CHROME_CDP_DAEMON_CONNECT_DELAY_MS: '5',
226 + PI_CHROME_CDP_DAEMON_CONNECT_RETRIES: '80',
230 + const list = await expectOk(['list'], env);
231 + assert.match(list, new RegExp(`^${TARGET_PREFIX}\\s+Fake Page\\s+https://example\\.test/`));
232 + assert.equal((await stat(stateDir)).mode & 0o777, 0o700);
233 + assert.ok(existsSync(join(stateDir, 'pages.json')));
235 + const snap = await expectOk(['snap', TARGET_PREFIX], env);
236 + assert.match(snap, /\[RootWebArea\] Fake Page/);
237 + assert.match(snap, /\[button\] Go/);
238 + assert.doesNotMatch(snap, /InlineTextBox/);
240 + assert.equal(await expectOk(['eval', TARGET_PREFIX, 'document.title'], env), 'Fake Title');
241 + assert.equal(await expectOk(['html', TARGET_PREFIX, '.card'], env), '<div class="card">Card</div>');
242 + assert.match(await expectOk(['nav', TARGET_PREFIX, 'https://example.test/next'], env), /Navigated to https:\/\/example\.test\/next/);
243 + assert.match(await expectOk(['net', TARGET_PREFIX], env), /script\s+https:\/\/example\.test\/app\.js/);
245 + const defaultShot = await expectOk(['shot', TARGET_PREFIX], env);
246 + const defaultScreenshot = join(stateDir, 'screenshot.png');
247 + assert.match(defaultShot, new RegExp(defaultScreenshot.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
248 + assert.equal(await readFile(defaultScreenshot, 'base64'), PNG_1X1);
250 + const screenshot = join(stateDir, 'shot.png');
251 + const shot = await expectOk(['shot', TARGET_PREFIX, screenshot], env);
252 + assert.match(shot, new RegExp(screenshot.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
253 + assert.match(shot, /DPR\): 2/);
254 + assert.equal(await readFile(screenshot, 'base64'), PNG_1X1);
256 + assert.equal(await expectOk(['click', TARGET_PREFIX, '#go'], env), 'Clicked <BUTTON> "Go"');
257 + assert.equal(await expectOk(['clickxy', TARGET_PREFIX, '10', '20'], env), 'Clicked at CSS (10, 20)');
258 + assert.equal(await expectOk(['type', TARGET_PREFIX, 'hello world'], env), 'Typed 11 characters');
259 + assert.equal(await expectOk(['loadall', TARGET_PREFIX, '#more', '1'], env), 'Clicked "#more" 2 time(s) until it disappeared');
260 + assert.match(await expectOk(['evalraw', TARGET_PREFIX, 'DOM.getDocument', '{}'], env), /"nodeName": "#document"/);
262 + const batchJson = JSON.stringify([
263 + { cmd: 'eval', args: ['document.title'] },
264 + { cmd: 'html', args: ['.card'] },
266 + const batch = JSON.parse(await expectOk(['batch', TARGET_PREFIX, batchJson], env));
267 + assert.deepEqual(batch.map(item => item.ok), [true, true]);
268 + assert.equal(batch[0].result, 'Fake Title');
269 + assert.equal(batch[1].result, '<div class="card">Card</div>');
271 + const daemonList = await expectOk(['list'], env);
272 + assert.match(daemonList, /Fake Page/);
273 + assert.ok(server.state.attached >= 1);
274 + assert.deepEqual(server.state.mouseEvents, ['mouseMoved', 'mousePressed', 'mouseReleased']);
275 + assert.deepEqual(server.state.typed, ['hello world']);
277 + await expectOk(['stop', TARGET_PREFIX], env);
279 + await runCdp(['stop'], env).catch(() => {});
280 + await rm(stateDir, { recursive: true, force: true });
281 + await server.close();
285 +test('cdp CLI safety caps are tunable and explicit', async () => {
286 + const server = await startFakeCdpServer();
287 + const stateDir = await mkdtemp(join(tmpdir(), 'pi-chrome-cdp-caps-test-'));
289 + PI_CHROME_CDP_WS_URL: server.wsUrl,
290 + PI_CHROME_CDP_STATE_DIR: stateDir,
291 + PI_CHROME_CDP_MAX_HTML_CHARS: '20',
292 + PI_CHROME_CDP_MAX_NET_ENTRIES: '0',
296 + await expectOk(['list'], env);
297 + const html = await expectOk(['html', TARGET_PREFIX], env);
298 + assert.match(html, /page HTML truncated/);
299 + const net = await expectOk(['net', TARGET_PREFIX], env);
300 + assert.doesNotMatch(net, /network entries truncated/);
302 + await runCdp(['stop'], env).catch(() => {});
303 + await rm(stateDir, { recursive: true, force: true });
304 + await server.close();
308 +test('cdp CLI discovers websocket via DevToolsActivePort override', async () => {
309 + const server = await startFakeCdpServer();
310 + const stateDir = await mkdtemp(join(tmpdir(), 'pi-chrome-cdp-portfile-test-'));
311 + const portFile = join(stateDir, 'DevToolsActivePort');
312 + await writeFile(portFile, `${server.port}\n${server.path}\n`);
314 + PI_CHROME_CDP_DEVTOOLS_ACTIVE_PORT: portFile,
315 + PI_CHROME_CDP_STATE_DIR: stateDir,
319 + const list = await expectOk(['list'], env);
320 + assert.match(list, /Fake Page/);
322 + await rm(stateDir, { recursive: true, force: true });
323 + await server.close();