primocode 7.3.0 → 7.4.0

package/lib/browser.js

@@ -1,492 +1,507 @@
-// Controlador do navegador do usuário via CDP (Chrome DevTools Protocol).
-// Sem dependências externas — usa apenas o módulo 'http' e um cliente WebSocket
-// mínimo escrito à mão em cima de 'net'/'tls'.
-//
-// Como funciona:
-//   1) launch() abre o Chrome do usuário com --remote-debugging-port=9222
-//      e um --user-data-dir dedicado (~/.primocode/chrome-profile) — assim
-//      o usuário logado nesse profile persiste (login GitHub, Vercel, etc).
-//   2) attach() descobre a aba ativa em /json/list e abre um WebSocket CDP.
-//   3) send(method, params) envia comandos CDP (Page.navigate, Input.dispatchMouseEvent...).
-//   4) close() encerra a conexão (o Chrome continua aberto para o usuário).
-//
-// Não usamos 'puppeteer' ou 'playwright' — a CLI continua com ZERO deps.
-
-'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const net = require('net');
-const path = require('path');
-const http = require('http');
-const crypto = require('crypto');
-const { spawn, execSync } = require('child_process');
-
-const PROFILE_DIR = path.join(os.homedir(), '.primocode', 'chrome-profile');
-const DEBUG_PORT = 9222;
-
-// ---- Helpers ---------------------------------------------------
-function findChrome() {
-    const platform = process.platform;
-    const candidates = platform === 'darwin' ? [
-        '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
-        '/Applications/Chromium.app/Contents/MacOS/Chromium',
-    ] : platform === 'win32' ? [
-        `${process.env['PROGRAMFILES']}\\Google\\Chrome\\Application\\chrome.exe`,
-        `${process.env['PROGRAMFILES(X86)']}\\Google\\Chrome\\Application\\chrome.exe`,
-        `${process.env['LOCALAPPDATA']}\\Google\\Chrome\\Application\\chrome.exe`,
-    ] : [
-        '/usr/bin/google-chrome',
-        '/usr/bin/google-chrome-stable',
-        '/usr/bin/chromium',
-        '/usr/bin/chromium-browser',
-        '/snap/bin/chromium',
-    ];
-    for (const p of candidates) {
-        try { if (p && fs.existsSync(p)) return p; } catch {}
-    }
-    return null;
-}
-
-function httpGetJson(url, timeoutMs = 3000) {
-    return new Promise((resolve, reject) => {
-        const req = http.get(url, (res) => {
-            let body = '';
-            res.on('data', (d) => (body += d));
-            res.on('end', () => {
-                try { resolve(JSON.parse(body)); } catch (e) { reject(new Error('JSON inválido: ' + body.slice(0, 100))); }
-            });
-        });
-        req.on('error', reject);
-        req.setTimeout(timeoutMs, () => { req.destroy(new Error('timeout')); });
-    });
-}
-
-function httpPutJson(url, timeoutMs = 3000) {
-    return new Promise((resolve, reject) => {
-        const u = new URL(url);
-        const req = http.request({
-            method: 'PUT', hostname: u.hostname, port: u.port, path: u.pathname + u.search,
-        }, (res) => {
-            let body = '';
-            res.on('data', (d) => (body += d));
-            res.on('end', () => {
-                try { resolve(JSON.parse(body)); } catch { resolve({ raw: body }); }
-            });
-        });
-        req.on('error', reject);
-        req.setTimeout(timeoutMs, () => { req.destroy(new Error('timeout')); });
-        req.end();
-    });
-}
-
-function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
-
-// ---- WebSocket client mínimo (RFC 6455) para CDP ----------------
-// Suficiente pra CDP (mensagens curtas, texto UTF-8, um cliente por página).
-class MiniWebSocket {
-    constructor() {
-        this.socket = null;
-        this.buffer = Buffer.alloc(0);
-        this.onMessage = () => {};
-        this.onClose = () => {};
-        this.closed = false;
-    }
-    connect(url) {
-        return new Promise((resolve, reject) => {
-            const u = new URL(url);
-            const isSecure = u.protocol === 'wss:';
-            if (isSecure) return reject(new Error('wss:// não suportado (CDP local usa ws://)'));
-            const key = crypto.randomBytes(16).toString('base64');
-            const port = u.port || 80;
-            const path = u.pathname + (u.search || '');
-            const sock = net.connect(Number(port), u.hostname, () => {
-                const req =
-                    `GET ${path} HTTP/1.1\r\n` +
-                    `Host: ${u.hostname}:${port}\r\n` +
-                    `Upgrade: websocket\r\n` +
-                    `Connection: Upgrade\r\n` +
-                    `Sec-WebSocket-Key: ${key}\r\n` +
-                    `Sec-WebSocket-Version: 13\r\n\r\n`;
-                sock.write(req);
-            });
-            let handshaked = false;
-            let headerBuf = Buffer.alloc(0);
-            sock.on('data', (data) => {
-                if (!handshaked) {
-                    headerBuf = Buffer.concat([headerBuf, data]);
-                    const sep = headerBuf.indexOf('\r\n\r\n');
-                    if (sep === -1) return;
-                    const header = headerBuf.slice(0, sep).toString();
-                    if (!/HTTP\/1\.1 101/.test(header)) return reject(new Error('handshake WS falhou: ' + header.split('\r\n')[0]));
-                    handshaked = true;
-                    this.socket = sock;
-                    const rest = headerBuf.slice(sep + 4);
-                    if (rest.length) this._onData(rest);
-                    resolve();
-                } else {
-                    this._onData(data);
-                }
-            });
-            sock.on('error', (err) => {
-                if (!handshaked) reject(err);
-                this.closed = true; this.onClose(err);
-            });
-            sock.on('close', () => { this.closed = true; this.onClose(); });
-        });
-    }
-    _onData(chunk) {
-        this.buffer = Buffer.concat([this.buffer, chunk]);
-        while (this.buffer.length >= 2) {
-            const b0 = this.buffer[0];
-            const b1 = this.buffer[1];
-            const fin = (b0 & 0x80) !== 0;
-            const opcode = b0 & 0x0f;
-            const masked = (b1 & 0x80) !== 0;
-            let len = b1 & 0x7f;
-            let offset = 2;
-            if (len === 126) {
-                if (this.buffer.length < 4) return;
-                len = this.buffer.readUInt16BE(2);
-                offset = 4;
-            } else if (len === 127) {
-                if (this.buffer.length < 10) return;
-                // ignora high 32 bits (mensagens CDP < 4GB)
-                len = this.buffer.readUInt32BE(6);
-                offset = 10;
-            }
-            let maskKey;
-            if (masked) {
-                if (this.buffer.length < offset + 4) return;
-                maskKey = this.buffer.slice(offset, offset + 4);
-                offset += 4;
-            }
-            if (this.buffer.length < offset + len) return;
-            let payload = this.buffer.slice(offset, offset + len);
-            if (masked && maskKey) {
-                const un = Buffer.alloc(payload.length);
-                for (let i = 0; i < payload.length; i++) un[i] = payload[i] ^ maskKey[i % 4];
-                payload = un;
-            }
-            this.buffer = this.buffer.slice(offset + len);
-            if (opcode === 0x8) { this._close(); return; }
-            if (opcode === 0x9) { this._sendFrame(0xa, payload); continue; } // ping -> pong
-            if (opcode === 0xa) continue; // pong
-            if (opcode === 0x1 || opcode === 0x0) {
-                // texto (não tratamos fragmentação — CDP não fragmenta)
-                if (fin) this.onMessage(payload.toString('utf8'));
-            }
-        }
-    }
-    _sendFrame(opcode, payload) {
-        if (!this.socket || this.closed) return;
-        const len = payload.length;
-        let header;
-        // cliente DEVE mascarar
-        const mask = crypto.randomBytes(4);
-        if (len < 126) {
-            header = Buffer.alloc(2);
-            header[0] = 0x80 | opcode;
-            header[1] = 0x80 | len;
-        } else if (len < 65536) {
-            header = Buffer.alloc(4);
-            header[0] = 0x80 | opcode;
-            header[1] = 0x80 | 126;
-            header.writeUInt16BE(len, 2);
-        } else {
-            header = Buffer.alloc(10);
-            header[0] = 0x80 | opcode;
-            header[1] = 0x80 | 127;
-            header.writeUInt32BE(0, 2);
-            header.writeUInt32BE(len, 6);
-        }
-        const masked = Buffer.alloc(len);
-        for (let i = 0; i < len; i++) masked[i] = payload[i] ^ mask[i % 4];
-        this.socket.write(Buffer.concat([header, mask, masked]));
-    }
-    send(str) { this._sendFrame(0x1, Buffer.from(str, 'utf8')); }
-    _close() { if (this.socket) { try { this.socket.end(); } catch {} } this.closed = true; }
-    close() { this._sendFrame(0x8, Buffer.alloc(0)); this._close(); }
-}
-
-// ---- Sessão CDP -------------------------------------------------
-class CDPSession {
-    constructor() {
-        this.ws = null;
-        this.msgId = 0;
-        this.pending = new Map(); // id -> { resolve, reject }
-        this.targetId = null;
-    }
-    async attach(wsUrl) {
-        this.ws = new MiniWebSocket();
-        this.ws.onMessage = (raw) => this._onMessage(raw);
-        this.ws.onClose = () => { this.pending.forEach(({ reject }) => reject(new Error('ws fechado'))); };
-        await this.ws.connect(wsUrl);
-    }
-    _onMessage(raw) {
-        let msg;
-        try { msg = JSON.parse(raw); } catch { return; }
-        if (msg.id !== undefined && this.pending.has(msg.id)) {
-            const { resolve, reject } = this.pending.get(msg.id);
-            this.pending.delete(msg.id);
-            if (msg.error) reject(new Error(msg.error.message || 'erro CDP'));
-            else resolve(msg.result || {});
-        }
-        // eventos são ignorados (não usamos aqui)
-    }
-    send(method, params = {}, timeoutMs = 15000) {
-        const id = ++this.msgId;
-        const payload = JSON.stringify({ id, method, params });
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                if (this.pending.has(id)) { this.pending.delete(id); reject(new Error(`timeout ${method}`)); }
-            }, timeoutMs);
-            this.pending.set(id, {
-                resolve: (r) => { clearTimeout(timer); resolve(r); },
-                reject: (e) => { clearTimeout(timer); reject(e); },
-            });
-            this.ws.send(payload);
-        });
-    }
-    close() { if (this.ws) this.ws.close(); }
-}
-
-// ---- Estado do módulo -------------------------------------------
-let currentSession = null;
-let chromeChild = null;
-
-async function ensureChromeRunning() {
-    // Já responde na porta?
-    try {
-        const v = await httpGetJson(`http://127.0.0.1:${DEBUG_PORT}/json/version`, 800);
-        if (v && v.webSocketDebuggerUrl) return { launched: false, version: v.Browser || 'chrome' };
-    } catch {}
-
-    const chrome = findChrome();
-    if (!chrome) throw new Error('Google Chrome não encontrado no sistema. Instale o Chrome para usar o controle de navegador.');
-
-    fs.mkdirSync(PROFILE_DIR, { recursive: true });
-
-    const args = [
-        `--remote-debugging-port=${DEBUG_PORT}`,
-        `--user-data-dir=${PROFILE_DIR}`,
-        '--no-first-run',
-        '--no-default-browser-check',
-        '--disable-features=Translate',
-        'about:blank',
-    ];
-    chromeChild = spawn(chrome, args, { detached: true, stdio: 'ignore' });
-    chromeChild.on('error', () => {});
-    chromeChild.unref();
-
-    // Espera a porta responder
-    const deadline = Date.now() + 12000;
-    let lastErr;
-    while (Date.now() < deadline) {
-        try {
-            const v = await httpGetJson(`http://127.0.0.1:${DEBUG_PORT}/json/version`, 500);
-            if (v && v.webSocketDebuggerUrl) return { launched: true, version: v.Browser || 'chrome' };
-        } catch (e) { lastErr = e; }
-        await sleep(250);
-    }
-    throw new Error('Chrome iniciou mas não expôs a porta de debug: ' + (lastErr ? lastErr.message : ''));
-}
-
-async function findOrCreatePageTarget(url) {
-    const list = await httpGetJson(`http://127.0.0.1:${DEBUG_PORT}/json/list`, 2000);
-    // 1) tenta reaproveitar uma aba já ativa
-    const existing = Array.isArray(list) ? list.find(t => t.type === 'page' && !t.url.startsWith('devtools://')) : null;
-    if (existing) return existing;
-    // 2) senão, cria nova
-    const created = await httpPutJson(`http://127.0.0.1:${DEBUG_PORT}/json/new?${encodeURIComponent(url || 'about:blank')}`, 3000);
-    return created;
-}
-
-async function connect(url) {
-    await ensureChromeRunning();
-    const target = await findOrCreatePageTarget(url);
-    if (!target || !target.webSocketDebuggerUrl) throw new Error('Não foi possível obter alvo de página do Chrome.');
-    if (currentSession) { try { currentSession.close(); } catch {} }
-    currentSession = new CDPSession();
-    currentSession.targetId = target.id;
-    await currentSession.attach(target.webSocketDebuggerUrl);
-    await currentSession.send('Page.enable');
-    await currentSession.send('DOM.enable');
-    await currentSession.send('Runtime.enable');
-    return { targetId: target.id, url: target.url };
-}
-
-async function ensure(url) {
-    if (!currentSession || currentSession.ws?.closed) return connect(url);
-    return { targetId: currentSession.targetId, url: '(reused)' };
-}
-
-// ---- Ações ------------------------------------------------------
-async function open(url) {
-    await ensure(url);
-    // Navega até URL solicitada
-    await currentSession.send('Page.navigate', { url });
-    // Espera "load" simples via polling do document.readyState
-    const deadline = Date.now() + 20000;
-    while (Date.now() < deadline) {
-        const r = await currentSession.send('Runtime.evaluate', {
-            expression: 'document.readyState', returnByValue: true,
-        });
-        if (r.result && r.result.value === 'complete') break;
-        await sleep(200);
-    }
-    return { ok: true, url };
-}
-
-async function navigate(url) { return open(url); }
-
-async function evaluate(js) {
-    await ensure();
-    const r = await currentSession.send('Runtime.evaluate', {
-        expression: js, returnByValue: true, awaitPromise: true,
-    });
-    if (r.exceptionDetails) throw new Error(r.exceptionDetails.text || r.exceptionDetails.exception?.description || 'JS error');
-    return r.result ? r.result.value : undefined;
-}
-
-async function click(x, y) {
-    await ensure();
-    await currentSession.send('Input.dispatchMouseEvent', { type: 'mouseMoved', x, y });
-    await currentSession.send('Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button: 'left', clickCount: 1 });
-    await currentSession.send('Input.dispatchMouseEvent', { type: 'mouseReleased', x, y, button: 'left', clickCount: 1 });
-    return { ok: true, x, y };
-}
-
-async function clickText(text) {
-    await ensure();
-    // procura elemento clicável cujo texto contenha o alvo e retorna centro do bounding box
-    const js = `(function(){
-        const t = ${JSON.stringify(text)}.toLowerCase();
-        const nodes = Array.from(document.querySelectorAll('a,button,[role="button"],input[type="submit"],input[type="button"],label'));
-        for (const el of nodes) {
-            const s = (el.innerText || el.value || el.getAttribute('aria-label') || '').toLowerCase().trim();
-            if (s && s.includes(t)) {
-                const r = el.getBoundingClientRect();
-                if (r.width && r.height) {
-                    el.scrollIntoView({block:'center'});
-                    const r2 = el.getBoundingClientRect();
-                    return { x: r2.left + r2.width/2, y: r2.top + r2.height/2, tag: el.tagName, text: s.slice(0,80) };
-                }
-            }
-        }
-        return null;
-    })()`;
-    const found = await evaluate(js);
-    if (!found) throw new Error(`nenhum elemento clicável encontrado com texto: ${text}`);
-    await sleep(200);
-    await click(found.x, found.y);
-    return { ok: true, ...found };
-}
-
-async function clickSelector(selector) {
-    await ensure();
-    const js = `(function(){
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return null;
-        el.scrollIntoView({block:'center'});
-        const r = el.getBoundingClientRect();
-        return { x: r.left + r.width/2, y: r.top + r.height/2, tag: el.tagName };
-    })()`;
-    const found = await evaluate(js);
-    if (!found) throw new Error(`seletor não encontrado: ${selector}`);
-    await sleep(200);
-    await click(found.x, found.y);
-    return { ok: true, selector, ...found };
-}
-
-async function type(text) {
-    await ensure();
-    // Insere via CDP
-    for (const ch of text) {
-        await currentSession.send('Input.insertText', { text: ch });
-    }
-    return { ok: true, len: text.length };
-}
-
-async function typeInSelector(selector, text, clear = true) {
-    await ensure();
-    const focused = await evaluate(`(function(){
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.focus();
-        ${clear ? "if ('value' in el) el.value = '';" : ''}
-        return true;
-    })()`);
-    if (!focused) throw new Error(`seletor não encontrado: ${selector}`);
-    await type(text);
-    // dispara evento input para frameworks reativos
-    await evaluate(`(function(){
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (el) { el.dispatchEvent(new Event('input', {bubbles:true})); el.dispatchEvent(new Event('change', {bubbles:true})); }
-    })()`);
-    return { ok: true, selector, len: text.length };
-}
-
-async function key(name) {
-    // 'Enter', 'Tab', 'Escape', 'Backspace', 'ArrowDown'...
-    const map = {
-        Enter:      { code: 'Enter',      key: 'Enter',      windowsVirtualKeyCode: 13, text: '\r' },
-        Tab:        { code: 'Tab',        key: 'Tab',        windowsVirtualKeyCode: 9 },
-        Escape:     { code: 'Escape',     key: 'Escape',     windowsVirtualKeyCode: 27 },
-        Backspace:  { code: 'Backspace',  key: 'Backspace',  windowsVirtualKeyCode: 8 },
-        ArrowDown:  { code: 'ArrowDown',  key: 'ArrowDown',  windowsVirtualKeyCode: 40 },
-        ArrowUp:    { code: 'ArrowUp',    key: 'ArrowUp',    windowsVirtualKeyCode: 38 },
-        ArrowLeft:  { code: 'ArrowLeft',  key: 'ArrowLeft',  windowsVirtualKeyCode: 37 },
-        ArrowRight: { code: 'ArrowRight', key: 'ArrowRight', windowsVirtualKeyCode: 39 },
-    };
-    const k = map[name];
-    if (!k) throw new Error(`tecla desconhecida: ${name}`);
-    await ensure();
-    await currentSession.send('Input.dispatchKeyEvent', { type: 'keyDown', ...k });
-    await currentSession.send('Input.dispatchKeyEvent', { type: 'keyUp', ...k });
-    return { ok: true, key: name };
-}
-
-async function screenshot(saveTo) {
-    await ensure();
-    const r = await currentSession.send('Page.captureScreenshot', { format: 'png' });
-    if (!r.data) throw new Error('captura vazia');
-    const filename = saveTo || `screenshot-${Date.now()}.png`;
-    fs.writeFileSync(filename, Buffer.from(r.data, 'base64'));
-    return { ok: true, path: filename, bytes: Buffer.byteLength(r.data, 'base64') };
-}
-
-async function currentUrl() {
-    await ensure();
-    return evaluate('location.href');
-}
-
-async function waitFor(selector, timeoutMs = 15000) {
-    await ensure();
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        const found = await evaluate(`!!document.querySelector(${JSON.stringify(selector)})`);
-        if (found) return { ok: true, selector };
-        await sleep(200);
-    }
-    throw new Error(`timeout esperando seletor: ${selector}`);
-}
-
-async function wait(ms) { await sleep(ms); return { ok: true, ms }; }
-
-async function scroll(dy) {
-    await ensure();
-    await evaluate(`window.scrollBy(0, ${Number(dy)||0})`);
-    return { ok: true, dy };
-}
-
-function close() {
-    if (currentSession) { try { currentSession.close(); } catch {} currentSession = null; }
-    return { ok: true };
-}
-
-module.exports = {
-    open, navigate, click, clickText, clickSelector, type, typeInSelector,
-    key, screenshot, evaluate, currentUrl, waitFor, wait, scroll, close,
-    _internal: { findChrome, PROFILE_DIR, DEBUG_PORT },
-};
+// Controlador do navegador do usuário via CDP (Chrome DevTools Protocol).
+// Sem dependências externas — usa apenas o módulo 'http' e um cliente WebSocket
+// mínimo escrito à mão em cima de 'net'/'tls'.
+//
+// Como funciona:
+//   1) launch() abre o Chrome do usuário com --remote-debugging-port=9222
+//      e um --user-data-dir dedicado (~/.primocode/chrome-profile) — assim
+//      o usuário logado nesse profile persiste (login GitHub, Vercel, etc).
+//   2) attach() descobre a aba ativa em /json/list e abre um WebSocket CDP.
+//   3) send(method, params) envia comandos CDP (Page.navigate, Input.dispatchMouseEvent...).
+//   4) close() encerra a conexão (o Chrome continua aberto para o usuário).
+//
+// Não usamos 'puppeteer' ou 'playwright' — a CLI continua com ZERO deps.
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const net = require('net');
+const path = require('path');
+const http = require('http');
+const crypto = require('crypto');
+const { spawn, execSync } = require('child_process');
+
+const PROFILE_DIR = path.join(os.homedir(), '.primocode', 'chrome-profile');
+const DEBUG_PORT = 9222;
+
+// ---- Helpers ---------------------------------------------------
+function findChrome() {
+    const platform = process.platform;
+    // 1) Respeita a variável de ambiente — aponta para qualquer Chrome/Chromium.
+    const env = [process.env.PRIMOCODE_CHROME, process.env.CHROME_PATH, process.env.CHROMIUM_PATH].filter(Boolean);
+    const candidates = env.concat(platform === 'darwin' ? [
+        '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+        '/Applications/Chromium.app/Contents/MacOS/Chromium',
+        '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+        '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
+    ] : platform === 'win32' ? [
+        `${process.env['PROGRAMFILES']}\\Google\\Chrome\\Application\\chrome.exe`,
+        `${process.env['PROGRAMFILES(X86)']}\\Google\\Chrome\\Application\\chrome.exe`,
+        `${process.env['LOCALAPPDATA']}\\Google\\Chrome\\Application\\chrome.exe`,
+        `${process.env['PROGRAMFILES(X86)']}\\Microsoft\\Edge\\Application\\msedge.exe`,
+        `${process.env['PROGRAMFILES']}\\Microsoft\\Edge\\Application\\msedge.exe`,
+    ] : [
+        '/usr/bin/google-chrome',
+        '/usr/bin/google-chrome-stable',
+        '/usr/bin/chromium',
+        '/usr/bin/chromium-browser',
+        '/snap/bin/chromium',
+        '/usr/bin/microsoft-edge',
+    ]);
+    for (const p of candidates) {
+        try { if (p && fs.existsSync(p)) return p; } catch {}
+    }
+    return null;
+}
+
+function httpGetJson(url, timeoutMs = 3000) {
+    return new Promise((resolve, reject) => {
+        const req = http.get(url, (res) => {
+            let body = '';
+            res.on('data', (d) => (body += d));
+            res.on('end', () => {
+                try { resolve(JSON.parse(body)); } catch (e) { reject(new Error('JSON inválido: ' + body.slice(0, 100))); }
+            });
+        });
+        req.on('error', reject);
+        req.setTimeout(timeoutMs, () => { req.destroy(new Error('timeout')); });
+    });
+}
+
+function httpPutJson(url, timeoutMs = 3000) {
+    return new Promise((resolve, reject) => {
+        const u = new URL(url);
+        const req = http.request({
+            method: 'PUT', hostname: u.hostname, port: u.port, path: u.pathname + u.search,
+        }, (res) => {
+            let body = '';
+            res.on('data', (d) => (body += d));
+            res.on('end', () => {
+                try { resolve(JSON.parse(body)); } catch { resolve({ raw: body }); }
+            });
+        });
+        req.on('error', reject);
+        req.setTimeout(timeoutMs, () => { req.destroy(new Error('timeout')); });
+        req.end();
+    });
+}
+
+function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
+
+// ---- WebSocket client mínimo (RFC 6455) para CDP ----------------
+// Suficiente pra CDP (mensagens curtas, texto UTF-8, um cliente por página).
+class MiniWebSocket {
+    constructor() {
+        this.socket = null;
+        this.buffer = Buffer.alloc(0);
+        this.onMessage = () => {};
+        this.onClose = () => {};
+        this.closed = false;
+    }
+    connect(url) {
+        return new Promise((resolve, reject) => {
+            const u = new URL(url);
+            const isSecure = u.protocol === 'wss:';
+            if (isSecure) return reject(new Error('wss:// não suportado (CDP local usa ws://)'));
+            const key = crypto.randomBytes(16).toString('base64');
+            const port = u.port || 80;
+            const path = u.pathname + (u.search || '');
+            const sock = net.connect(Number(port), u.hostname, () => {
+                const req =
+                    `GET ${path} HTTP/1.1\r\n` +
+                    `Host: ${u.hostname}:${port}\r\n` +
+                    `Upgrade: websocket\r\n` +
+                    `Connection: Upgrade\r\n` +
+                    `Sec-WebSocket-Key: ${key}\r\n` +
+                    `Sec-WebSocket-Version: 13\r\n\r\n`;
+                sock.write(req);
+            });
+            let handshaked = false;
+            let headerBuf = Buffer.alloc(0);
+            sock.on('data', (data) => {
+                if (!handshaked) {
+                    headerBuf = Buffer.concat([headerBuf, data]);
+                    const sep = headerBuf.indexOf('\r\n\r\n');
+                    if (sep === -1) return;
+                    const header = headerBuf.slice(0, sep).toString();
+                    if (!/HTTP\/1\.1 101/.test(header)) return reject(new Error('handshake WS falhou: ' + header.split('\r\n')[0]));
+                    handshaked = true;
+                    this.socket = sock;
+                    const rest = headerBuf.slice(sep + 4);
+                    if (rest.length) this._onData(rest);
+                    resolve();
+                } else {
+                    this._onData(data);
+                }
+            });
+            sock.on('error', (err) => {
+                if (!handshaked) reject(err);
+                this.closed = true; this.onClose(err);
+            });
+            sock.on('close', () => { this.closed = true; this.onClose(); });
+        });
+    }
+    _onData(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        while (this.buffer.length >= 2) {
+            const b0 = this.buffer[0];
+            const b1 = this.buffer[1];
+            const fin = (b0 & 0x80) !== 0;
+            const opcode = b0 & 0x0f;
+            const masked = (b1 & 0x80) !== 0;
+            let len = b1 & 0x7f;
+            let offset = 2;
+            if (len === 126) {
+                if (this.buffer.length < 4) return;
+                len = this.buffer.readUInt16BE(2);
+                offset = 4;
+            } else if (len === 127) {
+                if (this.buffer.length < 10) return;
+                // ignora high 32 bits (mensagens CDP < 4GB)
+                len = this.buffer.readUInt32BE(6);
+                offset = 10;
+            }
+            let maskKey;
+            if (masked) {
+                if (this.buffer.length < offset + 4) return;
+                maskKey = this.buffer.slice(offset, offset + 4);
+                offset += 4;
+            }
+            if (this.buffer.length < offset + len) return;
+            let payload = this.buffer.slice(offset, offset + len);
+            if (masked && maskKey) {
+                const un = Buffer.alloc(payload.length);
+                for (let i = 0; i < payload.length; i++) un[i] = payload[i] ^ maskKey[i % 4];
+                payload = un;
+            }
+            this.buffer = this.buffer.slice(offset + len);
+            if (opcode === 0x8) { this._close(); return; }
+            if (opcode === 0x9) { this._sendFrame(0xa, payload); continue; } // ping -> pong
+            if (opcode === 0xa) continue; // pong
+            if (opcode === 0x1 || opcode === 0x0) {
+                // texto (não tratamos fragmentação — CDP não fragmenta)
+                if (fin) this.onMessage(payload.toString('utf8'));
+            }
+        }
+    }
+    _sendFrame(opcode, payload) {
+        if (!this.socket || this.closed) return;
+        const len = payload.length;
+        let header;
+        // cliente DEVE mascarar
+        const mask = crypto.randomBytes(4);
+        if (len < 126) {
+            header = Buffer.alloc(2);
+            header[0] = 0x80 | opcode;
+            header[1] = 0x80 | len;
+        } else if (len < 65536) {
+            header = Buffer.alloc(4);
+            header[0] = 0x80 | opcode;
+            header[1] = 0x80 | 126;
+            header.writeUInt16BE(len, 2);
+        } else {
+            header = Buffer.alloc(10);
+            header[0] = 0x80 | opcode;
+            header[1] = 0x80 | 127;
+            header.writeUInt32BE(0, 2);
+            header.writeUInt32BE(len, 6);
+        }
+        const masked = Buffer.alloc(len);
+        for (let i = 0; i < len; i++) masked[i] = payload[i] ^ mask[i % 4];
+        this.socket.write(Buffer.concat([header, mask, masked]));
+    }
+    send(str) { this._sendFrame(0x1, Buffer.from(str, 'utf8')); }
+    _close() { if (this.socket) { try { this.socket.end(); } catch {} } this.closed = true; }
+    close() { this._sendFrame(0x8, Buffer.alloc(0)); this._close(); }
+}
+
+// ---- Sessão CDP -------------------------------------------------
+class CDPSession {
+    constructor() {
+        this.ws = null;
+        this.msgId = 0;
+        this.pending = new Map(); // id -> { resolve, reject }
+        this.targetId = null;
+    }
+    async attach(wsUrl) {
+        this.ws = new MiniWebSocket();
+        this.ws.onMessage = (raw) => this._onMessage(raw);
+        this.ws.onClose = () => { this.pending.forEach(({ reject }) => reject(new Error('ws fechado'))); };
+        await this.ws.connect(wsUrl);
+    }
+    _onMessage(raw) {
+        let msg;
+        try { msg = JSON.parse(raw); } catch { return; }
+        if (msg.id !== undefined && this.pending.has(msg.id)) {
+            const { resolve, reject } = this.pending.get(msg.id);
+            this.pending.delete(msg.id);
+            if (msg.error) reject(new Error(msg.error.message || 'erro CDP'));
+            else resolve(msg.result || {});
+        }
+        // eventos são ignorados (não usamos aqui)
+    }
+    send(method, params = {}, timeoutMs = 15000) {
+        const id = ++this.msgId;
+        const payload = JSON.stringify({ id, method, params });
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                if (this.pending.has(id)) { this.pending.delete(id); reject(new Error(`timeout ${method}`)); }
+            }, timeoutMs);
+            this.pending.set(id, {
+                resolve: (r) => { clearTimeout(timer); resolve(r); },
+                reject: (e) => { clearTimeout(timer); reject(e); },
+            });
+            this.ws.send(payload);
+        });
+    }
+    close() { if (this.ws) this.ws.close(); }
+}
+
+// ---- Estado do módulo -------------------------------------------
+let currentSession = null;
+let chromeChild = null;
+
+async function ensureChromeRunning() {
+    // Já responde na porta?
+    try {
+        const v = await httpGetJson(`http://127.0.0.1:${DEBUG_PORT}/json/version`, 800);
+        if (v && v.webSocketDebuggerUrl) return { launched: false, version: v.Browser || 'chrome' };
+    } catch {}
+
+    const chrome = findChrome();
+    if (!chrome) throw new Error('Google Chrome não encontrado no sistema. Instale o Chrome para usar o controle de navegador.');
+
+    fs.mkdirSync(PROFILE_DIR, { recursive: true });
+
+    const args = [
+        `--remote-debugging-port=${DEBUG_PORT}`,
+        `--user-data-dir=${PROFILE_DIR}`,
+        '--no-first-run',
+        '--no-default-browser-check',
+        '--disable-features=Translate',
+    ];
+    // Chrome recusa rodar como root com sandbox — comum em containers/servidores.
+    if (process.platform === 'linux' && process.getuid && process.getuid() === 0) {
+        args.push('--no-sandbox');
+    }
+    // Sem interface gráfica (CI, servidor): PRIMOCODE_BROWSER_HEADLESS=1.
+    if (process.env.PRIMOCODE_BROWSER_HEADLESS === '1' || process.env.PRIMOCODE_BROWSER_HEADLESS === 'true') {
+        args.push('--headless=new', '--disable-gpu', '--disable-dev-shm-usage');
+    }
+    args.push('about:blank');
+    chromeChild = spawn(chrome, args, { detached: true, stdio: 'ignore' });
+    chromeChild.on('error', () => {});
+    chromeChild.unref();
+
+    // Espera a porta responder
+    const deadline = Date.now() + 12000;
+    let lastErr;
+    while (Date.now() < deadline) {
+        try {
+            const v = await httpGetJson(`http://127.0.0.1:${DEBUG_PORT}/json/version`, 500);
+            if (v && v.webSocketDebuggerUrl) return { launched: true, version: v.Browser || 'chrome' };
+        } catch (e) { lastErr = e; }
+        await sleep(250);
+    }
+    throw new Error('Chrome iniciou mas não expôs a porta de debug: ' + (lastErr ? lastErr.message : ''));
+}
+
+async function findOrCreatePageTarget(url) {
+    const list = await httpGetJson(`http://127.0.0.1:${DEBUG_PORT}/json/list`, 2000);
+    // 1) tenta reaproveitar uma aba já ativa
+    const existing = Array.isArray(list) ? list.find(t => t.type === 'page' && !t.url.startsWith('devtools://')) : null;
+    if (existing) return existing;
+    // 2) senão, cria nova
+    const created = await httpPutJson(`http://127.0.0.1:${DEBUG_PORT}/json/new?${encodeURIComponent(url || 'about:blank')}`, 3000);
+    return created;
+}
+
+async function connect(url) {
+    await ensureChromeRunning();
+    const target = await findOrCreatePageTarget(url);
+    if (!target || !target.webSocketDebuggerUrl) throw new Error('Não foi possível obter alvo de página do Chrome.');
+    if (currentSession) { try { currentSession.close(); } catch {} }
+    currentSession = new CDPSession();
+    currentSession.targetId = target.id;
+    await currentSession.attach(target.webSocketDebuggerUrl);
+    await currentSession.send('Page.enable');
+    await currentSession.send('DOM.enable');
+    await currentSession.send('Runtime.enable');
+    return { targetId: target.id, url: target.url };
+}
+
+async function ensure(url) {
+    if (!currentSession || currentSession.ws?.closed) return connect(url);
+    return { targetId: currentSession.targetId, url: '(reused)' };
+}
+
+// ---- Ações ------------------------------------------------------
+async function open(url) {
+    await ensure(url);
+    // Navega até URL solicitada
+    await currentSession.send('Page.navigate', { url });
+    // Espera "load" simples via polling do document.readyState
+    const deadline = Date.now() + 20000;
+    while (Date.now() < deadline) {
+        const r = await currentSession.send('Runtime.evaluate', {
+            expression: 'document.readyState', returnByValue: true,
+        });
+        if (r.result && r.result.value === 'complete') break;
+        await sleep(200);
+    }
+    return { ok: true, url };
+}
+
+async function navigate(url) { return open(url); }
+
+async function evaluate(js) {
+    await ensure();
+    const r = await currentSession.send('Runtime.evaluate', {
+        expression: js, returnByValue: true, awaitPromise: true,
+    });
+    if (r.exceptionDetails) throw new Error(r.exceptionDetails.text || r.exceptionDetails.exception?.description || 'JS error');
+    return r.result ? r.result.value : undefined;
+}
+
+async function click(x, y) {
+    await ensure();
+    await currentSession.send('Input.dispatchMouseEvent', { type: 'mouseMoved', x, y });
+    await currentSession.send('Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button: 'left', clickCount: 1 });
+    await currentSession.send('Input.dispatchMouseEvent', { type: 'mouseReleased', x, y, button: 'left', clickCount: 1 });
+    return { ok: true, x, y };
+}
+
+async function clickText(text) {
+    await ensure();
+    // procura elemento clicável cujo texto contenha o alvo e retorna centro do bounding box
+    const js = `(function(){
+        const t = ${JSON.stringify(text)}.toLowerCase();
+        const nodes = Array.from(document.querySelectorAll('a,button,[role="button"],input[type="submit"],input[type="button"],label'));
+        for (const el of nodes) {
+            const s = (el.innerText || el.value || el.getAttribute('aria-label') || '').toLowerCase().trim();
+            if (s && s.includes(t)) {
+                const r = el.getBoundingClientRect();
+                if (r.width && r.height) {
+                    el.scrollIntoView({block:'center'});
+                    const r2 = el.getBoundingClientRect();
+                    return { x: r2.left + r2.width/2, y: r2.top + r2.height/2, tag: el.tagName, text: s.slice(0,80) };
+                }
+            }
+        }
+        return null;
+    })()`;
+    const found = await evaluate(js);
+    if (!found) throw new Error(`nenhum elemento clicável encontrado com texto: ${text}`);
+    await sleep(200);
+    await click(found.x, found.y);
+    return { ok: true, ...found };
+}
+
+async function clickSelector(selector) {
+    await ensure();
+    const js = `(function(){
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return null;
+        el.scrollIntoView({block:'center'});
+        const r = el.getBoundingClientRect();
+        return { x: r.left + r.width/2, y: r.top + r.height/2, tag: el.tagName };
+    })()`;
+    const found = await evaluate(js);
+    if (!found) throw new Error(`seletor não encontrado: ${selector}`);
+    await sleep(200);
+    await click(found.x, found.y);
+    return { ok: true, selector, ...found };
+}
+
+async function type(text) {
+    await ensure();
+    // Insere via CDP
+    for (const ch of text) {
+        await currentSession.send('Input.insertText', { text: ch });
+    }
+    return { ok: true, len: text.length };
+}
+
+async function typeInSelector(selector, text, clear = true) {
+    await ensure();
+    const focused = await evaluate(`(function(){
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return false;
+        el.focus();
+        ${clear ? "if ('value' in el) el.value = '';" : ''}
+        return true;
+    })()`);
+    if (!focused) throw new Error(`seletor não encontrado: ${selector}`);
+    await type(text);
+    // dispara evento input para frameworks reativos
+    await evaluate(`(function(){
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (el) { el.dispatchEvent(new Event('input', {bubbles:true})); el.dispatchEvent(new Event('change', {bubbles:true})); }
+    })()`);
+    return { ok: true, selector, len: text.length };
+}
+
+async function key(name) {
+    // 'Enter', 'Tab', 'Escape', 'Backspace', 'ArrowDown'...
+    const map = {
+        Enter:      { code: 'Enter',      key: 'Enter',      windowsVirtualKeyCode: 13, text: '\r' },
+        Tab:        { code: 'Tab',        key: 'Tab',        windowsVirtualKeyCode: 9 },
+        Escape:     { code: 'Escape',     key: 'Escape',     windowsVirtualKeyCode: 27 },
+        Backspace:  { code: 'Backspace',  key: 'Backspace',  windowsVirtualKeyCode: 8 },
+        ArrowDown:  { code: 'ArrowDown',  key: 'ArrowDown',  windowsVirtualKeyCode: 40 },
+        ArrowUp:    { code: 'ArrowUp',    key: 'ArrowUp',    windowsVirtualKeyCode: 38 },
+        ArrowLeft:  { code: 'ArrowLeft',  key: 'ArrowLeft',  windowsVirtualKeyCode: 37 },
+        ArrowRight: { code: 'ArrowRight', key: 'ArrowRight', windowsVirtualKeyCode: 39 },
+    };
+    const k = map[name];
+    if (!k) throw new Error(`tecla desconhecida: ${name}`);
+    await ensure();
+    await currentSession.send('Input.dispatchKeyEvent', { type: 'keyDown', ...k });
+    await currentSession.send('Input.dispatchKeyEvent', { type: 'keyUp', ...k });
+    return { ok: true, key: name };
+}
+
+async function screenshot(saveTo) {
+    await ensure();
+    const r = await currentSession.send('Page.captureScreenshot', { format: 'png' });
+    if (!r.data) throw new Error('captura vazia');
+    const filename = saveTo || `screenshot-${Date.now()}.png`;
+    fs.writeFileSync(filename, Buffer.from(r.data, 'base64'));
+    return { ok: true, path: filename, bytes: Buffer.byteLength(r.data, 'base64') };
+}
+
+async function currentUrl() {
+    await ensure();
+    return evaluate('location.href');
+}
+
+async function waitFor(selector, timeoutMs = 15000) {
+    await ensure();
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const found = await evaluate(`!!document.querySelector(${JSON.stringify(selector)})`);
+        if (found) return { ok: true, selector };
+        await sleep(200);
+    }
+    throw new Error(`timeout esperando seletor: ${selector}`);
+}
+
+async function wait(ms) { await sleep(ms); return { ok: true, ms }; }
+
+async function scroll(dy) {
+    await ensure();
+    await evaluate(`window.scrollBy(0, ${Number(dy)||0})`);
+    return { ok: true, dy };
+}
+
+function close() {
+    if (currentSession) { try { currentSession.close(); } catch {} currentSession = null; }
+    return { ok: true };
+}
+
+module.exports = {
+    open, navigate, click, clickText, clickSelector, type, typeInSelector,
+    key, screenshot, evaluate, currentUrl, waitFor, wait, scroll, close,
+    _internal: { findChrome, PROFILE_DIR, DEBUG_PORT },
+};