Skip to content

armgit / moli

Public Imported from GitHub
0

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

feat(emulation): support worker user agent overrides

ldm0312b0ffc6b7d
diff --git a/README.md b/README.md
index cb832505f..74bebb3e4 100644
--- a/README.md
+++ b/README.md
@@ -356,20 +356,6 @@ Its current intentional boundaries include:
paint architecture.
- It does not pursue pixel-for-pixel parity with Chrome or provide
high-fidelity Canvas/WebGL/media playback.
-- Emulation supports offline mode, but CPU throttling, network latency/throughput,
- packet shaping, and connection type overrides return a protocol error. CPU rates
- at or below 1 disable throttling; non-positive latency and throughput values
- disable network throttling. Unsupported combinations are rejected before
- changing offline state.
-- Device metrics support desktop geometry and capture transforms. `mobile:true`
- returns an unsupported error; mobile viewport-meta processing, text autosizing
- and overlay scrollbars are not implemented. Display features, device posture,
- forced overlay scrollbars, orientation-lock emulation and explicit viewport-meta
- processing are also rejected before changing existing metrics. Default scrollbar
- and viewport-meta settings, and disabling orientation-lock emulation, are accepted.
-- `Emulation.setUserAgentOverride` and `Network.setUserAgentOverride` support Page
- targets. Worker targets return an unsupported error; these rejected commands do
- not activate a Worker Emulation agent or affect its override precedence.
- `--layout` supports software screenshots and raster-backed CDP PDF
generation, but not every Chrome screenshot or print mode is implemented.
diff --git a/moli-browser-profile/src/identity.rs b/moli-browser-profile/src/identity.rs
index 4bd242091..bf04b3130 100644
--- a/moli-browser-profile/src/identity.rs
+++ b/moli-browser-profile/src/identity.rs
@@ -13,6 +13,7 @@ pub struct BrowserBrandVersion {
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
pub struct BrowserUserAgentMetadataOverride {
pub brands: Option<Vec<BrowserBrandVersion>>,
pub full_version_list: Option<Vec<BrowserBrandVersion>>,
diff --git a/moli-browser-profile/src/lib.rs b/moli-browser-profile/src/lib.rs
index 58aeb7619..3bccc80e4 100644
--- a/moli-browser-profile/src/lib.rs
+++ b/moli-browser-profile/src/lib.rs
@@ -5,6 +5,7 @@ mod profile_lock;
mod profile_manifest;
mod profile_partition_id;
mod profile_paths;
+mod user_agent_override;
mod window_surface;
pub use atomic_write::write_file_atomically;
@@ -23,6 +24,7 @@ pub use profile_partition_id::{
DEFAULT_PROFILE_PARTITION_ID, ProfilePartitionId, ProfilePartitionIdError,
};
pub use profile_paths::{BrowserProfilePartitionPaths, BrowserProfilePaths};
+pub use user_agent_override::UserAgentOverride;
pub use window_surface::{
DEFAULT_ACCEPT_LANGUAGE, DEFAULT_CDP_PRODUCT, DEFAULT_CONNECTION_DOWNLINK,
DEFAULT_CONNECTION_DOWNLINK_MAX, DEFAULT_CONNECTION_EFFECTIVE_TYPE, DEFAULT_CONNECTION_RTT,
diff --git a/moli-browser-profile/src/user_agent_override.rs b/moli-browser-profile/src/user_agent_override.rs
new file mode 100644
index 000000000..4dd9aa60d
--- /dev/null
+++ b/moli-browser-profile/src/user_agent_override.rs
@@ -0,0 +1,82 @@
+use serde::Deserialize;
+
+use crate::{BrowserBrandVersion, BrowserUserAgentMetadataOverride};
+
+/// The independent identity inputs accepted by CDP on both Pages and Workers.
+/// Keep absent and empty values distinct: even an empty optional input can
+/// activate an Inspector Emulation agent without contributing an override.
+#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct UserAgentOverride {
+ pub user_agent: String,
+ pub accept_language: Option<String>,
+ pub platform: Option<String>,
+ pub user_agent_metadata: Option<BrowserUserAgentMetadataOverride>,
+}
+
+impl UserAgentOverride {
+ pub fn activates_agent(&self) -> bool {
+ !self.user_agent.is_empty() || self.accept_language.is_some() || self.platform.is_some()
+ }
+
+ pub fn validate(&self) -> Result<(), &'static str> {
+ let header_value =
+ |value: &str| !value.bytes().any(|byte| matches!(byte, 0 | b'\r' | b'\n'));
+ if !header_value(&self.user_agent) {
+ return Err("Invalid characters found in userAgent");
+ }
+ if self
+ .accept_language
+ .as_deref()
+ .is_some_and(|value| !header_value(value))
+ {
+ return Err("Invalid characters found in acceptLanguage");
+ }
+ if let Some(metadata) = &self.user_agent_metadata {
+ if self.user_agent.is_empty() {
+ return Err("Empty userAgent invalid with userAgentMetadata provided");
+ }
+ validate_brands(metadata.brands.as_deref())?;
+ validate_brands(metadata.full_version_list.as_deref())?;
+ for (value, error) in [
+ (
+ metadata.full_version.as_deref(),
+ "Invalid full version string",
+ ),
+ (Some(metadata.platform.as_str()), "Invalid platform string"),
+ (
+ Some(metadata.platform_version.as_str()),
+ "Invalid platform version string",
+ ),
+ (
+ Some(metadata.architecture.as_str()),
+ "Invalid architecture string",
+ ),
+ (Some(metadata.model.as_str()), "Invalid model string"),
+ (metadata.bitness.as_deref(), "Invalid bitness string"),
+ ] {
+ validate_field(value, error)?;
+ }
+ for value in metadata.form_factors.iter().flatten() {
+ validate_field(Some(value), "Invalid form factor string")?;
+ }
+ }
+ Ok(())
+ }
+}
+
+fn validate_field(value: Option<&str>, error: &'static str) -> Result<(), &'static str> {
+ if value.is_some_and(|value| !value.bytes().all(|byte| (0x20..=0x7e).contains(&byte))) {
+ Err(error)
+ } else {
+ Ok(())
+ }
+}
+
+fn validate_brands(brands: Option<&[BrowserBrandVersion]>) -> Result<(), &'static str> {
+ for brand in brands.into_iter().flatten() {
+ validate_field(Some(&brand.brand), "Invalid brand string")?;
+ validate_field(Some(&brand.version), "Invalid brand version string")?;
+ }
+ Ok(())
+}
diff --git a/moli-fetch/src/blocking/cache/vary.rs b/moli-fetch/src/blocking/cache/vary.rs
index a3e261c51..5682ac21b 100644
--- a/moli-fetch/src/blocking/cache/vary.rs
+++ b/moli-fetch/src/blocking/cache/vary.rs
@@ -84,7 +84,8 @@ fn vary_request_header_value(
.map(|(_, value)| value)
};
if normalized_name == "user-agent" {
- return explicit_value().or_else(|| Some(config.user_agent().to_owned()));
+ return explicit_value()
+ .or_else(|| Some(request.browser_identity(config).user_agent().to_owned()));
}
if normalized_name == "accept-encoding" {
// libcurl synthesizes this header from `easy.accept_encoding("")`.
diff --git a/moli-fetch/src/blocking/mod.rs b/moli-fetch/src/blocking/mod.rs
index e695e6cbd..206d58b87 100644
--- a/moli-fetch/src/blocking/mod.rs
+++ b/moli-fetch/src/blocking/mod.rs
@@ -188,6 +188,14 @@ pub(crate) fn outgoing_request_headers_for_url(
outgoing.push((name.clone(), value.clone()));
}
+ if request.has_browser_identity_override() {
+ append_header_if_missing(
+ &mut outgoing,
+ "User-Agent",
+ request.browser_identity(config).user_agent().to_owned(),
+ );
+ }
+
append_browser_navigation_headers(&mut outgoing, config, request, request_url);
append_browser_subresource_headers(&mut outgoing, config, request, request_url);
append_browser_storage_access_header(&mut outgoing, request, request_url);
@@ -288,7 +296,10 @@ fn append_browser_navigation_headers(
append_header_if_missing(
outgoing,
"Accept-Language",
- config.browser_identity().accept_language().to_owned(),
+ request
+ .browser_identity(config)
+ .accept_language()
+ .to_owned(),
);
append_header_if_missing(outgoing, "Upgrade-Insecure-Requests", "1".to_owned());
append_header_if_missing(outgoing, "Sec-Fetch-Mode", "navigate".to_owned());
@@ -316,7 +327,7 @@ fn append_browser_navigation_headers(
append_header_if_missing(outgoing, "Cache-Control", "max-age=0".to_owned());
}
- append_browser_client_hints(outgoing, config);
+ append_browser_client_hints(outgoing, request.browser_identity(config));
}
fn append_browser_subresource_headers(
@@ -362,7 +373,10 @@ fn append_browser_subresource_headers(
append_header_if_missing(
outgoing,
"Accept-Language",
- config.browser_identity().accept_language().to_owned(),
+ request
+ .browser_identity(config)
+ .accept_language()
+ .to_owned(),
);
append_header_if_missing(
outgoing,
@@ -392,7 +406,7 @@ fn append_browser_subresource_headers(
| BrowserRequestMetadata::Xhr => "empty",
};
append_header_if_missing(outgoing, "Sec-Fetch-Dest", destination.to_owned());
- append_browser_client_hints(outgoing, config);
+ append_browser_client_hints(outgoing, request.browser_identity(config));
}
}
}
@@ -413,8 +427,10 @@ fn request_origin_header_value(request: &Request, request_url: &Url) -> Option<S
Some(request.serialized_origin())
}
-fn append_browser_client_hints(outgoing: &mut Vec<(String, String)>, config: &FetchConfig) {
- let identity = config.browser_identity();
+fn append_browser_client_hints(
+ outgoing: &mut Vec<(String, String)>,
+ identity: &moli_browser_profile::BrowserIdentityProfile,
+) {
let Some(sec_ch_ua) = identity.sec_ch_ua_value() else {
return;
};
@@ -591,7 +607,7 @@ pub(crate) fn configure_easy<H: Handler>(
config
.tls_config()
.configure(easy, request.allows_credentials_for_url(request_url))?;
- easy.useragent(config.user_agent())
+ easy.useragent(request.browser_identity(config).user_agent())
.context("failed to set curl user-agent")?;
easy.url(request_url.as_str())
.with_context(|| anyhow!("failed to set curl request url to {}", request_url))?;
diff --git a/moli-fetch/src/client_hints.rs b/moli-fetch/src/client_hints.rs
index 7ae3ff6cd..dbe16b752 100644
--- a/moli-fetch/src/client_hints.rs
+++ b/moli-fetch/src/client_hints.rs
@@ -197,7 +197,7 @@ pub(crate) fn prepare_client_hint_request(
request: &Request,
request_url: &Url,
) -> PreparedClientHintRequest {
- let identity = config.browser_identity();
+ let identity = request.browser_identity(config);
let browser_request =
request.is_navigation_request() || request.browser_request_metadata().is_some();
let mut effective_request = request.clone();
diff --git a/moli-fetch/src/request.rs b/moli-fetch/src/request.rs
index 750e97048..7ae14e4bb 100644
--- a/moli-fetch/src/request.rs
+++ b/moli-fetch/src/request.rs
@@ -50,6 +50,7 @@ pub struct Request {
pub cookie_context: NetworkCookieRequestContext,
timeout_policy: RequestTimeoutPolicy,
network_observation_recorder: Option<NetworkObservationRecorder>,
+ browser_identity: Option<std::sync::Arc<moli_browser_profile::BrowserIdentityProfile>>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -405,6 +406,7 @@ impl Request {
cookie_context: NetworkCookieRequestContext::top_level_navigation("GET"),
timeout_policy: RequestTimeoutPolicy::default(),
network_observation_recorder: None,
+ browser_identity: None,
})
}
@@ -435,6 +437,7 @@ impl Request {
cookie_context: NetworkCookieRequestContext::top_level_navigation("GET"),
timeout_policy: RequestTimeoutPolicy::default(),
network_observation_recorder: None,
+ browser_identity: None,
}
}
@@ -496,9 +499,34 @@ impl Request {
cookie_context: NetworkCookieRequestContext::subresource(method),
timeout_policy: RequestTimeoutPolicy::default(),
network_observation_recorder: None,
+ browser_identity: None,
}
}
+ /// Captures the execution context's identity for this request and redirects.
+ /// Updating a Worker must not rebuild the shared transport or mutate an
+ /// already admitted request's identity.
+ pub fn with_browser_identity(
+ mut self,
+ identity: std::sync::Arc<moli_browser_profile::BrowserIdentityProfile>,
+ ) -> Self {
+ self.browser_identity = Some(identity);
+ self
+ }
+
+ pub(crate) fn browser_identity<'a>(
+ &'a self,
+ config: &'a FetchConfig,
+ ) -> &'a moli_browser_profile::BrowserIdentityProfile {
+ self.browser_identity
+ .as_deref()
+ .unwrap_or_else(|| config.browser_identity())
+ }
+
+ pub(crate) fn has_browser_identity_override(&self) -> bool {
+ self.browser_identity.is_some()
+ }
+
pub fn with_min_request_timeout(mut self, minimum_request_timeout: Duration) -> Self {
self.timeout_policy.minimum_request_timeout = Some(minimum_request_timeout);
self
diff --git a/moli-page-types/src/navigator_overrides.rs b/moli-page-types/src/navigator_overrides.rs
index 14f33d7cf..63335015b 100644
--- a/moli-page-types/src/navigator_overrides.rs
+++ b/moli-page-types/src/navigator_overrides.rs
@@ -34,13 +34,23 @@ pub struct NavigatorQueryOverrides {
/// sessions use the same precedence, but each target owns its own registry.
#[derive(Debug, Default, PartialEq, Eq)]
pub struct NavigatorEmulationSessions {
- sessions: Vec<(crate::DevToolsSessionKey, NavigatorQueryOverrides)>,
+ sessions: Vec<(crate::DevToolsSessionKey, NavigatorEmulationSession)>,
+}
+
+#[derive(Debug, Default, PartialEq, Eq)]
+struct NavigatorEmulationSession {
+ queries: NavigatorQueryOverrides,
+ user_agent: Option<moli_browser_profile::UserAgentOverride>,
}
impl NavigatorEmulationSessions {
/// The first probe-using Emulation command activates an agent. Subsequent
/// commands preserve its position, even after clearing an individual value.
pub fn session_mut(&mut self, key: &crate::DevToolsSessionKey) -> &mut NavigatorQueryOverrides {
+ &mut self.activate(key).queries
+ }
+
+ fn activate(&mut self, key: &crate::DevToolsSessionKey) -> &mut NavigatorEmulationSession {
let index = match self
.sessions
.iter()
@@ -49,7 +59,7 @@ impl NavigatorEmulationSessions {
Some(index) => index,
None => {
self.sessions
- .push((key.clone(), NavigatorQueryOverrides::default()));
+ .push((key.clone(), NavigatorEmulationSession::default()));
self.sessions.len() - 1
}
};
@@ -65,10 +75,60 @@ impl NavigatorEmulationSessions {
.find(|(existing, _)| existing == key)
{
// Disabling alone does not activate a new Inspector agent.
- settings.automation = false;
+ settings.queries.automation = false;
+ }
+ }
+
+ pub fn set_user_agent_override(
+ &mut self,
+ key: &crate::DevToolsSessionKey,
+ value: moli_browser_profile::UserAgentOverride,
+ ) {
+ if value.activates_agent() {
+ self.activate(key).user_agent = Some(value);
+ } else if let Some((_, session)) = self
+ .sessions
+ .iter_mut()
+ .find(|(existing, _)| existing == key)
+ {
+ session.user_agent = None;
}
}
+ /// UA (together with its metadata) and language each use the last active
+ /// agent contributing that field. Clearing a field does not reorder agents.
+ pub fn effective_user_agent_override(&self) -> Option<moli_browser_profile::UserAgentOverride> {
+ let mut user_agent = None;
+ let mut accept_language = None;
+ for (_, session) in &self.sessions {
+ let Some(value) = &session.user_agent else {
+ continue;
+ };
+ if !value.user_agent.is_empty() {
+ user_agent = Some(value);
+ }
+ if let Some(language) = value
+ .accept_language
+ .as_ref()
+ .filter(|value| !value.is_empty())
+ {
+ accept_language = Some(language.clone());
+ }
+ }
+ (user_agent.is_some() || accept_language.is_some()).then(|| {
+ moli_browser_profile::UserAgentOverride {
+ user_agent: user_agent
+ .map(|value| value.user_agent.clone())
+ .unwrap_or_default(),
+ accept_language,
+ // Worker platform is fixed at creation. The parameter participates
+ // in activation, but Chromium applies it only to Page settings.
+ platform: None,
+ user_agent_metadata: user_agent.and_then(|value| value.user_agent_metadata.clone()),
+ }
+ })
+ }
+
pub fn remove(&mut self, key: &crate::DevToolsSessionKey) {
self.sessions.retain(|(existing, _)| existing != key);
}
@@ -79,7 +139,8 @@ impl NavigatorEmulationSessions {
pub fn effective(&self) -> NavigatorQueryOverrides {
let mut effective = NavigatorQueryOverrides::default();
- for (_, settings) in &self.sessions {
+ for (_, session) in &self.sessions {
+ let settings = &session.queries;
effective.automation |= settings.automation;
effective.data_saver = settings.data_saver.or(effective.data_saver);
effective.hardware_concurrency = settings
diff --git a/moli-protocol/src/conn/browser_context/network_owner.rs b/moli-protocol/src/conn/browser_context/network_owner.rs
index 7c26b8dd9..1470bfa02 100644
--- a/moli-protocol/src/conn/browser_context/network_owner.rs
+++ b/moli-protocol/src/conn/browser_context/network_owner.rs
@@ -747,16 +747,6 @@ impl CdpConnection {
session_id: Option<&str>,
browser_identity: Option<crate::conn::DevToolsBrowserIdentityOverride>,
) -> Result<Option<PendingPageCommand>, String> {
- if matches!(
- self.session_route(session_id),
- Some(
- CdpSessionRoute::DedicatedWorkerTarget { .. }
- | CdpSessionRoute::SharedWorkerTarget { .. }
- | CdpSessionRoute::ServiceWorkerTarget { .. }
- )
- ) {
- return Err("User agent overrides are not supported for workers".to_owned());
- }
let non_page_identity = browser_identity
.as_ref()
.map(crate::conn::DevToolsBrowserIdentityOverride::to_browser_identity);
diff --git a/moli-protocol/src/conn/dispatch.rs b/moli-protocol/src/conn/dispatch.rs
index 0fb7f28fb..1dcc40e81 100644
--- a/moli-protocol/src/conn/dispatch.rs
+++ b/moli-protocol/src/conn/dispatch.rs
@@ -653,6 +653,12 @@ impl CdpConnection {
},
)
}
+ "Emulation" | "Network" if let Some(step) = crate::domains::runtime::try_start_worker_emulation_command_dispatch(self, &cmd) => {
+ Some(match step {
+ crate::domains::runtime::RuntimeCommandTaskStep::Pending(pending) => self.pending_step(PendingCdpCommandDispatchKind::Runtime(pending)),
+ crate::domains::runtime::RuntimeCommandTaskStep::Complete(plan) => self.complete_with_output_plan(command_context, plan, cmd.id, cmd.session_id),
+ })
+ }
"Network" => Some(
match crate::domains::network::start_network_domain_command_dispatch(self, &cmd) {
crate::domains::network::NetworkDomainCommandTaskStep::Network(
@@ -840,12 +846,6 @@ impl CdpConnection {
}
},
),
- "Emulation" if let Some(step) = crate::domains::runtime::try_start_worker_emulation_command_dispatch(self, &cmd) => {
- Some(match step {
- crate::domains::runtime::RuntimeCommandTaskStep::Pending(pending) => self.pending_step(PendingCdpCommandDispatchKind::Runtime(pending)),
- crate::domains::runtime::RuntimeCommandTaskStep::Complete(plan) => self.complete_with_output_plan(command_context, plan, cmd.id, cmd.session_id),
- })
- }
"Emulation" => crate::domains::emulation::try_start_emulation_command_dispatch(
self, &cmd,
)
diff --git a/moli-protocol/src/domains/network/settings.rs b/moli-protocol/src/domains/network/settings.rs
index 0361d7d60..eacece250 100644
--- a/moli-protocol/src/domains/network/settings.rs
+++ b/moli-protocol/src/domains/network/settings.rs
@@ -1,12 +1,9 @@
use crate::conn::{CdpConnection, Cmd, DevToolsBrowserIdentityOverride};
use crate::domains::command_output::CommandOutputPlan;
#[allow(deprecated)]
-use chromiumoxide_cdp::cdp::browser_protocol::{
- emulation::SetUserAgentOverrideParams,
- network::{
- EmulateNetworkConditionsParams, SetBypassServiceWorkerParams, SetCacheDisabledParams,
- SetExtraHttpHeadersParams,
- },
+use chromiumoxide_cdp::cdp::browser_protocol::network::{
+ EmulateNetworkConditionsParams, SetBypassServiceWorkerParams, SetCacheDisabledParams,
+ SetExtraHttpHeadersParams,
};
use serde::Deserialize;
@@ -119,130 +116,22 @@ pub(crate) fn user_agent_override_for_command(
cmd: &Cmd<'_>,
base: &moli_browser_profile::BrowserIdentityProfile,
) -> Result<Option<DevToolsBrowserIdentityOverride>, CommandOutputPlan> {
- let params: SetUserAgentOverrideParams = match cmd.get_params() {
+ let params: moli_browser_profile::UserAgentOverride = match cmd.get_params() {
Ok(Some(params)) => params,
_ => return Err(CommandOutputPlan::error(-32602, "InvalidParams")),
};
- if !params.user_agent.is_empty() && !is_valid_chromium_header_value(&params.user_agent) {
- return Err(CommandOutputPlan::error(
- -32602,
- "Invalid characters found in userAgent",
- ));
- }
- if params
- .accept_language
- .as_deref()
- .is_some_and(|value| !value.is_empty() && !is_valid_chromium_header_value(value))
- {
- return Err(CommandOutputPlan::error(
- -32602,
- "Invalid characters found in acceptLanguage",
- ));
- }
- if params.user_agent.is_empty() && params.user_agent_metadata.is_some() {
- return Err(CommandOutputPlan::error(
- -32602,
- "Empty userAgent invalid with userAgentMetadata provided",
- ));
- }
- let full_version = match cmd
- .params
- .and_then(|params| params.get("userAgentMetadata"))
- .and_then(|metadata| metadata.get("fullVersion"))
- {
- None | Some(serde_json::Value::Null) => None,
- Some(serde_json::Value::String(value)) => Some(value.clone()),
- Some(_) => return Err(CommandOutputPlan::error(-32602, "InvalidParams")),
- };
- if let Some(metadata) = params.user_agent_metadata.as_ref() {
- validate_client_hint_brand_list(metadata.brands.as_deref())?;
- validate_client_hint_brand_list(metadata.full_version_list.as_deref())?;
- validate_client_hint_field(full_version.as_deref(), "Invalid full version string")?;
- validate_client_hint_field(Some(&metadata.platform), "Invalid platform string")?;
- validate_client_hint_field(
- Some(&metadata.platform_version),
- "Invalid platform version string",
- )?;
- validate_client_hint_field(Some(&metadata.architecture), "Invalid architecture string")?;
- validate_client_hint_field(Some(&metadata.model), "Invalid model string")?;
- validate_client_hint_field(metadata.bitness.as_deref(), "Invalid bitness string")?;
- if let Some(form_factors) = metadata.form_factors.as_deref() {
- for form_factor in form_factors {
- validate_client_hint_field(Some(form_factor), "Invalid form factor string")?;
- }
- }
- }
- let metadata = params.user_agent_metadata.map(|metadata| {
- moli_browser_profile::BrowserUserAgentMetadataOverride {
- brands: metadata.brands.map(|brands| {
- brands
- .into_iter()
- .map(|entry| moli_browser_profile::BrowserBrandVersion {
- brand: entry.brand,
- version: entry.version,
- })
- .collect()
- }),
- full_version_list: metadata.full_version_list.map(|brands| {
- brands
- .into_iter()
- .map(|entry| moli_browser_profile::BrowserBrandVersion {
- brand: entry.brand,
- version: entry.version,
- })
- .collect()
- }),
- full_version,
- platform: metadata.platform,
- platform_version: metadata.platform_version,
- architecture: metadata.architecture,
- model: metadata.model,
- mobile: metadata.mobile,
- bitness: metadata.bitness,
- wow64: metadata.wow64,
- form_factors: metadata.form_factors,
- }
- });
+ params
+ .validate()
+ .map_err(|message| CommandOutputPlan::error(-32602, message))?;
Ok(DevToolsBrowserIdentityOverride::from_command(
base,
params.user_agent,
params.accept_language,
params.platform,
- metadata,
+ params.user_agent_metadata,
))
}
-fn is_valid_chromium_header_value(value: &str) -> bool {
- !value.bytes().any(|byte| matches!(byte, 0 | b'\r' | b'\n'))
-}
-
-fn is_ascii_printable(value: &str) -> bool {
- value.bytes().all(|byte| (0x20..=0x7e).contains(&byte))
-}
-
-fn validate_client_hint_field(
- value: Option<&str>,
- error_message: &'static str,
-) -> Result<(), CommandOutputPlan> {
- if value.is_some_and(|value| !is_ascii_printable(value)) {
- return Err(CommandOutputPlan::error(-32602, error_message));
- }
- Ok(())
-}
-
-fn validate_client_hint_brand_list(
- brands: Option<&[chromiumoxide_cdp::cdp::browser_protocol::emulation::UserAgentBrandVersion]>,
-) -> Result<(), CommandOutputPlan> {
- let Some(brands) = brands else {
- return Ok(());
- };
- for brand in brands {
- validate_client_hint_field(Some(&brand.brand), "Invalid brand string")?;
- validate_client_hint_field(Some(&brand.version), "Invalid brand version string")?;
- }
- Ok(())
-}
-
fn extra_http_headers_from_params(
params: SetExtraHttpHeadersParams,
) -> Option<Vec<(String, String)>> {
diff --git a/moli-protocol/src/domains/runtime/dispatcher.rs b/moli-protocol/src/domains/runtime/dispatcher.rs
index dbf660bf4..4cbf0a5b6 100644
--- a/moli-protocol/src/domains/runtime/dispatcher.rs
+++ b/moli-protocol/src/domains/runtime/dispatcher.rs
@@ -919,10 +919,13 @@ pub(crate) fn try_start_worker_emulation_command_dispatch(
conn: &mut CdpConnection,
cmd: &Cmd<'_>,
) -> Option<RuntimeCommandTaskStep> {
- let action = match cmd.action {
- "setHardwareConcurrencyOverride" => "Emulation.setHardwareConcurrencyOverride",
- "setDataSaverOverride" => "Emulation.setDataSaverOverride",
- "setAutomationOverride" => "Emulation.setAutomationOverride",
+ let action = match cmd.method {
+ "Emulation.setHardwareConcurrencyOverride" => "Emulation.setHardwareConcurrencyOverride",
+ "Emulation.setDataSaverOverride" => "Emulation.setDataSaverOverride",
+ "Emulation.setAutomationOverride" => "Emulation.setAutomationOverride",
+ "Emulation.setUserAgentOverride" | "Network.setUserAgentOverride" => {
+ "Emulation.setUserAgentOverride"
+ }
_ => return None,
};
let pending = match conn.session_route(cmd.session_id) {
diff --git a/moli-protocol/src/domains/runtime/tests/mod.rs b/moli-protocol/src/domains/runtime/tests/mod.rs
index 4c0e7e4c1..f6fde6712 100644
--- a/moli-protocol/src/domains/runtime/tests/mod.rs
+++ b/moli-protocol/src/domains/runtime/tests/mod.rs
@@ -203,3 +203,5 @@ mod navigation;
mod objects;
mod service_worker;
mod shared_worker;
+
+mod worker_emulation;
diff --git a/moli-protocol/src/domains/runtime/tests/shared_worker.rs b/moli-protocol/src/domains/runtime/tests/shared_worker.rs
index f26179603..11bb5b89e 100644
--- a/moli-protocol/src/domains/runtime/tests/shared_worker.rs
+++ b/moli-protocol/src/domains/runtime/tests/shared_worker.rs
@@ -3725,7 +3725,7 @@ async fn worker_navigator_query_overrides_are_independent_of_the_page() {
}
#[tokio::test(flavor = "multi_thread")]
-async fn shared_worker_emulation_activation_ignores_rejected_user_agent_commands() {
+async fn shared_worker_emulation_activation_tracks_user_agent_commands() {
async fn snapshot(ctx: &mut TestContext, session_id: Option<&str>) -> serde_json::Value {
ctx.process_and_wait_for_response_async(json!({
"id": 99190, "sessionId": session_id, "method": "Runtime.evaluate",
@@ -3764,22 +3764,18 @@ async fn shared_worker_emulation_activation_ignores_rejected_user_agent_commands
.unwrap()
.to_owned();
- // Unsupported UA commands must neither alter the Page nor reserve a place
- // in the Worker's Emulation agent order. Both CDP spellings share the policy.
+ // Invalid UA commands must not reserve a place in the Worker agent order.
+ // Both CDP spellings validate before publishing any state.
for method in [
"Emulation.setUserAgentOverride",
"Network.setUserAgentOverride",
] {
ctx.process_and_wait_for_response_async(json!({
"id": 99103, "sessionId": first, "method": method,
- "params": {"userAgent": "worker-emulation-order"}
+ "params": {"userAgent": "invalid\nagent"}
}))
.await;
- ctx.expect_error(
- 99103,
- -32000,
- "User agent overrides are not supported for workers",
- );
+ ctx.expect_error(99103, -32602, "Invalid characters found in userAgent");
assert_eq!(snapshot(&mut ctx, Some(&first)).await, baseline);
assert_eq!(snapshot(&mut ctx, None).await, page_baseline);
}
@@ -3794,14 +3790,32 @@ async fn shared_worker_emulation_activation_ignores_rejected_user_agent_commands
"HardwareConcurrency must be a positive int32",
);
- // Activate the second session first through Data Saver. Its later updates
- // cannot overtake the first session, even when an individual value clears.
+ // UA alone activates the second agent before the first sets concurrency.
+ // Clearing UA must preserve that position for subsequent query overrides.
+ ctx.process_and_wait_for_response_async(json!({
+ "id": 99109, "sessionId": second, "method": "Emulation.setUserAgentOverride",
+ "params": {"userAgent": "worker-emulation-order"}
+ }))
+ .await;
+ ctx.expect_result(99109, json!({}), Some(&second));
+ ctx.process_and_wait_for_response_async(json!({
+ "id": 99110, "sessionId": first, "method": "Emulation.setHardwareConcurrencyOverride",
+ "params": {"hardwareConcurrency": 2}
+ }))
+ .await;
+ ctx.expect_result(99110, json!({}), Some(&first));
+ ctx.process_and_wait_for_response_async(json!({
+ "id": 99111, "sessionId": second, "method": "Network.setUserAgentOverride",
+ "params": {"userAgent": ""}
+ }))
+ .await;
+ ctx.expect_result(99111, json!({}), Some(&second));
for (session, method, params, expected) in [
(
&second,
"Emulation.setDataSaverOverride",
json!({"dataSaverEnabled": true}),
- json!([baseline[0], true]),
+ json!([2, true]),
),
(
&first,
diff --git a/moli-protocol/src/domains/runtime/tests/worker_emulation.rs b/moli-protocol/src/domains/runtime/tests/worker_emulation.rs
new file mode 100644
index 000000000..f4c5312d2
--- /dev/null
+++ b/moli-protocol/src/domains/runtime/tests/worker_emulation.rs
@@ -0,0 +1,321 @@
+use super::*;
+use axum::{Json, http::HeaderMap};
+use serde_json::Value;
+
+async fn evaluate(ctx: &mut TestContext, session: &str, expression: &str) -> Value {
+ ctx.process_and_wait_for_response_async(json!({
+ "id": 99200, "sessionId": session, "method": "Runtime.evaluate",
+ "params": {"expression": expression, "awaitPromise": true, "returnByValue": true}
+ }))
+ .await;
+ let response = take_response_by_id(ctx, 99200);
+ assert!(response.get("error").is_none(), "{response}");
+ assert!(
+ response["result"].get("exceptionDetails").is_none(),
+ "{response}"
+ );
+ response["result"]["result"]["value"].clone()
+}
+
+async fn set_ua(ctx: &mut TestContext, session: &str, method: &str, params: Value) {
+ ctx.process_and_wait_for_response_async(json!({
+ "id": 99201, "sessionId": session, "method": method, "params": params
+ }))
+ .await;
+ ctx.expect_result(99201, json!({}), Some(session));
+}
+
+const SNAPSHOT: &str = r#"(() => {
+ globalThis.heldNavigator ??= navigator;
+ globalThis.heldUaData ??= navigator.userAgentData;
+ return {
+ ua: heldNavigator.userAgent, app: heldNavigator.appVersion,
+ platform: heldNavigator.platform, language: heldNavigator.language,
+ languages: Array.from(heldNavigator.languages),
+ metadata: navigator.userAgentData.toJSON(), held: heldUaData.toJSON()
+ };
+})()"#;
+const HEADERS: &str = "fetch('/headers', {cache:'no-store'}).then(response => response.json())";
+
+async fn worker_user_agent_override(target_type: &str, create: &str) {
+ async fn page() -> impl IntoResponse {
+ (
+ [(CONTENT_TYPE.as_str(), "text/html")],
+ "<!doctype html><body>Worker UA</body>",
+ )
+ }
+ async fn worker() -> impl IntoResponse {
+ (
+ [(CONTENT_TYPE.as_str(), "text/javascript")],
+ r#"
+ onconnect = event => event.ports[0].postMessage('ready');
+ if (typeof registration !== 'undefined') {
+ addEventListener('install', event => event.waitUntil(skipWaiting()));
+ addEventListener('activate', event => event.waitUntil(clients.claim()));
+ }
+ "#,
+ )
+ }
+ async fn headers(headers: HeaderMap) -> Json<std::collections::BTreeMap<String, String>> {
+ Json(
+ headers
+ .iter()
+ .map(|(key, value)| (key.to_string(), value.to_str().unwrap().to_owned()))
+ .collect(),
+ )
+ }
+ async fn websocket(
+ headers: HeaderMap,
+ upgrade: axum::extract::ws::WebSocketUpgrade,
+ ) -> impl IntoResponse {
+ let ua = headers["user-agent"].to_str().unwrap().to_owned();
+ upgrade.on_upgrade(move |mut socket| async move {
+ socket
+ .send(axum::extract::ws::Message::Text(ua.into()))
+ .await
+ .unwrap();
+ while let Some(Ok(message)) = socket.recv().await {
+ if matches!(message, axum::extract::ws::Message::Close(_)) {
+ break;
+ }
+ }
+ })
+ }
+ async fn imported(headers: HeaderMap) -> impl IntoResponse {
+ (
+ [
+ ("content-type", "text/javascript"),
+ ("cache-control", "max-age=3600"),
+ ("vary", "User-Agent"),
+ ],
+ format!(
+ "globalThis.importedUA = {};",
+ serde_json::to_string(headers["user-agent"].to_str().unwrap()).unwrap()
+ ),
+ )
+ }
+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ let server = tokio::spawn(async move {
+ axum::serve(
+ listener,
+ Router::new()
+ .route("/page", get(page))
+ .route("/worker.js", get(worker))
+ .route("/headers", get(headers))
+ .route("/socket", get(websocket))
+ .route(
+ "/redirect",
+ get(|| async { axum::response::Redirect::temporary("/headers") }),
+ )
+ .route("/imported.js", get(imported)),
+ )
+ .await
+ .unwrap();
+ });
+ let mut ctx = TestContext::new();
+ with_loaded_http_document_async(
+ &mut ctx,
+ &format!("http://{addr}/page"),
+ "SID-page",
+ "TID-page",
+ )
+ .await;
+ ctx.process_async(json!({"id":99202,"method":"Target.setAutoAttach","params":{"autoAttach":true,"waitForDebuggerOnStart":false}})).await;
+ ctx.expect_result(99202, json!({}), None);
+ if target_type == "worker" {
+ ctx.process_async(json!({"id":99208,"sessionId":"SID-page","method":"Target.setAutoAttach","params":{"autoAttach":true,"waitForDebuggerOnStart":false,"flatten":true}})).await;
+ ctx.expect_result(99208, json!({}), Some("SID-page"));
+ }
+ evaluate(&mut ctx, "SID-page", create).await;
+ wait_until_message(&mut ctx, None, "Worker UA target", |message| {
+ message["method"] == "Target.attachedToTarget"
+ && message["params"]["targetInfo"]["type"] == target_type
+ })
+ .await;
+ let attached = ctx.take_first_matching("Worker UA target", |message| {
+ message["method"] == "Target.attachedToTarget"
+ && message["params"]["targetInfo"]["type"] == target_type
+ });
+ let session = attached["params"]["sessionId"].as_str().unwrap().to_owned();
+ let target = attached["params"]["targetInfo"]["targetId"]
+ .as_str()
+ .unwrap()
+ .to_owned();
+ let baseline = evaluate(&mut ctx, &session, SNAPSHOT).await;
+ let baseline_headers = evaluate(&mut ctx, &session, HEADERS).await;
+ let page_baseline = evaluate(&mut ctx, "SID-page", SNAPSHOT).await;
+ let page_headers = evaluate(&mut ctx, "SID-page", HEADERS).await;
+ // Seed both the renderer and HTTP caches before changing the Worker UA.
+ let import = "importScripts('/imported.js'); importedUA";
+ if target_type != "service_worker" {
+ assert_eq!(
+ evaluate(&mut ctx, &session, import).await,
+ baseline_headers["user-agent"]
+ );
+ }
+
+ set_ua(&mut ctx, &session, "Emulation.setUserAgentOverride", json!({
+ "userAgent":"Mozilla/5.0 WorkerAgent", "acceptLanguage":"fr-FR,fr", "platform":"ignored-in-worker",
+ "userAgentMetadata": {"brands":[{"brand":"Worker","version":"7"}], "platform":"WorkerOS", "platformVersion":"2", "architecture":"arm", "model":"M", "mobile":true}
+ })).await;
+ let mut expected = baseline.clone();
+ expected["language"] = json!("fr-FR");
+ expected["languages"] = json!(["fr-FR", "fr"]);
+ expected["metadata"] =
+ json!({"brands":[{"brand":"Worker","version":"7"}],"platform":"WorkerOS","mobile":true});
+ assert_eq!(evaluate(&mut ctx, &session, SNAPSHOT).await, expected);
+ let actual = evaluate(&mut ctx, &session, HEADERS).await;
+ assert_eq!(actual["user-agent"], "Mozilla/5.0 WorkerAgent");
+ assert_eq!(actual["accept-language"], "fr-FR,fr");
+ assert!(actual["sec-ch-ua"].as_str().unwrap().contains("Worker"));
+ assert_eq!(evaluate(&mut ctx, &session, "fetch('/redirect').then(response => response.json()).then(headers => headers['user-agent'])").await, "Mozilla/5.0 WorkerAgent");
+ assert_eq!(evaluate(&mut ctx, &session, "new Promise((resolve, reject) => { const socket = new WebSocket('ws://' + location.host + '/socket'); socket.onmessage = event => { socket.close(); resolve(event.data); }; socket.onerror = () => reject(new Error('websocket failed')); })").await, "Mozilla/5.0 WorkerAgent");
+ if target_type != "service_worker" {
+ assert_eq!(evaluate(&mut ctx, &session, "new Promise((resolve, reject) => { const xhr = new XMLHttpRequest(); xhr.open('GET','/headers'); xhr.onload = () => resolve(JSON.parse(xhr.responseText)['user-agent']); xhr.onerror = () => reject(new Error('xhr failed')); xhr.send(); })").await, "Mozilla/5.0 WorkerAgent");
+ }
+
+ if target_type != "service_worker" {
+ assert_eq!(
+ evaluate(&mut ctx, &session, import).await,
+ "Mozilla/5.0 WorkerAgent"
+ );
+ }
+ assert_eq!(evaluate(&mut ctx, &session, "navigator.userAgentData.getHighEntropyValues(['architecture','platformVersion']).then(x => [x.architecture,x.platformVersion])").await, json!(["arm", "2"]));
+ assert_eq!(
+ evaluate(&mut ctx, "SID-page", SNAPSHOT).await,
+ page_baseline
+ );
+ assert_eq!(evaluate(&mut ctx, "SID-page", HEADERS).await, page_headers);
+
+ // An override without metadata restores the Worker's creation metadata;
+ // its UA string, appVersion and platform also remain creation-time values.
+ set_ua(
+ &mut ctx,
+ &session,
+ "Network.setUserAgentOverride",
+ json!({"userAgent":"WorkerAlias", "acceptLanguage":"de-DE,de"}),
+ )
+ .await;
+ expected = baseline.clone();
+ expected["language"] = json!("de-DE");
+ expected["languages"] = json!(["de-DE", "de"]);
+ assert_eq!(evaluate(&mut ctx, &session, SNAPSHOT).await, expected);
+ assert_eq!(
+ evaluate(&mut ctx, &session, HEADERS).await["user-agent"],
+ "WorkerAlias"
+ );
+ if target_type != "service_worker" {
+ assert_eq!(evaluate(&mut ctx, &session, import).await, "WorkerAlias");
+ }
+ ctx.process_and_wait_for_response_async(json!({"id":99203,"sessionId":session,"method":"Emulation.setUserAgentOverride","params":{"userAgent":"bad\nagent"}})).await;
+ ctx.expect_error(99203, -32602, "Invalid characters found in userAgent");
+ assert_eq!(evaluate(&mut ctx, &session, SNAPSHOT).await, expected);
+ assert_eq!(
+ evaluate(&mut ctx, &session, HEADERS).await["user-agent"],
+ "WorkerAlias"
+ );
+
+ set_ua(
+ &mut ctx,
+ &session,
+ "Emulation.setUserAgentOverride",
+ json!({"userAgent":""}),
+ )
+ .await;
+ assert_eq!(evaluate(&mut ctx, &session, SNAPSHOT).await, baseline);
+ assert_eq!(
+ evaluate(&mut ctx, &session, HEADERS).await,
+ baseline_headers
+ );
+ // Sessions contribute UA/metadata and language independently. Updating the
+ // earlier agent cannot overtake a later agent; clearing reveals its value.
+ ctx.process_async(json!({"id":99206,"method":"Target.attachToTarget","params":{"targetId":target,"flatten":true}})).await;
+ let second = take_response_by_id(&mut ctx, 99206)["result"]["sessionId"]
+ .as_str()
+ .unwrap()
+ .to_owned();
+ set_ua(
+ &mut ctx,
+ &session,
+ "Emulation.setUserAgentOverride",
+ json!({"userAgent":"First", "acceptLanguage":"fr-FR"}),
+ )
+ .await;
+ set_ua(
+ &mut ctx,
+ &second,
+ "Network.setUserAgentOverride",
+ json!({"userAgent":"Second"}),
+ )
+ .await;
+ set_ua(
+ &mut ctx,
+ &session,
+ "Emulation.setUserAgentOverride",
+ json!({"userAgent":"FirstChanged", "acceptLanguage":"it-IT"}),
+ )
+ .await;
+ let headers = evaluate(&mut ctx, &session, HEADERS).await;
+ assert_eq!(headers["user-agent"], "Second");
+ assert_eq!(headers["accept-language"], "it-IT");
+ set_ua(
+ &mut ctx,
+ &second,
+ "Emulation.setUserAgentOverride",
+ json!({"userAgent":""}),
+ )
+ .await;
+ assert_eq!(
+ evaluate(&mut ctx, &second, HEADERS).await["user-agent"],
+ "FirstChanged"
+ );
+ ctx.process_async(
+ json!({"id":99207,"method":"Target.detachFromTarget","params":{"sessionId":second}}),
+ )
+ .await;
+ ctx.expect_result(99207, json!({}), None);
+
+ set_ua(
+ &mut ctx,
+ &session,
+ "Network.setUserAgentOverride",
+ json!({"userAgent":"DetachAgent"}),
+ )
+ .await;
+ ctx.process_async(
+ json!({"id":99204,"method":"Target.detachFromTarget","params":{"sessionId":session}}),
+ )
+ .await;
+ ctx.expect_result(99204, json!({}), None);
+ ctx.process_async(json!({"id":99205,"method":"Target.attachToTarget","params":{"targetId":target,"flatten":true}})).await;
+ let observer = take_response_by_id(&mut ctx, 99205)["result"]["sessionId"]
+ .as_str()
+ .unwrap()
+ .to_owned();
+ assert_eq!(evaluate(&mut ctx, &observer, SNAPSHOT).await, baseline);
+ assert_eq!(
+ evaluate(&mut ctx, &observer, HEADERS).await,
+ baseline_headers
+ );
+ server.abort();
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn dedicated_worker_user_agent_override_updates_requests_and_restores_on_detach() {
+ worker_user_agent_override(
+ "worker",
+ "globalThis.uaWorker = new Worker('/worker.js'); 'started'",
+ )
+ .await;
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn shared_worker_user_agent_override_updates_requests_and_restores_on_detach() {
+ worker_user_agent_override("shared_worker", "globalThis.uaWorker = new SharedWorker('/worker.js', 'ua'); uaWorker.port.start(); 'started'").await;
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn service_worker_user_agent_override_updates_requests_and_restores_on_detach() {
+ worker_user_agent_override("service_worker", "navigator.serviceWorker.register('/worker.js').then(() => navigator.serviceWorker.ready).then(() => 'ready')").await;
+}
diff --git a/moli-renderer-v8/src/context_bootstrap/navigator_runtime/navigator.rs b/moli-renderer-v8/src/context_bootstrap/navigator_runtime/navigator.rs
index 0014ca607..b0d8d2fc8 100644
--- a/moli-renderer-v8/src/context_bootstrap/navigator_runtime/navigator.rs
+++ b/moli-renderer-v8/src/context_bootstrap/navigator_runtime/navigator.rs
@@ -651,6 +651,45 @@ fn navigator_runtime_data_getter_callback<'s>(
rv.set(v8::undefined(scope).into());
return;
};
+ if matches!(key, "language" | "languages" | "userAgentData")
+ && let Some(identity) = worker_navigator_identity(scope, backing)
+ {
+ match key {
+ "language" => {
+ if let Some(value) = v8_string(scope, identity.language()) {
+ rv.set(value.into());
+ }
+ return;
+ }
+ "userAgentData" => {
+ // Like Chromium, each access takes a metadata snapshot. An
+ // already held NavigatorUAData keeps its original values.
+ rv.set(build_navigator_ua_data_object(scope, &identity).into());
+ return;
+ }
+ "languages" => {
+ let previous = get_private_value(scope, backing, NAVIGATOR_ACCEPT_LANGUAGE_SLOT)
+ .and_then(|value| value.to_string(scope))
+ .map(|value| value.to_rust_string_lossy(scope));
+ if previous.as_deref() != Some(identity.accept_language()) {
+ if let Some(value) = v8_string(scope, identity.accept_language()) {
+ set_private_value(
+ scope,
+ backing,
+ NAVIGATOR_ACCEPT_LANGUAGE_SLOT,
+ value.into(),
+ );
+ }
+ let _ = backing.set(
+ scope,
+ v8str(scope, "languages").into(),
+ v8::undefined(scope).into(),
+ );
+ }
+ }
+ _ => unreachable!(),
+ }
+ }
if let Some(subobject) = NavigatorSubobject::from_key(key) {
match ensure_navigator_subobject(scope, backing, subobject) {
Ok(value) => rv.set(value),
@@ -1092,6 +1131,9 @@ fn navigator_identity_from_backing<'s>(
scope: &mut v8::PinScope<'s, '_>,
backing: v8::Local<'s, v8::Object>,
) -> BrowserIdentityProfile {
+ if let Some(identity) = worker_navigator_identity(scope, backing) {
+ return identity;
+ }
if let Some(identity) = navigator_identity_profile(scope, backing) {
return identity;
}
@@ -1107,6 +1149,38 @@ fn navigator_identity_from_backing<'s>(
BrowserIdentityProfile::new(user_agent, accept_language)
}
+fn worker_navigator_identity<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ backing: v8::Local<'s, v8::Object>,
+) -> Option<BrowserIdentityProfile> {
+ if !get_private_value(scope, backing, WORKER_NAVIGATOR_BACKING_SLOT)
+ .is_some_and(|value| value.boolean_value(scope))
+ {
+ return None;
+ }
+ let base = navigator_identity_profile(scope, backing)?;
+ let value = scope
+ .get_slot::<std::rc::Rc<std::cell::RefCell<moli_page_types::NavigatorEmulationSessions>>>()
+ .and_then(|sessions| sessions.borrow().effective_user_agent_override());
+ Some(match value {
+ Some(value) => BrowserIdentityProfile::from_devtools_override(
+ &base,
+ // WorkerGlobalScope falls back to its creation metadata when the
+ // active UA override has no metadata. Its UA/appVersion/platform
+ // getters themselves continue to use the creation-time backing.
+ if value.user_agent_metadata.is_some() {
+ value.user_agent
+ } else {
+ String::new()
+ },
+ value.accept_language,
+ None,
+ value.user_agent_metadata,
+ ),
+ None => base,
+ })
+}
+
pub(in crate::context_bootstrap) fn set_navigator_identity_profile<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
diff --git a/moli-renderer-v8/src/network/policy.rs b/moli-renderer-v8/src/network/policy.rs
index ce801a5e1..6237e2dc7 100644
--- a/moli-renderer-v8/src/network/policy.rs
+++ b/moli-renderer-v8/src/network/policy.rs
@@ -29,6 +29,7 @@ struct PageNetworkPolicyState {
revision: u64,
memory_cache_partition_id: u64,
extra_http_headers: SharedHeaderList,
+ browser_identity: Option<Arc<moli_browser_profile::BrowserIdentityProfile>>,
blocked_url_patterns: SharedPatternList,
optional_resource_fetch_mask: OptionalResourceFetchMask,
subframe_loading_enabled: bool,
@@ -52,6 +53,7 @@ impl Default for PageNetworkPolicyState {
revision: 0,
memory_cache_partition_id: next_memory_cache_partition_id(),
extra_http_headers: Arc::from([]),
+ browser_identity: None,
blocked_url_patterns: Arc::from([]),
optional_resource_fetch_mask: OptionalResourceFetchMask::NONE,
subframe_loading_enabled: true,
@@ -156,6 +158,7 @@ impl PageNetworkPolicy {
revision: snapshot.configuration_revision,
memory_cache_partition_id,
extra_http_headers: snapshot.extra_http_headers,
+ browser_identity: snapshot.browser_identity,
blocked_url_patterns: snapshot.blocked_url_patterns,
optional_resource_fetch_mask: snapshot.optional_resource_fetch_mask,
subframe_loading_enabled: snapshot.subframe_loading_enabled,
@@ -182,8 +185,9 @@ impl PageNetworkPolicy {
Self {
state: Arc::new(Mutex::new(PageNetworkPolicyState {
revision: snapshot.configuration_revision,
- memory_cache_partition_id: self.memory_cache_partition_id(),
+ memory_cache_partition_id: snapshot.memory_cache_partition_id,
extra_http_headers: snapshot.extra_http_headers,
+ browser_identity: snapshot.browser_identity,
blocked_url_patterns: snapshot.blocked_url_patterns,
optional_resource_fetch_mask: snapshot.optional_resource_fetch_mask,
subframe_loading_enabled: snapshot.subframe_loading_enabled,
@@ -214,9 +218,11 @@ impl PageNetworkPolicy {
let state = self.state.lock();
let network_conditions = self.network_conditions.lock();
PageNetworkPolicySnapshot {
+ memory_cache_partition_id: state.memory_cache_partition_id,
configuration_revision: state.revision,
network_conditions_revision: network_conditions.revision,
extra_http_headers: state.extra_http_headers.clone(),
+ browser_identity: state.browser_identity.clone(),
network_offline: network_conditions.offline,
blocked_url_patterns: state.blocked_url_patterns.clone(),
optional_resource_fetch_mask: state.optional_resource_fetch_mask,
@@ -250,6 +256,27 @@ impl PageNetworkPolicy {
state.advance_revision();
}
+ pub(crate) fn set_browser_identity_override(
+ &self,
+ identity: Option<Arc<moli_browser_profile::BrowserIdentityProfile>>,
+ ) {
+ let mut state = self.state.lock();
+ if state.browser_identity == identity {
+ return;
+ }
+ state.browser_identity = identity;
+ // Worker imports must not reuse renderer-cache responses prepared for
+ // a different identity. The shared transport/cache budget is unchanged.
+ state.memory_cache_partition_id = next_memory_cache_partition_id();
+ state.advance_revision();
+ }
+
+ pub(crate) fn browser_identity_override(
+ &self,
+ ) -> Option<Arc<moli_browser_profile::BrowserIdentityProfile>> {
+ self.state.lock().browser_identity.clone()
+ }
+
pub fn set_network_offline(&self, offline: bool) {
let mut conditions = self.network_conditions.lock();
if conditions.offline == offline {
@@ -359,9 +386,11 @@ impl PageNetworkPolicy {
/// mutation cannot alter a request already being prepared.
#[derive(Debug, Clone)]
pub struct PageNetworkPolicySnapshot {
+ memory_cache_partition_id: u64,
configuration_revision: u64,
network_conditions_revision: u64,
extra_http_headers: SharedHeaderList,
+ browser_identity: Option<Arc<moli_browser_profile::BrowserIdentityProfile>>,
network_offline: bool,
blocked_url_patterns: SharedPatternList,
optional_resource_fetch_mask: OptionalResourceFetchMask,
@@ -408,6 +437,12 @@ impl PageNetworkPolicySnapshot {
}
pub(crate) fn apply_to_request(&self, mut request: Request) -> Result<Request> {
+ // Worker fetch/XHR enforce their loading policy at the API boundary,
+ // but still inherit the identity captured by their resource lease.
+ if let Some(identity) = &self.browser_identity {
+ request = request.with_browser_identity(identity.clone());
+ }
+
if !request.uses_page_network_policy() {
return Ok(request);
}
@@ -613,4 +648,46 @@ mod tests {
"resuming online must update the same network-condition handle"
);
}
+
+ #[test]
+ fn request_identity_is_frozen_before_later_worker_overrides() {
+ let policy = PageNetworkPolicy::default();
+ let config = moli_fetch::FetchConfig::default();
+ let identity = |ua: &str, language: &str| {
+ Arc::new(moli_browser_profile::BrowserIdentityProfile::new(
+ ua, language,
+ ))
+ };
+ policy.set_browser_identity_override(Some(identity("Worker/A", "fr-FR")));
+ let request_view = policy.frozen_request_view();
+ let partition = request_view.memory_cache_partition_id();
+ policy.set_browser_identity_override(Some(identity("Worker/B", "de-DE")));
+ assert_ne!(partition, policy.memory_cache_partition_id());
+ let request = || {
+ Request::get("https://example.test/worker-fetch")
+ .unwrap()
+ .with_browser_request_metadata(moli_fetch::BrowserRequestMetadata::Fetch)
+ };
+ let frozen = request_view.snapshot().apply_to_request(request()).unwrap();
+ let current = policy.snapshot().apply_to_request(request()).unwrap();
+ policy.set_browser_identity_override(None);
+ for (request, ua, language) in [
+ (frozen, "Worker/A", "fr-FR"),
+ (current, "Worker/B", "de-DE"),
+ ] {
+ let headers = moli_fetch::outgoing_request_headers(&config, &request, None);
+ assert!(
+ headers
+ .iter()
+ .any(|(name, value)| name.eq_ignore_ascii_case("user-agent") && value == ua)
+ );
+ assert!(
+ headers
+ .iter()
+ .any(|(name, value)| name.eq_ignore_ascii_case("accept-language")
+ && value == language)
+ );
+ }
+ assert!(policy.browser_identity_override().is_none());
+ }
}
diff --git a/moli-renderer-v8/src/network/request_client.rs b/moli-renderer-v8/src/network/request_client.rs
index 937b242fc..70e3824b5 100644
--- a/moli-renderer-v8/src/network/request_client.rs
+++ b/moli-renderer-v8/src/network/request_client.rs
@@ -951,6 +951,14 @@ impl ResourceRequestClient {
self.resource_runtime.client().browser_identity()
}
+ pub(crate) fn effective_browser_identity(
+ &self,
+ ) -> std::sync::Arc<moli_browser_profile::BrowserIdentityProfile> {
+ self.page_network_policy
+ .browser_identity_override()
+ .unwrap_or_else(|| std::sync::Arc::new(self.browser_identity().clone()))
+ }
+
pub fn http_proxy(&self) -> Option<&str> {
self.resource_runtime.client().http_proxy()
}
diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rs
index d1cf16af4..998d460e3 100644
--- a/moli-renderer-v8/src/worker/global_scope/fetch.rs
+++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs
@@ -1291,7 +1291,11 @@ pub(crate) fn register_worker_websocket<'s>(
.and_then(|header| header.clone());
let context = WebSocketConnectOptions {
origin: moli_url::origin_ascii_serialization(&document_url),
- user_agent: loader.request_client().user_agent().to_owned(),
+ user_agent: loader
+ .request_client()
+ .effective_browser_identity()
+ .user_agent()
+ .to_owned(),
extra_headers: extra_http_headers,
http_proxy: loader.request_client().http_proxy().map(ToOwned::to_owned),
http_no_proxy: loader
diff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rs
index 146a4909c..208aa718d 100644
--- a/moli-renderer-v8/src/worker/thread/mod.rs
+++ b/moli-renderer-v8/src/worker/thread/mod.rs
@@ -1585,6 +1585,9 @@ async fn worker_main(
parent_tx.clone(),
matches!(global_kind, WorkerGlobalKind::Shared { .. }),
);
+ worker_isolate
+ .worker_runtime_inspector()
+ .bind_request_client(loader.request_client().clone());
install_worker_promise_rejection_dispatch(
worker_isolate.worker_isolate_mut(),
parent_tx.clone(),
diff --git a/moli-renderer-v8/src/worker/thread/runtime_inspector.rs b/moli-renderer-v8/src/worker/thread/runtime_inspector.rs
index 789d61079..2b0172aad 100644
--- a/moli-renderer-v8/src/worker/thread/runtime_inspector.rs
+++ b/moli-renderer-v8/src/worker/thread/runtime_inspector.rs
@@ -1,5 +1,5 @@
use std::{
- cell::{Cell, RefCell, UnsafeCell},
+ cell::{Cell, OnceCell, RefCell, UnsafeCell},
collections::{HashMap, HashSet, VecDeque},
rc::{Rc, Weak},
};
@@ -365,6 +365,7 @@ pub(super) struct WorkerRuntimeInspector {
sessions: RefCell<HashMap<String, Rc<v8::inspector::V8InspectorSession>>>,
detached_sessions: RefCell<HashSet<String>>,
navigator_emulation: Rc<RefCell<moli_page_types::NavigatorEmulationSessions>>,
+ identity: OnceCell<WorkerIdentity>,
inspector: v8::inspector::V8Inspector,
outbound: WorkerInspectorOutbound,
default_context: Rc<RefCell<Option<v8::Global<v8::Context>>>>,
@@ -374,6 +375,11 @@ pub(super) struct WorkerRuntimeInspector {
shared_worker: bool,
}
+struct WorkerIdentity {
+ client: crate::network::ResourceRequestClient,
+ inherited: Option<std::sync::Arc<moli_browser_profile::BrowserIdentityProfile>>,
+}
+
struct WorkerInspectorExecutor {
isolate: UnsafeCell<v8::UnsafeRawIsolatePtr>,
inspector: Weak<WorkerRuntimeInspector>,
@@ -452,6 +458,7 @@ impl WorkerRuntimeInspector {
sessions: RefCell::new(HashMap::new()),
detached_sessions: RefCell::new(HashSet::new()),
navigator_emulation,
+ identity: OnceCell::new(),
outbound: WorkerInspectorOutbound::default(),
default_context,
default_execution_context_id: Cell::new(None),
@@ -495,6 +502,45 @@ impl WorkerRuntimeInspector {
self.inspector.context_destroyed(context);
}
+ pub(super) fn bind_request_client(&self, client: crate::network::ResourceRequestClient) {
+ let inherited = client.page_network_policy().browser_identity_override();
+ assert!(
+ self.identity
+ .set(WorkerIdentity { client, inherited })
+ .is_ok(),
+ "Worker identity must be bound once"
+ );
+ }
+
+ fn update_user_agent_override(&self) {
+ let Some(worker) = self.identity.get() else {
+ return;
+ };
+ let client = &worker.client;
+ let base = worker
+ .inherited
+ .as_deref()
+ .unwrap_or_else(|| client.browser_identity());
+ let identity = self
+ .navigator_emulation
+ .borrow()
+ .effective_user_agent_override()
+ .map(|value| {
+ std::sync::Arc::new(
+ moli_browser_profile::BrowserIdentityProfile::from_devtools_override(
+ base,
+ value.user_agent,
+ value.accept_language,
+ None,
+ value.user_agent_metadata,
+ ),
+ )
+ });
+ client
+ .page_network_policy()
+ .set_browser_identity_override(identity.or_else(|| worker.inherited.clone()));
+ }
+
pub(super) fn detach_session(&self, inspector_session_id: Option<&str>) {
let session_key = worker_inspector_session_key(inspector_session_id);
self.sessions.borrow_mut().remove(&session_key);
@@ -504,6 +550,7 @@ impl WorkerRuntimeInspector {
.unwrap_or(moli_page_types::DevToolsSessionKey::Primary),
);
self.detached_sessions.borrow_mut().insert(session_key);
+ self.update_user_agent_override();
}
pub(super) fn attach_session(&self, inspector_session_id: Option<&str>) {
@@ -589,6 +636,20 @@ impl WorkerRuntimeInspector {
let invalid =
|message| Some(json!({"id":command["id"],"error":{"code":-32602,"message":message}}));
match command["method"].as_str()? {
+ "Emulation.setUserAgentOverride" | "Network.setUserAgentOverride" => {
+ let Ok(value) = serde_json::from_value::<moli_browser_profile::UserAgentOverride>(
+ command["params"].clone(),
+ ) else {
+ return invalid("InvalidParams");
+ };
+ if let Err(message) = value.validate() {
+ return invalid(message);
+ }
+ self.navigator_emulation
+ .borrow_mut()
+ .set_user_agent_override(&key, value);
+ self.update_user_agent_override();
+ }
"Emulation.setHardwareConcurrencyOverride" => {
let value = command["params"]["hardwareConcurrency"]
.as_u64()
diff --git a/moli-renderer-v8/src/worker/thread/tests/network.rs b/moli-renderer-v8/src/worker/thread/tests/network.rs
index 8db9427e0..b58e6f6a1 100644
--- a/moli-renderer-v8/src/worker/thread/tests/network.rs
+++ b/moli-renderer-v8/src/worker/thread/tests/network.rs
@@ -1555,7 +1555,7 @@ async fn worker_navigator_uses_loader_identity_for_user_agent_data() {
.expect("channel closed");
assert_eq!(
expect_post_json(msg),
- r#"{"userAgent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.1.2.3 Safari/537.36","appVersion":"5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.1.2.3 Safari/537.36","language":"fr-CA","languages":["fr-CA","fr","en"],"constructorType":"function","constructorOwn":true,"dataType":"object","sameObject":true,"instance":true,"tag":"[object NavigatorUAData]","json":{"brands":[{"brand":"Chromium","version":"146"},{"brand":"Not-A.Brand","version":"24"},{"brand":"Google Chrome","version":"146"}],"mobile":false,"platform":"Windows"},"emptyKeys":["brands","mobile","platform"],"selectedKeys":["architecture","brands","formFactors","fullVersionList","mobile","platform","uaFullVersion"],"selected":{"architecture":"x86","brands":[{"brand":"Chromium","version":"146"},{"brand":"Not-A.Brand","version":"24"},{"brand":"Google Chrome","version":"146"}],"formFactors":["Desktop"],"fullVersionList":[{"brand":"Chromium","version":"146.1.2.3"},{"brand":"Not-A.Brand","version":"24.0.0.0"},{"brand":"Google Chrome","version":"146.1.2.3"}],"mobile":false,"platform":"Windows","uaFullVersion":"146.1.2.3"},"missingArgument":"TypeError"}"#
+ r#"{"userAgent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.1.2.3 Safari/537.36","appVersion":"5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.1.2.3 Safari/537.36","language":"fr-CA","languages":["fr-CA","fr","en"],"constructorType":"function","constructorOwn":true,"dataType":"object","sameObject":false,"instance":true,"tag":"[object NavigatorUAData]","json":{"brands":[{"brand":"Chromium","version":"146"},{"brand":"Not-A.Brand","version":"24"},{"brand":"Google Chrome","version":"146"}],"mobile":false,"platform":"Windows"},"emptyKeys":["brands","mobile","platform"],"selectedKeys":["architecture","brands","formFactors","fullVersionList","mobile","platform","uaFullVersion"],"selected":{"architecture":"x86","brands":[{"brand":"Chromium","version":"146"},{"brand":"Not-A.Brand","version":"24"},{"brand":"Google Chrome","version":"146"}],"formFactors":["Desktop"],"fullVersionList":[{"brand":"Chromium","version":"146.1.2.3"},{"brand":"Not-A.Brand","version":"24.0.0.0"},{"brand":"Google Chrome","version":"146.1.2.3"}],"mobile":false,"platform":"Windows","uaFullVersion":"146.1.2.3"},"missingArgument":"TypeError"}"#
);
}
diff --git a/moli-renderer-v8/src/worker/thread/tests/postmessage.rs b/moli-renderer-v8/src/worker/thread/tests/postmessage.rs
index 43c461caf..07a57bd34 100644
--- a/moli-renderer-v8/src/worker/thread/tests/postmessage.rs
+++ b/moli-renderer-v8/src/worker/thread/tests/postmessage.rs
@@ -2103,7 +2103,7 @@ async fn shared_worker_navigator_exposes_canonical_user_agent_data() {
"JSON.stringify(__wire)",
)
.await,
- r#"{"constructorType":"function","dataType":"object","instance":true,"sameObject":true,"userAgent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.1.2.3 Safari/537.36","languages":["de-DE","de"],"brands":[{"brand":"Chromium","version":"146"},{"brand":"Not-A.Brand","version":"24"},{"brand":"Google Chrome","version":"146"}],"emptyKeys":["brands","mobile","platform"],"selectedKeys":["architecture","brands","mobile","platform"],"architecture":"x86"}"#
+ r#"{"constructorType":"function","dataType":"object","instance":true,"sameObject":false,"userAgent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.1.2.3 Safari/537.36","languages":["de-DE","de"],"brands":[{"brand":"Chromium","version":"146"},{"brand":"Not-A.Brand","version":"24"},{"brand":"Google Chrome","version":"146"}],"emptyKeys":["brands","mobile","platform"],"selectedKeys":["architecture","brands","mobile","platform"],"architecture":"x86"}"#
);
}
diff --git a/moli-wpt-compat/fixtures/wpt/ported/worker/worker-global-surface-basic.html b/moli-wpt-compat/fixtures/wpt/ported/worker/worker-global-surface-basic.html
index e462ac0e4..1fd7ca294 100644
--- a/moli-wpt-compat/fixtures/wpt/ported/worker/worker-global-surface-basic.html
+++ b/moli-wpt-compat/fixtures/wpt/ported/worker/worker-global-surface-basic.html
@@ -271,7 +271,8 @@ promise_test(async function () {
assert_equals(message.data.uaDataCtorOwn, true, "worker should expose NavigatorUAData");
assert_equals(message.data.uaDataCtorType, "function", "NavigatorUAData type");
assert_equals(message.data.uaDataType, "object", "navigator.userAgentData type");
- assert_equals(message.data.uaDataSameObject, true, "userAgentData should be SameObject");
+ // Each access returns a metadata snapshot; held snapshots retain their values.
+ assert_equals(message.data.uaDataSameObject, false, "userAgentData should return a new snapshot");
assert_equals(
message.data.uaDataInstance,
true,