@testmuai/playwright-bindings 0.1.17 → 0.1.19-beta.1

package/dist/helpers/devtools.js

@@ -1,6 +1,7 @@
 import { ClipboardStore, installClipboard, pasteViaPage, runClipboardQuery } from './clipboard.js';
 import * as configure from '../configure.js';
 import { log } from '../log.js';
+import { SSEWireParser } from './sseParser.js';
 // ── State ──
 let networkEntries = [];
 let networkSequence = 0;
@@ -14,14 +15,29 @@ let wsActive = false;
 let wsConfigured = false; // true once WS capture was started this run
 let wsSeq = 0; // global monotonic across all connections
 let wsConnCounter = 0; // connection-id allocator
+// SSE capture (CDP-based, Chromium-only). CDP sessions are NOT auto-managed
+// like page.on — keep a page->CDPSession registry and detach each on stop.
+let sseConnections = [];
+let sseActive = false;
+let sseConfigured = false; // true once SSE capture was started this run
+let sseSeq = 0; // global monotonic across all connections
+let sseConnCounter = 0; // connection-id allocator
+const sseMsgCounter = new Map(); // connectionId -> per-conn messageIndex
+const sseSessions = new Map(); // the page->session registry
+const sseTasks = new Set(); // pending scheduled tasks (response/popup)
 let pageRef = null;
 let contextRef = null;
+let pageListenerActive = false; // true once context.on('page') is wired this run
+let extraPages = []; // tabs opened mid-run that got capture listeners
 const MAX_NETWORK = 5000;
 const MAX_BODY = 65536;
 const MAX_CONSOLE = 50000;
 const MAX_WS_CONN = 256;
 const MAX_WS_FRAMES = 2000;
 const WS_PRESERVE_FIRST_N = 20;
+const MAX_SSE_CONN = 256;
+const MAX_SSE_MSGS = 2000;
+const SSE_PRESERVE_FIRST_N = 20;
 // Raw-byte budget for a binary frame so its base64 stays <= MAX_BODY and decodes cleanly
 // (multiple of 3 → no mid-stream base64 padding). Math.floor(65536/4)*3 = 49152. Matches Python.
 const MAX_WS_RAW_BUDGET = Math.floor(MAX_BODY / 4) * 3;
