Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
use crate::content_security_policy::ContentSecurityPolicy;
use super::*;
pub(crate) struct ScriptVmCapturedDocumentEnvironment {
environment: Option<ScriptVmInitialDocumentEnvironment>,
isolate: RendererDocumentIsolateHandle,
}
impl ScriptVmInitialDocumentEnvironment {
pub(crate) fn origin(&self) -> &str {
&self.origin
}
}
impl ScriptVmCapturedDocumentEnvironment {
pub(crate) fn origin(&self) -> &str {
&self
.environment
.as_ref()
.expect("captured environment has not been consumed")
.origin
}
pub(super) fn new(
environment: ScriptVmInitialDocumentEnvironment,
isolate: RendererDocumentIsolateHandle,
) -> Self {
Self {
environment: Some(environment),
isolate,
}
}
pub(crate) fn take(
mut self,
isolate_identity: usize,
) -> Result<ScriptVmInitialDocumentEnvironment> {
anyhow::ensure!(
self.isolate.identity_key() == isolate_identity,
"inherited V8 security token belongs to another isolate"
);
Ok(self
.environment
.take()
.expect("captured environment is consumed once"))
}
}
impl Drop for ScriptVmCapturedDocumentEnvironment {
fn drop(&mut self) {
if let Some(environment) = self.environment.take() {
// Reuse the existing entered-isolate release queue, including when
// a navigation is cancelled while this isolate is in a pause loop.
self.isolate
.deferred_context_host_release_queue()
.defer_v8_handle_state(vec![Box::new(environment)]);
}
}
}
impl ScriptVmInitialDocumentEnvironment {
pub(crate) fn inherited_in_scope(
scope: &mut v8::PinScope<'_, '_>,
opener: v8::Local<'_, v8::Object>,
origin: String,
storage_key: moli_storage_key::MoliStorageKey,
base_url: url::Url,
policy_container: crate::document_runtime::DocumentPolicyContainer,
) -> Result<Self> {
let context = opener
.get_creation_context(scope)
.ok_or_else(|| anyhow!("navigation initiator has no live creation context"))?;
let security_token = (!policy_container.sandbox.forces_opaque_origin)
.then(|| v8::Global::new(scope, context.get_security_token(scope)));
let document_domain_override = (!policy_container.sandbox.forces_opaque_origin)
.then(|| crate::util::context_host_ptr_from_context_slot(context))
.flatten()
.map(|host_ptr| {
let host = unsafe { &*host_ptr };
let child = host
.window_execution_context_identity_for_access_check(context)
.and_then(|identity| match identity.dispatch_scope() {
crate::native_bridge::OwnerDispatchScope::Child(handle) => Some(handle),
_ => None,
});
host.inherited_document_domain(child)
})
.unwrap_or_default();
Ok(Self {
security_token,
document_domain_override,
origin,
policy_container,
fallback_base_url: Some(base_url),
storage_key: Some(storage_key),
})
}
}
impl ScriptVm {
pub(crate) fn set_extra_http_headers(&mut self, headers: &moli_fetch::RequestHeaders) {
self._context_host
.borrow_mut()
.set_extra_http_headers(headers);
}
pub(crate) fn set_main_navigation_policy_container(
&mut self,
policy: crate::document_runtime::DocumentPolicyContainer,
) {
let was_opaque = self
.document_runtime
.document_sandbox_policy()
.forces_opaque_origin;
self.document_runtime
.set_main_navigation_policy_container(policy);
// The main context exists before its navigation response policy is applied.
// Refresh its token so a CSP sandbox cannot retain the URL's tuple token.
let _ = self.with_default_context_scope(|scope, host_ptr| {
let key = unsafe { &*host_ptr }.main_default_world_security_token_key();
let context = scope.get_current_context();
if !crate::native_bridge::set_window_security_token(scope, context, key.as_deref()) {
tracing::warn!(
"failed to refresh main Window security token; using unique context token"
);
}
let host = unsafe { &*host_ptr };
let is_opaque = host.document_sandbox_policy().forces_opaque_origin;
if was_opaque != is_opaque {
let origin = if is_opaque {
"null".into()
} else {
moli_url::origin_ascii_serialization(host.document_url())
};
crate::context_bootstrap::set_window_origin_runtime_state(
scope,
context.global(scope),
&origin,
)?;
}
Ok(())
});
}
pub(crate) fn document_content_security_policies(&self) -> Vec<ContentSecurityPolicy> {
self._context_host
.borrow()
.document_content_security_policies()
.to_vec()
}
pub(crate) fn set_stored_document_start_scripts(&mut self, scripts: &[DocumentStartScript]) {
self._context_host
.borrow_mut()
.set_stored_document_start_scripts(scripts);
}
pub(crate) fn set_stored_runtime_bindings(
&mut self,
bindings: &[crate::protocol_types::RuntimeBindingRegistration],
) {
self._context_host
.borrow_mut()
.set_stored_runtime_bindings(bindings);
}
pub(crate) fn set_inspector_session_runtime_bindings(
&mut self,
inspector_session_id: Option<&str>,
bindings: &[crate::protocol_types::RuntimeBindingRegistration],
) {
self.page_inspector
.set_runtime_bindings_for_session(inspector_session_id, bindings);
}
pub(crate) fn inspector_session_runtime_bindings(
&self,
inspector_session_id: Option<&str>,
) -> Vec<crate::protocol_types::RuntimeBindingRegistration> {
self.page_inspector
.runtime_bindings_for_session(inspector_session_id)
}
pub(crate) fn detach_runtime_inspector_session(
&mut self,
inspector_session_id: Option<&str>,
) -> bool {
self._context_host
.borrow_mut()
.remove_dom_debugger_session(inspector_session_id);
let devtools_session = DevToolsSessionKey::from_wire_session_id(
inspector_session_id.filter(|session_id| !session_id.is_empty()),
);
let detached = self.page_inspector.detach_session(inspector_session_id);
self._context_host
.borrow_mut()
.native_bridge_mut()
.web_mcp
.disable_session(&devtools_session);
let retired_worlds = self.retire_isolated_worlds_for_devtools_session(&devtools_session);
detached || retired_worlds != 0
}
pub(crate) fn set_permission_overrides(
&mut self,
overrides: &[crate::protocol_types::PermissionOverrideRegistration],
) {
self._context_host
.borrow_mut()
.set_permission_overrides(overrides);
}
pub(crate) fn set_emulated_media(
&mut self,
overrides: &crate::protocol_types::EmulatedMediaOverrides,
) {
{
let mut host = self._context_host.borrow_mut();
if host.emulated_media() == overrides {
return;
}
host.queue_environment_change();
host.set_emulated_media(overrides);
}
self.sync_document_fonts_for_environment();
}
pub(crate) fn set_emulated_media_for_bootstrap(
&mut self,
overrides: &crate::protocol_types::EmulatedMediaOverrides,
) {
self._context_host
.borrow_mut()
.set_emulated_media(overrides);
}
pub(crate) fn set_idle_override(
&mut self,
idle_override: Option<crate::protocol_types::EmulatedIdleOverride>,
) {
self._context_host
.borrow_mut()
.set_idle_override(idle_override);
}
pub(crate) fn set_idle_override_and_sync_surface(
&mut self,
idle_override: Option<crate::protocol_types::EmulatedIdleOverride>,
) -> Result<()> {
self.set_idle_override(idle_override);
let context_ptr: *const v8::Global<v8::Context> = &self.page_default_runtime.context;
self.with_context_scope_by_ptr(context_ptr, |scope, _| {
crate::context_bootstrap::apply_idle_override_to_current_context(scope, idle_override);
Ok(())
})
}
pub(crate) fn stylesheet_preload_media_matches(&self, media: Option<&str>) -> bool {
let Some(media) = media.map(str::trim).filter(|media| !media.is_empty()) else {
return true;
};
let host = self._context_host.borrow();
crate::style_engine::media_list::evaluate_media_query_list(
media,
Some(host.emulated_media()),
host.style_viewport(),
)
}
pub(crate) fn fetch_subresource_interception_matches(
&self,
resource_type: crate::types::SubresourceResourceType,
) -> bool {
let host = self._context_host.borrow();
host.fetch_subresource_interception_enabled()
&& host
.fetch_subresource_interception_resource_type()
.is_none_or(|intercepted| intercepted == resource_type)
}
pub(crate) fn set_viewport_surface(
&mut self,
viewport_surface: Option<crate::protocol_types::ViewportSurface>,
) -> Result<()> {
{
let mut host = self._context_host.borrow_mut();
if host.viewport_surface() == viewport_surface {
return Ok(());
}
host.queue_environment_change();
host.set_viewport_surface(viewport_surface);
}
self.sync_document_fonts_for_environment();
Ok(())
}
/// Seeds the initial viewport before document-start scripts can materialize
/// Window surfaces or register media-query listeners.
pub(crate) fn set_viewport_surface_for_bootstrap(
&mut self,
viewport_surface: Option<crate::protocol_types::ViewportSurface>,
) {
self._context_host
.borrow_mut()
.set_viewport_surface(viewport_surface);
}
pub(crate) fn set_document_activity(
&mut self,
activity: moli_page_types::DocumentActivity,
) -> Result<()> {
let mut host = self._context_host.borrow_mut();
if host.document_activity() != activity {
host.queue_environment_change();
host.set_document_activity(activity);
}
Ok(())
}
pub(crate) fn set_document_activity_for_bootstrap(
&mut self,
activity: moli_page_types::DocumentActivity,
) {
self._context_host
.borrow_mut()
.set_document_activity(activity);
}
pub(crate) fn set_layout_policy(&mut self, policy: moli_page_types::LayoutPolicy) {
self._context_host.borrow_mut().set_layout_policy(policy);
}
pub(crate) fn set_scrollbars_hidden(&mut self, hidden: bool) -> bool {
self._context_host
.borrow_mut()
.set_scrollbars_hidden(hidden)
}
pub(super) fn sync_document_fonts_for_environment(&mut self) {
self.renderer_document_isolate
.with_renderer_document_isolate_mut(|isolate| {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let context = v8::Local::new(scope, &self.page_default_runtime.context);
let scope = &mut v8::ContextScope::new(scope, context);
let host = self._context_host.borrow();
for document in host.documents_with_adopted_style_sheets() {
crate::native_bridge::document::sync_document_fonts_for_handle(
scope, &host, document,
);
}
});
}
pub(crate) fn set_network_offline(&mut self, offline: bool) {
self._context_host.borrow_mut().set_network_offline(offline);
}
pub(crate) fn set_navigator_overrides(
&mut self,
overrides: &moli_page_types::NavigatorOverrides,
) {
self._context_host
.borrow_mut()
.set_navigator_overrides(overrides);
}
pub(crate) fn set_navigator_overrides_and_sync_surface(
&mut self,
overrides: &moli_page_types::NavigatorOverrides,
) -> Result<()> {
let changed = self
._context_host
.borrow_mut()
.set_navigator_overrides(overrides);
if changed {
let context_ptr: *const v8::Global<v8::Context> = &self.page_default_runtime.context;
self.with_context_scope_by_ptr(context_ptr, |scope, _| {
crate::context_bootstrap::notify_geolocation_override_changed(scope);
Ok(())
})?;
}
Ok(())
}
pub(crate) fn set_bypass_service_worker(&mut self, bypass: bool) {
self._context_host
.borrow_mut()
.set_bypass_service_worker(bypass);
}
pub(crate) fn set_cache_disabled(&mut self, disabled: bool) {
self._context_host.borrow_mut().set_cache_disabled(disabled);
}
pub(crate) fn set_blocked_url_patterns(&mut self, patterns: &[String]) {
self._context_host
.borrow_mut()
.set_blocked_url_patterns(patterns);
}
pub(crate) fn set_fetch_subresource_interception(
&mut self,
enabled: bool,
resource_type: Option<SubresourceResourceType>,
) {
self._context_host
.borrow_mut()
.set_fetch_subresource_interception(enabled, resource_type);
}
}
impl ScriptVm {
pub(crate) fn capture_about_blank_reload_environment(
&mut self,
preserve_navigation_referrer: bool,
) -> Result<ScriptVmInitialDocumentEnvironment> {
self.with_default_context_scope(|scope, host_ptr| {
let host = unsafe { &mut *host_ptr };
let origin = host
.current_main_document_resource_loader()
.expect("a live Document has a resource authority")
.fetch_context()
.origin()
.to_owned();
let fallback_base_url = if preserve_navigation_referrer {
host.dom_host()
.node(host.document_handle())
.and_then(|node| node.as_document())
.map(|document| document.fallback_base_url().clone())
} else {
Some(host.document_base_url_for_handle(host.document_handle()))
};
let mut policy_container = host.document_policy_container().clone();
let source = if preserve_navigation_referrer {
url::Url::parse(&policy_container.document_referrer).ok()
} else {
Some(host.document_url().clone())
};
policy_container.document_referrer = source
.as_ref()
.and_then(|source| {
moli_fetch::referrer_value(
source,
host.document_url(),
None,
policy_container.referrer_policy.as_deref(),
)
})
.unwrap_or_default();
let token = scope.get_current_context().get_security_token(scope);
Ok(ScriptVmInitialDocumentEnvironment {
security_token: Some(v8::Global::new(scope, token)),
document_domain_override: host.inherited_document_domain(None),
origin,
policy_container,
fallback_base_url,
storage_key: Some(host.top_web_storage_scope().storage_key().clone()),
})
})
}
}