Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(fetch): strip response URL fragments and retain clone URLs

ldm02ec1024152c2
diff --git a/moli-renderer-v8/src/network_host/fetch_surface.rs b/moli-renderer-v8/src/network_host/fetch_surface.rs
index f85413d75..56bf4b8d1 100644
--- a/moli-renderer-v8/src/network_host/fetch_surface.rs
+++ b/moli-renderer-v8/src/network_host/fetch_surface.rs
@@ -7,7 +7,7 @@ use crate::context_bootstrap::readable_stream_disturbed;
pub(in crate::network_host) use crate::util::constructor_prototype;
use crate::util::{
callback_data_index_value, callback_data_item, get_private_value, set_private_value,
- throw_range_error,
+ throw_range_error, v8_string,
};
use crate::web_api_interfaces;
use crate::webidl;
@@ -510,6 +510,16 @@ fn response_slot_attribute_getter_callback<'s>(
rv.set(v8::Boolean::new(scope, body_used).into());
return;
}
+ if slot == RESPONSE_URL_SLOT {
+ let url = response_slot_string(scope, this, slot).unwrap_or_default();
+ let url = url.split_once('#').map_or(url.as_str(), |(url, _)| url);
+ rv.set(
+ v8_string(scope, url)
+ .map(|value| value.into())
+ .unwrap_or_else(|| v8::undefined(scope).into()),
+ );
+ return;
+ }
let value =
response_slot_value(scope, this, slot).unwrap_or_else(|| v8::undefined(scope).into());
rv.set(value);
@@ -890,6 +900,9 @@ fn response_clone_callback<'s>(
}
};
if let Some(clone) = ctor.new_instance(scope, &[body, init.into()]) {
+ if let Some(url) = response_slot_value(scope, this, RESPONSE_URL_SLOT) {
+ set_response_slot_value(scope, clone, RESPONSE_URL_SLOT, url);
+ }
rv.set(clone.into());
} else {
rv.set_undefined();
diff --git a/moli-renderer-v8/src/network_host/xhr/bindings/constants.rs b/moli-renderer-v8/src/network_host/xhr/bindings/constants.rs
index a951cf578..8a22b234e 100644
--- a/moli-renderer-v8/src/network_host/xhr/bindings/constants.rs
+++ b/moli-renderer-v8/src/network_host/xhr/bindings/constants.rs
@@ -199,8 +199,13 @@ fn xhr_string_getter(
return;
};
let value = xhr_state_string_property(scope, xhr, key).unwrap_or_default();
+ let value = if key == XHR_RESPONSE_URL_SLOT {
+ value.split_once('#').map_or(value.as_str(), |(url, _)| url)
+ } else {
+ value.as_str()
+ };
rv.set(
- v8_string(scope, &value)
+ v8_string(scope, value)
.map(|string| string.into())
.unwrap_or_else(|| v8::undefined(scope).into()),
);
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.rs
index 5e9c3fd33..96ba21955 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
@@ -276,6 +276,104 @@ fn spawn_blocking_xhr_response_server(
(format!("http://{addr}"), server)
}
+#[tokio::test]
+async fn response_url_getters_exclude_fragments_without_changing_request_urls() {
+ run_page_vm_async_test(async move {
+ let mut page_vm = test_page_vm_with_document_url(
+ Url::parse("https://response-url-fragment.test/").unwrap(),
+ );
+ let local_executor = page_vm.local_executor.clone();
+ let observed = local_executor
+ .run(async move {
+ page_vm.vm_mut().eval(
+ r#"
+ (async () => {
+ const results = [];
+ for (const url of [
+ "data:text/plain,hello#fragment",
+ "data:text/plain,empty#",
+ "data:text/plain,encoded%23hash?query#fragment",
+ "data:text/plain,plain"
+ ]) {
+ const request = new Request(url);
+ const response = await fetch(request);
+ const clone = response.clone();
+ const asyncXhr = new XMLHttpRequest();
+ asyncXhr.open("GET", url);
+ await new Promise((resolve, reject) => {
+ asyncXhr.onload = resolve;
+ asyncXhr.onerror = () => reject(new Error("XHR failed"));
+ asyncXhr.send();
+ });
+ const syncXhr = new XMLHttpRequest();
+ syncXhr.open("GET", url, false);
+ syncXhr.send();
+ results.push({
+ request: request.url,
+ response: response.url,
+ clone: clone.url,
+ asyncXhr: asyncXhr.responseURL,
+ syncXhr: syncXhr.responseURL,
+ body: await response.text(),
+ cloneBody: await clone.text(),
+ asyncBody: asyncXhr.responseText,
+ syncBody: syncXhr.responseText
+ });
+ }
+ return results;
+ })().then(
+ results => { globalThis.__responseUrls = results; },
+ error => { globalThis.__responseUrls = { error: String(error) }; }
+ ).finally(() => { globalThis.__responseUrlsDone = true; });
+ "#,
+ )?;
+ drive_websocket_until_done(
+ &mut page_vm,
+ "String(globalThis.__responseUrlsDone === true)",
+ "response URL fragment checks should finish",
+ )
+ .await?;
+ page_vm
+ .vm_mut()
+ .eval("JSON.stringify(globalThis.__responseUrls)")
+ })
+ .await
+ .expect("response URL test should run on owner lane");
+ let expected = [
+ (
+ "data:text/plain,hello#fragment",
+ "data:text/plain,hello",
+ "hello",
+ ),
+ ("data:text/plain,empty#", "data:text/plain,empty", "empty"),
+ (
+ "data:text/plain,encoded%23hash?query#fragment",
+ "data:text/plain,encoded%23hash?query",
+ "encoded#hash?query",
+ ),
+ ("data:text/plain,plain", "data:text/plain,plain", "plain"),
+ ]
+ .map(|(request, response, body)| {
+ serde_json::json!({
+ "request": request,
+ "response": response,
+ "clone": response,
+ "asyncXhr": response,
+ "syncXhr": response,
+ "body": body,
+ "cloneBody": body,
+ "asyncBody": body,
+ "syncBody": body,
+ })
+ });
+ assert_eq!(
+ serde_json::from_str::<serde_json::Value>(&observed).unwrap(),
+ serde_json::json!(expected)
+ );
+ })
+ .await;
+}
+
#[tokio::test]
async fn event_source_streams_sse_and_records_incremental_network_output() {
run_page_vm_async_test(async move {