exl100

cdp.mjs (4576B)

---

 // Pilotage d'un Chromium headless par le protocole DevTools, sans dépendance (pas de Playwright sur hotrats).
 import { spawn } from 'node:child_process';
 import { writeFileSync } from 'node:fs';
 
 export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
 export async function open(url, { port = Number(process.env.CDP_PORT ?? 9334), width = 1000, height = 1400 } = {}) {
   const chrome = spawn(process.env.CHROME ?? 'chromium', [
     '--headless=new', '--no-sandbox', '--hide-scrollbars',
     '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader',
     `--remote-debugging-port=${port}`, `--window-size=${width},${height}`, 'about:blank',
   ], { stdio: 'ignore' });
 
   let target;
   for (let i = 0; i < 50 && !target; i++) {
     await sleep(200);
     try {
       const r = await fetch(`http://127.0.0.1:${port}/json/new?about:blank`, { method: 'PUT' });
       target = await r.json();
     } catch { /* pas encore prêt */ }
   }
   if (!target) { chrome.kill(); throw new Error('Chromium ne répond pas'); }
 
   const ws = new WebSocket(target.webSocketDebuggerUrl);
   await new Promise((r) => ws.addEventListener('open', r));
   let id = 0;
   const pending = new Map();
   const logs = [];
   ws.addEventListener('message', (ev) => {
     const m = JSON.parse(ev.data);
     if (m.id && pending.has(m.id)) { pending.get(m.id)(m.result ?? m.error); pending.delete(m.id); }
     else if (m.method === 'Runtime.consoleAPICalled') logs.push(`[${m.params.type}] ${m.params.args.map((a) => a.value ?? a.description).join(' ')}`);
     else if (m.method === 'Runtime.exceptionThrown') logs.push(`[exception] ${m.params.exceptionDetails.exception?.description ?? m.params.exceptionDetails.text}`);
   });
   const send = (method, params = {}) => new Promise((r) => { const i = ++id; pending.set(i, r); ws.send(JSON.stringify({ id: i, method, params })); });
   const evaluate = async (expression) => (await send('Runtime.evaluate', { expression, returnByValue: true, awaitPromise: true })).result?.value;
   const screenshot = async (path) => {
     const png = (await send('Page.captureScreenshot', { format: 'png' })).data;
     writeFileSync(path, Buffer.from(png, 'base64'));
     return path;
   };
   // Coordonnées de la page pour un point de l'écran Smalltalk (640×480 mis à l'échelle CSS)
   const canvasPoint = async (x, y) => {
     const r = await evaluate("(() => { const c = document.getElementById('canvas').getBoundingClientRect(); return [c.left, c.top, c.width, c.height]; })()");
     const [left, top, w, h] = r;
     return { x: left + (x * w) / 640, y: top + (y * h) / 480 };
   };
   const mouse = async (type, x, y, button = 'none', clickCount = 1) =>
     send('Input.dispatchMouseEvent', { type, x, y, button, clickCount, buttons: button === 'left' ? 1 : button === 'right' ? 2 : button === 'middle' ? 4 : 0 });
   const click = async (sx, sy, button = 'left') => {
     const p = await canvasPoint(sx, sy);
     await mouse('mouseMoved', p.x, p.y);
     await sleep(100);
     await mouse('mousePressed', p.x, p.y, button);
     await sleep(120);
     await mouse('mouseReleased', p.x, p.y, button);
   };
   // Frappe : chaque touche porte un `code` physique et un keyCode, sinon SDL ne la reconnaît pas
   // (symbole 0) ; les caractères passent par le keypress (texte), Entrée par le keydown seul.
   const keyOf = (ch) => {
     if (ch === '\r') return { key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13, text: '\r' };
     if (/[a-z]/i.test(ch)) return { key: ch, code: `Key${ch.toUpperCase()}`, windowsVirtualKeyCode: ch.toUpperCase().charCodeAt(0), text: ch };
     if (/[0-9]/.test(ch)) return { key: ch, code: `Digit${ch}`, windowsVirtualKeyCode: ch.charCodeAt(0), text: ch };
     if (ch === ' ') return { key: ' ', code: 'Space', windowsVirtualKeyCode: 32, text: ' ' };
     return { key: ch, code: 'Unidentified', windowsVirtualKeyCode: 0, text: ch };
   };
   const type = async (text) => {
     for (const ch of text) {
       const k = keyOf(ch);
       await send('Input.dispatchKeyEvent', { type: 'keyDown', key: k.key, code: k.code, windowsVirtualKeyCode: k.windowsVirtualKeyCode, text: k.text, unmodifiedText: k.text });
       await send('Input.dispatchKeyEvent', { type: 'keyUp', key: k.key, code: k.code, windowsVirtualKeyCode: k.windowsVirtualKeyCode });
       await sleep(40);
     }
   };
   const close = () => { ws.close(); chrome.kill(); };
 
   await send('Runtime.enable');
   await send('Page.enable');
   await send('Page.navigate', { url });
   return { send, evaluate, logs, screenshot, canvasPoint, mouse, click, type, close };
 }