Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
Fix CDP execution context replay on reconnect
ldm09800a2b0913e
diff --git a/moli-cdp-smoke/README.md b/moli-cdp-smoke/README.mdindex e70786c92..4494f2f23 100644--- a/moli-cdp-smoke/README.md+++ b/moli-cdp-smoke/README.md@@ -70,6 +70,16 @@ the CDP Network success/failure terminal skeleton. The local Chromium sourcecheckout remains useful for locating the WPT assets but is not counted as anexecutable pass while its snapshot and binary are mismatched.+The Puppeteer existing-Page reconnect contract was calibrated on 2026-08-19+with the pinned puppeteer-core 24.30.0 against Debian `/usr/bin/chromium`+145.0.7632.116. One complete Puppeteer-group run created a second Page through+`PUT /json/new`, evaluated in the original Page through one `puppeteer.connect()`+session, disconnected that session, and evaluated the same target and retained+main-world marker through a replacement connection. Chromium returned `42` in+both sessions. The identical probe timed out at the replacement evaluation after+10,000 ms when Moli's parent-session renderer-inspector detach fix was removed,+and passed after the fix was restored.+## Current CoverageThe current suite is a strong core smoke gate, not a complete Playwright compatibility suite.@@ -129,7 +139,7 @@ Covered well:live DOM text; sampled `innerText` is recorded but may remain stale until thenext layout refresh by design.- The focused raw `dom-parser-mutations` group holds a parser-blocking head script after an early head-only `DOM.getDocument` and requires Chromium's exact root-agent sequence: commit `DOM.documentUpdated`, parser-tail BODY `DOM.childNodeInserted`, DCL `DOM.documentUpdated`, then `Page.domContentEventFired`. It also proves that the early frontend node id is stale after the DCL barrier and that a refreshed snapshot contains the complete BODY.-- Optional Puppeteer over CDP group for `puppeteer.connect()`, browser-target and page-target `CDPSession`, `page.goto()`, `page.reload()`, selector-backed DOM activation navigation, same-document hash and History API navigation, `page.evaluate(fetch)`, keyboard input via `page.type()`, CSS / `$eval` / XPath element selection, and DOM interactions across text input, textarea, label/checkbox, radio, select, details/summary, disabled button, and form submission. It also covers `ElementHandle.boundingBox()` / `evaluate()` / `uploadFile()`, DedicatedWorker `workercreated` / `WebWorker.evaluate()` / exact-once worker-session console routing / explicit terminate / navigation-destroy lifecycle, current-viewport `page.screenshot({captureBeyondViewport:false})`, alert and console events, browser-session download behavior/events/artifact with peer-session event isolation, request interception `respond()` / `continue()`, page-scoped `CDPSession` Network event observation, and layout-backed `page.click()` dispatch.+- Optional Puppeteer over CDP group for `puppeteer.connect()`, reconnecting an existing parked-then-promoted Page through a fresh browser session, browser-target and page-target `CDPSession`, `page.goto()`, `page.reload()`, selector-backed DOM activation navigation, same-document hash and History API navigation, `page.evaluate(fetch)`, keyboard input via `page.type()`, CSS / `$eval` / XPath element selection, and DOM interactions across text input, textarea, label/checkbox, radio, select, details/summary, disabled button, and form submission. It also covers `ElementHandle.boundingBox()` / `evaluate()` / `uploadFile()`, DedicatedWorker `workercreated` / `WebWorker.evaluate()` / exact-once worker-session console routing / explicit terminate / navigation-destroy lifecycle, current-viewport `page.screenshot({captureBeyondViewport:false})`, alert and console events, browser-session download behavior/events/artifact with peer-session event isolation, request interception `respond()` / `continue()`, page-scoped `CDPSession` Network event observation, and layout-backed `page.click()` dispatch.- `browser.new_context()`, `context.new_page()`, multiple pages in one context, target switching, popup-scoped `page.route()` plus `evaluate(fetch)`, popup CDPSession response-stage body / stream / fulfill / fail flows, and held multi-context route / response-stage resume without cross-context Network event bleed.- Top-level navigation, redirect final URL/response, reload-like click navigation, and history back/forward.- Reload, same-document hash navigation, `history.pushState()` observation, Playwright `add_init_script()` page/context injection, `page.exposeFunction()` / `page.exposeBinding()` plus context-level exposed functions, and basic `domcontentloaded` / `load` / `networkidle` load-state waits with a parser-discovered delayed image.diff --git a/moli-cdp-smoke/moli_cdp_smoke/puppeteer_smoke.mjs b/moli-cdp-smoke/moli_cdp_smoke/puppeteer_smoke.mjsindex 3233310e1..08d1bd261 100644--- a/moli-cdp-smoke/moli_cdp_smoke/puppeteer_smoke.mjs+++ b/moli-cdp-smoke/moli_cdp_smoke/puppeteer_smoke.mjs@@ -54,6 +54,147 @@ async function discoverWebSocket(endpoint) {return payload.webSocketDebuggerUrl;}+async function listPageTargets(endpoint) {+ const response = await fetch(`${endpoint.replace(/\/$/, '')}/json/list`);+ if (!response.ok) {+ throw new Error(`CDP target discovery failed with HTTP ${response.status}`);+ }+ const payload = await response.json();+ if (!Array.isArray(payload)) {+ throw new Error(`CDP target discovery returned an invalid payload: ${JSON.stringify(payload)}`);+ }+ return payload.filter(target => target?.type === 'page' && typeof target.id === 'string');+}++async function createPageTarget(endpoint) {+ const response = await fetch(+ `${endpoint.replace(/\/$/, '')}/json/new?${encodeURIComponent('about:blank')}`,+ { method: 'PUT' },+ );+ if (!response.ok) {+ throw new Error(`CDP target creation failed with HTTP ${response.status}`);+ }+ const target = await response.json();+ if (target?.type !== 'page' || typeof target.id !== 'string') {+ throw new Error(`CDP target creation returned an invalid payload: ${JSON.stringify(target)}`);+ }+ return target;+}++async function closePageTarget(endpoint, targetId) {+ const response = await fetch(+ `${endpoint.replace(/\/$/, '')}/json/close/${encodeURIComponent(targetId)}`,+ );+ if (!response.ok) {+ throw new Error(`CDP target ${targetId} cleanup failed with HTTP ${response.status}`);+ }+}++async function pageByTargetId(browser, targetId, label) {+ const target = await withTimeout(+ `${label} target`,+ browser.waitForTarget(candidate => {+ return candidate.type() === 'page' && candidate._targetId === targetId;+ }, { timeout: 10000 }),+ );+ const page = await withTimeout(`${label} page`, target.page());+ if (!page) {+ throw new Error(`${label} target ${targetId} did not expose a Page`);+ }+ return page;+}++async function runPuppeteerReconnectSmoke(puppeteer, endpoint, browserWSEndpoint) {+ let pages = await listPageTargets(endpoint);+ let originalTargetCreated = false;+ if (pages.length === 0) {+ pages = [await createPageTarget(endpoint)];+ originalTargetCreated = true;+ }+ const originalTargetId = pages[0].id;+ // Materializing a second Page parks the original Page in Moli. Accessing the+ // original through Puppeteer then promotes it again, which is the lifecycle+ // required to exercise parent-session detach cleanup on disconnect.+ const temporaryTarget = await createPageTarget(endpoint);+ if (temporaryTarget.id === originalTargetId) {+ throw new Error(`CDP target creation reused the existing target id ${originalTargetId}`);+ }++ let firstBrowser;+ let replacementBrowser;+ let completed = false;+ try {+ firstBrowser = await withTimeout(+ 'first Puppeteer reconnect probe connect',+ puppeteer.connect({ browserWSEndpoint, protocolTimeout: 10000 }),+ );+ const originalPage = await pageByTargetId(+ firstBrowser,+ originalTargetId,+ 'first Puppeteer reconnect probe',+ );+ const firstResult = await withTimeout(+ 'first Puppeteer reconnect probe evaluate',+ originalPage.evaluate(() => {+ globalThis.__moliPuppeteerReconnectMarker = 29;+ return 6 * 7;+ }),+ );+ if (firstResult !== 42) {+ throw new Error(`unexpected first Puppeteer reconnect probe result: ${firstResult}`);+ }+ await firstBrowser.disconnect();+ firstBrowser = undefined;++ replacementBrowser = await withTimeout(+ 'replacement Puppeteer reconnect probe connect',+ puppeteer.connect({ browserWSEndpoint, protocolTimeout: 10000 }),+ );+ const replacementPage = await pageByTargetId(+ replacementBrowser,+ originalTargetId,+ 'replacement Puppeteer reconnect probe',+ );+ const replacementResult = await withTimeout(+ 'replacement Puppeteer reconnect probe evaluate',+ replacementPage.evaluate(() => ({+ answer: 6 * 7,+ marker: globalThis.__moliPuppeteerReconnectMarker,+ })),+ );+ if (replacementResult?.answer !== 42 || replacementResult?.marker !== 29) {+ throw new Error(+ `unexpected replacement Puppeteer reconnect probe result: ${JSON.stringify(replacementResult)}`,+ );+ }+ completed = true;+ return {+ existingTargetReused: true,+ firstEvaluation: firstResult,+ replacementEvaluation: replacementResult.answer,+ };+ } finally {+ if (replacementBrowser) {+ await replacementBrowser.disconnect().catch(() => {});+ }+ if (firstBrowser) {+ await firstBrowser.disconnect().catch(() => {});+ }+ await closePageTarget(endpoint, temporaryTarget.id).catch(error => {+ if (completed) {+ throw error;+ }+ });+ if (originalTargetCreated) {+ await closePageTarget(endpoint, originalTargetId).catch(error => {+ if (completed) {+ throw error;+ }+ });+ }+ }+}+async function createBrowserContext(browser) {if (typeof browser.createBrowserContext === 'function') {return await browser.createBrowserContext();@@ -80,13 +221,20 @@ async function main() {const browserWSEndpoint = await discoverWebSocket(endpoint);const isMoliEndpoint = browserWSEndpoint.endsWith('/devtools/browser/moli-browser');trace(`discovered ${browserWSEndpoint}`);+ const results = [];+ const record = (name, data = {}) => results.push({ name, ok: true, ...data });+ const reconnectResult = await runPuppeteerReconnectSmoke(+ puppeteer,+ endpoint,+ browserWSEndpoint,+ );+ record('puppeteer_existing_page_reconnect_runtime_context', reconnectResult);+ trace('reconnected to existing Page with a fresh Puppeteer session');const browser = await withTimeout('puppeteer.connect',puppeteer.connect({ browserWSEndpoint, protocolTimeout: 10000 }),);trace('connected');- const results = [];- const record = (name, data = {}) => results.push({ name, ok: true, ...data });let context;let browserCdp;diff --git a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rsindex 639c38938..bd80947a7 100644--- a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs+++ b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs@@ -58,6 +58,131 @@ fn response_by_id(messages: &[serde_json::Value], id: u64) -> &serde_json::Value.unwrap_or_else(|| panic!("missing response id {id}: {messages:#?}"))}+async fn enable_runtime_and_expect_default_context(+ socket: &mut tokio_tungstenite::WebSocketStream<+ tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>,+ >,+ command_id: u64,+ session_id: Option<&str>,+ label: &str,+) -> Vec<serde_json::Value> {+ let mut messages =+ send_cdp_command(socket, command_id, "Runtime.enable", session_id, json!({})).await;+ assert_eq!(response_by_id(&messages, command_id)["result"], json!({}));+ if !messages.iter().any(|message| {+ message.get("sessionId").and_then(serde_json::Value::as_str) == session_id+ && message["method"] == json!("Runtime.executionContextCreated")+ && message["params"]["context"]["auxData"]["isDefault"] == json!(true)+ }) {+ messages.extend(+ send_cdp_command(+ socket,+ command_id + 1,+ "Runtime.evaluate",+ session_id,+ json!({ "expression": "void 0" }),+ )+ .await,+ );+ }+ assert!(+ messages.iter().any(|message| {+ message.get("sessionId").and_then(serde_json::Value::as_str) == session_id+ && message["method"] == json!("Runtime.executionContextCreated")+ && message["params"]["context"]["auxData"]["isDefault"] == json!(true)+ }),+ "{label} did not report the existing default context before the next Runtime response: {messages:#?}"+ );+ messages+}++async fn puppeteer_auto_attach_existing_page(+ browser: &mut tokio_tungstenite::WebSocketStream<+ tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>,+ >,+ command_id: u64,+ page_target_id: &str,+) -> String {+ let tab_target_id = format!("TAB-{page_target_id}");+ send_cdp_command_without_wait(+ browser,+ command_id,+ "Target.setAutoAttach",+ None,+ json!({+ "autoAttach": true,+ "waitForDebuggerOnStart": true,+ "flatten": true,+ "filter": [+ { "type": "page", "exclude": true },+ {}+ ]+ }),+ )+ .await;+ let mut saw_root_response = false;+ let mut saw_tab_attach = false;+ let root_auto_attach = recv_until_match(browser, |message| {+ saw_root_response |= message["id"] == json!(command_id);+ saw_tab_attach |= message["method"] == json!("Target.attachedToTarget")+ && message["params"]["targetInfo"]["targetId"] == json!(tab_target_id);+ saw_root_response && saw_tab_attach+ })+ .await;+ assert_eq!(+ response_by_id(&root_auto_attach, command_id)["result"],+ json!({})+ );+ let tab_session_id = root_auto_attach+ .iter()+ .find(|message| {+ message["method"] == json!("Target.attachedToTarget")+ && message["params"]["targetInfo"]["targetId"] == json!(tab_target_id)+ })+ .and_then(|message| message["params"]["sessionId"].as_str())+ .expect("auto-attached tab session")+ .to_owned();++ let child_command_id = command_id + 1;+ send_cdp_command_without_wait(+ browser,+ child_command_id,+ "Target.setAutoAttach",+ Some(&tab_session_id),+ json!({+ "autoAttach": true,+ "waitForDebuggerOnStart": false,+ "flatten": true,+ "filter": [{}]+ }),+ )+ .await;+ let mut saw_child_response = false;+ let mut saw_page_attach = false;+ let tab_auto_attach = recv_until_match(browser, |message| {+ saw_child_response |= message["id"] == json!(child_command_id);+ saw_page_attach |= message["sessionId"] == json!(tab_session_id)+ && message["method"] == json!("Target.attachedToTarget")+ && message["params"]["targetInfo"]["targetId"] == json!(page_target_id);+ saw_child_response && saw_page_attach+ })+ .await;+ assert_eq!(+ response_by_id(&tab_auto_attach, child_command_id)["result"],+ json!({})+ );+ tab_auto_attach+ .iter()+ .find(|message| {+ message["sessionId"] == json!(tab_session_id)+ && message["method"] == json!("Target.attachedToTarget")+ && message["params"]["targetInfo"]["targetId"] == json!(page_target_id)+ })+ .and_then(|message| message["params"]["sessionId"].as_str())+ .expect("auto-attached page session")+ .to_owned()+}+async fn fetch_server_json(addr: std::net::SocketAddr, path: &str) -> serde_json::Value {let (status, body) = fetch_server_response(addr, "GET", path).await;assert_eq!(status, 200, "unexpected HTTP status for {path}");@@ -1699,6 +1824,118 @@ async fn websocket_cdp_shared_owner_survives_idle_browser_reconnect() {abort_test_cdp_server(server).await;}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn websocket_cdp_puppeteer_reconnect_replays_existing_runtime_context() {+ let (addr, server) = spawn_test_protocol_server().await;+ let (status, body) = fetch_server_response(addr, "PUT", "/json/new?about%3Ablank").await;+ assert_eq!(status, 200);+ let created_target: serde_json::Value =+ serde_json::from_slice(&body).expect("created target descriptor");+ let created_target_id = created_target["id"]+ .as_str()+ .expect("created target id")+ .to_owned();+ assert_ne!(created_target_id, DEFAULT_TARGET_ID);+ // Materializing a second Page parks the old default Page. Puppeteer's+ // first Page command promotes that existing target back to the active+ // slot, which is the reconnect lifecycle that regressed.+ let target_id = DEFAULT_TARGET_ID.to_owned();++ let (mut browser, _) =+ connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))+ .await+ .expect("connect first browser websocket");+ let page_session_id = puppeteer_auto_attach_existing_page(&mut browser, 1, &target_id).await;+ let page_enabled = send_cdp_command(+ &mut browser,+ 3,+ "Page.enable",+ Some(&page_session_id),+ json!({}),+ )+ .await;+ assert_eq!(response_by_id(&page_enabled, 3)["result"], json!({}));+ let _ = enable_runtime_and_expect_default_context(+ &mut browser,+ 4,+ Some(&page_session_id),+ "first Runtime.enable",+ )+ .await;+ let utility_world = send_cdp_command(+ &mut browser,+ 6,+ "Page.createIsolatedWorld",+ Some(&page_session_id),+ json!({+ "frameId": target_id,+ "worldName": "__puppeteer_utility_world__moli_reconnect",+ "grantUniveralAccess": true+ }),+ )+ .await;+ assert!(+ response_by_id(&utility_world, 6)["result"]["executionContextId"]+ .as_i64()+ .is_some(),+ "failed to create the persistent Puppeteer utility world: {utility_world:#?}"+ );++ browser+ .close(None)+ .await+ .expect("close first browser frontend");+ wait_for_websocket_close(&mut browser, "first browser frontend").await;++ let (mut replacement, _) =+ connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))+ .await+ .expect("connect replacement browser websocket");+ let replacement_page_session_id =+ puppeteer_auto_attach_existing_page(&mut replacement, 1, &target_id).await;+ assert_ne!(replacement_page_session_id, page_session_id);+ let page_enabled = send_cdp_command(+ &mut replacement,+ 3,+ "Page.enable",+ Some(&replacement_page_session_id),+ json!({}),+ )+ .await;+ assert_eq!(response_by_id(&page_enabled, 3)["result"], json!({}));+ let replay = enable_runtime_and_expect_default_context(+ &mut replacement,+ 4,+ Some(&replacement_page_session_id),+ "replacement Runtime.enable",+ )+ .await;+ assert!(+ replay.iter().any(|message| {+ message["sessionId"] == json!(replacement_page_session_id)+ && message["method"] == json!("Runtime.executionContextCreated")+ && message["params"]["context"]["name"]+ == json!("__puppeteer_utility_world__moli_reconnect")+ }),+ "replacement Runtime.enable did not replay the existing Puppeteer utility world: {replay:#?}"+ );++ let evaluated = send_cdp_command(+ &mut replacement,+ 6,+ "Runtime.evaluate",+ Some(&replacement_page_session_id),+ json!({ "expression": "6 * 7", "returnByValue": true }),+ )+ .await;+ assert_eq!(+ response_by_id(&evaluated, 6)["result"]["result"]["value"],+ json!(42)+ );++ abort_test_cdp_server(server).await;+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn websocket_cdp_browser_reconnect_clears_detached_session_emulated_media() {let (addr, server) = spawn_test_protocol_server().await;diff --git a/moli-protocol/src/domains/target/lifecycle.rs b/moli-protocol/src/domains/target/lifecycle.rsindex d7b1e8f21..fdf2bf35d 100644--- a/moli-protocol/src/domains/target/lifecycle.rs+++ b/moli-protocol/src/domains/target/lifecycle.rs@@ -2458,6 +2458,19 @@ async fn detach_attached_session_for_owner_async(conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);return;};+ // A parent-session detach cascade bypasses the direct+ // Target.detachFromTarget path. Release the renderer inspector+ // here before resetting protocol state so the replacement primary+ // session gets a fresh Runtime.enable context inventory.+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(+ out.background_events_mut(),+ command_context.protocol_events_mut(),+ Some(session_id),+ "Target detached",+ );+ let _ = conn+ .detach_runtime_inspector_session_for_session_owner_async(Some(session_id))+ .await;events::fail_pending_fetch_state_for_target_background_events_async(conn,out.background_events_mut(),