Skip to content

armgit / moli

Public Imported from GitHub
0

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

21.9 KB
Raw Blame
use anyhow::Result;

use super::document_cookie_diagnostics::{
    DocumentCookieFacadeTelemetrySnapshot, DocumentCookieOwnerSnapshot,
};
use super::protocol_support::{
    EmulatedIdleOverride, EmulatedMediaOverrides, PermissionOverrideRegistration,
    SubresourceResourceType, ViewportSurface,
};
use super::{CompletedPageCommand, Page, PendingDevToolsIoCommandDispatch, PendingPageCommand};
use crate::renderer::{
    RendererPageCommand, RendererPageCookieFacadeSnapshotReply, RendererPageReply,
    RendererRuntimeInspectorResponseSender,
};
use moli_renderer_v8::network::BrowserResourceRuntime;

impl Page {
    pub async fn set_fetch_subresource_interception_async(
        &mut self,
        enabled: bool,
        resource_type: Option<SubresourceResourceType>,
    ) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::SetFetchSubresourceInterception {
                enabled,
                resource_type,
            },
            "set fetch subresource interception",
        )
        .await
    }

    pub fn start_set_fetch_subresource_interception(
        &self,
        enabled: bool,
        resource_type: Option<SubresourceResourceType>,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::SetFetchSubresourceInterception {
            enabled,
            resource_type,
        })
    }

    pub fn finish_set_fetch_subresource_interception(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set fetch subresource interception",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }

    pub fn start_set_javascript_dialog_handler_enabled(
        &self,
        enabled: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::SetJavaScriptDialogHandlerEnabled(
            enabled,
        ))
    }

    pub(crate) async fn replace_browser_resource_runtime_async(
        &mut self,
        resource_runtime: &BrowserResourceRuntime,
    ) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::ReplaceBrowserResourceRuntime {
                resource_runtime: resource_runtime.clone(),
                navigator_identity: resource_runtime.browser_identity().clone(),
            },
            "replace browser resource runtime",
        )
        .await
    }

    pub fn start_replace_browser_resource_runtime(
        &self,
        resource_runtime: &BrowserResourceRuntime,
    ) -> Result<PendingPageCommand> {
        self.start_replace_browser_resource_runtime_with_navigator_identity(
            resource_runtime,
            resource_runtime.browser_identity().clone(),
        )
    }

    pub fn start_replace_browser_resource_runtime_with_navigator_identity(
        &self,
        resource_runtime: &BrowserResourceRuntime,
        navigator_identity: moli_browser_profile::BrowserIdentityProfile,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::ReplaceBrowserResourceRuntime {
            resource_runtime: resource_runtime.clone(),
            navigator_identity,
        })
    }

    pub fn finish_replace_browser_resource_runtime(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "replace browser resource runtime",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }

    pub async fn set_extra_http_headers_async(
        &mut self,
        headers: &moli_fetch::RequestHeaders,
    ) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::SetExtraHttpHeaders(headers.clone()),
            "set extra HTTP headers",
        )
        .await
    }

    pub fn start_set_extra_http_headers(
        &self,
        headers: &moli_fetch::RequestHeaders,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::SetExtraHttpHeaders(headers.clone()))
    }

    pub fn finish_set_extra_http_headers(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set extra HTTP headers",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }

    pub async fn set_network_request_policy_async(
        &mut self,
        extra_http_headers: &moli_fetch::RequestHeaders,
        bypass_service_worker: bool,
        cache_disabled: bool,
        blocked_url_patterns: &[String],
    ) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::SetNetworkRequestPolicy {
                extra_http_headers: extra_http_headers.clone(),
                bypass_service_worker,
                cache_disabled,
                blocked_url_patterns: blocked_url_patterns.to_vec(),
            },
            "set network request policy",
        )
        .await
    }

    pub fn start_set_network_request_policy(
        &self,
        extra_http_headers: &moli_fetch::RequestHeaders,
        bypass_service_worker: bool,
        cache_disabled: bool,
        blocked_url_patterns: &[String],
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::SetNetworkRequestPolicy {
            extra_http_headers: extra_http_headers.clone(),
            bypass_service_worker,
            cache_disabled,
            blocked_url_patterns: blocked_url_patterns.to_vec(),
        })
    }

    pub fn finish_set_network_request_policy(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set network request policy",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }

    pub async fn set_permission_overrides_async(
        &mut self,
        overrides: &[PermissionOverrideRegistration],
    ) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::SetPermissionOverrides(overrides.to_vec()),
            "set permission overrides",
        )
        .await
    }

    pub fn start_set_permission_overrides(
        &self,
        overrides: &[PermissionOverrideRegistration],
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::SetPermissionOverrides(
            overrides.to_vec(),
        ))
    }

    pub fn finish_set_permission_overrides(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set permission overrides",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }

    pub fn start_set_idle_override(
        &mut self,
        idle_override: Option<EmulatedIdleOverride>,
    ) -> Result<PendingPageCommand> {
        let pending =
            self.start_page_command(RendererPageCommand::SetIdleOverride(idle_override))?;
        self.record_admitted_idle_override(idle_override);
        Ok(pending)
    }

    /// Records frame-host state after either a typed or frontend command has
    /// been admitted. It belongs to this Page, not the target's replay policy.
    pub fn record_admitted_idle_override(&mut self, idle_override: Option<EmulatedIdleOverride>) {
        // SetIdleOverride is synchronous browser-side state in Chromium. Make
        // it visible at command admission so a navigation from another CDP
        // session cannot observe an older protocol snapshot after the renderer
        // has already accepted the command.
        self.idle_override = idle_override;
    }

    pub fn finish_set_idle_override(&mut self, completion: CompletedPageCommand) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set idle override",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }

    pub async fn set_script_execution_disabled_async(&mut self, disabled: bool) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::SetScriptExecutionDisabled(disabled),
            "set script execution disabled",
        )
        .await
    }

    /// Admits the DevTools IO-agent setting through the target's shared IO
    /// task FIFO without entering the renderer owner's Main command queue.
    pub fn start_set_script_execution_disabled_from_io(
        &self,
        disabled: bool,
    ) -> PendingDevToolsIoCommandDispatch {
        let route = self
            .handle
            .enqueue_set_script_execution_disabled_io_command(
                self.renderer_agent_attachment_id,
                self.renderer_devtools_command_session_id.clone(),
                disabled,
            );
        Self::pending_devtools_io_command_dispatch(route)
    }

    /// Publishes the terminal Emulation response through the concrete
    /// renderer DevTools session that owns this Page attachment.
    pub fn start_set_script_execution_disabled_from_io_with_response(
        &self,
        inspector_session_id: Option<String>,
        disabled: bool,
        response: RendererRuntimeInspectorResponseSender,
    ) -> Result<PendingDevToolsIoCommandDispatch> {
        let attachment = self.renderer_agent_attachment_id.ok_or_else(|| {
            anyhow::anyhow!("Emulation IO response requires a renderer attachment")
        })?;
        let route = self
            .handle
            .enqueue_set_script_execution_disabled_io_command_with_response(
                attachment,
                inspector_session_id,
                disabled,
                response,
            );
        Ok(Self::pending_devtools_io_command_dispatch(route))
    }

    pub async fn set_bypass_content_security_policy_async(&mut self, bypass: bool) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::SetBypassContentSecurityPolicy(bypass),
            "set bypass content security policy",
        )
        .await
    }

    pub fn start_set_bypass_content_security_policy(
        &self,
        bypass: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::SetBypassContentSecurityPolicy(bypass))
    }

    pub fn finish_set_bypass_content_security_policy(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set bypass content security policy",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }

    /// Updates the DevTools hiding override; the browser startup flag remains effective.
    pub async fn set_scrollbars_hidden_async(&mut self, hidden: bool) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::SetScrollbarsHidden(hidden),
            "set scrollbars hidden",
        )
        .await
    }

    pub fn start_set_scrollbars_hidden(&self, hidden: bool) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::SetScrollbarsHidden(hidden))
    }

    pub fn finish_set_scrollbars_hidden(&mut self, completion: CompletedPageCommand) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set scrollbars hidden",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }

    pub async fn set_emulated_media_async(
        &mut self,
        overrides: &EmulatedMediaOverrides,
    ) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::SetEmulatedMedia(overrides.clone()),
            "set emulated media",
        )
        .await
    }

    pub fn start_set_emulated_media(
        &self,
        overrides: &EmulatedMediaOverrides,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::SetEmulatedMedia(overrides.clone()))
    }

    pub fn finish_set_emulated_media(&mut self, completion: CompletedPageCommand) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set emulated media",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }

    pub async fn set_viewport_surface_async(
        &mut self,
        viewport_surface: Option<ViewportSurface>,
    ) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::SetViewportSurface(viewport_surface),
            "set viewport surface",
        )
        .await
    }

    pub fn start_set_viewport_surface(
        &self,
        viewport_surface: Option<ViewportSurface>,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::SetViewportSurface(viewport_surface))
    }

    pub fn finish_set_viewport_surface(&mut self, completion: CompletedPageCommand) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set viewport surface",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }

    pub(crate) async fn retire_document_resource_authorities_async(&mut self) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::RetireDocumentResourceAuthorities,
            "retire document resource authorities",
        )
        .await
    }

    pub async fn apply_document_cookie_facade_overrides_async(
        &mut self,
        overrides: &moli_cookie_jar::BrowserCookieFacadeOverrides,
    ) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::ApplyDocumentCookieFacadeOverrides(overrides.clone()),
            "apply document cookie facade overrides",
        )
        .await
    }

    pub async fn clear_document_cookie_facade_overrides_async(&mut self) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::ClearDocumentCookieFacadeOverrides,
            "clear document cookie facade overrides",
        )
        .await
    }

    pub async fn document_cookie_telemetry_snapshot_async(
        &mut self,
    ) -> Result<DocumentCookieFacadeTelemetrySnapshot> {
        let reply = self
            .dispatch_page_command_async(RendererPageCommand::DocumentCookieTelemetrySnapshot)
            .await?;
        match reply {
            RendererPageReply::CookieFacadeSnapshot(snapshot) => match *snapshot {
                RendererPageCookieFacadeSnapshotReply::Telemetry(snapshot) => Ok(snapshot.into()),
                other => Page::unexpected_page_reply(
                    "document cookie telemetry page command",
                    "a cookie facade telemetry snapshot reply",
                    RendererPageReply::CookieFacadeSnapshot(Box::new(other)),
                ),
            },
            other => Page::unexpected_page_reply(
                "document cookie telemetry page command",
                "a cookie facade telemetry snapshot reply",
                other,
            ),
        }
    }

    pub async fn document_cookie_owner_snapshot_async(
        &mut self,
    ) -> Result<DocumentCookieOwnerSnapshot> {
        let pending = self.start_document_cookie_owner_snapshot()?;
        self.finish_document_cookie_owner_snapshot(pending.wait().await?)
    }

    pub fn start_document_cookie_owner_snapshot(&self) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentCookieOwnerSnapshot)
    }

    pub fn finish_document_cookie_owner_snapshot(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<DocumentCookieOwnerSnapshot> {
        let reply = self.finish_page_command(completion);
        match reply {
            RendererPageReply::CookieFacadeSnapshot(snapshot) => match *snapshot {
                RendererPageCookieFacadeSnapshotReply::Owner(snapshot) => Ok((*snapshot).into()),
                other => Page::unexpected_page_reply(
                    "document cookie owner page command",
                    "a cookie facade owner snapshot reply",
                    RendererPageReply::CookieFacadeSnapshot(Box::new(other)),
                ),
            },
            other => Page::unexpected_page_reply(
                "document cookie owner page command",
                "a cookie facade owner snapshot reply",
                other,
            ),
        }
    }

    pub async fn set_network_offline_async(&mut self, offline: bool) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::SetNetworkOffline(offline),
            "set network offline",
        )
        .await
    }

    pub async fn set_navigator_overrides_async(
        &mut self,
        overrides: &moli_page_types::NavigatorOverrides,
    ) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::SetNavigatorOverrides(overrides.clone()),
            "set navigator overrides",
        )
        .await
    }

    pub fn start_set_navigator_overrides(
        &self,
        overrides: &moli_page_types::NavigatorOverrides,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::SetNavigatorOverrides(
            overrides.clone(),
        ))
    }

    pub fn finish_set_navigator_overrides(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set navigator overrides",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }

    /// Apply one captured target policy in a single renderer owner turn.
    pub fn start_set_navigator_and_document_activity(
        &self,
        navigator_overrides: moli_page_types::NavigatorOverrides,
        document_activity: moli_page_types::DocumentActivity,
    ) -> Result<PendingPageCommand> {
        let pending =
            self.start_page_command(RendererPageCommand::SetNavigatorAndDocumentActivity {
                navigator_overrides,
                document_activity,
            })?;
        self.requested_document_activity.set(document_activity);
        Ok(pending)
    }

    /// Last activity policy admitted by this Page. It includes queued updates,
    /// so a focus reversal cannot be skipped while its renderer is busy.
    pub fn document_activity(&self) -> moli_page_types::DocumentActivity {
        self.requested_document_activity.get()
    }

    pub async fn set_document_activity_async(
        &mut self,
        activity: moli_page_types::DocumentActivity,
    ) -> Result<()> {
        let pending = self.start_set_document_activity(activity)?;
        self.finish_set_document_activity(pending.wait().await?)
    }

    pub fn start_set_document_activity(
        &self,
        activity: moli_page_types::DocumentActivity,
    ) -> Result<PendingPageCommand> {
        let pending =
            self.start_page_command(RendererPageCommand::SetDocumentActivity(activity))?;
        self.requested_document_activity.set(activity);
        Ok(pending)
    }

    pub fn finish_set_document_activity(&mut self, completion: CompletedPageCommand) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set document activity",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }

    pub fn start_set_network_offline(&self, offline: bool) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::SetNetworkOffline(offline))
    }

    pub fn finish_set_network_offline(&mut self, completion: CompletedPageCommand) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set network offline",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }

    pub async fn set_bypass_service_worker_async(&mut self, bypass: bool) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::SetBypassServiceWorker(bypass),
            "set bypass service worker",
        )
        .await
    }

    pub fn start_set_bypass_service_worker(&self, bypass: bool) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::SetBypassServiceWorker(bypass))
    }

    pub fn finish_set_bypass_service_worker(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set bypass service worker",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }

    pub async fn set_blocked_url_patterns_async(&mut self, patterns: &[String]) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::SetBlockedUrlPatterns(patterns.to_vec()),
            "set blocked URL patterns",
        )
        .await
    }

    pub fn start_set_blocked_url_patterns(
        &self,
        patterns: &[String],
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::SetBlockedUrlPatterns(
            patterns.to_vec(),
        ))
    }

    pub fn finish_set_blocked_url_patterns(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set blocked URL patterns",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }
}