Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
Support instance-scoped CDP Browser.close shutdown
nengc99d2914c705
diff --git a/moli-protocol-server/src/cdp_writer.rs b/moli-protocol-server/src/cdp_writer.rsindex 88569afdf..c6e57076a 100644--- a/moli-protocol-server/src/cdp_writer.rs+++ b/moli-protocol-server/src/cdp_writer.rs@@ -1,4 +1,4 @@-use std::time::Instant;+use std::time::{Duration, Instant};use axum::extract::ws::{Message, WebSocket};use futures_util::{SinkExt, stream::SplitSink};@@ -17,6 +17,7 @@ mod tests;const DEFAULT_WRITER_QUEUE_CAPACITY: usize = 1024;const DEFAULT_MAX_PENDING_WRITER_BYTES: usize = 64 * 1024 * 1024;const DEFAULT_MAX_WRITER_MESSAGE_BYTES: usize = 64 * 1024 * 1024;+const WRITER_CLOSE_TIMEOUT: Duration = Duration::from_secs(1);#[derive(Clone)]pub(crate) struct CdpSocketSink {@@ -35,6 +36,7 @@ struct ProtocolOutputEnvelope {enum SocketWriterCommand {Output(ProtocolOutputEnvelope),+ Flush(oneshot::Sender<bool>),CloseAfterFlush,}@@ -84,8 +86,21 @@ fn spawn_socket_sink_with_limits(command}};- let SocketWriterCommand::Output(envelope) = command else {- break;+ let envelope = match command {+ SocketWriterCommand::Output(envelope) => envelope,+ SocketWriterCommand::CloseAfterFlush => break,+ SocketWriterCommand::Flush(completed) => {+ let flushed = tokio::select! {+ biased;+ _ = close_rx.changed() => false,+ result = socket.flush() => result.is_ok(),+ };+ let _ = completed.send(flushed);+ if !flushed {+ break;+ }+ continue;+ }};let ProtocolOutputEnvelope {message,@@ -131,10 +146,10 @@ fn spawn_socket_sink_with_limits(}match close_signal {SocketCloseSignal::PeerCloseReceived => {- let _ = socket.flush().await;+ let _ = tokio::time::timeout(WRITER_CLOSE_TIMEOUT, socket.flush()).await;}SocketCloseSignal::Open | SocketCloseSignal::ImmediateClose => {- let _ = socket.close().await;+ let _ = tokio::time::timeout(WRITER_CLOSE_TIMEOUT, socket.close()).await;}}notify_socket_writer_finished(&mut finished_tx);@@ -151,6 +166,21 @@ fn spawn_socket_sink_with_limits(}impl CdpSocketSink {+ /// Confirms that every preceding output was flushed by the sole writer.+ /// Callers must bound their wait; a stalled peer must not trigger shutdown.+ pub(crate) async fn flush(&self) -> bool {+ let (completed, receiver) = oneshot::channel();+ if self+ .output_tx+ .send(SocketWriterCommand::Flush(completed))+ .await+ .is_err()+ {+ return false;+ }+ receiver.await.unwrap_or(false)+ }+pub(crate) fn enqueue_owned_message(&self, message: Value) -> bool {let available_pending_bytes = self.pending_byte_budget.available();let serialization_limit = self.max_message_bytes.min(available_pending_bytes);diff --git a/moli-protocol-server/src/cdp_writer/tests.rs b/moli-protocol-server/src/cdp_writer/tests.rsindex c4024c301..e18396b11 100644--- a/moli-protocol-server/src/cdp_writer/tests.rs+++ b/moli-protocol-server/src/cdp_writer/tests.rs@@ -67,6 +67,32 @@ fn graceful_close_is_queued_after_existing_output() {));}+#[tokio::test]+async fn flush_confirmation_is_ordered_after_output_and_propagates_failure() {+ let (sink, mut output_rx, _close_rx) = test_sink_with_limits(+ 2,+ DEFAULT_MAX_PENDING_WRITER_BYTES,+ DEFAULT_MAX_WRITER_MESSAGE_BYTES,+ );+ assert!(sink.enqueue_owned_message(json!({"id": 1, "result": {}})));+ let pending = tokio::spawn(async move { sink.flush().await });+ assert!(matches!(+ output_rx.recv().await,+ Some(SocketWriterCommand::Output(_))+ ));+ let Some(SocketWriterCommand::Flush(completed)) = output_rx.recv().await else {+ panic!("flush must be queued after preceding output");+ };+ assert!(+ !pending.is_finished(),+ "queue admission is not a flush confirmation"+ );+ completed+ .send(false)+ .expect("flush waiter remains attached");+ assert!(!pending.await.expect("flush task"));+}+#[test]fn peer_close_signal_has_priority_over_immediate_close() {let (sink, _output_rx, close_rx) = test_sink();diff --git a/moli-protocol-server/src/protocol_server/cdp.rs b/moli-protocol-server/src/protocol_server/cdp.rsindex 6257b86ef..4cb29b9f4 100644--- a/moli-protocol-server/src/protocol_server/cdp.rs+++ b/moli-protocol-server/src/protocol_server/cdp.rs@@ -274,8 +274,14 @@ pub(super) async fn ws_browser_upgrade_handler(return StatusCode::NOT_FOUND.into_response();}let owner_registry = state.cdp_owner_registry;+ let shutdown = state.shutdown;ws.on_upgrade(move |socket| {- run_shared_frontend_socket(socket, owner_registry, CdpFrontendSocketKind::Browser)+ run_shared_frontend_socket(+ socket,+ owner_registry,+ CdpFrontendSocketKind::Browser,+ shutdown,+ )})}@@ -296,13 +302,14 @@ pub(super) async fn ws_target_upgrade_handler(let Some(route) = state.cdp_agent_host_directory.lookup_target(&target_id) else {return StatusCode::NOT_FOUND.into_response();};- target_ws_upgrade_response(ws, target_id, route.endpoint)+ target_ws_upgrade_response(ws, target_id, route.endpoint, state.shutdown)}async fn run_shared_frontend_socket(socket: WebSocket,owner_registry: SharedCdpOwnerRegistry,kind: CdpFrontendSocketKind,+ shutdown: super::instance_shutdown::InstanceShutdown,) {let endpoint = match owner_registry.shared_owner() {Ok(endpoint) => endpoint,@@ -311,19 +318,21 @@ async fn run_shared_frontend_socket(return;}};- run_cdp_frontend_socket(socket, endpoint, kind).await;+ run_cdp_frontend_socket(socket, endpoint, kind, shutdown).await;}fn target_ws_upgrade_response(ws: WebSocketUpgrade,target_id: String,endpoint: crate::cdp_frontend::CdpFrontendEndpoint,+ shutdown: super::instance_shutdown::InstanceShutdown,) -> Response {ws.on_upgrade(move |socket| async move {run_cdp_frontend_socket(socket,endpoint,CdpFrontendSocketKind::Target { target_id },+ shutdown,).await;})diff --git a/moli-protocol-server/src/protocol_server/cdp_socket.rs b/moli-protocol-server/src/protocol_server/cdp_socket.rsindex e5f34edf3..d3aa40b74 100644--- a/moli-protocol-server/src/protocol_server/cdp_socket.rs+++ b/moli-protocol-server/src/protocol_server/cdp_socket.rs@@ -1,8 +1,15 @@use axum::extract::ws::{Message, WebSocket};use futures_util::StreamExt;+use serde_json::{Value, json};use std::time::Duration;-use crate::{cdp_frontend::CdpFrontendEndpoint, cdp_writer::spawn_socket_sink};+use super::instance_shutdown::InstanceShutdown;+use crate::{+ cdp_frontend::CdpFrontendEndpoint,+ cdp_writer::{CdpSocketSink, spawn_socket_sink},+};++const BROWSER_CLOSE_FLUSH_BUDGET: Duration = Duration::from_secs(1);pub(super) enum CdpFrontendSocketKind {Browser,@@ -13,7 +20,12 @@ pub(super) async fn run_cdp_frontend_socket(socket: WebSocket,endpoint: CdpFrontendEndpoint,kind: CdpFrontendSocketKind,+ shutdown: InstanceShutdown,) -> bool {+ let Some(_connection) = shutdown.connection() else {+ return false;+ };+ let browser_socket = matches!(&kind, CdpFrontendSocketKind::Browser);let (socket_tx, mut socket_rx) = socket.split();let (sink, mut writer_finished_rx) = spawn_socket_sink(socket_tx);let socket_sink = sink.clone();@@ -41,6 +53,7 @@ pub(super) async fn run_cdp_frontend_socket(let exit = loop {tokio::select! {+ _ = shutdown.requested() => break CdpSocketExit::TransportClose,_ = endpoint.wait_for_shutdown() => break CdpSocketExit::TransportClose,_ = &mut writer_finished_rx => break CdpSocketExit::WriterFinished,maybe_message = socket_rx.next() => {@@ -49,6 +62,16 @@ pub(super) async fn run_cdp_frontend_socket(};match message {Message::Text(text) => {+ if let Some((response, should_close)) = browser_close_response(&text, browser_socket) {+ if should_close {+ acknowledge_browser_close(&socket_sink, &shutdown, response).await;+ break CdpSocketExit::TransportClose;+ }+ if !socket_sink.enqueue_owned_message(response) {+ break CdpSocketExit::TransportClose;+ }+ continue;+ }if !endpoint.command(frontend_id, text.to_string()).await {break CdpSocketExit::TransportClose;}@@ -74,6 +97,47 @@ pub(super) async fn run_cdp_frontend_socket(true}+// Instance control belongs to the browser-root transport, not an attached page+// or an individual owner actor. Every other command keeps its existing route.+fn browser_close_response(text: &str, browser_socket: bool) -> Option<(Value, bool)> {+ if !browser_socket {+ return None;+ }+ let command: Value = serde_json::from_str(text).ok()?;+ if command.get("method")?.as_str()? != "Browser.close" || command.get("sessionId").is_some() {+ return None;+ }+ let id = command.get("id")?.as_u64()?;+ if command+ .get("params")+ .is_some_and(|params| !params.as_object().is_some_and(serde_json::Map::is_empty))+ {+ return Some((+ json!({"id": id, "error": {"code": -32602, "message": "InvalidParams"}}),+ false,+ ));+ }+ Some((json!({"id": id, "result": {}}), true))+}++async fn acknowledge_browser_close(+ sink: &CdpSocketSink,+ shutdown: &InstanceShutdown,+ response: Value,+) -> bool {+ if !sink.enqueue_owned_message(response) {+ return false;+ }+ if !matches!(+ tokio::time::timeout(BROWSER_CLOSE_FLUSH_BUDGET, sink.flush()).await,+ Ok(true)+ ) {+ return false;+ }+ shutdown.request();+ true+}+enum CdpSocketExit {WriterFinished,PeerClose,@@ -120,3 +184,55 @@ impl Drop for CdpFrontendDetachGuard {self.detach();}}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn only_a_valid_browser_root_close_can_request_instance_shutdown() {+ for params in [+ json!({"id": 7, "method": "Browser.close"}),+ json!({"id": 7, "method": "Browser.close", "params": {}}),+ ] {+ let (response, close) = browser_close_response(¶ms.to_string(), true).unwrap();+ assert!(close);+ assert_eq!(response, json!({"id": 7, "result": {}}));+ }+ for command in [+ json!({"id": 7, "method": "Browser.close", "sessionId": "page"}),+ json!({"id": 7, "method": "Browser.close", "sessionId": null}),+ json!({"id": -1, "method": "Browser.close"}),+ json!({"id": "7", "method": "Browser.close"}),+ json!({"method": "Browser.close"}),+ json!({"id": 7, "method": "browser.close"}),+ ] {+ assert!(browser_close_response(&command.to_string(), true).is_none());+ }+ assert!(browser_close_response(r#"{"id":7,"method":"Browser.close"}"#, false).is_none());+ for params in [json!(null), json!([]), json!({"force": true})] {+ let (response, close) = browser_close_response(+ &json!({"id": 7, "method": "Browser.close", "params": params}).to_string(),+ true,+ )+ .unwrap();+ assert!(!close);+ assert_eq!(response["error"]["code"], -32602);+ }+ }++ #[tokio::test]+ async fn failed_or_unconfirmed_flush_does_not_stop_the_instance() {+ let shutdown = InstanceShutdown::default();+ let sink = CdpSocketSink::for_test();+ assert!(!acknowledge_browser_close(&sink, &shutdown, json!({"id": 1, "result": {}})).await);+ let (sink, _stalled_writer) = CdpSocketSink::with_stalled_writer_for_test(2);+ assert!(!acknowledge_browser_close(&sink, &shutdown, json!({"id": 2, "result": {}})).await);+ assert!(+ tokio::time::timeout(Duration::from_millis(10), shutdown.requested())+ .await+ .is_err()+ );+ assert!(shutdown.connection().is_some());+ }+}diff --git a/moli-protocol-server/src/protocol_server/instance_shutdown.rs b/moli-protocol-server/src/protocol_server/instance_shutdown.rsnew file mode 100644index 000000000..4a326c46c--- /dev/null+++ b/moli-protocol-server/src/protocol_server/instance_shutdown.rs@@ -0,0 +1,102 @@+use tokio::sync::watch;++/// One server instance's persistent stop signal and admitted WebSocket workers.+/// It is not an ownership or authentication mechanism for protocol clients.+#[derive(Clone, Debug)]+pub(super) struct InstanceShutdown {+ state: watch::Sender<ShutdownState>,+}++#[derive(Clone, Copy, Debug, Default)]+struct ShutdownState {+ requested: bool,+ connections: usize,+}++impl Default for InstanceShutdown {+ fn default() -> Self {+ let (state, _) = watch::channel(ShutdownState::default());+ Self { state }+ }+}++impl InstanceShutdown {+ pub(super) fn request(&self) {+ self.state.send_modify(|state| state.requested = true);+ }++ pub(super) async fn requested(&self) {+ let mut receiver = self.state.subscribe();+ let _ = receiver.wait_for(|state| state.requested).await;+ }++ pub(super) fn connection(&self) -> Option<InstanceConnection> {+ let mut admitted = false;+ self.state.send_if_modified(|state| {+ if state.requested {+ return false;+ }+ let Some(count) = state.connections.checked_add(1) else {+ return false;+ };+ state.connections = count;+ admitted = true;+ true+ });+ admitted.then(|| InstanceConnection(self.clone()))+ }++ pub(super) async fn drained(&self) {+ let mut receiver = self.state.subscribe();+ let _ = receiver.wait_for(|state| state.connections == 0).await;+ }+}++pub(super) struct InstanceConnection(InstanceShutdown);++impl Drop for InstanceConnection {+ fn drop(&mut self) {+ self.0.state.send_modify(|state| state.connections -= 1);+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use std::time::Duration;+ use tokio::time::timeout;++ #[tokio::test]+ async fn shutdown_is_persistent_and_repeated_requests_do_not_admit_connections() {+ let instance = InstanceShutdown::default();+ let connection = instance.connection().expect("initial connection admitted");+ instance.request();+ instance.request();+ timeout(Duration::from_millis(100), instance.requested())+ .await+ .expect("late subscriber observes stop");+ assert!(instance.connection().is_none());+ assert!(+ timeout(Duration::from_millis(10), instance.drained())+ .await+ .is_err()+ );+ drop(connection);+ timeout(Duration::from_millis(100), instance.drained())+ .await+ .expect("all workers released");+ }++ #[tokio::test]+ async fn shutdown_does_not_affect_another_instance() {+ let first = InstanceShutdown::default();+ let second = InstanceShutdown::default();+ first.request();+ assert!(second.connection().is_some());+ assert!(+ timeout(Duration::from_millis(10), second.requested())+ .await+ .is_err()+ );+ }+}diff --git a/moli-protocol-server/src/protocol_server/mod.rs b/moli-protocol-server/src/protocol_server/mod.rsindex 88b54b135..3738b8ba3 100644--- a/moli-protocol-server/src/protocol_server/mod.rs+++ b/moli-protocol-server/src/protocol_server/mod.rs@@ -1,8 +1,10 @@#[cfg(test)]use std::path::PathBuf;use std::{+ future::IntoFuture,net::SocketAddr,sync::{Arc, atomic::AtomicU64},+ time::Duration,};use anyhow::Result;@@ -10,9 +12,10 @@ use anyhow::{Context, anyhow};use axum::{Router,body::Body,+ extract::State,http::{HeaderValue, Request, header},middleware::{self, Next},- response::Response,+ response::{IntoResponse, Response},routing::{any, get, post, put},serve::ListenerExt,};@@ -39,6 +42,7 @@ mod cdp;mod cdp_agent_host;mod cdp_owner;mod cdp_socket;+mod instance_shutdown;mod protocol_local_executor;mod tcp_options;mod webdriver_bidi;@@ -47,6 +51,7 @@ mod webdriver_files;use cdp_agent_host::SharedCdpAgentHostDirectory;use cdp_owner::SharedCdpOwnerRegistry;+use instance_shutdown::InstanceShutdown;use webdriver_bidi::SharedBidiSessionRegistry;use webdriver_classic::SharedClassicSessionRegistry;@@ -158,19 +163,50 @@ impl ProtocolServer {self.config.screencast_interval_ms,)?;- let cdp_owner_registry = app_state.cdp_owner_registry.clone();- let app = build_router(app_state);+ serve_listener(listener, app_state).await+ }+}- let listener = listener.tap_io(|tcp_stream| {- tcp_options::configure_accepted_protocol_stream(tcp_stream);+/// Shared by the executable and instance-lifecycle integration tests.+async fn serve_listener(listener: TcpListener, app_state: AppState) -> Result<()> {+ const SHUTDOWN_BUDGET: Duration = Duration::from_secs(5);+ let shutdown = app_state.shutdown.clone();+ let cdp_owner_registry = app_state.cdp_owner_registry.clone();+ let classic_session_registry = app_state.classic_session_registry.clone();+ let cookie_profile = app_state.cookie_profile.clone();+ let listener =+ listener.tap_io(|stream| tcp_options::configure_accepted_protocol_stream(stream));+ let stop_accepting = shutdown.clone();+ let serving = axum::serve(listener, build_router(app_state))+ .with_graceful_shutdown(async move { stop_accepting.requested().await })+ .into_future();+ tokio::pin!(serving);+ let completed = tokio::select! {+ result = &mut serving => Some(result),+ _ = shutdown.requested() => None,+ };+ shutdown.request();+ tokio::time::timeout(SHUTDOWN_BUDGET, async {+ let (_, result) = tokio::join!(cdp_owner_registry.shutdown(), async {+ // Drain in-flight HTTP requests before taking the final Classic+ // session set. New requests and upgraded sockets are rejected.+ match completed {+ Some(result) => result,+ None => (&mut serving).await,+ }+ .context("protocol server failed")?;+ classic_session_registry.shutdown(&cookie_profile).await?;+ shutdown.drained().await;+ Ok(())});- let result = axum::serve(listener, app).await;- cdp_owner_registry.shutdown().await;- result.context("protocol server failed")- }+ result+ })+ .await+ .context("protocol server shutdown timed out; checkpoints may be incomplete")?}fn build_router(app_state: AppState) -> Router {+ let shutdown = app_state.shutdown.clone();Router::new().route("/status", get(webdriver_classic::webdriver_classic_status)).route("/status/", get(webdriver_classic::webdriver_classic_status))@@ -686,6 +722,18 @@ fn build_router(app_state: AppState) -> Router {.layer(middleware::from_fn(classic_webdriver_response_headers_middleware,))+ .layer(middleware::from_fn_with_state(shutdown, instance_admission))+}++async fn instance_admission(+ State(shutdown): State<InstanceShutdown>,+ request: Request<Body>,+ next: Next,+) -> Response {+ let Some(_connection) = shutdown.connection() else {+ return axum::http::StatusCode::SERVICE_UNAVAILABLE.into_response();+ };+ next.run(request).await}async fn classic_webdriver_response_headers_middleware(@@ -737,6 +785,7 @@ fn is_websocket_upgrade_request(request: &Request<Body>) -> bool {#[derive(Clone)]struct AppState {+ shutdown: InstanceShutdown,browser_ws_url: String,page_ws_url: String,bidi_ws_url: String,@@ -810,6 +859,7 @@ impl AppState {screencast_interval_ms,);Self {+ shutdown: InstanceShutdown::default(),browser_ws_url: format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"),page_ws_url: format!("ws://{addr}/devtools/page/{DEFAULT_TARGET_ID}"),bidi_ws_url: format!("ws://{addr}/session"),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 b86eb9580..dea98a6fb 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@@ -4,6 +4,7 @@ mod auto_attach_startup;mod auxiliary_page_identity;mod auxiliary_page_retirement;mod blank_navigation_inheritance;+mod browser_close;mod noopener_blank_inheritance;mod popup_navigation_referrer;diff --git a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page/browser_close.rs b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page/browser_close.rsnew file mode 100644index 000000000..3ff276900--- /dev/null+++ b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page/browser_close.rs@@ -0,0 +1,249 @@+use super::*;++async fn instance(+ cookie_path: Option<PathBuf>,+) -> (+ SocketAddr,+ tokio::task::JoinHandle<anyhow::Result<()>>,+ AppState,+) {+ let listener = TcpListener::bind("127.0.0.1:0")+ .await+ .expect("bind owned instance");+ let addr = listener.local_addr().expect("owned instance address");+ let state = AppState::from_parts(+ addr,+ SharedCookieProfile::new(Vec::new(), cookie_path.into_iter().collect()),+ Arc::new(StoragePartitionState::open(None).expect("in-memory storage")),+ protocol_server_test_runtime_config(+ FetchConfig::default(),+ OptionalResourceFetchMask::NONE,+ ),+ crate::config::DEFAULT_SCREENCAST_INTERVAL_MS,+ );+ let serving = state.clone();+ let task = tokio::spawn(async move { serve_listener(listener, serving).await });+ (addr, task, state)+}++async fn browser(addr: SocketAddr) -> TestCdpSocket {+ connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))+ .await+ .expect("connect owned browser")+ .0+}++async fn joined(task: tokio::task::JoinHandle<anyhow::Result<()>>) {+ timeout(Duration::from_secs(7), task)+ .await+ .expect("instance exits within total shutdown budget")+ .expect("server task joins")+ .expect("server completes shutdown without a timeout or join error");+}++async fn closed(socket: &mut TestCdpSocket) {+ timeout(Duration::from_secs(2), async {+ while let Some(Ok(message)) = socket.next().await {+ if matches!(message, WsMessage::Close(_)) {+ break;+ }+ }+ })+ .await+ .expect("owned socket terminates");+}++async fn close_instance(socket: &mut TestCdpSocket, id: u64) {+ let response = send_cdp_command(socket, id, "Browser.close", None, json!({})).await;+ assert_eq!(+ response_by_id(&response, id),+ &json!({"id": id, "result": {}}),+ "the close response must arrive before transport EOF"+ );+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn browser_close_joins_its_listener_connections_and_checkpoint_only() {+ let profile = TempDir::new("browser-close-checkpoint");+ fs::create_dir_all(&profile.path).expect("own checkpoint directory");+ let cookie_path = profile.path.join("cookies.json");+ let (addr, task, state) = instance(Some(cookie_path.clone())).await;+ let (other_addr, other_task, other_state) = instance(None).await;+ let mut root = browser(addr).await;+ let mut other_root = browser(other_addr).await;+ let first = create_dynamic_target(&mut root, 1).await;+ let _second = create_dynamic_target(&mut root, 2).await;+ let mut page = connect_dynamic_page(addr, &first).await;+ let cookie = send_cdp_command(&mut page, 3, "Network.setCookie", None,+ json!({"name": "owned-close", "value": "persisted", "url": "https://browser-close.invalid/"})).await;+ assert!(response_by_id(&cookie, 3)["error"].is_null());++ // Keep both independent BiDi and Classic-attached BiDi sockets open while+ // closing the instance; upgraded connections cannot be left detached.+ let (mut bidi, _) = connect_async(format!("ws://{addr}/session"))+ .await+ .expect("BiDi");+ let bidi_session = send_cdp_command(&mut bidi, 4, "session.new", None, json!({})).await;+ assert_eq!(response_by_id(&bidi_session, 4)["type"], "success");+ let classic = build_router(state.clone())+ .oneshot(+ Request::builder()+ .method(Method::POST)+ .uri("/session")+ .header(header::CONTENT_TYPE, "application/json")+ .body(Body::from("{}"))+ .expect("Classic session request"),+ )+ .await+ .expect("Classic response");+ assert_eq!(classic.status(), StatusCode::OK);+ let classic: serde_json::Value = serde_json::from_slice(+ &to_bytes(classic.into_body(), 65536)+ .await+ .expect("Classic body"),+ )+ .expect("Classic JSON");+ let classic_id = classic["value"]["sessionId"].as_str().expect("Classic ID");+ let (mut attached, _) = connect_async(format!("ws://{addr}/session/{classic_id}"))+ .await+ .expect("attached BiDi");+ let attached_ready =+ send_cdp_command(&mut attached, 5, "browser.getUserContexts", None, json!({})).await;+ assert_eq!(response_by_id(&attached_ready, 5)["type"], "success");+ assert!(state.classic_session_registry.has_session(classic_id));++ close_instance(&mut root, 100).await;+ joined(task).await;+ closed(&mut root).await;+ closed(&mut page).await;+ closed(&mut bidi).await;+ closed(&mut attached).await;+ assert!(+ tokio::net::TcpStream::connect(addr).await.is_err(),+ "closed listener must not accept"+ );+ assert_eq!(state.cdp_owner_registry.owner_count(), 0);+ assert!(!state.classic_session_registry.has_session(classic_id));+ assert_eq!(state.bidi_session_registry.lock().active_session_count(), 0);+ let persisted = cookie_cache::load_cookie_cache(&cookie_path).expect("checkpoint on disk");+ assert!(+ persisted+ .iter()+ .any(|cookie| cookie.name == "owned-close" && cookie.value == "persisted")+ );++ let version =+ send_cdp_command(&mut other_root, 101, "Browser.getVersion", None, json!({})).await;+ assert!(response_by_id(&version, 101)["result"]["product"].is_string());+ assert!(!other_task.is_finished(), "another instance survives");+ assert!(other_state.shutdown.connection().is_some());+ close_instance(&mut other_root, 102).await;+ joined(other_task).await;+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn page_attached_invalid_close_and_frontend_disconnect_do_not_stop_instance() {+ let (addr, task, state) = instance(None).await;+ let mut root = browser(addr).await;+ let target = create_dynamic_target(&mut root, 1).await;+ let mut page = connect_dynamic_page(addr, &target).await;+ let attach = send_cdp_command(+ &mut root,+ 2,+ "Target.attachToTarget",+ None,+ json!({"targetId": target, "flatten": true}),+ )+ .await;+ let session = response_by_id(&attach, 2)["result"]["sessionId"]+ .as_str()+ .expect("attached ID");+ let page_close = send_cdp_command(&mut page, 3, "Browser.close", None, json!({})).await;+ assert!(response_by_id(&page_close, 3)["error"].is_object());+ let attached_close =+ send_cdp_command(&mut root, 4, "Browser.close", Some(session), json!({})).await;+ assert!(response_by_id(&attached_close, 4)["error"].is_object());+ let invalid =+ send_cdp_command(&mut root, 5, "Browser.close", None, json!({"force": true})).await;+ assert_eq!(response_by_id(&invalid, 5)["error"]["code"], -32602);+ root.close(None).await.expect("disconnect viewer only");+ closed(&mut root).await;+ let alive = send_cdp_command(+ &mut page,+ 6,+ "Runtime.evaluate",+ None,+ json!({"expression": "21 * 2"}),+ )+ .await;+ assert_eq!(response_by_id(&alive, 6)["result"]["result"]["value"], 42);+ assert!(!task.is_finished());+ assert!(state.shutdown.connection().is_some());+ let mut replacement = browser(addr).await;+ close_instance(&mut replacement, 7).await;+ joined(task).await;+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn simultaneous_close_requests_finish_once_without_hanging() {+ let (addr, task, state) = instance(None).await;+ let mut first = browser(addr).await;+ let mut second = browser(addr).await;+ let (left, right) = tokio::join!(+ first.send(WsMessage::Text(+ json!({"id": 1, "method": "Browser.close"})+ .to_string()+ .into()+ )),+ second.send(WsMessage::Text(+ json!({"id": 2, "method": "Browser.close", "params": {}})+ .to_string()+ .into()+ ))+ );+ assert!(left.is_ok() || right.is_ok());+ async fn accepted(socket: &mut TestCdpSocket) -> bool {+ timeout(Duration::from_secs(2), async {+ while let Some(Ok(message)) = socket.next().await {+ if let WsMessage::Text(text) = message {+ let response: serde_json::Value =+ serde_json::from_str(&text).expect("close JSON");+ if response["result"] == json!({}) {+ return true;+ }+ }+ }+ false+ })+ .await+ .unwrap_or(false)+ }+ let (left, right) = tokio::join!(accepted(&mut first), accepted(&mut second));+ assert!(+ left || right,+ "at least one close is acknowledged before exit"+ );+ joined(task).await;+ assert_eq!(state.cdp_owner_registry.owner_count(), 0);+ assert!(tokio::net::TcpStream::connect(addr).await.is_err());+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn incomplete_worker_drain_is_bounded_and_not_reported_as_clean_shutdown() {+ let (addr, task, state) = instance(None).await;+ let held_worker = state+ .shutdown+ .connection()+ .expect("controlled stalled worker");+ let mut root = browser(addr).await;+ close_instance(&mut root, 1).await;+ let error = timeout(Duration::from_secs(7), task)+ .await+ .expect("bounded shutdown")+ .expect("server task joins")+ .expect_err("stalled worker cannot be clean shutdown");+ assert!(error.to_string().contains("checkpoints may be incomplete"));+ assert_eq!(state.cdp_owner_registry.owner_count(), 0);+ assert!(tokio::net::TcpStream::connect(addr).await.is_err());+ drop(held_worker);+}diff --git a/moli-protocol-server/src/protocol_server/webdriver_bidi.rs b/moli-protocol-server/src/protocol_server/webdriver_bidi.rsindex 49e8e146e..820de530d 100644--- a/moli-protocol-server/src/protocol_server/webdriver_bidi.rs+++ b/moli-protocol-server/src/protocol_server/webdriver_bidi.rs@@ -57,7 +57,7 @@ use crate::cdp_scheduler::{use super::webdriver_files::selected_files_from_paths;use super::{- AppState, CookieProfileCommit, SharedCookieProfile,+ AppState, CookieProfileCommit, SharedCookieProfile, instance_shutdown::InstanceShutdown,protocol_local_executor::spawn_protocol_local_task,};@@ -71,6 +71,7 @@ pub(super) async fn ws_bidi_session_upgrade_handler(let web_socket_url = state.bidi_ws_url;let session_registry = state.bidi_session_registry;let cookie_profile = state.cookie_profile;+ let shutdown = state.shutdown;let navigation_runtime_config = NavigationRuntimeConfig::new_with_layout_configuration(state.fetch_config,state.optional_resource_fetch_mask,@@ -86,6 +87,7 @@ pub(super) async fn ws_bidi_session_upgrade_handler(initial_cookie_snapshot,initial_storage_partition,navigation_runtime_config,+ shutdown,)})}@@ -114,6 +116,9 @@ pub(super) async fn ws_bidi_existing_session_upgrade_handler(.map(str::to_owned);let web_socket_url = format!("{}/{}", state.bidi_ws_url.trim_end_matches('/'), session_id);ws.on_upgrade(move |socket| async move {+ let Some(_connection) = state.shutdown.connection() else {+ return;+ };if !runtime.attach_bidi_socket(socket,@@ -137,7 +142,11 @@ async fn handle_bidi_session_socket(initial_cookie_snapshot: Vec<StoredCookie>,initial_storage_partition: CdpInitialStoragePartition,navigation_runtime_config: NavigationRuntimeConfig,+ shutdown: InstanceShutdown,) {+ let Some(_connection) = shutdown.connection() else {+ return;+ };let cookie_commit = spawn_protocol_local_task("bidi-socket", move || {handle_bidi_session_socket_local(socket,@@ -146,6 +155,7 @@ async fn handle_bidi_session_socket(initial_cookie_snapshot,initial_storage_partition,navigation_runtime_config,+ shutdown,)}).await;@@ -169,6 +179,7 @@ async fn handle_bidi_session_socket_local(initial_cookie_snapshot: Vec<StoredCookie>,initial_storage_partition: CdpInitialStoragePartition,navigation_runtime_config: NavigationRuntimeConfig,+ shutdown: InstanceShutdown,) -> CookieProfileCommit {let mut actor = BidiSocketActor::new(socket, web_socket_url);let (mut scheduler, mut receivers) = CdpScheduler::new_with_initial_state_runtime_config(@@ -182,6 +193,7 @@ async fn handle_bidi_session_socket_local(adapter_scheduler.schedule_turn_if_needed(&scheduler, page_javascript_blocked);tokio::select! {biased;+ _ = shutdown.requested() => break,maybe_message = actor.socket.recv() => {let Some(message) = maybe_message else {break;diff --git a/moli-protocol-server/src/protocol_server/webdriver_classic.rs b/moli-protocol-server/src/protocol_server/webdriver_classic.rsindex 609c13897..604e5a2b3 100644--- a/moli-protocol-server/src/protocol_server/webdriver_classic.rs+++ b/moli-protocol-server/src/protocol_server/webdriver_classic.rs@@ -1607,6 +1607,12 @@ pub(super) async fn webdriver_classic_new_session(State(state): State<AppState>,body: Bytes,) -> Response {+ let Some(instance_connection) = state.shutdown.connection() else {+ return classic_error_into_response(ClassicError::new(+ ClassicErrorCode::SessionNotCreated,+ "protocol server is shutting down",+ ));+ };let params = match classic_json_body(&body) {Ok(params) => params,Err(error) => return classic_error_into_response(error),@@ -1671,6 +1677,7 @@ pub(super) async fn webdriver_classic_new_session(state.subframe_loading_enabled,state.layout_configuration,),+ instance_connection,);let create_context = ClassicDevToolsCommandContext::new(session.session_id.as_str());let target_id = match runtimediff --git a/moli-protocol-server/src/protocol_server/webdriver_classic/state.rs b/moli-protocol-server/src/protocol_server/webdriver_classic/state.rsindex 2358a7d4a..2c1fae1d7 100644--- a/moli-protocol-server/src/protocol_server/webdriver_classic/state.rs+++ b/moli-protocol-server/src/protocol_server/webdriver_classic/state.rs@@ -37,7 +37,10 @@ use crate::cdp_scheduler::{use super::super::webdriver_bidi::{BidiSocketActor, BidiSocketActorInput, SharedBidiSessionRegistry,};-use super::super::{CookieProfileCommit, protocol_local_executor::spawn_protocol_local_task};+use super::super::{+ CookieProfileCommit, SharedCookieProfile, instance_shutdown::InstanceConnection,+ protocol_local_executor::spawn_protocol_local_task,+};const CLASSIC_SCRIPT_TERMINATION_TIMEOUT: Duration = Duration::from_secs(5);@@ -47,6 +50,35 @@ pub(in crate::protocol_server) struct SharedClassicSessionRegistry {}impl SharedClassicSessionRegistry {+ pub(in crate::protocol_server) async fn shutdown(+ &self,+ cookie_profile: &SharedCookieProfile,+ ) -> anyhow::Result<()> {+ let runtimes = {+ let mut manager = self.inner.lock();+ let session_ids = manager.runtimes.keys().cloned().collect::<Vec<_>>();+ session_ids+ .iter()+ .filter_map(|id| manager.release_session(id))+ .collect::<Vec<_>>()+ };+ let commits = futures_util::future::join_all(+ runtimes+ .into_iter()+ .map(ClassicSessionRuntimeHandle::shutdown_and_join),+ )+ .await;+ let mut result = Ok(());+ for commit in commits {+ if let Err(error) = commit.and_then(|commit| cookie_profile.commit_and_save(commit))+ && result.is_ok()+ {+ result = Err(error);+ }+ }+ result+ }+pub(super) fn lock(&self) -> parking_lot::MutexGuard<'_, ClassicSessionManager> {self.inner.lock()}@@ -473,6 +505,7 @@ impl ClassicSessionBinding {#[derive(Debug, Clone)]pub(in crate::protocol_server) struct ClassicSessionRuntimeHandle {tx: mpsc::UnboundedSender<ClassicSessionRuntimeRequest>,+ completion: Arc<tokio::sync::Mutex<Option<oneshot::Receiver<CookieProfileCommit>>>>,}impl ClassicSessionRuntimeHandle {@@ -480,17 +513,24 @@ impl ClassicSessionRuntimeHandle {initial_cookie_snapshot: Vec<StoredCookie>,initial_storage_partition: CdpInitialStoragePartition,navigation_runtime_config: NavigationRuntimeConfig,+ instance_connection: InstanceConnection,) -> Self {let (tx, rx) = mpsc::unbounded_channel();- let _runtime_finished_rx = spawn_protocol_local_task("classic-session", move || {- classic_session_runtime_loop(- rx,- initial_cookie_snapshot,- initial_storage_partition,- navigation_runtime_config,- )- });- Self { tx }+ let runtime_finished_rx =+ spawn_protocol_local_task("classic-session", move || async move {+ let _instance_connection = instance_connection;+ classic_session_runtime_loop(+ rx,+ initial_cookie_snapshot,+ initial_storage_partition,+ navigation_runtime_config,+ )+ .await+ });+ Self {+ tx,+ completion: Arc::new(tokio::sync::Mutex::new(Some(runtime_finished_rx))),+ }}pub(super) async fn execute(@@ -811,6 +851,19 @@ impl ClassicSessionRuntimeHandle {.unwrap_or_else(|_| CookieProfileCommit::unchanged())}+ async fn shutdown_and_join(self) -> anyhow::Result<CookieProfileCommit> {+ let completion = self.completion.clone();+ let _ = self.shutdown().await;+ let receiver = completion+ .lock()+ .await+ .take()+ .ok_or_else(|| anyhow::anyhow!("Classic runtime completion already consumed"))?;+ receiver+ .await+ .map_err(|_| anyhow::anyhow!("Classic runtime stopped before checkpoint completion"))+ }+pub(in crate::protocol_server) async fn attach_bidi_socket(&self,socket: WebSocket,