Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(runtime): defer child-frame evaluation through the Inspector owner

ldm0218755595980
diff --git a/moli-protocol/src/domains/runtime/tests/evaluate.rs b/moli-protocol/src/domains/runtime/tests/evaluate.rs
index 9048fee61..a230ec3c1 100644
--- a/moli-protocol/src/domains/runtime/tests/evaluate.rs
+++ b/moli-protocol/src/domains/runtime/tests/evaluate.rs
@@ -100,6 +100,7 @@ async fn assert_empty_http_error_navigation(ctx: &mut TestContext, error_url: &s
);
}
+mod child_await;
mod contexts;
mod dom_integration;
mod evaluation;
diff --git a/moli-protocol/src/domains/runtime/tests/evaluate/child_await.rs b/moli-protocol/src/domains/runtime/tests/evaluate/child_await.rs
new file mode 100644
index 000000000..d2da78ae3
--- /dev/null
+++ b/moli-protocol/src/domains/runtime/tests/evaluate/child_await.rs
@@ -0,0 +1,235 @@
+use super::*;
+
+async fn child_context(ctx: &mut TestContext) -> i64 {
+ with_loaded_document_async(
+ ctx,
+ r#"<!doctype html><title>parent</title><iframe srcdoc="<title>child</title><body>child realm</body>"></iframe>"#,
+ )
+ .await;
+ ctx.process_async(json!({"id": 12_001, "method": "Page.getFrameTree"}))
+ .await;
+ let frame_id =
+ take_response_by_id(ctx, 12_001)["result"]["frameTree"]["childFrames"][0]["frame"]["id"]
+ .as_str()
+ .expect("the iframe must have its own browsing context")
+ .to_owned();
+ ctx.process_async(json!({
+ "id": 12_002, "method": "Page.createIsolatedWorld",
+ "params": {"frameId": frame_id, "worldName": "child-await-materialization"}
+ }))
+ .await;
+ assert!(take_response_by_id(ctx, 12_002)["result"]["executionContextId"].is_i64());
+ ctx.process_async(json!({"id": 12_003, "method": "Runtime.enable"}))
+ .await;
+ assert_eq!(take_response_by_id(ctx, 12_003)["result"], json!({}));
+ crate::testing::wait_until_message(ctx, None, "child default execution context", |message| {
+ message["method"] == "Runtime.executionContextCreated"
+ && message["params"]["context"]["auxData"]["frameId"] == frame_id
+ && message["params"]["context"]["auxData"]["isDefault"] == true
+ })
+ .await;
+ ctx.sent
+ .iter()
+ .find(|message| {
+ message["method"] == "Runtime.executionContextCreated"
+ && message["params"]["context"]["auxData"]["frameId"] == frame_id
+ && message["params"]["context"]["auxData"]["isDefault"] == true
+ })
+ .and_then(|message| message["params"]["context"]["id"].as_i64())
+ .expect("Runtime.enable must report the actual child default context")
+}
+
+#[tokio::test]
+async fn child_runtime_evaluate_timer_reply_follows_console_on_owner_turns() {
+ let mut ctx = TestContext::new();
+ let context_id = child_context(&mut ctx).await;
+ ctx.sent.clear();
+ ctx.process_async(json!({
+ "id": 12_010, "method": "Runtime.evaluate",
+ "params": {
+ "contextId": context_id, "returnByValue": true, "awaitPromise": true,
+ "expression": "new Promise(resolve => setTimeout(() => { console.log('child-await-output'); resolve({value:42, title:document.title, child:window!==top}); }, 20))"
+ }
+ }))
+ .await;
+ crate::testing::wait_until_message(
+ &mut ctx,
+ None,
+ "child timer-backed Inspector reply",
+ |message| message["id"] == 12_010,
+ )
+ .await;
+ let console = ctx
+ .sent
+ .iter()
+ .position(|message| {
+ message["method"] == "Runtime.consoleAPICalled"
+ && message["params"]["executionContextId"] == context_id
+ && message["params"]["args"][0]["value"] == "child-await-output"
+ })
+ .expect("the real child timer must run without a follow-up evaluation");
+ let terminal = ctx
+ .sent
+ .iter()
+ .position(|message| message["id"] == 12_010)
+ .unwrap();
+ assert!(
+ console < terminal,
+ "concrete output must precede the response: {:?}",
+ ctx.sent
+ );
+ let response = take_response_by_id(&mut ctx, 12_010);
+ assert_eq!(
+ response["result"]["result"]["value"],
+ json!({"value":42, "title":"child", "child":true})
+ );
+ assert!(!ctx.conn.has_pending_inspector_awaits());
+}
+
+#[tokio::test]
+async fn child_runtime_evaluate_preserves_native_exception_details() {
+ let mut ctx = TestContext::new();
+ let context_id = child_context(&mut ctx).await;
+ for (id, expression, await_promise) in [
+ (
+ 12_020,
+ "throw new TypeError('child-await-rejection')",
+ false,
+ ),
+ (
+ 12_021,
+ "new Promise((resolve,reject) => setTimeout(() => reject(new TypeError('child-await-rejection')), 20))",
+ true,
+ ),
+ ] {
+ ctx.process_async(json!({
+ "id": id, "method": "Runtime.evaluate",
+ "params": {"contextId":context_id, "expression":expression,
+ "returnByValue":true, "awaitPromise":await_promise}
+ }))
+ .await;
+ let response = wait_for_response_by_id_async(&mut ctx, None, id).await;
+ assert!(response.get("error").is_none(), "{response:?}");
+ let details = &response["result"]["exceptionDetails"];
+ assert_eq!(
+ details["exception"]["className"], "TypeError",
+ "{response:?}"
+ );
+ assert!(
+ details["exception"]["description"]
+ .as_str()
+ .unwrap()
+ .contains("child-await-rejection")
+ );
+ assert!(details["exceptionId"].is_number(), "{response:?}");
+ assert!(
+ !details["stackTrace"]["callFrames"]
+ .as_array()
+ .unwrap()
+ .is_empty(),
+ "{response:?}"
+ );
+ assert!(!ctx.conn.has_pending_inspector_awaits());
+ }
+}
+
+#[tokio::test]
+async fn child_runtime_evaluate_pending_promise_releases_page_dispatch() {
+ let mut ctx = TestContext::new();
+ let context_id = child_context(&mut ctx).await;
+ ctx.sent.clear();
+ ctx.process_async(json!({
+ "id": 12_030, "method": "Runtime.evaluate",
+ "params": {
+ "contextId":context_id, "returnByValue":true, "awaitPromise":true,
+ "expression":"new Promise(resolve => { globalThis.resolveChildAwait = resolve; console.log('child-await-pending'); })"
+ }
+ }))
+ .await;
+ crate::testing::wait_until_message(
+ &mut ctx,
+ None,
+ "unresolved child expression started",
+ |message| {
+ message["method"] == "Runtime.consoleAPICalled"
+ && message["params"]["args"][0]["value"] == "child-await-pending"
+ },
+ )
+ .await;
+ assert!(!ctx.sent.iter().any(|message| message["id"] == 12_030));
+ assert!(
+ ctx.conn
+ .has_unclaimed_pending_inspector_awaits_for_session_owner(None)
+ );
+ assert!(
+ !ctx.conn
+ .has_claimed_pending_inspector_awaits_for_session_owner(None)
+ );
+ ctx.process_async(json!({
+ "id":12_031, "method":"Runtime.evaluate",
+ "params":{"expression":"document.title", "returnByValue":true}
+ }))
+ .await;
+ assert_eq!(
+ take_response_by_id(&mut ctx, 12_031)["result"]["result"]["value"],
+ "parent"
+ );
+ assert!(!ctx.sent.iter().any(|message| message["id"] == 12_030));
+ ctx.process_async(json!({
+ "id":12_032, "method":"Runtime.evaluate",
+ "params":{"contextId":context_id, "expression":"resolveChildAwait(42)", "returnByValue":true}
+ }))
+ .await;
+ let response = wait_for_response_by_id_async(&mut ctx, None, 12_030).await;
+ assert_eq!(response["result"]["result"]["value"], 42);
+ assert!(!ctx.conn.has_pending_inspector_awaits());
+}
+
+#[tokio::test]
+async fn child_runtime_evaluate_frame_retirement_rejects_pending_and_stale_requests() {
+ let mut ctx = TestContext::new();
+ let context_id = child_context(&mut ctx).await;
+ ctx.sent.clear();
+ ctx.process_async(json!({
+ "id":12_040, "method":"Runtime.evaluate",
+ "params":{"contextId":context_id, "returnByValue":true, "awaitPromise":true,
+ "expression":"new Promise(() => { console.log('child-await-retire'); })"}
+ }))
+ .await;
+ crate::testing::wait_until_message(
+ &mut ctx,
+ None,
+ "child expression before retirement",
+ |message| {
+ message["method"] == "Runtime.consoleAPICalled"
+ && message["params"]["args"][0]["value"] == "child-await-retire"
+ },
+ )
+ .await;
+ assert!(!ctx.sent.iter().any(|message| message["id"] == 12_040));
+ ctx.process_async(json!({
+ "id":12_041, "method":"Runtime.evaluate",
+ "params":{"expression":"document.querySelector('iframe').remove()", "returnByValue":true}
+ }))
+ .await;
+ let response = wait_for_response_by_id_async(&mut ctx, None, 12_040).await;
+ assert_eq!(response["error"]["code"], -32000, "{response:?}");
+ assert!(
+ !response["error"]["message"]
+ .as_str()
+ .unwrap()
+ .contains("outside an owner continuation")
+ );
+ assert!(!ctx.conn.has_pending_inspector_awaits());
+ ctx.process_async(json!({
+ "id":12_042, "method":"Runtime.evaluate",
+ "params":{"contextId":context_id, "expression":"42", "returnByValue":true}
+ }))
+ .await;
+ let stale = take_response_by_id(&mut ctx, 12_042);
+ assert_eq!(stale["error"]["code"], -32000);
+ assert!(
+ !ctx.sent.iter().any(|message| message["id"] == 12_040),
+ "retirement must have a single terminal"
+ );
+}
diff --git a/moli-renderer-v8/src/runtime/page_dom.rs b/moli-renderer-v8/src/runtime/page_dom.rs
index feef92393..0be59a0d2 100644
--- a/moli-renderer-v8/src/runtime/page_dom.rs
+++ b/moli-renderer-v8/src/runtime/page_dom.rs
@@ -750,11 +750,6 @@ impl PageVm {
action: &str,
raw_json: &str,
) -> Result<Vec<RendererRuntimeInspectorMessage>> {
- if action == "evaluate"
- && let Some(messages) = self.try_dispatch_child_default_runtime_evaluate(raw_json)?
- {
- return Ok(messages);
- }
let prepared_json =
self.prepare_runtime_protocol_message_with_context_resolution(action, raw_json)?;
let messages = self
@@ -779,34 +774,6 @@ impl PageVm {
raw_json: &str,
deferred_response: RendererRuntimeInspectorResponseSender,
) -> Result<Vec<RendererRuntimeInspectorMessage>> {
- if action == "evaluate"
- && let Some(messages) = self.try_dispatch_child_default_runtime_evaluate(raw_json)?
- {
- let call_id = deferred_response.call_id();
- if let Some(message) = messages.into_iter().next() {
- if deferred_response.response_delivery()
- == moli_page_types::RendererInspectorResponseDelivery::SessionSink
- {
- let deferred_response = self.vm().route_frontend_runtime_inspector_response(
- inspector_session_id,
- deferred_response,
- )?;
- let settlement = deferred_response.finalize_output(
- RendererRuntimeCommandOutput::from_inspector_message(message),
- );
- self.append_runtime_command_output_settlement(settlement);
- } else if let Err(message) =
- deferred_response.send(message.into_v8_inspector_message())
- {
- tracing::debug!(
- call_id,
- message = ?message,
- "dropping child-frame runtime response because deferred receiver was closed"
- );
- }
- }
- return Ok(Vec::new());
- }
let prepared_json =
self.prepare_runtime_protocol_message_with_context_resolution(action, raw_json)?;
self.dispatch_runtime_protocol_message_with_command_output(
@@ -1126,103 +1093,6 @@ impl PageVm {
}
}
- fn try_dispatch_child_default_runtime_evaluate(
- &mut self,
- raw_json: &str,
- ) -> Result<Option<Vec<RendererRuntimeInspectorMessage>>> {
- let message: Value = serde_json::from_str(raw_json)?;
- if message.get("method").and_then(Value::as_str) != Some("Runtime.evaluate") {
- return Ok(None);
- }
- let Some(params) = message.get("params").and_then(Value::as_object) else {
- return Ok(None);
- };
- let Some(context_id) = params.get("contextId").and_then(Value::as_i64) else {
- return Ok(None);
- };
- if self
- .vm_mut()
- .child_default_frame_id_for_execution_context_id(context_id)
- .is_none()
- {
- return Ok(None);
- }
- if params.get("objectGroup").is_some()
- || params.get("generatePreview").and_then(Value::as_bool) == Some(true)
- || params.get("returnByValue").and_then(Value::as_bool) != Some(true)
- {
- return Ok(None);
- }
- let expression = params
- .get("expression")
- .and_then(Value::as_str)
- .unwrap_or_default();
- let await_promise = params
- .get("awaitPromise")
- .and_then(Value::as_bool)
- .unwrap_or(false);
- let user_gesture = params
- .get("userGesture")
- .and_then(Value::as_bool)
- .unwrap_or(false);
- let file_prompt_handler = params
- .get(crate::script_vm::WEBDRIVER_BIDI_FILE_PROMPT_HANDLER_PARAM)
- .and_then(Value::as_str)
- .filter(|handler| matches!(*handler, "accept" | "dismiss"));
- let id = message.get("id").cloned().unwrap_or(Value::Null);
- let result = self
- .vm_mut()
- .evaluate_expression_by_value_payload_in_context_with_await(
- Some(context_id),
- expression,
- await_promise,
- user_gesture,
- file_prompt_handler,
- );
- let response = match result {
- Ok(payload) if payload.get("exception").is_none() => {
- json!({ "id": id, "result": { "result": payload } })
- }
- Ok(payload) => {
- let description = payload
- .get("exception")
- .and_then(Value::as_str)
- .unwrap_or("Error");
- json!({
- "id": id,
- "result": {
- "result": {
- "type": "object",
- "subtype": "error",
- "description": description,
- },
- "exceptionDetails": {
- "text": "Uncaught",
- "executionContextId": context_id,
- "exception": {
- "type": "object",
- "subtype": "error",
- "description": description,
- },
- },
- },
- })
- }
- Err(error) => {
- json!({
- "id": id,
- "error": {
- "code": -32000,
- "message": error.to_string(),
- },
- })
- }
- };
- Ok(Some(vec![RendererRuntimeInspectorMessage::protocol(
- response,
- )]))
- }
-
fn prepare_runtime_protocol_message_with_context_resolution(
&mut self,
action: &str,
diff --git a/moli-renderer-v8/src/runtime/tests/extracted/runtime_scripts.rs b/moli-renderer-v8/src/runtime/tests/extracted/runtime_scripts.rs
index 8473489be..00da3d838 100644
--- a/moli-renderer-v8/src/runtime/tests/extracted/runtime_scripts.rs
+++ b/moli-renderer-v8/src/runtime/tests/extracted/runtime_scripts.rs
@@ -721,38 +721,87 @@ async fn child_default_runtime_evaluate_pending_await_promise_does_not_leak_inte
);
let child_context_id = child_context_ids[0];
- let evaluate = dispatch_runtime_protocol_with_context_resolution_for_test(
+ let (response_tx, mut response_rx) = oneshot::channel();
+ let (evaluate, _) = page
+ .run_async_command(
+ RendererPageCommand::dispatch_runtime_protocol_message_with_context_resolution_and_deferred_response(
+ None,
+ "evaluate".to_owned(),
+ serde_json::json!({
+ "id": 67,
+ "method": "Runtime.evaluate",
+ "params": {
+ "contextId": child_context_id,
+ "expression": "new Promise(resolve => { globalThis.resolveChildAwait = resolve; })",
+ "awaitPromise": true,
+ "returnByValue": true
+ }
+ }).to_string(),
+ RendererRuntimeInspectorResponseSender::new(67, response_tx),
+ ),
+ )
+ .await
+ .expect("child Runtime.evaluate awaitPromise should dispatch");
+ assert!(matches!(
+ evaluate,
+ RendererPageReply::RuntimeInspectorProtocolMessages(ref messages) if messages.is_empty()
+ ));
+ assert!(matches!(
+ response_rx.try_recv(),
+ Err(tokio::sync::oneshot::error::TryRecvError::Empty)
+ ));
+
+ let resolved = dispatch_runtime_protocol_with_context_resolution_for_test(
&page,
"evaluate",
serde_json::json!({
- "id": 67,
+ "id": 68,
"method": "Runtime.evaluate",
"params": {
"contextId": child_context_id,
- "expression": "new Promise(() => {})",
- "awaitPromise": true,
+ "expression": "resolveChildAwait('child-result'); 'resolved'",
"returnByValue": true
}
}),
)
.await
- .expect("child Runtime.evaluate awaitPromise should dispatch");
- let response =
- runtime_protocol_response_by_id(&evaluate, 67).expect("child awaitPromise response");
+ .expect("the pending child evaluation must release Page dispatch");
+ assert_eq!(
+ runtime_protocol_response_by_id(&resolved, 68).expect("resolver response")["result"]["result"]
+ ["value"],
+ serde_json::json!("resolved")
+ );
+ let completion = tokio::time::timeout(Duration::from_secs(2), &mut response_rx)
+ .await
+ .expect("the child Promise response must settle on its Page owner")
+ .expect("the child response must retain its callback owner");
+ assert_eq!(completion.call_id, 67);
+ let response = completion
+ .output
+ .protocol_response(67)
+ .expect("child awaitPromise response");
+ let messages: Vec<_> = completion
+ .output
+ .messages()
+ .iter()
+ .cloned()
+ .map(RendererRuntimeInspectorMessage::into_v8_inspector_message)
+ .collect();
let messages_json =
- serde_json::to_string(&evaluate).expect("Runtime.evaluate messages should serialize");
+ serde_json::to_string(&messages).expect("Runtime.evaluate messages should serialize");
assert!(
!messages_json.contains("__moliAwaitPromiseToken"),
- "child Runtime.evaluate awaitPromise leaked internal polling token: {evaluate:?}"
+ "child Runtime.evaluate awaitPromise leaked internal polling token: {messages_json}"
);
assert!(
!messages_json.contains("__moliPendingPromise"),
- "child Runtime.evaluate awaitPromise leaked internal pending marker: {evaluate:?}"
+ "child Runtime.evaluate awaitPromise leaked internal pending marker: {messages_json}"
);
assert!(
- response.get("error").is_some() || response["result"]["exceptionDetails"].is_object(),
- "pending child Runtime.evaluate awaitPromise must fail closed instead of returning an internal success payload: {response:?}"
+ response.get("error").is_none() && response["result"].get("exceptionDetails").is_none(),
+ "a resolved child Promise must return its native result: {response:?}"
);
+ assert_eq!(response["result"]["result"]["value"], "child-result");
page.close_async()
.await
diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs
index 0ef7a5b5a..c35e0ee90 100644
--- a/moli-renderer-v8/src/script_vm.rs
+++ b/moli-renderer-v8/src/script_vm.rs
@@ -1436,15 +1436,6 @@ impl ScriptVm {
)
}
- pub(super) fn route_frontend_runtime_inspector_response(
- &self,
- inspector_session_id: Option<&str>,
- response: RendererRuntimeInspectorResponseSender,
- ) -> Result<RendererRuntimeInspectorResponseSender> {
- self.page_inspector
- .route_frontend_response(inspector_session_id, response)
- }
-
fn dispatch_internal_runtime_evaluate_protocol_message(
&mut self,
raw_json: &str,
diff --git a/moli-renderer-v8/src/script_vm/inspector/agent.rs b/moli-renderer-v8/src/script_vm/inspector/agent.rs
index 8a4297211..12ee5c903 100644
--- a/moli-renderer-v8/src/script_vm/inspector/agent.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/agent.rs
@@ -351,17 +351,6 @@ impl RendererDevToolsAgent {
self.state.borrow().sessions.frontend_routes()
}
- pub(super) fn frontend_outbound(
- &self,
- session_key: &DevToolsSessionKey,
- ) -> Option<InspectorOutbound> {
- self.state
- .borrow()
- .sessions
- .frontend_session_and_outbound(session_key)
- .map(|(_, outbound)| outbound)
- }
-
pub(super) fn deactivate_all_routes(&self) {
self.state.borrow().sessions.deactivate_all();
}
diff --git a/moli-renderer-v8/src/script_vm/inspector/mod.rs b/moli-renderer-v8/src/script_vm/inspector/mod.rs
index 6ab308cb9..cc9ae1828 100644
--- a/moli-renderer-v8/src/script_vm/inspector/mod.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/mod.rs
@@ -36,7 +36,6 @@ pub(crate) use self::v8_backend::{
use crate::devtools::target::RendererDevToolsTargetHandle;
#[cfg(test)]
use crate::runtime::RendererRuntimeCommandOutputRecorder;
-use crate::runtime::RendererRuntimeInspectorResponseSender;
use crate::{
frame_owner_model::FrameRealmId,
protocol_types::RuntimeBindingRegistration,
@@ -45,8 +44,8 @@ use crate::{
};
use anyhow::Result;
use moli_page_types::{
- DevToolsSessionKey, RendererDevToolsAgentToken, RendererInspectorResponseDelivery,
- RendererInspectorSessionRestoreSnapshot, V8InspectorSessionState,
+ DevToolsSessionKey, RendererDevToolsAgentToken, RendererInspectorSessionRestoreSnapshot,
+ V8InspectorSessionState,
};
use serde_json::{Value, json};
use std::{cell::RefCell, collections::HashMap};
@@ -155,22 +154,6 @@ impl DocumentInspectorBinding {
}
}
- pub(super) fn route_frontend_response(
- &self,
- inspector_session_id: Option<&str>,
- response: RendererRuntimeInspectorResponseSender,
- ) -> Result<RendererRuntimeInspectorResponseSender> {
- if response.response_delivery() == RendererInspectorResponseDelivery::AdapterReply {
- return Ok(response);
- }
- let session_key = inspector_session_key(inspector_session_id);
- let outbound = self
- .agent
- .frontend_outbound(&session_key)
- .ok_or_else(|| anyhow::anyhow!("Inspector frontend session is not available"))?;
- Ok(outbound.route_frontend_response(response))
- }
-
pub(super) fn v8_session_state(
&self,
inspector_session_id: Option<&str>,
diff --git a/moli-renderer-v8/src/script_vm/inspector/tests.rs b/moli-renderer-v8/src/script_vm/inspector/tests.rs
index aff847ffd..7ba494c71 100644
--- a/moli-renderer-v8/src/script_vm/inspector/tests.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/tests.rs
@@ -1,5 +1,6 @@
use super::*;
use crate::inspector_session::InspectorSessionOutput;
+use crate::runtime::RendererRuntimeInspectorResponseSender;
#[test]
fn inspector_outbound_queue_reports_its_exact_length_until_flushed() {
diff --git a/moli-renderer-v8/src/script_vm/runtime_evaluation.rs b/moli-renderer-v8/src/script_vm/runtime_evaluation.rs
index 26506c59b..d6954925b 100644
--- a/moli-renderer-v8/src/script_vm/runtime_evaluation.rs
+++ b/moli-renderer-v8/src/script_vm/runtime_evaluation.rs
@@ -39,26 +39,6 @@ impl ScriptVm {
self.require_completed_runtime_evaluate(outcome)
}
- pub(crate) fn evaluate_expression_by_value_payload_in_context_with_await(
- &mut self,
- execution_context_id: Option<i64>,
- expression: &str,
- await_promise: bool,
- user_gesture: bool,
- file_prompt_handler: Option<&str>,
- ) -> Result<Value> {
- let outcome = self.begin_runtime_evaluate(
- execution_context_id,
- expression,
- await_promise,
- user_gesture,
- file_prompt_handler,
- RuntimeEvaluateCodeGenerationPolicy::from_cdp(None),
- RuntimeEvaluateResultMode::ByValue,
- )?;
- self.require_completed_runtime_evaluate(outcome)
- }
-
pub(crate) fn performance_metric_snapshot(
&mut self,
) -> Result<RendererPerformanceMetricSnapshot> {