Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(xhr): normalize script-visible response headers

ldm0c6418d05e2af
diff --git a/moli-renderer-v8/src/network_host/headers.rs b/moli-renderer-v8/src/network_host/headers.rs
index 33273f271..8b789082b 100644
--- a/moli-renderer-v8/src/network_host/headers.rs
+++ b/moli-renderer-v8/src/network_host/headers.rs
@@ -10,5 +10,5 @@ pub(crate) use self::store::headers_entries;
pub(crate) use self::store::{HeadersGuard, filter_headers_for_guard};
pub(super) use self::store::{
build_headers_object, build_headers_object_with_state, headers_entries_from_init,
- mark_headers_immutable,
+ mark_headers_immutable, normalized_headers_entries,
};
diff --git a/moli-renderer-v8/src/network_host/headers/store.rs b/moli-renderer-v8/src/network_host/headers/store.rs
index ab08f172f..947c644d1 100644
--- a/moli-renderer-v8/src/network_host/headers/store.rs
+++ b/moli-renderer-v8/src/network_host/headers/store.rs
@@ -6,9 +6,11 @@ pub(crate) use self::entries::{HeadersGuard, filter_headers_for_guard, headers_e
pub(in crate::network_host::headers) use self::entries::{
header_allowed_by_guard, headers_are_immutable, headers_guard,
};
-pub(in crate::network_host) use self::entries::{mark_headers_immutable, set_headers_entries};
+pub(in crate::network_host) use self::entries::{
+ mark_headers_immutable, normalized_headers_entries, set_headers_entries,
+};
pub(in crate::network_host::headers) use self::entries::{
- normalized_header_name_or_throw, normalized_header_value_or_throw, normalized_headers_entries,
+ normalized_header_name_or_throw, normalized_header_value_or_throw,
};
pub(in crate::network_host) use self::init::headers_entries_from_init;
pub(in crate::network_host) use self::projection::{
diff --git a/moli-renderer-v8/src/network_host/headers/store/entries.rs b/moli-renderer-v8/src/network_host/headers/store/entries.rs
index 4118101ed..c6799ce49 100644
--- a/moli-renderer-v8/src/network_host/headers/store/entries.rs
+++ b/moli-renderer-v8/src/network_host/headers/store/entries.rs
@@ -112,7 +112,7 @@ pub(in crate::network_host) fn headers_entries_json(entries: &[(String, String)]
serde_json::to_string(&entries).unwrap_or_else(|_| "[]".to_owned())
}
-pub(in crate::network_host::headers) fn normalized_headers_entries(
+pub(in crate::network_host) fn normalized_headers_entries(
entries: &[(String, String)],
) -> Vec<(String, String)> {
let mut normalized = Vec::<(String, String)>::new();
diff --git a/moli-renderer-v8/src/network_host/xhr/delivery/response.rs b/moli-renderer-v8/src/network_host/xhr/delivery/response.rs
index 494913ef4..3a085bff3 100644
--- a/moli-renderer-v8/src/network_host/xhr/delivery/response.rs
+++ b/moli-renderer-v8/src/network_host/xhr/delivery/response.rs
@@ -423,7 +423,11 @@ fn set_xhr_response_head(
.unwrap_or(&head.final_url);
set_xhr_state_string(scope, xhr, XHR_RESPONSE_URL_SLOT, response_url.as_str());
- let headers_json = serde_json::to_string(&head.headers).unwrap_or_else(|_| "[]".to_owned());
+ // All delivery paths expose the same filtered header list, including
+ // synchronous workers and responses fulfilled without HTTP transport.
+ // Keep head.headers intact for MIME processing and network metadata.
+ let headers = super::super::header_surface::xhr_response_headers_for_script(&head.headers);
+ let headers_json = serde_json::to_string(&headers).unwrap_or_else(|_| "[]".to_owned());
set_xhr_state_string(scope, xhr, XHR_RESPONSE_HEADERS_SLOT, &headers_json);
}
diff --git a/moli-renderer-v8/src/network_host/xhr/header_surface.rs b/moli-renderer-v8/src/network_host/xhr/header_surface.rs
index 4aed82df5..13152a380 100644
--- a/moli-renderer-v8/src/network_host/xhr/header_surface.rs
+++ b/moli-renderer-v8/src/network_host/xhr/header_surface.rs
@@ -60,6 +60,25 @@ pub(super) fn xhr_set_request_header_callback<'s>(
set_xhr_state_string(scope, xhr, XHR_REQUEST_HEADERS_SLOT, &new_json);
}
+pub(super) fn xhr_response_headers_for_script(
+ headers: &[(String, String)],
+) -> Vec<(String, String)> {
+ use crate::network_host::headers::{
+ HeadersGuard, filter_headers_for_guard, normalized_headers_entries,
+ };
+
+ let mut headers =
+ normalized_headers_entries(&filter_headers_for_guard(headers, HeadersGuard::Response));
+ // XHR uses legacy uppercase-byte order, unlike Headers iteration. Keep
+ // the serialized names lowercase and preserve duplicate values in order.
+ headers.sort_by(|(left, _), (right, _)| {
+ left.bytes()
+ .map(|byte| byte.to_ascii_uppercase())
+ .cmp(right.bytes().map(|byte| byte.to_ascii_uppercase()))
+ });
+ headers
+}
+
pub(super) fn xhr_get_all_response_headers_callback(
scope: &mut v8::PinScope<'_, '_>,
args: v8::FunctionCallbackArguments<'_>,
@@ -73,9 +92,6 @@ pub(super) fn xhr_get_all_response_headers_callback(
if let Ok(headers) = serde_json::from_str::<Vec<(String, String)>>(&headers_json) {
headers
.iter()
- .filter(|(name, _)| {
- !response_header_name_is(name, &HeaderName::from_static("set-cookie"))
- })
.map(|(name, value)| format!("{name}: {value}\r\n"))
.collect::<String>()
} else {
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 74d7095c3..5e9c3fd33 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
@@ -2766,7 +2766,7 @@ async fn synchronous_xhr_blocks_send_and_returns_materialized_response() {
assert_eq!(
observed,
format!(
- r#"{{"events":["readystatechange:1","readystatechange:4","load:7:7:true","loadend:7:7:true"],"readyState":4,"status":200,"statusText":"OK","responseText":"sync-ok","responseURL":"{xhr_url}","contentType":"text/plain; charset=utf-8","allHeaders":"content-type: text/plain; charset=utf-8\r\ncontent-length: 7\r\nconnection: close\r\n"}}"#
+ r#"{{"events":["readystatechange:1","readystatechange:4","load:7:7:true","loadend:7:7:true"],"readyState":4,"status":200,"statusText":"OK","responseText":"sync-ok","responseURL":"{xhr_url}","contentType":"text/plain; charset=utf-8","allHeaders":"connection: close\r\ncontent-length: 7\r\ncontent-type: text/plain; charset=utf-8\r\n"}}"#
)
);
let (records, _, _) = split_network_output_items(network_output);
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/mod.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/mod.rs
index 0ed207cd9..888a5b0f6 100644
--- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/mod.rs
+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/mod.rs
@@ -5,6 +5,7 @@ mod cssom;
mod dom;
mod forms;
mod misc;
+mod response_headers;
mod shadow_dom;
mod style_invalidation;
mod xhr;
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/response_headers.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/response_headers.rs
new file mode 100644
index 000000000..5418e7418
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/response_headers.rs
@@ -0,0 +1,92 @@
+use super::*;
+
+#[test]
+fn xhr_response_headers_are_filtered_combined_and_sorted_before_events() {
+ let fixture: serde_json::Value = serde_json::from_str(include_str!(
+ "../../../../tests/fixtures/xhr-response-headers.json"
+ ))
+ .unwrap();
+ let headers: Vec<(String, String)> =
+ serde_json::from_value(fixture["headers"].clone()).unwrap();
+ for streaming in [false, true] {
+ let mut vm = new_storage_test_vm("https://xhr-response-headers.test/");
+ vm.set_fetch_subresource_interception(
+ true,
+ Some(crate::types::SubresourceResourceType::Xhr),
+ );
+ vm.eval(&format!(
+ "{}\nglobalThis.headerResult = null; xhrResponseHeadersProbe('/response', {}).then(result => {{ headerResult = result; }}, error => {{ headerResult = {{error:String(error.stack || error)}}; }});",
+ include_str!("../../../../tests/fixtures/xhr-response-headers.js"),
+ fixture["expected"],
+ )).unwrap();
+ // Both credential modes must expose the same filtered response.
+ for _ in 0..2 {
+ let pending = vm.take_pending_subresource_fetch_infos();
+ assert_eq!(pending.len(), 1);
+ let request = &pending[0];
+ let head = moli_fetch::ResponseHead {
+ final_url: request.url.clone(),
+ status: 200,
+ headers: headers.clone(),
+ request_cookie_report: None,
+ cookie_set_reports: Vec::new(),
+ redirected: false,
+ redirect_chain: Vec::new(),
+ from_cache: false,
+ negotiated_http_version: None,
+ };
+ if streaming {
+ let body_source_id = crate::network_host::new_network_body_source_id();
+ vm.start_streaming_async_subresource_fetch(
+ crate::types::AsyncSubresourceStreamingStarted {
+ internal_id: request.internal_id,
+ request_url: request.url.clone(),
+ request_method: "GET".to_owned(),
+ request_headers: Vec::new(),
+ request_body: None,
+ skip_fetch_security_validation: false,
+ response_filter: None,
+ body_source_id,
+ head,
+ network_request_headers: None,
+ },
+ )
+ .unwrap();
+ vm.append_streaming_async_subresource_fetch_chunk(body_source_id, b"body".to_vec());
+ vm.finish_streaming_async_subresource_fetch(
+ request.internal_id,
+ body_source_id,
+ Ok(()),
+ )
+ .unwrap();
+ } else {
+ vm.complete_async_subresource_fetch(
+ crate::types::AsyncSubresourceFetchCompletion {
+ response_filter: None,
+ skip_fetch_security_validation: false,
+ internal_id: request.internal_id,
+ request_url: request.url.clone(),
+ request_method: "GET".to_owned(),
+ request_headers: Vec::new(),
+ request_body: None,
+ response_status_text: None,
+ network_error_text: None,
+ result: Ok(
+ crate::protocol_types::NavigationResponse::from_head_and_body(
+ head,
+ "body".to_owned(),
+ b"body".to_vec(),
+ ),
+ ),
+ },
+ )
+ .unwrap();
+ }
+ vm.exec("0", None).unwrap();
+ }
+ let result: serde_json::Value =
+ serde_json::from_str(&vm.eval("JSON.stringify(headerResult)").unwrap()).unwrap();
+ assert_eq!(result["state"], "pass", "streaming={streaming}: {result}");
+ assert_eq!(result["checks"].as_array().unwrap().len(), 270);
+ }
+}
diff --git a/moli-renderer-v8/tests/fixtures/xhr-response-headers.js b/moli-renderer-v8/tests/fixtures/xhr-response-headers.js
new file mode 100644
index 000000000..f473abd1c
--- /dev/null
+++ b/moli-renderer-v8/tests/fixtures/xhr-response-headers.js
@@ -0,0 +1,56 @@
+async function xhrResponseHeadersProbe(url, expected) {
+ const checks = [];
+ const check = (label, actual, wanted) => checks.push({
+ label, actual, wanted, pass: actual === wanted
+ });
+ const block = expected.map(([name, value]) => `${name}: ${value}\r\n`).join('');
+ const forbidden = ['set-cookie', 'SET-COOKIE', 'SeT-CoOkIe', 'set-cookie2', 'SET-COOKIE2'];
+ function empty(xhr, phase) {
+ check(`${phase}/all`, xhr.getAllResponseHeaders(), '');
+ check(`${phase}/ordinary`, xhr.getResponseHeader('foo-test'), null);
+ for (const name of forbidden) check(`${phase}/${name}`, xhr.getResponseHeader(name), null);
+ }
+ function visible(xhr, phase) {
+ check(`${phase}/all`, xhr.getAllResponseHeaders(), block);
+ for (const [name, value] of expected) {
+ check(`${phase}/${name}`, xhr.getResponseHeader(name), value);
+ check(`${phase}/${name}/uppercase`, xhr.getResponseHeader(name.toUpperCase()), value);
+ }
+ for (const name of [...forbidden, 'missing', ' foo-test', 'foo-test ', 'foo:test', 'foo-test\n']) {
+ check(`${phase}/${name}/absent`, xhr.getResponseHeader(name), null);
+ }
+ }
+ for (const async of typeof document === 'undefined' ? [true, false] : [true]) {
+ for (const credentials of [false, true]) {
+ const xhr = new XMLHttpRequest();
+ const label = `${async}/${credentials}`;
+ empty(xhr, `${label}/unsent`);
+ xhr.open('GET', url, async);
+ xhr.withCredentials = credentials;
+ empty(xhr, `${label}/opened`);
+ const seen = new Set();
+ xhr.onreadystatechange = () => {
+ if (xhr.readyState >= 2 && !seen.has(xhr.readyState)) {
+ seen.add(xhr.readyState);
+ visible(xhr, `${label}/state${xhr.readyState}`);
+ }
+ };
+ if (async) {
+ await new Promise((resolve, reject) => {
+ xhr.onload = resolve;
+ xhr.onerror = () => reject(new Error(`${label}: network error`));
+ xhr.send();
+ });
+ check(`${label}/states`, Array.from(seen).join(','), '2,3,4');
+ } else {
+ xhr.send();
+ visible(xhr, `${label}/sync-done`);
+ }
+ check(`${label}/done`, xhr.readyState, 4);
+ check(`${label}/body`, xhr.responseText, 'body');
+ xhr.open('GET', url, async);
+ empty(xhr, `${label}/reopened`);
+ }
+ }
+ return {state: checks.every(entry => entry.pass) ? 'pass' : 'fail', checks};
+}
diff --git a/moli-renderer-v8/tests/fixtures/xhr-response-headers.json b/moli-renderer-v8/tests/fixtures/xhr-response-headers.json
new file mode 100644
index 000000000..9622e082e
--- /dev/null
+++ b/moli-renderer-v8/tests/fixtures/xhr-response-headers.json
@@ -0,0 +1,142 @@
+{
+ "headers": [
+ [
+ "z-LAST",
+ "end"
+ ],
+ [
+ "foo-TEST",
+ "1"
+ ],
+ [
+ "SeT-Cookie",
+ "hidden=secret; HttpOnly; Path=/"
+ ],
+ [
+ "__Custom",
+ "token"
+ ],
+ [
+ "Foo-test",
+ ""
+ ],
+ [
+ "FOO-TEST",
+ "3"
+ ],
+ [
+ "Set-Cookie2",
+ "legacy=secret"
+ ],
+ [
+ "X-Empty",
+ ""
+ ],
+ [
+ "X-Bytes",
+ "\u00ff\u00c3\u00bf"
+ ],
+ [
+ "Content-Type",
+ "TEXT/PLAIN; charset=GBK; title=MiXeD"
+ ],
+ [
+ "X-Set-Cookie",
+ "public"
+ ],
+ [
+ "Set-Cookie20",
+ "public2"
+ ],
+ [
+ "~Late",
+ "tilde"
+ ],
+ [
+ "!Early",
+ "bang"
+ ],
+ [
+ "HEYA",
+ "\t "
+ ],
+ [
+ "heya",
+ "\u000b\f"
+ ],
+ [
+ "heya",
+ "x"
+ ],
+ [
+ "heya",
+ ""
+ ],
+ [
+ "HeYa",
+ ""
+ ],
+ [
+ "Content-Length",
+ "4"
+ ],
+ [
+ "Connection",
+ "close"
+ ]
+ ],
+ "expected": [
+ [
+ "!early",
+ "bang"
+ ],
+ [
+ "connection",
+ "close"
+ ],
+ [
+ "content-length",
+ "4"
+ ],
+ [
+ "content-type",
+ "TEXT/PLAIN; charset=GBK; title=MiXeD"
+ ],
+ [
+ "foo-test",
+ "1, , 3"
+ ],
+ [
+ "heya",
+ ", \u000b\f, x, , "
+ ],
+ [
+ "set-cookie20",
+ "public2"
+ ],
+ [
+ "x-bytes",
+ "\u00ff\u00c3\u00bf"
+ ],
+ [
+ "x-empty",
+ ""
+ ],
+ [
+ "x-set-cookie",
+ "public"
+ ],
+ [
+ "z-last",
+ "end"
+ ],
+ [
+ "__custom",
+ "token"
+ ],
+ [
+ "~late",
+ "tilde"
+ ]
+ ]
+}