Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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<Option
conn.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.rs
index 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.rs
index 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();