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): align session and shared worker routing
ldm02e5203791519
diff --git a/moli-protocol-server/src/cdp_frontend_router/routing/command.rs b/moli-protocol-server/src/cdp_frontend_router/routing/command.rsindex aee168d60..054225b5b 100644--- a/moli-protocol-server/src/cdp_frontend_router/routing/command.rs+++ b/moli-protocol-server/src/cdp_frontend_router/routing/command.rs@@ -6,9 +6,25 @@ use super::{CdpFrontendRoutingState, cdp_error_response,frontend_registry::DirectChildLookupError,pending_commands::{CdpCommandFrontend, PendingCommandEffect, PendingCommandRoute},+ set_top_level_session_id,};use crate::cdp_frontend_router::CdpPreparedFrontendCommand;+fn immediate_error_response(+ frontend_id: u64,+ command_id: Option<u64>,+ client_session_id: Option<&str>,+ code: i32,+ error_message: &str,+) -> CdpPreparedFrontendCommand {+ let mut message = cdp_error_response(command_id, code, error_message);+ set_top_level_session_id(&mut message, client_session_id);+ CdpPreparedFrontendCommand::ImmediateResponse {+ frontend_id,+ message,+ }+}+impl CdpFrontendRoutingState {pub(in crate::cdp_frontend_router) fn prepare_command_str(&mut self,@@ -17,14 +33,13 @@ impl CdpFrontendRoutingState {) -> Option<CdpPreparedFrontendCommand> {match ParsedCdpCommand::parse_str(raw) {Ok(command) => self.prepare_command(frontend_id, command),- Err(error) => Some(CdpPreparedFrontendCommand::ImmediateResponse {+ Err(error) => Some(immediate_error_response(frontend_id,- message: cdp_error_response(- error.command_id(),- error.response_code(),- error.response_message(),- ),- }),+ error.command_id(),+ None,+ error.response_code(),+ error.response_message(),+ )),}}@@ -51,14 +66,13 @@ impl CdpFrontendRoutingState {let base_session_id = self.frontends.base_session_id(frontend_id)?.to_owned();let dispatch_session_id = if let Some(session_id) = client_session_id.as_deref() {if !self.frontends.owns_client_session(frontend_id, session_id) {- return Some(CdpPreparedFrontendCommand::ImmediateResponse {+ return Some(immediate_error_response(frontend_id,- message: cdp_error_response(- Some(client_command_id),- -32001,- "Unknown sessionId",- ),- });+ Some(client_command_id),+ None,+ -32001,+ "Unknown sessionId",+ ));}Some(session_id.to_owned())} else {@@ -81,10 +95,13 @@ impl CdpFrontendRoutingState {(-32000, "Multiple sessions attached, specify id.")}};- return Some(CdpPreparedFrontendCommand::ImmediateResponse {+ return Some(immediate_error_response(frontend_id,- message: cdp_error_response(Some(client_command_id), code, message),- });+ Some(client_command_id),+ client_session_id.as_deref(),+ code,+ message,+ ));}};let command = if let Some(session_id) = target_session_reference.as_deref() {@@ -95,14 +112,13 @@ impl CdpFrontendRoutingState {?error,"frontend routing could not serialize a Target session reference");- return Some(CdpPreparedFrontendCommand::ImmediateResponse {+ return Some(immediate_error_response(frontend_id,- message: cdp_error_response(- Some(client_command_id),- -32603,- "Internal error",- ),- });+ Some(client_command_id),+ client_session_id.as_deref(),+ -32603,+ "Internal error",+ ));}}} else {@@ -116,10 +132,13 @@ impl CdpFrontendRoutingState {Ok(command_id) => command_id,Err(error) => {tracing::error!(?error, "frontend routing command id allocation failed");- return Some(CdpPreparedFrontendCommand::ImmediateResponse {+ return Some(immediate_error_response(frontend_id,- message: cdp_error_response(Some(client_command_id), -32603, "Internal error"),- });+ Some(client_command_id),+ client_session_id.as_deref(),+ -32603,+ "Internal error",+ ));}};let command = match command@@ -131,10 +150,13 @@ impl CdpFrontendRoutingState {?error,"frontend routing could not serialize a rewritten typed CDP command");- return Some(CdpPreparedFrontendCommand::ImmediateResponse {+ return Some(immediate_error_response(frontend_id,- message: cdp_error_response(Some(client_command_id), -32603, "Internal error"),- });+ Some(client_command_id),+ client_session_id.as_deref(),+ -32603,+ "Internal error",+ ));}};self.pending_commands.insert(diff --git a/moli-protocol-server/src/cdp_frontend_router/routing/tests.rs b/moli-protocol-server/src/cdp_frontend_router/routing/tests.rsindex f4d56ec52..580fa69af 100644--- a/moli-protocol-server/src/cdp_frontend_router/routing/tests.rs+++ b/moli-protocol-server/src/cdp_frontend_router/routing/tests.rs@@ -511,6 +511,144 @@ fn legacy_target_id_reference_requires_one_direct_child_session() {assert_eq!(command["params"]["sessionId"], json!("SID-grandchild"));}+#[test]+fn rejected_nested_detach_preserves_the_request_session_route() {+ let mut routing = CdpFrontendRoutingState::default();+ routing+ .register_browser_frontend(5, "SID-browser".to_owned(), test_sink())+ .expect("register browser frontend");+ routing.register_child_session(5, Some("SID-browser"), "SID-page", Some("TID-page"));+ routing.register_child_session(5, Some("SID-page"), "SID-worker", Some("TID-worker"));+ routing.register_child_session(+ 5,+ Some("SID-worker"),+ "SID-shared-worker",+ Some("TID-shared-worker"),+ );++ let Some(CdpPreparedFrontendCommand::ImmediateResponse { message, .. }) = routing+ .prepare_command(+ 5,+ parsed_command(+ json!({+ "id": 61,+ "method": "Target.detachFromTarget",+ "sessionId": "SID-page",+ "params": { "sessionId": "SID-shared-worker" },+ })+ .to_string(),+ ),+ )+ else {+ panic!("non-direct nested session was accepted by the page Target handler");+ };++ assert_eq!(message["id"], json!(61));+ assert_eq!(message["error"]["code"], json!(-32602));+ assert_eq!(message["sessionId"], json!("SID-page"));++ let command = expect_prepared_command(+ routing.prepare_command(+ 5,+ parsed_command(+ json!({+ "id": 62,+ "method": "Target.detachFromTarget",+ "sessionId": "SID-worker",+ "params": { "sessionId": "SID-shared-worker" },+ })+ .to_string(),+ ),+ ),+ "direct shared-worker detach",+ );+ let command = serde_json::from_str::<Value>(command.json()).expect("detach command JSON");+ assert_eq!(command["sessionId"], json!("SID-worker"));+ assert_eq!(command["params"]["sessionId"], json!("SID-shared-worker"));+}++#[test]+fn target_command_errors_preserve_only_valid_client_session_routes() {+ let mut routing = CdpFrontendRoutingState::default();+ routing+ .register_browser_frontend(5, "SID-browser".to_owned(), test_sink())+ .expect("register browser frontend");+ routing.register_child_session(5, Some("SID-browser"), "SID-page", Some("TID-page"));++ for (id, method, params, expected_message) in [+ (+ 70,+ "Target.sendMessageToTarget",+ json!({ "sessionId": "SID-missing", "message": "{}" }),+ "No session with given id",+ ),+ (+ 71,+ "Target.detachFromTarget",+ json!({ "targetId": "TID-missing" }),+ "No session for given target id",+ ),+ ] {+ let Some(CdpPreparedFrontendCommand::ImmediateResponse { message, .. }) = routing+ .prepare_command(+ 5,+ parsed_command(+ json!({+ "id": id,+ "method": method,+ "sessionId": "SID-page",+ "params": params,+ })+ .to_string(),+ ),+ )+ else {+ panic!("invalid {method} target session reference was accepted");+ };++ assert_eq!(message["id"], json!(id));+ assert_eq!(message["error"]["code"], json!(-32602));+ assert_eq!(message["error"]["message"], json!(expected_message));+ assert_eq!(message["sessionId"], json!("SID-page"));+ }++ let Some(CdpPreparedFrontendCommand::ImmediateResponse { message, .. }) = routing+ .prepare_command(+ 5,+ parsed_command(+ json!({+ "id": 72,+ "method": "Target.detachFromTarget",+ "params": { "sessionId": "SID-missing" },+ })+ .to_string(),+ ),+ )+ else {+ panic!("invalid root Target session reference was accepted");+ };+ assert!(message.get("sessionId").is_none());++ let Some(CdpPreparedFrontendCommand::ImmediateResponse { message, .. }) = routing+ .prepare_command(+ 5,+ parsed_command(+ json!({+ "id": 73,+ "method": "Runtime.evaluate",+ "sessionId": "SID-stale",+ "params": { "expression": "1" },+ })+ .to_string(),+ ),+ )+ else {+ panic!("unknown outer session was accepted");+ };+ assert_eq!(message["error"]["code"], json!(-32001));+ assert!(message.get("sessionId").is_none());+}+#[test]fn attached_event_registers_child_before_attach_response() {let mut routing = CdpFrontendRoutingState::default();diff --git a/moli-protocol/src/domains/target.rs b/moli-protocol/src/domains/target.rsindex 16fd743c8..b94ed5b6f 100644--- a/moli-protocol/src/domains/target.rs+++ b/moli-protocol/src/domains/target.rs@@ -58,6 +58,18 @@ pub(in crate::domains) use worker_target::{service_worker_target_lifecycle_prepared_outputs_for_event,shared_worker_target_lifecycle_prepared_outputs_for_event,};++/// Browser-owned auto-attach policies may observe browser-level targets.+///+/// A target filter narrows the target kinds requested by one TargetHandler; it+/// does not expand a page or worker TargetHandler to browser-global targets.+fn browser_level_auto_attach_owner_session_allowed(+ conn: &CdpConnection,+ owner_session_id: Option<&str>,+) -> bool {+ owner_session_id.is_none() || conn.is_browser_session_id(owner_session_id)+}+pub(crate) struct PendingTargetCommandDispatch {command_id: Option<u64>,session_id: Option<String>,diff --git a/moli-protocol/src/domains/target/lifecycle.rs b/moli-protocol/src/domains/target/lifecycle.rsindex 9cb45a71a..d7b1e8f21 100644--- a/moli-protocol/src/domains/target/lifecycle.rs+++ b/moli-protocol/src/domains/target/lifecycle.rs@@ -386,7 +386,10 @@ fn top_level_page_auto_attach_owner_sessions(conn: &CdpConnection) -> Vec<Optionconn.auto_attach_owner_sessions_for_target_type("page").into_iter().filter(|owner_session_id| {- top_level_page_auto_attach_owner_session_allowed(conn, owner_session_id.as_deref())+ super::browser_level_auto_attach_owner_session_allowed(+ conn,+ owner_session_id.as_deref(),+ )}).collect()}@@ -395,39 +398,14 @@ fn top_level_tab_auto_attach_owner_sessions(conn: &CdpConnection) -> Vec<Option<conn.auto_attach_owner_sessions_for_target_type("tab").into_iter().filter(|owner_session_id| {- top_level_tab_auto_attach_owner_session_allowed(conn, owner_session_id.as_deref())+ super::browser_level_auto_attach_owner_session_allowed(+ conn,+ owner_session_id.as_deref(),+ )}).collect()}-fn top_level_page_auto_attach_owner_session_allowed(- conn: &CdpConnection,- owner_session_id: Option<&str>,-) -> bool {- match owner_session_id {- None => true,- Some(owner_session_id) => matches!(- conn.session_route(Some(owner_session_id)),- Some(crate::conn::CdpSessionRoute::Browser)- ),- }-}--fn top_level_tab_auto_attach_owner_session_allowed(- conn: &CdpConnection,- owner_session_id: Option<&str>,-) -> bool {- match owner_session_id {- None => true,- Some(session_id) => {- matches!(- conn.session_route(Some(session_id)),- Some(crate::conn::CdpSessionRoute::Browser)- )- }- }-}-fn activate_browser_context_for_create_target(conn: &mut CdpConnection,command: &DevToolsCreateTargetCommand,@@ -1792,12 +1770,13 @@ async fn set_auto_attach_inner_async(}let attach_page_targets = conn.auto_attach_owner_allows_target_type(owner_session_id, "page")- && top_level_page_auto_attach_owner_session_allowed(conn, owner_session_id);+ && super::browser_level_auto_attach_owner_session_allowed(conn, owner_session_id);let attach_tab_targets = conn.auto_attach_owner_allows_target_type(owner_session_id, "tab")- && top_level_tab_auto_attach_owner_session_allowed(conn, owner_session_id);- let attach_shared_worker_targets =- conn.auto_attach_owner_allows_target_type(owner_session_id, "shared_worker");+ && super::browser_level_auto_attach_owner_session_allowed(conn, owner_session_id);+ let attach_shared_worker_targets = conn+ .auto_attach_owner_allows_target_type(owner_session_id, "shared_worker")+ && super::browser_level_auto_attach_owner_session_allowed(conn, owner_session_id);let attach_dedicated_worker_targets =conn.auto_attach_owner_allows_target_type(owner_session_id, "worker");let attach_service_worker_targets =diff --git a/moli-protocol/src/domains/target/tests/tests_target_attachment.rs b/moli-protocol/src/domains/target/tests/tests_target_attachment.rsindex 151abcad6..6a70a676b 100644--- a/moli-protocol/src/domains/target/tests/tests_target_attachment.rs+++ b/moli-protocol/src/domains/target/tests/tests_target_attachment.rs@@ -2504,6 +2504,126 @@ async fn set_auto_attach_true_attaches_existing_unattached_shared_worker_target(assert!(ctx.conn.auto_attach);}+#[tokio::test(flavor = "multi_thread")]+async fn non_browser_auto_attach_owners_do_not_replay_existing_shared_worker_targets() {+ let mut ctx = TestContext::new();+ load_bc_with_target(&mut ctx, "BID-9", "TID-page");+ assert!(+ ctx.conn+ .prepare_auto_attached_page_session_binding("TID-page", "SID-page".to_owned())+ );+ let owner_page = ctx+ .conn+ .target_page_residence_identity_for_session(Some("SID-page"))+ .expect("page owner residence");+ push_dedicated_worker_target(&mut ctx, 2401, "TID-dedicated-worker", owner_page);+ assert!(+ ctx.conn+ .prepare_auto_attached_dedicated_worker_session_binding(+ "TID-dedicated-worker",+ "SID-dedicated-worker".to_owned(),+ )+ );+ push_shared_worker_target(+ &mut ctx,+ SharedWorkerInstanceId::from_u64(2402),+ "TID-shared-worker",+ "https://example.test/shared-worker.js",+ "shared",+ Some("SID-shared-worker"),+ );++ for (id, owner_session_id) in [+ (2403, "SID-page"),+ (2404, "SID-dedicated-worker"),+ (2405, "SID-shared-worker"),+ ] {+ ctx.process_async(json!({+ "id": id,+ "method": "Target.setAutoAttach",+ "sessionId": owner_session_id,+ "params": {+ "autoAttach": true,+ "waitForDebuggerOnStart": true,+ "flatten": true,+ "filter": [{"type": "shared_worker"}],+ }+ }))+ .await;++ ctx.expect_result(id, json!({}), Some(owner_session_id));+ assert!(+ ctx.sent.is_empty(),+ "{owner_session_id} must not receive a browser-level shared-worker target: {:?}",+ ctx.sent+ );+ }++ let shared_worker_sessions = ctx+ .conn+ .browser_context+ .as_ref()+ .and_then(|context| context.shared_worker_target("TID-shared-worker"))+ .expect("shared-worker target should remain registered")+ .session_ids();+ assert_eq!(+ shared_worker_sessions,+ vec!["SID-shared-worker"],+ "a shared-worker TargetHandler must not auto-attach its own target"+ );+}++#[tokio::test(flavor = "multi_thread")]+async fn browser_session_auto_attach_replays_an_existing_shared_worker_once() {+ let mut ctx = TestContext::new();+ load_bc(&mut ctx, "BID-9");+ push_shared_worker_target(+ &mut ctx,+ SharedWorkerInstanceId::from_u64(2410),+ "TID-shared-worker",+ "https://example.test/shared-worker.js",+ "shared",+ None,+ );+ ctx.conn.register_browser_session("SID-browser".to_owned());++ for id in [2411, 2412] {+ ctx.process_async(json!({+ "id": id,+ "method": "Target.setAutoAttach",+ "sessionId": "SID-browser",+ "params": {+ "autoAttach": true,+ "waitForDebuggerOnStart": false,+ "flatten": true,+ "filter": [{"type": "shared_worker"}],+ }+ }))+ .await;++ if id == 2411 {+ let attached = ctx.take_one();+ assert_eq!(attached["method"], "Target.attachedToTarget");+ assert_eq!(attached["sessionId"], "SID-browser");+ assert_eq!(+ attached["params"]["targetInfo"]["targetId"],+ "TID-shared-worker"+ );+ assert_eq!(attached["params"]["targetInfo"]["type"], "shared_worker");+ }+ ctx.expect_result(id, json!({}), Some("SID-browser"));+ assert!(ctx.sent.is_empty());+ }++ assert_eq!(+ ctx.conn+ .attached_sessions_for_target("TID-shared-worker")+ .len(),+ 1,+ "re-enabling one browser TargetHandler must not duplicate its attachment"+ );+}+#[tokio::test(flavor = "multi_thread")]async fn dedicated_worker_existing_target_auto_attach_requires_its_owner_page_session() {let mut ctx = TestContext::new();diff --git a/moli-protocol/src/domains/target/worker_target.rs b/moli-protocol/src/domains/target/worker_target.rsindex fb21ab60b..941e80311 100644--- a/moli-protocol/src/domains/target/worker_target.rs+++ b/moli-protocol/src/domains/target/worker_target.rs@@ -950,6 +950,18 @@ pub(super) fn dedicated_worker_auto_attach_owner_session_allowed(== Some(owner_page)}+fn shared_worker_auto_attach_owner_sessions(conn: &CdpConnection) -> Vec<Option<String>> {+ conn.auto_attach_owner_sessions_for_target_type("shared_worker")+ .into_iter()+ .filter(|owner_session_id| {+ super::browser_level_auto_attach_owner_session_allowed(+ conn,+ owner_session_id.as_deref(),+ )+ })+ .collect()+}+fn dedicated_worker_auto_attach_owner_sessions(conn: &CdpConnection,owner_page: &TargetPageResidenceIdentity,@@ -1500,7 +1512,7 @@ fn register_shared_worker_target(}let target_id = conn.gen_target_id();let should_emit_created = conn.has_any_target_discovery();- let auto_attach_owners = conn.auto_attach_owner_sessions_for_target_type("shared_worker");+ let auto_attach_owners = shared_worker_auto_attach_owner_sessions(conn);let attached_sessions = auto_attach_owners.iter().map(|owner| {@@ -3576,7 +3588,9 @@ mod worker_target_attachment_tests;#[cfg(test)]mod tests {use super::*;- use crate::conn::{BrowserContext, CdpTargetFilter, CdpTargetFilterEntry};+ use crate::conn::{+ BrowserContext, CdpTargetFilter, CdpTargetFilterEntry, DedicatedWorkerTargetState,+ };fn runtime_inspector_messages(messages: Vec<Value>) -> Vec<RendererRuntimeInspectorMessage> {messages@@ -5946,6 +5960,87 @@ mod tests {assert!(attachment.is_current());}+ #[test]+ fn shared_worker_registration_only_auto_attaches_browser_level_owners() {+ let (mut conn, owner_page, owner_renderer_page) = dedicated_worker_fixture();+ assert!(+ conn.prepare_auto_attached_page_session_binding("TID-page", "SID-page".to_owned(),)+ );+ conn.register_browser_session("SID-browser-1".to_owned());+ conn.register_browser_session("SID-browser-2".to_owned());++ conn.browser_context+ .as_mut()+ .expect("browser context")+ .insert_dedicated_worker_target(DedicatedWorkerTargetState::new(+ owner_page,+ owner_renderer_page.owner_local_host_id(),+ 91,+ "TID-dedicated-worker".to_owned(),+ "https://example.test/worker.js".to_owned(),+ Vec::new(),+ ));+ assert!(conn.prepare_auto_attached_dedicated_worker_session_binding(+ "TID-dedicated-worker",+ "SID-dedicated-worker".to_owned(),+ ));++ let mut owner_shared_worker = SharedWorkerTargetState::new(+ moli_core::RendererOwnerLocalHostId::new_for_testing(2),+ SharedWorkerInstanceId::from_u64(92),+ "TID-owner-shared-worker".to_owned(),+ None,+ "https://example.test/owner-shared-worker.js".to_owned(),+ "owner".to_owned(),+ );+ owner_shared_worker.attach_session("SID-shared-worker".to_owned());+ conn.browser_context+ .as_mut()+ .expect("browser context")+ .insert_shared_worker_target(owner_shared_worker);++ for (owner, wait_for_debugger_on_start) in [+ (None, false),+ (Some("SID-browser-1"), false),+ (Some("SID-browser-2"), true),+ (Some("SID-page"), true),+ (Some("SID-dedicated-worker"), true),+ (Some("SID-shared-worker"), true),+ ] {+ conn.set_auto_attach_owner(+ owner,+ true,+ wait_for_debugger_on_start,+ CdpTargetFilter::default_auto_attach(),+ );+ }++ let outputs =+ register_shared_worker_target(&mut conn, "BID-1", None, shared_worker_info(93))+ .worker_target_lifecycle_outputs;+ let mut attached_owners = outputs+ .iter()+ .filter_map(shared_worker_attached_output)+ .map(|(_, prepared_attach)| {+ assert_eq!(prepared_attach.sessions().len(), 1);+ let (_, owner, _, _, waiting_for_debugger) =+ prepared_attach.sessions()[0].clone().into_parts();+ (owner, waiting_for_debugger)+ })+ .collect::<Vec<_>>();+ attached_owners.sort();++ assert_eq!(+ attached_owners,+ vec![+ (None, false),+ (Some("SID-browser-1".to_owned()), false),+ (Some("SID-browser-2".to_owned()), true),+ ],+ "page and worker TargetHandlers must not receive browser-level shared workers"+ );+ }+#[test]fn shared_worker_target_registration_respects_auto_attach_filter() {let mut conn = CdpConnection::default();