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(fetch): bypass interception for local blob and data URLs
ldm0f3c87f394d54
diff --git a/moli-protocol/src/domains/fetch/tests/runtime_fetch.rs b/moli-protocol/src/domains/fetch/tests/runtime_fetch.rsindex d2627f579..1d0bceb7f 100644--- a/moli-protocol/src/domains/fetch/tests/runtime_fetch.rs+++ b/moli-protocol/src/domains/fetch/tests/runtime_fetch.rs@@ -13,6 +13,124 @@ use crate::testing::{protocol_events_into_internal_messages, wait_until_scheduler_message,};+#[tokio::test(flavor = "multi_thread")]+async fn runtime_local_fetch_and_xhr_bypass_request_and_response_interception() {+ for request_stage in ["Request", "Response"] {+ let mut ctx = TestContext::new();+ with_loaded_http_document(+ &mut ctx,+ "data:text/html,<html><body>ready</body></html>",+ "SID-1",+ "TID-1",+ )+ .await;+ enable_runtime_async(&mut ctx, "SID-1", 1).await;+ ctx.process_async(json!({+ "id": 2,+ "method": "Fetch.enable",+ "sessionId": "SID-1",+ "params": { "patterns": [{ "urlPattern": "*", "requestStage": request_stage }] }+ }))+ .await;+ ctx.expect_result(2, json!({}), Some("SID-1"));++ ctx.process_async(json!({+ "id": 3,+ "method": "Runtime.evaluate",+ "sessionId": "SID-1",+ "params": {+ "expression": r#"+globalThis.__localInterceptionResult = 'pending';+(async () => {+ const check = (value, message) => { if (!value) throw new Error(message); };+ const blob = URL.createObjectURL(new Blob(['payload'], {type: 'text/plain'}));+ const revoked = URL.createObjectURL(new Blob(['revoked']));+ URL.revokeObjectURL(revoked);+ try {+ for (const [url, method, success] of [+ [blob + '#fragment', 'GET', true],+ [blob, 'POST', false],+ ['data:text/plain,payload', 'POST', true],+ [revoked, 'GET', false],+ ['data:invalid', 'GET', false],+ ]) {+ let response;+ try { response = await fetch(url, {method}); }+ catch (error) {+ check(!success && error instanceof TypeError, 'fetch rejection: ' + error);+ }+ check(Boolean(response) === success, 'fetch outcome: ' + url);+ if (response) {+ check(response.status === 200 && await response.text() === 'payload', 'fetch response');+ }+ for (const async of [true, false]) {+ const xhr = new XMLHttpRequest();+ xhr.open(method, url, async);+ const label = [url, method, async].join(':');+ if (async) {+ await new Promise((resolve, reject) => {+ let returned = false;+ const events = [];+ xhr.onload = () => events.push('load');+ xhr.onerror = () => events.push('error');+ xhr.onloadend = () => {+ try {+ check(returned, label + ': completion during send');+ check(events.join(',') === (success ? 'load' : 'error'), label + ': events');+ resolve();+ } catch (error) { reject(error); }+ };+ xhr.send();+ returned = true;+ });+ } else {+ let failure;+ try { xhr.send(); } catch (error) { failure = error; }+ check(success ? failure === undefined : failure instanceof DOMException && failure.name === 'NetworkError', label + ': exception');+ }+ check(xhr.readyState === 4 && xhr.status === (success ? 200 : 0), label + ': state/status');+ check(xhr.responseText === (success ? 'payload' : ''), label + ': body');+ }+ }+ } finally { URL.revokeObjectURL(blob); }+})().then(+ () => { globalThis.__localInterceptionResult = 'ok'; },+ error => { globalThis.__localInterceptionResult = String(error); },+);+'scheduled'+"#+ }+ }))+ .await;+ let scheduled = take_response_by_id(&mut ctx, 3);+ assert_eq!(scheduled["result"]["result"]["value"], "scheduled");+ assert!(+ ctx.sent+ .iter()+ .all(|message| message["method"] != "Fetch.requestPaused"),+ "local requests must bypass {request_stage} interception: {:?}",+ ctx.sent+ );++ evaluate_until_value_async(+ &mut ctx,+ "SID-1",+ 4,+ "globalThis.__localInterceptionResult",+ &json!("ok"),+ "local fetch and XHR completion with Fetch enabled",+ )+ .await;+ assert!(+ ctx.sent+ .iter()+ .all(|message| message["method"] != "Fetch.requestPaused"),+ "local responses and errors must bypass {request_stage} interception: {:?}",+ ctx.sent+ );+ }+}+async fn wait_for_request_paused(ctx: &mut TestContext, url: &str, description: &str) -> Value {wait_for_request_paused_on_session(ctx, "SID-1", url, None, description).await}diff --git a/moli-renderer-v8/src/network_host/fetch/bindings.rs b/moli-renderer-v8/src/network_host/fetch/bindings.rsindex c46e9ae9f..b3511bb2e 100644--- a/moli-renderer-v8/src/network_host/fetch/bindings.rs+++ b/moli-renderer-v8/src/network_host/fetch/bindings.rs@@ -281,6 +281,30 @@ fn window_fetch_callback_in_relevant_realm<'s>(return;}+ // Renderer-owned URLs, including local errors, bypass network interception.+ match resolve_local_fetch(host, &prepared) {+ Ok(Some(response)) => {+ let response_obj = build_fetch_response_object_for_request_mode(+ scope,+ &prepared.request_origin,+ prepared.request_mode,+ response,+ );+ resolver.resolve(scope, response_obj.into());+ rv.set(promise.into());+ return;+ }+ Ok(None) => {}+ Err(message) => {+ let exception = v8_string(scope, &message)+ .map(|message| v8::Exception::type_error(scope, message))+ .unwrap_or_else(|| v8::undefined(scope).into());+ resolver.reject(scope, exception);+ rv.set(promise.into());+ return;+ }+ }+if host.should_intercept_subresource(SubresourceResourceType::Fetch) {record_intercepted_fetch(scope, host, resolver, prepared);rv.set(promise.into());@@ -308,29 +332,6 @@ fn window_fetch_callback_in_relevant_realm<'s>(}}- match resolve_local_fetch(host, &prepared) {- Ok(Some(response)) => {- let response_obj = build_fetch_response_object_for_request_mode(- scope,- &prepared.request_origin,- prepared.request_mode,- response,- );- resolver.resolve(scope, response_obj.into());- rv.set(promise.into());- return;- }- Ok(None) => {}- Err(message) => {- let exception = v8_string(scope, &message)- .map(|message| v8::Exception::type_error(scope, message))- .unwrap_or_else(|| v8::undefined(scope).into());- resolver.reject(scope, exception);- rv.set(promise.into());- return;- }- }-let internal_id = match spawn_network_fetch(scope, host, resolver, prepared) {Ok(internal_id) => internal_id,Err(message) => {diff --git a/moli-renderer-v8/src/network_host/xhr/send.rs b/moli-renderer-v8/src/network_host/xhr/send.rsindex 02e0dfb46..1166fd6bc 100644--- a/moli-renderer-v8/src/network_host/xhr/send.rs+++ b/moli-renderer-v8/src/network_host/xhr/send.rs@@ -164,23 +164,7 @@ pub(super) fn xhr_send_callback<'s>(return;}- if host.should_intercept_subresource(SubresourceResourceType::Xhr) {- if !async_request {- record_synchronous_xhr_failure(- scope,- host,- xhr,- prepared,- "Synchronous XMLHttpRequest interception is not supported".to_owned(),- );- return;- }- let internal_id = record_intercepted_xhr(scope, host, xhr, prepared);- set_xhr_state_number(scope, xhr, XHR_ACTIVE_INTERNAL_ID_SLOT, internal_id as f64);- schedule_xhr_timeout(scope, host, xhr, internal_id);- return;- }-+ // Renderer-owned URLs, including local errors, bypass network interception.if let Some(result) = local_url_response_result(&prepared.resolved_url, &prepared.method) {match result {Ok(response) if async_request => {@@ -200,6 +184,23 @@ pub(super) fn xhr_send_callback<'s>(return;}+ if host.should_intercept_subresource(SubresourceResourceType::Xhr) {+ if !async_request {+ record_synchronous_xhr_failure(+ scope,+ host,+ xhr,+ prepared,+ "Synchronous XMLHttpRequest interception is not supported".to_owned(),+ );+ return;+ }+ let internal_id = record_intercepted_xhr(scope, host, xhr, prepared);+ set_xhr_state_number(scope, xhr, XHR_ACTIVE_INTERNAL_ID_SLOT, internal_id as f64);+ schedule_xhr_timeout(scope, host, xhr, internal_id);+ return;+ }+if host.network_offline() {if async_request {record_offline_xhr_failure(scope, host, xhr, prepared);diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr.rs b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr.rsindex 26be41f01..f1a57bc0c 100644--- a/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr.rs+++ b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr.rs@@ -4002,7 +4002,18 @@ async fn window_fetch_file_url_rejects_before_interception_or_transport() {#[tokio::test]async fn blob_fetch_and_xhr_reject_non_get_methods_in_window_and_worker() {- run_page_vm_async_test(async move {+ check_blob_fetch_and_xhr_methods_in_window_and_worker(false).await;+}++#[tokio::test]+async fn blob_fetch_and_xhr_bypass_interception_in_window_and_worker() {+ check_blob_fetch_and_xhr_methods_in_window_and_worker(true).await;+}++fn check_blob_fetch_and_xhr_methods_in_window_and_worker(+ interception: bool,+) -> impl std::future::Future<Output = ()> {+ Box::pin(run_page_vm_async_test(async move {for worker in [false, true] {let mut page_vm = test_page_vm();let local_executor = page_vm.local_executor.clone();@@ -4096,8 +4107,11 @@ async fn blob_fetch_and_xhr_reject_non_get_methods_in_window_and_worker() {"globalThis.__blobMethodResult = 'pending'; {probe}.then(() => {{ globalThis.__blobMethodResult = 'ok'; }}, error => {{ globalThis.__blobMethodResult = String(error); }})")};- let (result, network_output) = local_executor+ let (result, pending_count, network_output) = local_executor.run(async move {+ page_vm+ .vm_mut()+ .set_fetch_subresource_interception(interception, None);page_vm.vm_mut().eval(&script)?;drive_websocket_until_done(&mut page_vm,@@ -4106,21 +4120,37 @@ async fn blob_fetch_and_xhr_reject_non_get_methods_in_window_and_worker() {).await?;let result = page_vm.vm_mut().eval("globalThis.__blobMethodResult")?;- Ok::<_, anyhow::Error>((result, page_vm.vm_mut().take_network_output()))+ let pending_count = page_vm+ .vm_mut()+ .take_pending_subresource_fetch_infos()+ .len();+ Ok::<_, anyhow::Error>((+ result,+ pending_count,+ page_vm.vm_mut().take_network_output(),+ ))}).await.expect("blob method probe should run on owner lane");assert_eq!(result, "ok", "worker={worker}");+ assert_eq!(+ pending_count, 0,+ "local fetch and XHR must bypass interception; worker={worker}"+ );let (records, _, _) = split_network_output_items(network_output);let failures = records.iter()- .filter(|record| matches!(record.outcome(), SubresourceNetworkOutcome::Failure { error_text }- if error_text.contains("blob URL fetch requires GET")))+ .filter(|record| {+ matches!(record.outcome(), SubresourceNetworkOutcome::Failure { error_text }+ if error_text.contains("blob URL fetch requires GET"))+ }).count();- assert_eq!(failures, 56, "each rejected request must record a local network error; worker={worker}");+ assert_eq!(+ failures, 56,+ "each rejected request must record a local network error; worker={worker}"+ );}- })- .await;+ }))}#[tokio::test]diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rsindex 38d06b2d1..5fa97fa24 100644--- a/moli-renderer-v8/src/worker/global_scope/fetch.rs+++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs@@ -2083,7 +2083,9 @@ pub(in crate::worker) fn worker_fetch_callback<'s>(return;}- if fetch_subresource_interception_enabled+ // Local URLs are resolved by the worker fetch task without interception.+ if !matches!(resolved_url.scheme(), "blob" | "data")+ && fetch_subresource_interception_enabled&& fetch_subresource_interception_resource_type.is_none_or(|expected| {expected.has_same_cdp_fetch_interception_type(SubresourceResourceType::Fetch)})