Skip to content

armgit / moli

Public Imported from GitHub
0

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

25.1 KB
Raw Blame
use super::devtools_session::DevToolsNetworkSessionState;
use super::javascript_dialog::TargetJavaScriptDialogState;
use super::page_target_host::PageTargetHost;
use crate::domains::audits_output_state::TargetAuditsSessionState;
use moli_core::page::V8InspectorSessionState;

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub(crate) enum PerformanceTimeDomain {
    #[default]
    TimeTicks,
    ThreadTicks,
}

impl PerformanceTimeDomain {
    pub(crate) fn as_str(self) -> &'static str {
        match self {
            Self::TimeTicks => "timeTicks",
            Self::ThreadTicks => "threadTicks",
        }
    }
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub(crate) struct TargetPerformanceSessionState {
    enabled: bool,
    time_domain: PerformanceTimeDomain,
}

impl TargetPerformanceSessionState {
    pub(crate) fn enabled(self) -> bool {
        self.enabled
    }

    pub(crate) fn time_domain(self) -> PerformanceTimeDomain {
        self.time_domain
    }

    pub(crate) fn enable(&mut self, time_domain: PerformanceTimeDomain) -> bool {
        if self.enabled && self.time_domain != time_domain {
            return false;
        }
        self.time_domain = time_domain;
        self.enabled = true;
        true
    }

    pub(crate) fn disable(&mut self) {
        self.enabled = false;
    }

    pub(crate) fn set_time_domain(&mut self, time_domain: PerformanceTimeDomain) -> bool {
        if self.enabled {
            return false;
        }
        self.time_domain = time_domain;
        true
    }
}

impl PageTargetHost {
    pub(crate) fn effective_user_agent_override(&self) -> Option<&str> {
        self.devtools_sessions
            .effective_user_agent_override()
            .or_else(|| {
                self.network_policy
                    .base_browser_identity
                    .profile()
                    .map(moli_browser_profile::BrowserIdentityProfile::user_agent)
            })
    }

    pub(crate) fn effective_policy(&self) -> EffectiveTargetPolicy {
        let devtools_network = self.devtools_sessions.effective_network_policy();
        let mut extra_headers = self.network_policy.base_extra_headers.clone();
        overlay_extra_headers(&mut extra_headers, &devtools_network.extra_headers);
        EffectiveTargetPolicy {
            cache_disabled: self.network_policy.base_cache_disabled
                || devtools_network.cache_disabled,
            bypass_service_worker: devtools_network.bypass_service_worker,
            blocked_url_patterns: devtools_network.blocked_url_patterns,
            extra_headers,
            browser_identity_override: self
                .devtools_sessions
                .effective_network_browser_identity_override()
                .or_else(|| self.network_policy.base_browser_identity.profile_owned()),
            renderer_browser_identity_override: self
                .devtools_sessions
                .effective_renderer_browser_identity_override()
                .or_else(|| self.network_policy.base_browser_identity.profile_owned()),
        }
    }

    pub(crate) fn effective_renderer_browser_identity_override_owned(
        &self,
    ) -> Option<moli_browser_profile::BrowserIdentityProfile> {
        self.effective_policy()
            .renderer_browser_identity_override_owned()
    }

    pub(crate) fn mutate_devtools_network_session_state<T>(
        &mut self,
        session_key: &moli_page_types::DevToolsSessionKey,
        f: impl FnOnce(&mut DevToolsNetworkSessionState) -> T,
    ) -> T {
        let session = self.devtools_sessions.ensure_session(session_key);
        f(&mut session.network_session_state)
    }

    pub(crate) fn set_devtools_browser_identity_override(
        &mut self,
        session_key: &moli_page_types::DevToolsSessionKey,
        browser_identity_override: Option<super::DevToolsBrowserIdentityOverride>,
    ) {
        self.devtools_sessions
            .set_browser_identity_override(session_key, browser_identity_override);
    }