@@ -47,6 +63,19 @@ export async function startCapture(page, context) {
         startConsoleCapture(page);
     if (devtools.websocket)
         startWebSocketCapture(page);
+    if (devtools.sse) {
+        // SSE rides a CDP session (Chromium-only); attach is async. The
+        // non-Chromium hard-fail lives in session.ts run() BEFORE this runs.
+        await startSSECaptureInitial(page);
+    }
+    // Page-based captures (network/console/websocket/sse) only listen on the page
+    // they were attached to. Re-arm them on tabs opened later (window.open,
+    // target=_blank) via the context's 'page' event — otherwise those tabs are
+    // silently uncaptured. (performance/clipboard ride context init scripts and
+    // already cover every page.)
+    if (devtools.network || devtools.console || devtools.websocket || devtools.sse) {
+        attachContextPageListener(context);
+    }
     if (devtools.performance)
         await installPerformance(context);
     const enabled = Object.entries(devtools).filter(([, v]) => v).map(([k]) => k);
@@ -54,14 +83,86 @@ export async function startCapture(page, context) {
         log.test(`DevTools capture started: ${enabled.join(', ')}`);
 }
 export function stopCapture(page) {
+    detachContextPageListener();
     if (networkActive)
         stopNetworkCapture(page);
     if (consoleActive)
         stopConsoleCapture(page);
     if (wsActive)
         stopWebSocketCapture(page);
+    // SSE CDP sessions are detached asynchronously by stopSSECapture(); this sync
+    // stop only flips sseActive off (so handlers short-circuit). The context
+    // 'page' listener is removed above, so no new popup-attach task is scheduled
+    // before stopSSECapture() drains and detaches.
+    sseActive = false;
+    // The per-type stops above only detach the initial page; also detach the
+    // tabs opened mid-run so no listener outlives the capture session.
+    detachExtraPages();
+}
+// ── New-page propagation — capture tabs opened after startCapture ──
+function attachContextPageListener(context) {
+    if (pageListenerActive || !context)
+        return;
+    try {
+        context.on('page', onNewPage);
+        pageListenerActive = true;
+    }
+    catch { /* ignore */ }
+}
+function detachContextPageListener() {
+    if (pageListenerActive && contextRef) {
+        try {
+            contextRef.removeListener('page', onNewPage);
+        }
+        catch { /* ignore */ }
+    }
+    pageListenerActive = false;
+}
+function detachExtraPages() {
+    // Removing a listener that was never attached (only network enabled, say) is
+    // a safe no-op.
+    for (const p of extraPages) {
+        detachNetworkListeners(p);
+        detachConsoleListeners(p);
+        detachWebSocketListeners(p);
+    }
+    extraPages = [];
+}
+function onNewPage(page) {
+    // Attach the currently-active capture listeners to a newly opened page.
+    // Attach-only — never resets accumulated state (which the start* helpers do).
+    // Each capture type is guarded independently so one failure can't skip the rest.
+    let attached = false;
+    for (const [active, attach] of [
+        [networkActive, attachNetworkListeners],
+        [consoleActive, attachConsoleListeners],
+        [wsActive, attachWebSocketListeners],
+    ]) {
+        if (!active)
+            continue;
+        try {
+            attach(page);
+            attached = true;
+        }
+        catch { /* ignore */ }
+    }
+    // SSE attach is async (own CDP session) — schedule it as a tracked task.
+    // The session is registered in sseSessions and detached by stopSSECapture.
+    if (sseActive) {
+        try {
+            schedule(attachSseToPage(page));
+        }
+        catch { /* ignore */ }
+    }
+    if (attached && !extraPages.includes(page))
+        extraPages.push(page);
 }
 export function resetCapture() {
+    // Remove any live listeners on the (possibly reused) context/tabs before
+    // dropping our refs, so a later startCapture can't double-register them.
+    // detachContextPageListener() also clears pageListenerActive.
+    detachContextPageListener();
+    detachExtraPages();
     networkEntries = [];
     networkSequence = 0;
     networkActive = false;
@@ -75,6 +176,17 @@ export function resetCapture() {
     wsConnCounter = 0;
     wsById.clear();
     wsFrameCounter.clear();
+    // SSE: best-effort sync reset for test isolation. Live CDP sessions should be
+    // detached via stopSSECapture() in the async teardown; here we drop refs so a
+    // fresh run starts clean.
+    sseConnections = [];
+    sseActive = false;
+    sseConfigured = false;
+    sseSeq = 0;
+    sseConnCounter = 0;
+    sseMsgCounter.clear();
+    sseSessions.clear();
+    sseTasks.clear();
     pendingRequests.clear();
     pageRef = null;
     contextRef = null;
@@ -84,13 +196,15 @@ function startNetworkCapture(page) {
     networkEntries = [];
     networkSequence = 0;
     networkActive = true;
+    attachNetworkListeners(page);
+}
+function attachNetworkListeners(page) {
     page.on('request', onRequest);
     page.on('response', onResponse);
     page.on('requestfinished', onRequestFinished);
     page.on('requestfailed', onRequestFailed);
 }
-function stopNetworkCapture(page) {
-    networkActive = false;
+function detachNetworkListeners(page) {
     try {
         page.removeListener('request', onRequest);
         page.removeListener('response', onResponse);
@@ -99,13 +213,27 @@ function stopNetworkCapture(page) {
     }
     catch { /* ignore */ }
 }
+function stopNetworkCapture(page) {
+    networkActive = false;
+    detachNetworkListeners(page);
+}
 function onRequest(request) {
     if (!networkActive)
         return;
     const u = new URL(request.url());
     const qp = {};
     u.searchParams.forEach((v, k) => { qp[k] = v; });
-    let requestBody = request.postData() ?? null;
+    // request.postData() decodes the body via Buffer.toString('utf-8'), which
+    // substitutes invalid bytes (it won't throw the way Python's post_data does),
+    // but guard anyway so a future Playwright change can't let an error escape
+    // this event listener — parity with the Python binding.
+    let requestBody;
+    try {
+        requestBody = request.postData() ?? null;
+    }
+    catch {
+        requestBody = null;
+    }
     if (requestBody && requestBody.length > MAX_BODY) {
         requestBody = requestBody.slice(0, MAX_BODY);
     }
@@ -147,7 +275,14 @@ async function onResponse(response) {
     entry.responseStatus = response.status();
     entry.responseHeaders = await response.allHeaders();
     const ct = entry.responseHeaders['content-type'] ?? '';
-    if (TEXT_TYPES.some(t => ct.includes(t))) {
+    // SSE responses (text/event-stream) are long-lived streams whose body
+    // never resolves until the stream closes — reading it here would hang the
+    // capture. SSE is captured separately via CDP, so skip the body read.
+    // Match before the generic 'text' substring (which catches event-stream).
+    if (ct.includes('text/event-stream')) {
+        entry.responseBody = null;
+    }
+    else if (TEXT_TYPES.some(t => ct.includes(t))) {
         try {
             let body = await response.text();
             if (body.length > MAX_BODY)
@@ -184,17 +319,23 @@ function startConsoleCapture(page) {
     consoleEntries = [];
     consoleSequence = 0;
     consoleActive = true;
+    attachConsoleListeners(page);
+}
+function attachConsoleListeners(page) {
     page.on('console', onConsoleMessage);
     page.on('pageerror', onPageError);
 }
-function stopConsoleCapture(page) {
-    consoleActive = false;
+function detachConsoleListeners(page) {
     try {
         page.removeListener('console', onConsoleMessage);
         page.removeListener('pageerror', onPageError);
     }
     catch { /* ignore */ }
 }
+function stopConsoleCapture(page) {
+    consoleActive = false;
+    detachConsoleListeners(page);
+}
 async function onConsoleMessage(msg) {
     if (!consoleActive)
         return;
@@ -259,15 +400,21 @@ function startWebSocketCapture(page) {
     wsConnCounter = 0;
     wsById.clear();
     wsFrameCounter.clear();
+    attachWebSocketListeners(page);
+}
+function attachWebSocketListeners(page) {
     page.on('websocket', onWebSocket);
 }
-function stopWebSocketCapture(page) {
-    wsActive = false;
+function detachWebSocketListeners(page) {
     try {
         page.removeListener('websocket', onWebSocket);
     }
     catch { /* ignore */ }
 }
+function stopWebSocketCapture(page) {
+    wsActive = false;
+    detachWebSocketListeners(page);
+}
 function onWebSocket(ws) {
     if (!wsActive)
         return;
@@ -392,6 +539,254 @@ function reindexWsById(removed) {
             wsById.set(k, v - 1);
     }
 }
+// ── SSE capture (CDP, Chromium-only) ──
+function schedule(p) {
+    // Track a scheduled task so teardown can drain it; remove on completion.
+    sseTasks.add(p);
+    void p.finally(() => sseTasks.delete(p));
+}
+function normSseEvent(name) {
+    // CDP eventName "" or "message" -> null (default event type).
+    return !name || name === 'message' ? null : name;
+}
+function isEventStream(resp) {
+    const mime = (resp.mimeType ?? '').split(';')[0].trim().toLowerCase();
+    if (mime === 'text/event-stream')
+        return true;
+    const headers = resp.headers ?? {};
+    const ct = headers['content-type'] ?? headers['Content-Type'] ?? '';
+    return ct.toLowerCase().includes('text/event-stream');
+}
+function allocSseConn(url, transport) {
+    if (sseConnections.length >= MAX_SSE_CONN)
+        evictOldestClosedSse();
+    let domain = '';
+    let path = '/';
+    try {
+        const u = new URL(url || '');
+        domain = u.hostname;
+        path = u.pathname || '/';
+    }
+    catch { /* malformed */ }
+    const conn = {
+        connectionId: `sse_${sseConnCounter}`,
+        url: url || '', domain, path,
+        openedTsMs: Date.now(),
+        closedTsMs: null,
+        error: null,
+        transport,
+        messages: [],
+        droppedMessages: 0,
+    };
+    sseConnCounter++;
+    sseConnections.push(conn);
+    return conn;
+}
+function appendSseMessage(conn, msg) {
+    // per-connection ring with first-N preserved; messageIndex stays monotonic via
+    // sseMsgCounter (NOT messages.length, which repeats after eviction).
+    if (conn.messages.length >= MAX_SSE_MSGS) {
+        if (SSE_PRESERVE_FIRST_N < conn.messages.length) {
+            conn.messages.splice(SSE_PRESERVE_FIRST_N, 1);
+            conn.droppedMessages++;
+        }
+    }
+    conn.messages.push(msg);
+}
+function evictOldestClosedSse() {
+    // Session request-maps hold object refs (not indices), so no re-index needed;
+    // just drop the evicted conn's message counter.
+    for (let i = 0; i < sseConnections.length; i++) {
+        if (sseConnections[i].closedTsMs !== null) {
+            sseMsgCounter.delete(sseConnections[i].connectionId);
+            sseConnections.splice(i, 1);
+            return;
+        }
+    }
+    if (sseConnections.length) {
+        sseMsgCounter.delete(sseConnections[0].connectionId);
+        sseConnections.splice(0, 1);
+    }
+}
+function emitSse(conn, ev, transport) {
+    if (!sseActive)
+        return;
+    try {
+        let data = ev.data ?? '';
+        const truncated = Boolean(ev.truncated) || data.length > MAX_BODY;
+        data = data.slice(0, MAX_BODY);
+        const cid = conn.connectionId;
+        const midx = sseMsgCounter.get(cid) ?? 0;
+        sseMsgCounter.set(cid, midx + 1);
+        appendSseMessage(conn, {
+            connectionId: cid,
+            data,
+            event: ev.event,
+            id: ev.id,
+            retry: ev.retry,
+            transport,
+            truncated,
+            tsMs: Date.now(),
+            seq: sseSeq,
+            messageIndex: midx,
+        });
+        sseSeq++;
+    }
+    catch { /* ignore */ }
+}
+/**
+ * Create a CDP session on `page`, wire SSE handlers, register it in the
+ * page->session registry, and return it. Handlers close over per-session request
+ * maps (requestId collides across CDP targets).
+ */
+export async function startSSECapture(page) {
+    const cdp = await page.context().newCDPSession(page);
+    await cdp.send('Network.enable');
+    const streams = new Map();
+    const native = new Map();
+    const getNativeConn = (rid, url = '') => {
+        let conn = native.get(rid);
+        if (!conn) {
+            conn = allocSseConn(url, 'eventsource');
+            native.set(rid, conn);
+        }
+        else if (url && !conn.url) {
+            conn.url = url;
+            try {
+                const u = new URL(url);
+                conn.domain = u.hostname;
+                conn.path = u.pathname || '/';
+            }
+            catch { /* malformed */ }
+        }
+        return conn;
+    };
+    const decodeB64 = (b64) => Buffer.from(b64, 'base64');
+    cdp.on('Network.eventSourceMessageReceived', (p) => {
+        if (!sseActive)
+            return;
+        try {
+            const conn = getNativeConn(p.requestId);
+            emitSse(conn, {
+                event: normSseEvent(p.eventName),
+                data: p.data ?? '',
+                id: p.eventId || null,
+                retry: null,
+            }, 'eventsource');
+        }
+        catch { /* ignore */ }
+    });
+    const onResponse = async (p) => {
+        if (!sseActive)
+            return;
+        try {
+            const resp = p.response ?? {};
+            if (!isEventStream(resp))
+                return;
+            const rid = p.requestId;
+            const rtype = p.type ?? 'Other';
+            if (rtype === 'EventSource') {
+                // Native EventSource is pre-parsed; never stream it (double-count).
+                getNativeConn(rid, resp.url ?? '');
+                return;
+            }
+            const transport = rtype.toLowerCase();
+            const conn = allocSseConn(resp.url ?? '', transport);
+            // NOT-yet-primed: dataReceived arriving during the streamResourceContent await
+            // is queued (not fed) so bufferedData (earlier bytes) parses first — ordering
+            // must not rely on event-loop scheduling (a buffered burst on connect would
+            // otherwise corrupt the parse).
+            const entry = { conn, parser: new SSEWireParser(), dec: new TextDecoder('utf-8'), transport, primed: false, pending: [] };
+            streams.set(rid, entry);
+            let buffered;
+            try {
+                const res = await cdp.send('Network.streamResourceContent', { requestId: rid });
+                buffered = res?.bufferedData;
+            }
+            catch {
+                buffered = undefined;
+            }
+            if (buffered) {
+                for (const ev of entry.parser.feed(entry.dec.decode(decodeB64(buffered), { stream: true })))
+                    emitSse(conn, ev, transport);
+            }
+            for (const chunk of entry.pending) {
+                for (const ev of entry.parser.feed(entry.dec.decode(decodeB64(chunk), { stream: true })))
+                    emitSse(conn, ev, transport);
+            }
+            entry.pending = [];
+            entry.primed = true;
+        }
+        catch { /* ignore */ }
+    };
+    cdp.on('Network.responseReceived', (p) => schedule(onResponse(p)));
+    cdp.on('Network.dataReceived', (p) => {
+        if (!sseActive)
+            return;
+        try {
+            const st = streams.get(p.requestId);
+            if (!st || !p.data)
+                return;
+            if (!st.primed) {
+                st.pending.push(p.data);
+                return;
+            }
+            for (const ev of st.parser.feed(st.dec.decode(decodeB64(p.data), { stream: true })))
+                emitSse(st.conn, ev, st.transport);
+        }
+        catch { /* ignore */ }
+    });
+    const markClosed = (rid, error) => {
+        try {
+            const conn = streams.get(rid)?.conn ?? native.get(rid);
+            if (!conn)
+                return;
+            conn.closedTsMs = Date.now();
+            if (error)
+                conn.error = String(error);
+        }
+        catch { /* ignore */ }
+    };
+    cdp.on('Network.loadingFinished', (p) => markClosed(p.requestId));
+    cdp.on('Network.loadingFailed', (p) => markClosed(p.requestId, p.errorText));
+    sseSessions.set(page, cdp);
+    return cdp;
+}
+async function startSSECaptureInitial(page) {
+    sseConnections = [];
+    sseActive = true;
+    sseConfigured = true;
+    sseSeq = 0;
+    sseConnCounter = 0;
+    sseMsgCounter.clear();
+    sseSessions.clear();
+    await startSSECapture(page);
+}
+async function attachSseToPage(page) {
+    // Popup attach: a tab opened after startCapture gets its own CDP session.
+    try {
+        await startSSECapture(page);
+    }
+    catch { /* ignore */ }
+}
+/**
+ * Async SSE teardown: stop handlers, drain pending tasks, detach every CDP
+ * session. The context 'page' listener is removed by the sync stopCapture
+ * BEFORE this runs, so no new popup-attach task can be scheduled mid-teardown.
+ */
+export async function stopSSECapture() {
+    sseActive = false;
+    const pending = [...sseTasks];
+    if (pending.length)
+        await Promise.allSettled(pending);
+    for (const cdp of [...sseSessions.values()]) {
+        try {
+            await cdp.detach();
+        }
+        catch { /* ignore */ }
+    }
+    sseSessions.clear();
+}
 // ── Performance ──
 const WEB_VITALS_INIT_SCRIPT = 
 // Vendored web-vitals v4 IIFE
@@ -489,6 +884,43 @@ function buildWebSocketAPI() {
         get all() { return [...wsConnections]; },
     };
 }
+/**
+ * Build a query API object for SSE — injected as `sse` into the user's code,
+ * alongside `network`. Light filters; the query code does the rest. Mirror of
+ * the Python _ReadOnlySSELog.
+ */
+function buildSSEAPI() {
+    const matchUrl = (c, url, urlGlob) => {
+        if (url && c.url !== url)
+            return false;
+        if (urlGlob && !globToRegExp(urlGlob).test(c.url))
+            return false;
+        return true;
+    };
+    return {
+        connections(filter) {
+            let results = [...sseConnections];
+            if (filter)
+                results = results.filter(c => matchUrl(c, filter.url, filter.urlGlob));
+            return results;
+        },
+        messages(filter) {
+            const out = [];
+            for (const c of sseConnections) {
+                if (filter && !matchUrl(c, filter.url, filter.urlGlob))
+                    continue;
+                for (const m of c.messages) {
+                    if (filter?.event !== undefined && m.event !== filter.event)
+                        continue;
+                    out.push(m);
+                }
+            }
+            out.sort((a, b) => a.seq - b.seq); // global merge order across connections
+            return out;
+        },
+        get all() { return [...sseConnections]; },
+    };
+}
 /**
  * Build a query API object for console — injected as `consoleLog` into the user's code.
  */
@@ -534,19 +966,24 @@ function buildStorageAPI(data) {
     };
 }
 export async function devtoolsNetworkQuery(codeJs) {
-    const network = buildNetworkAPI();
     try {
-        // Pass the `websocket` arg only when WS capture was configured, so the no-WS
-        // call stays the original single-arg form.
-        let result;
+        // Build args dynamically, gated on the PERSISTENT configured flags (never
+        // .length — eviction can splice connections to 0 mid-session, which would
+        // drop the object and silently pass + regress WS). websocket and sse are
+        // independent: a query can use network only, +ws, +sse, or all three. When
+        // neither was configured this is the exact single-arg form (byte-identical).
+        const names = ['network'];
+        const values = [buildNetworkAPI()];
         if (wsConfigured) {
-            const fn = new Function('network', 'websocket', `"use strict";\n${codeJs}`);
-            result = fn(network, buildWebSocketAPI());
+            names.push('websocket');
+            values.push(buildWebSocketAPI());
         }
-        else {
-            const fn = new Function('network', `"use strict";\n${codeJs}`);
-            result = fn(network);
+        if (sseConfigured) {
+            names.push('sse');
+            values.push(buildSSEAPI());
         }
+        const fn = new Function(...names, `"use strict";\n${codeJs}`);
+        const result = fn(...values);
         return result != null ? String(result) : '';
     }
     catch (e) {