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::automation::{
AutomationCommand, AutomationResult, DevToolsAddNetworkDataCollectorCommand,
DevToolsBrowserContextId, DevToolsError, DevToolsErrorKind,
DevToolsRemoveNetworkDataCollectorCommand, DevToolsSetCacheBehaviorCommand, DevToolsTargetId,
};
use crate::conn::{CdpConnection, Cmd, CommandOwnerScope};
use super::storage::{
CdpCookieParam, DeleteCookiesParams, associated_cookies_to_json, cookie_query_report_to_json,
cookie_set_report_to_json,
};
pub fn http_status_text(status: u16) -> &'static str {
if status == 203 {
return "Non-Authoritative Information";
}
http::StatusCode::from_u16(status)
.ok()
.and_then(|status| status.canonical_reason())
.unwrap_or("")
}
pub fn cdp_cookie_query_report(
report: &moli_cookie_jar::StoredCookieQueryReport,
) -> serde_json::Value {
cookie_query_report_to_json(report)
}
pub fn cdp_request_headers_object(
headers: &[(String, String)],
cookie_access_report: Option<&moli_cookie_jar::StoredCookieQueryReport>,
) -> serde_json::Map<String, serde_json::Value> {
events::request_headers_as_json_object(headers, cookie_access_report)
}
mod activity;
mod agent;
mod backlog;
mod collectors;
mod cookie_context;
mod cookies;
mod events;
mod load_resource;
mod main_document_progress;
mod output;
mod output_queue;
mod response_body;
pub(crate) mod settings;
#[cfg(test)]
mod tests;
/// Removes one session's Network contributions, then applies the newly
/// aggregated target policy before the session disappears.
pub(in crate::domains) async fn dispose_session_policy_async(
conn: &mut CdpConnection,
session_id: &str,
) -> anyhow::Result<()> {
conn.clear_devtools_network_session_policy_async(session_id)
.await
}
use super::actions::NetworkAction;
use super::command_output::CommandOutputPlan;
pub(crate) use activity::NetworkPreparedOutputSlot;
pub(crate) use activity::NetworkPreparedOutputs;
pub(in crate::domains) use activity::{
network_backlog_prepared_outputs_for_owner, project_network_backlog_async,
project_pending_subresource_continue_async, project_renderer_network_live_async,
project_subresource_fetch_interception_async,
};
pub use agent::IoStreamState;
pub(crate) use agent::TargetIoStreamRead;
pub(crate) use agent::{
CapturedRequestBody, CapturedResponseBody, CollectedNetworkDataArtifact,
NetworkBacklogPreferredRequestId, RetiringTargetNetworkAgentState, TargetNetworkAgentState,
};
pub(crate) use backlog::{
NetworkBacklogProjectionContext, emit_pending_network_backlog_activity_background_events,
emit_prepared_renderer_network_live_background_events, record_subresource_request_body,
};
pub(crate) use collectors::NetworkDataCollectorStore;
pub(crate) use cookie_context::navigation_cookie_request_context;
use cookies::{
start_clear_browser_cookies_command, start_delete_cookies_command,
start_get_all_cookies_command, start_get_cookies_command, start_set_cookie_command,
start_set_cookies_command,
};
#[cfg(test)]
pub(crate) use events::emit_cdp_network_automation_event;
pub(crate) use events::{
emit_body_finished, emit_loading_failed, emit_loading_finished, emit_request_will_be_sent,
emit_request_will_be_sent_extra_info, emit_response_received,
emit_response_received_extra_info, emit_response_received_without_extra_info_event,
fetch_subresource_initial_request_network_events, headers_as_json_object,
request_headers_as_json_object,
};
pub use events::{fetch_auth_required_params, fetch_request_paused_params};
#[cfg(test)]
pub(crate) use main_document_progress::FailedNavigationDocumentPolicy;
#[cfg(test)]
pub(crate) use main_document_progress::empty_main_document_progress_gate_for_test;
pub(crate) use main_document_progress::{
CompletedDocumentProgressTransfer, CompletedDownloadProgressTransfer,
CompletedMainDocumentNetworkEvents, FailedNavigationResponseMode,
MainDocumentBodyNetworkProgress, MainDocumentBodyProgressSource,
MainDocumentProgressBackgroundEventBarrier, MainDocumentProgressGate,
MaterializedDownloadDocumentProgress, MaterializedFailedDocumentProgress,
MaterializedLoadedDocumentProgress, MaterializedNavigationLoadOutcome,
emit_child_document_navigation_network_background_events,
emit_fetch_navigation_initial_request_for_pause_background_events,
failed_navigation_progress_gate, materialize_loaded_navigation_progress,
materialize_navigation_failure_preserving_committed_document,
materialize_navigation_load_result, record_completed_main_document_response_body,
record_failed_main_document_response_body, record_main_document_request_body,
response_stage_main_document_navigation_network_progress,
start_observed_main_document_navigation_progress_background_events,
};
pub(crate) use output::{
TargetSubresourceFetchPauseNetworkOutput, TargetSubresourceFetchPauseOutput,
};
pub(crate) use output_queue::{
PendingNetworkBacklogDeliverySnapshot, PendingSubresourceNetworkActivity,
PendingSubresourceNetworkActivitySession, PendingWebSocketNetworkActivity,
PendingWebSocketNetworkActivitySession, TargetNetworkBacklogPreparedDelivery,
TargetNetworkBacklogRequestIdResolver, TargetNetworkOutputQueue, TargetSubresourcePlanOutput,
};
use response_body::{
get_network_data_result, get_request_post_data_command_output_plan,
get_response_body_command_output_plan,
};
use settings::clear_browser_cache_command_output_plan;
pub(crate) struct PendingNetworkCommandDispatch {
command_id: Option<u64>,
owner_scope: CommandOwnerScope,
kind: PendingNetworkCommandKind,
pending: PendingNetworkCommandWork,
}
pub(crate) struct CompletedNetworkCommandDispatch {
command_id: Option<u64>,
owner_scope: CommandOwnerScope,
kind: PendingNetworkCommandKind,
completed: CompletedNetworkCommandWork,
}
enum PendingNetworkCommandWork {
Page {
attachment_id: Option<moli_core::page::RendererAgentAttachmentId>,
pending: moli_core::page::PendingPageCommand,
},
Resource(Box<moli_core::page::RendererPreparedNetworkResourceLoad>),
}
enum CompletedNetworkCommandWork {
Page {
attachment_id: Option<moli_core::page::RendererAgentAttachmentId>,
completed: Result<Box<moli_core::page::CompletedPageCommand>, String>,
},
Resource(moli_core::page::RendererNetworkResourceLoadOutcome),
}
impl PendingNetworkCommandWork {
fn page(pending: moli_core::page::PendingPageCommand) -> Self {
Self::Page {
attachment_id: pending.renderer_agent_attachment_id(),
pending,
}
}
}
pub(crate) enum NetworkCommandTaskStep {
Pending(PendingNetworkCommandDispatch),
Complete(CommandOutputPlan),
}
enum PendingNetworkCommandKind {
Enable,
Disable,
SetCacheDisabled,
SetExtraHttpHeaders,
SetBlockedUrls,
SetBypassServiceWorker,
EmulateNetworkConditions,
SetUserAgentOverride,
PrepareNetworkResourceLoad,
FetchNetworkResource,
}
impl PendingNetworkCommandDispatch {
pub(crate) async fn wait(self) -> CompletedNetworkCommandDispatch {
let completed = match self.pending {
PendingNetworkCommandWork::Page {
attachment_id,
pending,
} => CompletedNetworkCommandWork::Page {
attachment_id,
completed: pending
.wait()
.await
.map(Box::new)
.map_err(|error| error.to_string()),
},
PendingNetworkCommandWork::Resource(pending) => {
CompletedNetworkCommandWork::Resource((*pending).execute().await)
}
};
CompletedNetworkCommandDispatch {
command_id: self.command_id,
owner_scope: self.owner_scope,
kind: self.kind,
completed,
}
}
}
impl CompletedNetworkCommandDispatch {
pub(crate) fn command_id(&self) -> Option<u64> {
self.command_id
}
pub(crate) fn session_id(&self) -> Option<&str> {
self.owner_scope.session_id()
}
}
pub(crate) enum NetworkDomainCommandTaskStep {
Network(NetworkCommandTaskStep),
Storage(crate::domains::storage::StorageCommandTaskStep),
Complete(CommandOutputPlan),
}
pub(crate) fn start_network_domain_command_dispatch(
conn: &mut CdpConnection,
cmd: &Cmd<'_>,
) -> NetworkDomainCommandTaskStep {
let Some(action) = cmd.parse_action::<NetworkAction>() else {
return NetworkDomainCommandTaskStep::Complete(CommandOutputPlan::error(
-32601,
"UnknownMethod",
));
};
match action {
NetworkAction::Enable => NetworkDomainCommandTaskStep::Network(
start_set_network_domain_enabled_command(conn, cmd, true),
),
NetworkAction::Disable => NetworkDomainCommandTaskStep::Network(
start_set_network_domain_enabled_command(conn, cmd, false),
),
NetworkAction::SetCacheDisabled => {
NetworkDomainCommandTaskStep::Network(start_set_cache_disabled_command(conn, cmd))
}
NetworkAction::SetBypassServiceWorker => NetworkDomainCommandTaskStep::Network(
start_set_bypass_service_worker_command(conn, cmd),
),
NetworkAction::SetExtraHttpHeaders => {
NetworkDomainCommandTaskStep::Network(start_set_extra_http_headers_command(conn, cmd))
}
NetworkAction::SetBlockedUrls => {
NetworkDomainCommandTaskStep::Network(start_set_blocked_urls_command(conn, cmd))
}
NetworkAction::EmulateNetworkConditions => NetworkDomainCommandTaskStep::Network(
start_emulate_network_conditions_command(conn, cmd),
),
NetworkAction::SetUserAgentOverride => {
NetworkDomainCommandTaskStep::Network(start_set_user_agent_override_command(conn, cmd))
}
NetworkAction::SetCookie => {
NetworkDomainCommandTaskStep::Storage(start_set_cookie_command(conn, cmd))
}
NetworkAction::SetCookies => {
NetworkDomainCommandTaskStep::Storage(start_set_cookies_command(conn, cmd))
}
NetworkAction::ClearBrowserCache => NetworkDomainCommandTaskStep::Complete(
clear_browser_cache_command_output_plan(conn, cmd),
),
NetworkAction::DeleteCookies => {
NetworkDomainCommandTaskStep::Storage(start_delete_cookies_command(conn, cmd))
}
NetworkAction::ClearBrowserCookies => {
NetworkDomainCommandTaskStep::Storage(start_clear_browser_cookies_command(conn, cmd))
}
NetworkAction::GetCookies => {
NetworkDomainCommandTaskStep::Storage(start_get_cookies_command(conn, cmd))
}
NetworkAction::GetAllCookies => {
NetworkDomainCommandTaskStep::Storage(start_get_all_cookies_command(conn, cmd))
}
NetworkAction::GetResponseBody => {
NetworkDomainCommandTaskStep::Complete(get_response_body_command_output_plan(conn, cmd))
}
NetworkAction::GetRequestPostData => NetworkDomainCommandTaskStep::Complete(
get_request_post_data_command_output_plan(conn, cmd),
),
NetworkAction::LoadNetworkResource => NetworkDomainCommandTaskStep::Network(
load_resource::start_load_network_resource_command(conn, cmd),
),
}
}
pub(crate) fn execute_devtools_network_command(
conn: &mut CdpConnection,
command: AutomationCommand,
) -> Result<AutomationResult, DevToolsError> {
match command {
AutomationCommand::AddNetworkDataCollector(command) => {
add_network_data_collector_result(conn, command)
}
AutomationCommand::RemoveNetworkDataCollector(command) => {
remove_network_data_collector_result(conn, command)
}
AutomationCommand::DisownNetworkData(command) => {
response_body::disown_network_data_result(conn, command)
}
AutomationCommand::GetNetworkData(command) => get_network_data_result(conn, command),
AutomationCommand::SetCacheBehavior(command) => set_cache_behavior_result(conn, command),
_ => Err(DevToolsError::new(
DevToolsErrorKind::Unsupported,
"UnsupportedDevToolsNetworkCommand",
)),
}
}
fn add_network_data_collector_result(
conn: &mut CdpConnection,
mut command: DevToolsAddNetworkDataCollectorCommand,
) -> Result<AutomationResult, DevToolsError> {
command.target_ids = validate_network_data_collector_target_ids(conn, &command.target_ids)?;
command.browser_context_ids =
resolve_network_data_collector_browser_context_ids(conn, &command.browser_context_ids)?;
conn.network_data_collectors.add_collector(command)
}
fn remove_network_data_collector_result(
conn: &mut CdpConnection,
command: DevToolsRemoveNetworkDataCollectorCommand,
) -> Result<AutomationResult, DevToolsError> {
conn.network_data_collectors
.remove_collector(&command.collector_id)?;
Ok(AutomationResult::Empty)
}
fn validate_network_data_collector_target_ids(
conn: &CdpConnection,
target_ids: &[DevToolsTargetId],
) -> Result<Vec<DevToolsTargetId>, DevToolsError> {
let mut out = Vec::new();
for target_id in target_ids {
if conn
.target_session_route_for_target_id(target_id.as_str())
.is_some()
{
out.push(target_id.clone());
continue;
}
if conn.has_attached_child_frame_id(target_id.as_str()) {
return Err(DevToolsError::new(
DevToolsErrorKind::InvalidArgument,
"Data collectors are available only on top-level browsing contexts",
));
}
return Err(DevToolsError::new(
DevToolsErrorKind::NoSuchTarget,
"NoSuchTarget",
));
}
out.sort();
out.dedup();
Ok(out)
}
fn resolve_network_data_collector_browser_context_ids(
conn: &mut CdpConnection,
browser_context_ids: &[DevToolsBrowserContextId],
) -> Result<Vec<DevToolsBrowserContextId>, DevToolsError> {
let mut resolved = Vec::new();
for browser_context_id in browser_context_ids {
let browser_context_id = browser_context_id.as_str();
if browser_context_id == "default" {
let mut default_context_ids = conn
.browser_contexts()
.filter(|context| is_moli_internal_default_user_context(&context.id))
.map(|context| context.id.clone())
.collect::<Vec<_>>();
if default_context_ids.is_empty() {
let id = conn.default_browser_context_id().to_owned();
conn.insert_browser_context(conn.new_browser_context(id.clone()));
default_context_ids.push(id);
}
resolved.extend(
default_context_ids
.into_iter()
.map(DevToolsBrowserContextId::from),
);
continue;
}
if !conn.has_browser_context_id(browser_context_id) {
return Err(DevToolsError::new(
DevToolsErrorKind::NoSuchTarget,
"UnknownBrowserContextId",
));
}
resolved.push(DevToolsBrowserContextId::from(browser_context_id));
}
resolved.sort();
resolved.dedup();
Ok(resolved)
}
fn is_moli_internal_default_user_context(browser_context_id: &str) -> bool {
browser_context_id == "BID-default"
|| browser_context_id
.strip_prefix("BID-")
.is_some_and(|suffix| {
!suffix.is_empty() && suffix.bytes().all(|byte| byte.is_ascii_digit())
})
}
fn set_cache_behavior_result(
conn: &mut CdpConnection,
command: DevToolsSetCacheBehaviorCommand,
) -> Result<AutomationResult, DevToolsError> {
let target_ids = if command.target_ids.is_empty() {
conn.set_global_cache_disabled(command.cache_disabled);
top_level_target_ids(conn)
} else {
validate_top_level_target_ids(conn, &command)?
};
for target_id in target_ids {
if !conn.set_cache_disabled_for_target(&target_id, command.cache_disabled) {
return Err(DevToolsError::new(
DevToolsErrorKind::NoSuchTarget,
"NoSuchTarget",
));
}
}
Ok(AutomationResult::Empty)
}
fn top_level_target_ids(conn: &CdpConnection) -> Vec<String> {
conn.browser_contexts()
.flat_map(|browser_context| {
browser_context
.active_target_id()
.map(str::to_owned)
.into_iter()
.chain(
browser_context
.background_targets()
.map(|target| target.target_id().to_owned()),
)
})
.collect()
}
fn validate_top_level_target_ids(
conn: &CdpConnection,
command: &DevToolsSetCacheBehaviorCommand,
) -> Result<Vec<String>, DevToolsError> {
let mut target_ids = Vec::new();
for target_id in &command.target_ids {
let target_id = target_id.as_str();
if conn.target_session_route_for_target_id(target_id).is_none() {
return Err(DevToolsError::new(
DevToolsErrorKind::NoSuchTarget,
"NoSuchTarget",
));
}
target_ids.push(target_id.to_owned());
}
target_ids.sort();
target_ids.dedup();
Ok(target_ids)
}
fn pending_network_page_command_step(
conn: &mut CdpConnection,
command_id: Option<u64>,
session_id: Option<&str>,
kind: PendingNetworkCommandKind,
start: impl FnOnce(
&mut CdpConnection,
) -> Result<Option<moli_core::page::PendingPageCommand>, String>,
) -> NetworkCommandTaskStep {
let owner_scope = CommandOwnerScope::capture(conn, session_id);
let result = start(conn);
match result {
Ok(Some(pending)) => NetworkCommandTaskStep::Pending(PendingNetworkCommandDispatch {
command_id,
owner_scope,
kind,
pending: PendingNetworkCommandWork::page(pending),
}),
Ok(None) => NetworkCommandTaskStep::Complete(CommandOutputPlan::success()),
Err(message) if message == "BrowserContextNotLoaded" => NetworkCommandTaskStep::Complete(
CommandOutputPlan::error(-31998, "BrowserContextNotLoaded"),
),
Err(message) => NetworkCommandTaskStep::Complete(CommandOutputPlan::error(-32000, message)),
}
}
fn start_set_network_domain_enabled_command(
conn: &mut CdpConnection,
cmd: &Cmd<'_>,
enabled: bool,
) -> NetworkCommandTaskStep {
let updated = if enabled {
conn.enable_network_listener_for_session_owner(cmd.session_id)
} else {
conn.disable_network_listener_for_session_owner(cmd.session_id)
};
if !updated {
return NetworkCommandTaskStep::Complete(CommandOutputPlan::error(
-31998,
"BrowserContextNotLoaded",
));
}
let kind = if enabled {
PendingNetworkCommandKind::Enable
} else {
PendingNetworkCommandKind::Disable
};
let owner_scope = CommandOwnerScope::capture(conn, cmd.session_id);
match conn.start_replay_effective_network_request_policy_for_session_owner(cmd.session_id) {
Ok(Some(pending)) => NetworkCommandTaskStep::Pending(PendingNetworkCommandDispatch {
command_id: cmd.id,
owner_scope,
kind,
pending: PendingNetworkCommandWork::page(pending),
}),
Ok(None) => NetworkCommandTaskStep::Complete(if enabled {
settings::enabled_command_output_plan(conn, cmd.session_id)
} else {
CommandOutputPlan::success()
}),
Err(error) => NetworkCommandTaskStep::Complete(CommandOutputPlan::error(-32000, error)),
}
}
fn start_set_extra_http_headers_command(
conn: &mut CdpConnection,
cmd: &Cmd<'_>,
) -> NetworkCommandTaskStep {
let headers = match settings::extra_http_headers_for_command(cmd) {
Ok(headers) => headers,
Err(plan) => return NetworkCommandTaskStep::Complete(plan),
};
pending_network_page_command_step(
conn,
cmd.id,
cmd.session_id,
PendingNetworkCommandKind::SetExtraHttpHeaders,
|conn| conn.start_set_extra_http_headers_for_session_owner(cmd.session_id, headers),
)
}
fn start_set_cache_disabled_command(
conn: &mut CdpConnection,
cmd: &Cmd<'_>,
) -> NetworkCommandTaskStep {
let cache_disabled = match settings::cache_disabled_for_command(cmd) {
Ok(cache_disabled) => cache_disabled,
Err(plan) => return NetworkCommandTaskStep::Complete(plan),
};
pending_network_page_command_step(
conn,
cmd.id,
cmd.session_id,
PendingNetworkCommandKind::SetCacheDisabled,
|conn| conn.start_set_cache_disabled_for_session_owner(cmd.session_id, cache_disabled),
)
}
fn start_set_blocked_urls_command(
conn: &mut CdpConnection,
cmd: &Cmd<'_>,
) -> NetworkCommandTaskStep {
let patterns = match settings::blocked_urls_for_command(cmd) {
Ok(patterns) => patterns,
Err(plan) => return NetworkCommandTaskStep::Complete(plan),
};
pending_network_page_command_step(
conn,
cmd.id,
cmd.session_id,
PendingNetworkCommandKind::SetBlockedUrls,
|conn| conn.start_set_blocked_url_patterns_for_session_owner(cmd.session_id, patterns),
)
}
fn start_set_bypass_service_worker_command(
conn: &mut CdpConnection,
cmd: &Cmd<'_>,
) -> NetworkCommandTaskStep {
let bypass = match settings::bypass_service_worker_for_command(cmd) {
Ok(bypass) => bypass,
Err(plan) => return NetworkCommandTaskStep::Complete(plan),
};
pending_network_page_command_step(
conn,
cmd.id,
cmd.session_id,
PendingNetworkCommandKind::SetBypassServiceWorker,
|conn| conn.start_set_bypass_service_worker_for_session_owner(cmd.session_id, bypass),
)
}
fn start_emulate_network_conditions_command(
conn: &mut CdpConnection,
cmd: &Cmd<'_>,
) -> NetworkCommandTaskStep {
let offline = match settings::network_offline_for_emulation_command(cmd) {
Ok(offline) => offline,
Err(plan) => return NetworkCommandTaskStep::Complete(plan),
};
pending_network_page_command_step(
conn,
cmd.id,
cmd.session_id,
PendingNetworkCommandKind::EmulateNetworkConditions,
|conn| conn.start_set_network_offline_for_session_owner(cmd.session_id, offline),
)
}
fn start_set_user_agent_override_command(
conn: &mut CdpConnection,
cmd: &Cmd<'_>,
) -> NetworkCommandTaskStep {
let base_identity = conn.base_browser_identity().clone();
let browser_identity = match settings::user_agent_override_for_command(cmd, &base_identity) {
Ok(browser_identity) => browser_identity,
Err(plan) => return NetworkCommandTaskStep::Complete(plan),
};
pending_network_page_command_step(
conn,
cmd.id,
cmd.session_id,
PendingNetworkCommandKind::SetUserAgentOverride,
|conn| {
conn.start_set_devtools_browser_identity_override_for_session_owner(
cmd.session_id,
browser_identity,
)
},
)
}
pub(crate) fn complete_pending_network_command(
conn: &mut CdpConnection,
completed: CompletedNetworkCommandDispatch,
) -> NetworkCommandTaskStep {
match completed.kind {
PendingNetworkCommandKind::Enable => {
NetworkCommandTaskStep::Complete(complete_network_policy_refresh(conn, completed, true))
}
PendingNetworkCommandKind::Disable => NetworkCommandTaskStep::Complete(
complete_network_policy_refresh(conn, completed, false),
),
PendingNetworkCommandKind::SetCacheDisabled => NetworkCommandTaskStep::Complete(
complete_network_policy_refresh(conn, completed, false),
),
PendingNetworkCommandKind::SetExtraHttpHeaders => {
NetworkCommandTaskStep::Complete(complete_unit_page_network_command(
conn,
completed,
NetworkPageCommandFinish::ExtraHttpHeaders,
))
}
PendingNetworkCommandKind::SetBlockedUrls => {
NetworkCommandTaskStep::Complete(complete_unit_page_network_command(
conn,
completed,
NetworkPageCommandFinish::BlockedUrls,
))
}
PendingNetworkCommandKind::SetBypassServiceWorker => {
NetworkCommandTaskStep::Complete(complete_unit_page_network_command(
conn,
completed,
NetworkPageCommandFinish::BypassServiceWorker,
))
}
PendingNetworkCommandKind::EmulateNetworkConditions => {
NetworkCommandTaskStep::Complete(complete_unit_page_network_command(
conn,
completed,
NetworkPageCommandFinish::NetworkOffline,
))
}
PendingNetworkCommandKind::SetUserAgentOverride => NetworkCommandTaskStep::Complete(
complete_rebuild_loader_network_command(conn, completed),
),
PendingNetworkCommandKind::PrepareNetworkResourceLoad => {
load_resource::complete_network_resource_preparation(conn, completed)
}
PendingNetworkCommandKind::FetchNetworkResource => NetworkCommandTaskStep::Complete(
load_resource::complete_network_resource_fetch(conn, completed),
),
}
}
#[derive(Clone, Copy)]
enum NetworkPageCommandFinish {
RequestPolicy,
ExtraHttpHeaders,
BlockedUrls,
BypassServiceWorker,
NetworkOffline,
}
fn complete_network_policy_refresh(
conn: &mut CdpConnection,
completed: CompletedNetworkCommandDispatch,
enabled: bool,
) -> CommandOutputPlan {
let owner_scope = completed.owner_scope.clone();
let session_id = owner_scope.session_id().map(str::to_owned);
let completion = match completed.completed {
CompletedNetworkCommandWork::Page {
completed: Ok(completion),
..
} => *completion,
CompletedNetworkCommandWork::Page {
attachment_id,
completed: Err(error),
} => {
if network_page_configuration_will_be_replayed(conn, &owner_scope, attachment_id) {
return if enabled {
settings::enabled_command_output_plan(conn, session_id.as_deref())
} else {
CommandOutputPlan::success()
};
}
return CommandOutputPlan::error(-32000, error);
}
CompletedNetworkCommandWork::Resource(_) => {
return CommandOutputPlan::error(-32000, "InvalidNetworkCommandCompletion");
}
};
if let Err(error) = finish_network_page_operation_on_current_attachment(
conn.loaded_page_mut_for_owner(&owner_scope),
NetworkPageCommandFinish::RequestPolicy,
completion,
) {
return CommandOutputPlan::error(-32000, error);
}
if enabled {
settings::enabled_command_output_plan(conn, owner_scope.session_id())
} else {
CommandOutputPlan::success()
}
}
fn complete_unit_page_network_command(
conn: &mut CdpConnection,
completed: CompletedNetworkCommandDispatch,
finish: NetworkPageCommandFinish,
) -> CommandOutputPlan {
let owner_scope = completed.owner_scope.clone();
let completion = match completed.completed {
CompletedNetworkCommandWork::Page {
completed: Ok(completion),
..
} => *completion,
CompletedNetworkCommandWork::Page {
attachment_id,
completed: Err(error),
} => {
if network_page_configuration_will_be_replayed(conn, &owner_scope, attachment_id) {
return CommandOutputPlan::success();
}
return CommandOutputPlan::error(-32000, error);
}
CompletedNetworkCommandWork::Resource(_) => {
return CommandOutputPlan::error(-32000, "InvalidNetworkCommandCompletion");
}
};
match finish_network_page_operation_on_current_attachment(
conn.loaded_page_mut_for_owner(&owner_scope),
finish,
completion,
) {
Ok(()) => CommandOutputPlan::success(),
Err(error) => CommandOutputPlan::error(-32000, error),
}
}
fn finish_network_page_operation_on_current_attachment(
page: Option<&mut moli_core::page::Page>,
finish: NetworkPageCommandFinish,
completion: moli_core::page::CompletedPageCommand,
) -> Result<(), String> {
let completion_attachment = completion.renderer_agent_attachment_id();
if let Some(page) = page
&& page.renderer_agent_attachment_id() == completion_attachment
{
let result = match finish {
NetworkPageCommandFinish::RequestPolicy => {
page.finish_set_network_request_policy(completion)
}
NetworkPageCommandFinish::ExtraHttpHeaders => {
page.finish_set_extra_http_headers(completion)
}
NetworkPageCommandFinish::BlockedUrls => {
page.finish_set_blocked_url_patterns(completion)
}
NetworkPageCommandFinish::BypassServiceWorker => {
page.finish_set_bypass_service_worker(completion)
}
NetworkPageCommandFinish::NetworkOffline => page.finish_set_network_offline(completion),
};
return result.map_err(|error| error.to_string());
}
// Target/session policy was committed before renderer dispatch. If a
// navigation installs another attachment before this frozen unit reply is
// decoded, consume the old turn without applying its PageState snapshot
// to the replacement. Prepared-document commit configuration carries the
// authoritative policy into that replacement.
completion
.into_unit_page_command_turn()
.map(drop)
.map_err(|error| format!("stale Network command returned an unexpected reply: {error}"))
}
fn complete_rebuild_loader_network_command(
conn: &mut CdpConnection,
completed: CompletedNetworkCommandDispatch,
) -> CommandOutputPlan {
let owner_scope = completed.owner_scope.clone();
let completion = match completed.completed {
CompletedNetworkCommandWork::Page {
completed: Ok(completion),
..
} => *completion,
CompletedNetworkCommandWork::Page {
attachment_id,
completed: Err(error),
} => {
if network_page_configuration_will_be_replayed(conn, &owner_scope, attachment_id) {
return CommandOutputPlan::success();
}
return CommandOutputPlan::error(-32000, error);
}
CompletedNetworkCommandWork::Resource(_) => {
return CommandOutputPlan::error(-32000, "InvalidNetworkCommandCompletion");
}
};
match conn.finish_rebuild_resource_runtime_for_owner(&owner_scope, completion) {
Ok(()) => CommandOutputPlan::success(),
Err(error) => CommandOutputPlan::error(-32000, error),
}
}
fn network_page_configuration_will_be_replayed(
conn: &mut CdpConnection,
owner_scope: &CommandOwnerScope,
dispatched_attachment: Option<moli_core::page::RendererAgentAttachmentId>,
) -> bool {
let Some(dispatched_attachment) = dispatched_attachment else {
return false;
};
let owner_still_exists = conn.target_owner_identity_for_owner(owner_scope).is_some();
let current_attachment = conn
.loaded_page_mut_for_owner(owner_scope)
.and_then(|page| page.renderer_agent_attachment_id());
owner_still_exists && current_attachment != Some(dispatched_attachment)
}
#[cfg(test)]
mod status_text_tests {
use super::http_status_text;
#[test]
fn status_text_uses_hyphenated_standard_phrase_for_203() {
assert_eq!(http_status_text(203), "Non-Authoritative Information");
}
}