    pub(crate) fn set_devtools_locale_override(
        &mut self,
        session_key: &moli_page_types::DevToolsSessionKey,
        locale_override: Option<String>,
    ) -> Result<(), &'static str> {
        self.devtools_sessions
            .set_locale_override(session_key, locale_override)
    }

    pub(crate) fn set_devtools_timezone_override(
        &mut self,
        session_key: &moli_page_types::DevToolsSessionKey,
        timezone_override: Option<String>,
    ) -> Result<(), &'static str> {
        self.devtools_sessions
            .set_timezone_override(session_key, timezone_override)
    }

    pub(crate) fn set_base_locale_override(
        &mut self,
        locale_override: Option<String>,
    ) -> Result<(), &'static str> {
        self.environment_owner
            .set_locale(locale_override.as_deref())
    }

    pub(crate) fn set_base_timezone_override(
        &mut self,
        timezone_override: Option<String>,
    ) -> Result<(), &'static str> {
        self.environment_owner
            .set_timezone(timezone_override.as_deref())
    }

    pub(crate) fn clear_devtools_network_state(
        &mut self,
        session_key: &moli_page_types::DevToolsSessionKey,
    ) {
        self.devtools_sessions.clear_network_state(session_key);
    }

    pub(crate) fn clear_devtools_emulation_policy_state(
        &mut self,
        session_key: &moli_page_types::DevToolsSessionKey,
    ) {
        self.devtools_sessions
            .clear_emulation_policy_state(session_key);
    }

    pub(crate) fn has_pending_javascript_dialog(&self) -> bool {
        self.devtools_sessions.states().any(|session| {
            !session
                .page_session_state
                .javascript_dialog_state
                .is_empty()
        })
    }

    pub(crate) fn has_non_default_session_state(&self) -> bool {
        self.devtools_sessions.has_non_default_state()
            || self.runtime_slot.primary_network_events_enabled()
            || self.network_policy != TargetNetworkPolicyState::default()
            || self.http_proxy_override.is_some()
            || self.http_no_proxy_override.is_some()
            || self.tls_verify_host_override.is_some()
            || self.environment_owner.has_override()
            || self.effective_emulation_state != super::EffectiveTargetEmulationState::default()
            || self.input_intercept_drags_enabled
            || self.input_drag_intercepted
            || self.css_enabled
            || self.fetch_owner.config_snapshot() != super::fetch::TargetFetchConfig::default()
    }

    /// Clears target-level state owned by the primary DevTools handlers.
    ///
    /// Per-session handler state, Fetch state, and Network observation state
    /// have their own disposal steps. Keeping them out of this helper makes
    /// the final session-registry removal a pure commit operation.
    pub(crate) fn reset_primary_session_target_state_fields(&mut self) {
        self.network_policy.clear_session_scoped_state();
        self.http_proxy_override = None;
        self.http_no_proxy_override = None;
        self.tls_verify_host_override = None;
        self.input_intercept_drags_enabled = false;
        self.input_drag_intercepted = false;
        self.css_enabled = false;
    }
}

fn overlay_extra_headers(
    effective: &mut moli_fetch::RequestHeaders,
    layer: &moli_fetch::RequestHeaders,
) {
    for (name, value) in layer {
        effective.retain(|(existing, _)| !existing.eq_ignore_ascii_case(name));
        effective.push((name.clone(), value.clone()));
    }
}

/// Immutable policy derived from target-owned base state and every attached
/// DevTools session. It is deliberately not stored on `PageTargetHost`: the
/// session registry remains the only source of truth.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub(crate) struct EffectiveTargetPolicy {
    cache_disabled: bool,
    bypass_service_worker: bool,
    blocked_url_patterns: Vec<String>,
    extra_headers: moli_fetch::RequestHeaders,
    browser_identity_override: Option<moli_browser_profile::BrowserIdentityProfile>,
    renderer_browser_identity_override: Option<moli_browser_profile::BrowserIdentityProfile>,
}

impl EffectiveTargetPolicy {
    pub(crate) fn delta(&self, next: &Self) -> EffectiveTargetPolicyDelta {
        EffectiveTargetPolicyDelta {
            network_request: self.cache_disabled != next.cache_disabled
                || self.bypass_service_worker != next.bypass_service_worker
                || self.blocked_url_patterns != next.blocked_url_patterns
                || self.extra_headers != next.extra_headers,
            browser_identity: self.browser_identity_override != next.browser_identity_override,
            renderer_browser_identity: self.renderer_browser_identity_override
                != next.renderer_browser_identity_override,
        }
    }

    pub(crate) fn cache_disabled(&self) -> bool {
        self.cache_disabled
    }

    pub(crate) fn bypass_service_worker(&self) -> bool {
        self.bypass_service_worker
    }

    pub(crate) fn blocked_url_patterns(&self) -> &[String] {
        &self.blocked_url_patterns
    }

    pub(crate) fn extra_headers(&self) -> &moli_fetch::RequestHeaders {
        &self.extra_headers
    }

    pub(crate) fn browser_identity_override(
        &self,
    ) -> Option<&moli_browser_profile::BrowserIdentityProfile> {
        self.browser_identity_override.as_ref()
    }

    pub(crate) fn renderer_browser_identity_override_owned(
        &self,
    ) -> Option<moli_browser_profile::BrowserIdentityProfile> {
        self.renderer_browser_identity_override.clone()
    }
}

/// Renderer surfaces that must be replayed after an effective policy change.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub(crate) struct EffectiveTargetPolicyDelta {
    pub(crate) network_request: bool,
    pub(crate) browser_identity: bool,
    pub(crate) renderer_browser_identity: bool,
}

impl EffectiveTargetPolicyDelta {
    pub(crate) fn browser_identity_changed(self) -> bool {
        self.browser_identity || self.renderer_browser_identity
    }

    pub(crate) fn is_empty(self) -> bool {
        !self.network_request && !self.browser_identity && !self.renderer_browser_identity
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum PageScreencastFormat {
    Png,
    Jpeg,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct PageScreencastConfig {
    format: PageScreencastFormat,
    quality: u8,
    max_width: Option<u32>,
    max_height: Option<u32>,
    every_nth_frame: u32,
}

impl PageScreencastConfig {
    pub(crate) fn new(
        format: PageScreencastFormat,
        quality: u8,
        max_width: Option<u32>,
        max_height: Option<u32>,
        every_nth_frame: u32,
    ) -> Self {
        debug_assert!(every_nth_frame > 0);
        Self {
            format,
            quality,
            max_width,
            max_height,
            every_nth_frame,
        }
    }

    pub(crate) fn format(&self) -> PageScreencastFormat {
        self.format
    }

    pub(crate) fn quality(&self) -> u8 {
        self.quality
    }

    pub(crate) fn max_width(&self) -> Option<u32> {
        self.max_width
    }

    pub(crate) fn max_height(&self) -> Option<u32> {
        self.max_height
    }

    pub(crate) fn every_nth_frame(&self) -> u32 {
        self.every_nth_frame
    }
}

impl Default for PageScreencastConfig {
    fn default() -> Self {
        Self::new(PageScreencastFormat::Png, 80, None, None, 1)
    }
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub(crate) struct PageScreencastSessionState {
    generation: i32,
    config: Option<PageScreencastConfig>,
    capture_in_progress: bool,
    awaiting_ack: bool,
}

impl PageScreencastSessionState {
    pub(crate) fn is_active(&self) -> bool {
        self.config.is_some()
    }

    pub(crate) fn generation(&self) -> i32 {
        self.generation
    }

    pub(crate) fn config(&self) -> Option<&PageScreencastConfig> {
        self.config.as_ref()
    }

    pub(crate) fn capture_in_progress(&self) -> bool {
        self.capture_in_progress
    }

    pub(crate) fn awaiting_ack(&self) -> bool {
        self.awaiting_ack
    }

    pub(crate) fn start(&mut self, config: PageScreencastConfig) -> i32 {
        self.generation = self
            .generation
            .checked_add(1)
            .filter(|generation| *generation > 0)
            .unwrap_or(1);
        self.config = Some(config);
        self.capture_in_progress = false;
        self.awaiting_ack = false;
        self.generation
    }

    pub(crate) fn stop(&mut self) {
        self.config = None;
        self.capture_in_progress = false;
        self.awaiting_ack = false;
    }

    pub(crate) fn capture_eligible(&self, generation: i32) -> bool {
        self.is_active()
            && self.generation == generation
            && !self.capture_in_progress
            && !self.awaiting_ack
    }

    pub(crate) fn begin_capture(&mut self, generation: i32) -> bool {
        if !self.capture_eligible(generation) {
            return false;
        }
        self.capture_in_progress = true;
        true
    }

    pub(crate) fn complete_capture(&mut self, generation: i32, frame_emitted: bool) -> bool {
        if !self.is_active() || self.generation != generation || !self.capture_in_progress {
            return false;
        }
        self.capture_in_progress = false;
        self.awaiting_ack = frame_emitted;
        true
    }

    pub(crate) fn acknowledge_frame(&mut self, generation: i32) -> bool {
        if !self.is_active() || self.generation != generation || !self.awaiting_ack {
            return false;
        }
        self.awaiting_ack = false;
        true
    }
}

#[derive(Debug, Clone)]
pub(crate) struct TargetPageSessionState {
    pub(crate) input_events_ignored: bool,
    pub(crate) page_domain_enabled: bool,
    pub(crate) page_domain_subscription_generation: u64,
    pub(crate) page_lifecycle_events: bool,
    pub(crate) audits: TargetAuditsSessionState,
    pub(crate) log_enabled: bool,
    pub(crate) performance: TargetPerformanceSessionState,
    pub(crate) page_bypass_csp_enabled: bool,
    pub(crate) page_font_families: serde_json::Map<String, serde_json::Value>,
    pub(crate) page_file_chooser_opened_event_enabled: bool,
    pub(crate) page_intercept_file_chooser_dialog_enabled: bool,
    pub(crate) page_screencast: PageScreencastSessionState,
    pub(crate) javascript_dialog_state: TargetJavaScriptDialogState,
}

impl Default for TargetPageSessionState {
    fn default() -> Self {
        Self {
            input_events_ignored: false,
            page_domain_enabled: false,
            page_domain_subscription_generation: 0,
            page_lifecycle_events: false,
            audits: TargetAuditsSessionState::default(),
            log_enabled: false,
            performance: TargetPerformanceSessionState::default(),
            page_bypass_csp_enabled: false,
            page_font_families: serde_json::Map::new(),
            page_file_chooser_opened_event_enabled: false,
            page_intercept_file_chooser_dialog_enabled: false,
            page_screencast: PageScreencastSessionState::default(),
            javascript_dialog_state: TargetJavaScriptDialogState::default(),
        }
    }
}

impl TargetPageSessionState {
    pub(crate) fn enable_page_domain(&mut self, subscription_generation: u64) {
        if !self.page_domain_enabled {
            self.page_domain_enabled = true;
            self.page_domain_subscription_generation = subscription_generation;
        }
    }

    pub(crate) fn disable_page_domain(&mut self) {
        self.page_domain_enabled = false;
    }

    pub(crate) fn page_domain_subscription_generation(&self) -> Option<u64> {
        self.page_domain_enabled
            .then_some(self.page_domain_subscription_generation)
    }

    pub(crate) fn page_domain_subscription_is_current(&self, generation: u64) -> bool {
        self.page_domain_enabled && self.page_domain_subscription_generation == generation
    }

    pub(crate) fn clear_loaded_document_context_state(&mut self) {
        self.javascript_dialog_state.clear();
    }
}

impl PartialEq for TargetPageSessionState {
    fn eq(&self, other: &Self) -> bool {
        self.input_events_ignored == other.input_events_ignored
            && self.page_domain_enabled == other.page_domain_enabled
            && self.page_lifecycle_events == other.page_lifecycle_events
            && self.audits == other.audits
            && self.log_enabled == other.log_enabled
            && self.performance == other.performance
            && self.page_bypass_csp_enabled == other.page_bypass_csp_enabled
            && self.page_font_families == other.page_font_families
            && self.page_file_chooser_opened_event_enabled
                == other.page_file_chooser_opened_event_enabled
            && self.page_intercept_file_chooser_dialog_enabled
                == other.page_intercept_file_chooser_dialog_enabled
            && self.page_screencast == other.page_screencast
            && self.javascript_dialog_state == other.javascript_dialog_state
    }
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub(crate) struct TargetRuntimeSessionState {
    /// Protocol-side projection of whether this frontend session subscribed to
    /// Runtime domain events. Renderer V8 RuntimeAgent owns the real agent
    /// enabled state on loaded page / available worker paths.
    pub(crate) runtime_frontend_enabled: bool,
    /// Whether this frontend session has observed at least one live Runtime
    /// execution context for the current document/worker lifetime.
    pub(crate) runtime_contexts_reported_to_frontend: bool,
    pub(crate) inspector_enabled: bool,
    /// Mirrors Chromium's per-InspectorHandler crash delivery bit. It records
    /// whether this frontend session has ever received Inspector.targetCrashed,
    /// so a later renderer recovery can emit targetReloadedAfterCrash only to
    /// sessions that observed a crash.
    pub(crate) inspector_target_crashed_delivered: bool,
}

impl TargetRuntimeSessionState {
    pub(crate) fn record_inspector_target_crashed(&mut self) {
        self.inspector_target_crashed_delivered = true;
    }

    pub(crate) fn inspector_target_crashed_delivered(self) -> bool {
        self.inspector_target_crashed_delivered
    }
}

#[derive(Debug, Clone, Default, PartialEq)]
pub(crate) struct InspectorSessionState {
    pub(crate) v8_state: Option<V8InspectorSessionState>,
}

#[derive(Debug, Clone, PartialEq, Default)]
pub(crate) struct TargetNetworkPolicyState {
    // Target-wide policy contributed by WebDriver BiDi or connection defaults.
    base_cache_disabled: bool,
    network_offline: bool,
    base_browser_identity: super::BaseBrowserIdentityOverrideState,
    // Target-scoped headers contributed by WebDriver BiDi.
    base_extra_headers: moli_fetch::RequestHeaders,
}

impl TargetNetworkPolicyState {
    pub(crate) fn set_base_cache_disabled(&mut self, cache_disabled: bool) {
        self.base_cache_disabled = cache_disabled;
    }

    pub(crate) fn clear_session_scoped_state(&mut self) {
        let base_cache_disabled = self.base_cache_disabled;
        let base_extra_headers = std::mem::take(&mut self.base_extra_headers);
        let base_browser_identity = std::mem::take(&mut self.base_browser_identity);
        *self = Self::default();
        self.base_cache_disabled = base_cache_disabled;
        self.base_extra_headers = base_extra_headers;
        self.base_browser_identity = base_browser_identity;
    }

    pub(crate) fn network_offline(&self) -> bool {
        self.network_offline
    }

    pub(crate) fn set_network_offline(&mut self, network_offline: bool) {
        self.network_offline = network_offline;
    }

    pub(crate) fn replace_base_extra_headers(&mut self, extra_headers: moli_fetch::RequestHeaders) {
        self.base_extra_headers = extra_headers;
    }

    #[cfg(test)]
    pub(crate) fn push_extra_header(&mut self, header: (String, String)) {
        let mut headers = self.base_extra_headers.clone();
        headers.push((header.0, header.1.into_bytes()));
        self.replace_base_extra_headers(headers);
    }

    #[cfg(test)]
    pub(crate) fn set_user_agent_override(&mut self, user_agent: String) {
        self.set_browser_identity_override(moli_browser_profile::BrowserIdentityProfile::new(
            user_agent,
            moli_browser_profile::DEFAULT_ACCEPT_LANGUAGE,
        ));
    }

    pub(crate) fn set_browser_identity_override(
        &mut self,
        browser_identity: moli_browser_profile::BrowserIdentityProfile,
    ) {
        self.base_browser_identity.replace_profile(browser_identity);
    }

    pub(crate) fn clear_browser_identity_override(&mut self) {
        self.base_browser_identity = super::BaseBrowserIdentityOverrideState::default();
    }

    pub(crate) fn set_base_user_agent_override(
        &mut self,
        user_agent: Option<String>,
        fallback: &moli_browser_profile::BrowserIdentityProfile,
    ) {
        self.base_browser_identity
            .set_user_agent(user_agent, fallback);
    }

    pub(crate) fn set_base_accept_language_override(
        &mut self,
        accept_language: Option<String>,
        fallback: &moli_browser_profile::BrowserIdentityProfile,
    ) {
        self.base_browser_identity
            .set_accept_language(accept_language, fallback);
    }
}

#[cfg(test)]
mod tests {
    use super::{PageScreencastConfig, PageScreencastFormat, PageScreencastSessionState};
    use crate::conn::PageTargetHost;
    use moli_page_types::DevToolsSessionKey;

    #[test]
    fn devtools_emulation_overrides_reveal_target_base_state_when_cleared() {
        let mut state = PageTargetHost::empty("TID-policy-test".to_owned());
        state.network_policy.set_browser_identity_override(
            moli_browser_profile::BrowserIdentityProfile::new("Moli/Base", "en-GB"),
        );

        state
            .set_devtools_locale_override(&DevToolsSessionKey::Primary, Some("fr-FR".to_owned()))
            .unwrap();
        state
            .set_devtools_timezone_override(
                &DevToolsSessionKey::Primary,
                Some("Europe/Paris".to_owned()),
            )
            .unwrap();
        state.set_devtools_browser_identity_override(
            &DevToolsSessionKey::Primary,
            crate::conn::DevToolsBrowserIdentityOverride::from_command(
                &moli_browser_profile::BrowserIdentityProfile::default(),
                "Moli/CDP".to_owned(),
                Some("fr-FR".to_owned()),
                None,
                None,
            ),
        );
        state
            .devtools_sessions
            .primary_mut()
            .emulation_session_state
            .max_touch_points = 4;
        let effective = state.effective_policy();
        assert_eq!(
            effective
                .browser_identity_override()
                .map(moli_browser_profile::BrowserIdentityProfile::user_agent),
            Some("Moli/CDP")
        );

        state.clear_devtools_network_state(&DevToolsSessionKey::Primary);
        state.clear_devtools_emulation_policy_state(&DevToolsSessionKey::Primary);
        let effective = state.effective_policy();
        assert_eq!(
            state
                .devtools_sessions
                .primary()
                .emulation_session_state
                .max_touch_points,
            4,
            "clearing policy contributions must leave the handler's renderer state intact"
        );
        assert_eq!(
            effective
                .browser_identity_override()
                .map(moli_browser_profile::BrowserIdentityProfile::user_agent),
            Some("Moli/Base")
        );
    }

    fn jpeg_config() -> PageScreencastConfig {
        PageScreencastConfig::new(PageScreencastFormat::Jpeg, 80, Some(1200), Some(900), 1)
    }

    #[test]
    fn screencast_state_enforces_generation_and_single_outstanding_frame() {
        let mut state = PageScreencastSessionState::default();
        let first_generation = state.start(jpeg_config());
        assert_eq!(first_generation, 1);
        assert!(state.begin_capture(first_generation));
        assert!(!state.begin_capture(first_generation));
        assert!(state.complete_capture(first_generation, true));
        assert!(state.awaiting_ack());
        assert!(!state.begin_capture(first_generation));
        assert!(!state.acknowledge_frame(first_generation + 1));
        assert!(state.awaiting_ack());
        assert!(state.acknowledge_frame(first_generation));
        assert!(!state.awaiting_ack());
        assert!(state.begin_capture(first_generation));
    }

    #[test]
    fn repeated_start_and_stop_invalidate_old_capture_state() {
        let mut state = PageScreencastSessionState::default();
        let first_generation = state.start(jpeg_config());
        assert!(state.begin_capture(first_generation));

        let second_generation = state.start(PageScreencastConfig::default());
        assert_eq!(second_generation, first_generation + 1);
        assert!(!state.capture_in_progress());
        assert!(!state.awaiting_ack());
        assert!(!state.complete_capture(first_generation, true));
        assert!(state.begin_capture(second_generation));

        state.stop();
        assert!(!state.is_active());
        assert!(!state.capture_in_progress());
        assert!(!state.complete_capture(second_generation, true));
    }
}