Skip to content

armgit / moli

Public Imported from GitHub
0

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

28.3 KB
Raw Blame
use anyhow::Context;
use chromiumoxide_cdp::cdp::browser_protocol::browser::{
    CancelDownloadParams, SetWindowBoundsParams,
};
use serde::Deserialize;
use serde_json::{Value, json};
use std::str::FromStr;

use crate::automation::{
    AutomationCommand, AutomationResult, DevToolsError, DevToolsErrorKind,
    DevToolsSetDownloadBehaviorCommand, DevToolsSetPermissionCommand,
};
use crate::conn::{BrowserWindowBounds, CdpConnection, Cmd, DownloadCommandError};
use crate::domains::actions::BrowserAction;
use crate::domains::command_output::CommandOutputPlan;
use crate::version;
use moli_core::page::{CompletedPageCommand, PendingPageCommand};

const DEV_TOOLS_WINDOW_ID: u32 = 1_923_710_101;
const DOWNLOAD_BEHAVIORS: &[&str] = &["default", "deny", "allow", "allowAndName"];

pub(crate) fn is_valid_download_behavior(behavior: &str) -> bool {
    DOWNLOAD_BEHAVIORS.contains(&behavior)
}

/// Disables Browser-domain observation owned by one DevTools session.
pub(in crate::domains) fn dispose_session_handler(conn: &mut CdpConnection, session_id: &str) {
    conn.download_behavior
        .set_browser_events_enabled_for_session(Some(session_id), false);
}

pub(crate) struct PendingBrowserCommandDispatch {
    command_id: Option<u64>,
    response_session_id: Option<String>,
    kind: PendingBrowserCommandKind,
}

pub(crate) struct CompletedBrowserCommandDispatch {
    command_id: Option<u64>,
    response_session_id: Option<String>,
    kind: CompletedBrowserCommandKind,
}

pub(crate) enum BrowserCommandTaskStep {
    Pending(PendingBrowserCommandDispatch),
    Complete(CommandOutputPlan),
}

enum PendingBrowserCommandKind {
    OpenDownloadAsStream {
        pending: tokio::task::JoinHandle<Result<Vec<u8>, DownloadCommandError>>,
    },
    ApplyPermissionOverrides {
        pending: Vec<PendingBrowserPageCommand>,
    },
}

enum CompletedBrowserCommandKind {
    OpenDownloadAsStream {
        completed: anyhow::Result<Vec<u8>>,
    },
    ApplyPermissionOverrides {
        completed: Vec<CompletedBrowserPageCommand>,
    },
}

struct PendingBrowserPageCommand {
    target: PendingBrowserPageTarget,
    pending: PendingPageCommand,
}

struct CompletedBrowserPageCommand {
    target: PendingBrowserPageTarget,
    completed: anyhow::Result<CompletedPageCommand>,
}

#[derive(Clone)]
struct PendingBrowserPageTarget {
    browser_context_id: String,
    target_id: String,
    page_id: u64,
    attachment_id: Option<moli_core::page::RendererAgentAttachmentId>,
}

impl PendingBrowserCommandDispatch {
    pub(crate) async fn wait(self) -> CompletedBrowserCommandDispatch {
        let kind = match self.kind {
            PendingBrowserCommandKind::OpenDownloadAsStream { pending } => {
                CompletedBrowserCommandKind::OpenDownloadAsStream {
                    completed: pending
                        .await
                        .map_err(anyhow::Error::from)
                        .and_then(|result| result.map_err(anyhow::Error::from)),
                }
            }
            PendingBrowserCommandKind::ApplyPermissionOverrides { pending } => {
                let mut completed = Vec::with_capacity(pending.len());
                for page_command in pending {
                    completed.push(CompletedBrowserPageCommand {
                        target: page_command.target,
                        completed: page_command.pending.wait().await,
                    });
                }
                CompletedBrowserCommandKind::ApplyPermissionOverrides { completed }
            }
        };
        CompletedBrowserCommandDispatch {
            command_id: self.command_id,
            response_session_id: self.response_session_id,
            kind,
        }
    }
}

impl CompletedBrowserCommandDispatch {
    pub(crate) fn command_id(&self) -> Option<u64> {
        self.command_id
    }

    pub(crate) fn session_id(&self) -> Option<&str> {
        self.response_session_id.as_deref()
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, strum::EnumString, strum::IntoStaticStr)]
#[strum(serialize_all = "lowercase")]
enum PermissionSetting {
    Granted,
    Denied,
    Prompt,
}

impl PermissionSetting {
    fn parse(value: &str) -> Option<Self> {
        Self::from_str(value).ok()
    }

    fn label(self) -> &'static str {
        self.into()
    }
}

fn normalize_permission_setting(value: String) -> String {
    PermissionSetting::parse(&value)
        .map(PermissionSetting::label)
        .unwrap_or(value.as_str())
        .to_owned()
}

pub(crate) fn try_start_browser_command_dispatch(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
) -> BrowserCommandTaskStep {
    let Some(action) = cmd.parse_action::<BrowserAction>() else {
        return BrowserCommandTaskStep::Complete(CommandOutputPlan::error(-32601, "UnknownMethod"));
    };
    match action {
        BrowserAction::GetVersion => BrowserCommandTaskStep::Complete(get_version(conn)),
        BrowserAction::GetWindowForTarget => {
            BrowserCommandTaskStep::Complete(get_window_for_target(conn, cmd))
        }
        BrowserAction::SetWindowBounds => {
            BrowserCommandTaskStep::Complete(set_window_bounds(conn, cmd))
        }
        BrowserAction::SetDownloadBehavior => {
            BrowserCommandTaskStep::Complete(set_download_behavior_command_output_plan(conn, cmd))
        }
        BrowserAction::CancelDownload => {
            BrowserCommandTaskStep::Complete(cancel_download(conn, cmd))
        }
        BrowserAction::OpenDownloadAsStream => start_open_download_as_stream_command(conn, cmd),
        BrowserAction::SetPermission => start_set_permission_command(conn, cmd),
        BrowserAction::GrantPermissions => start_grant_permissions_command(conn, cmd),
        BrowserAction::ResetPermissions => start_reset_permissions_command(conn, cmd),
    }
}

fn get_version(conn: &CdpConnection) -> CommandOutputPlan {
    CommandOutputPlan::result(json!({
        "protocolVersion": version::PROTOCOL_VERSION,
        "product": version::PRODUCT,
        "revision": version::REVISION,
        "userAgent": conn.user_agent(),
        "jsVersion": version::js_version(),
    }))
}

fn bounds_json(bounds: &BrowserWindowBounds) -> Value {
    let mut value = json!({
        "windowState": bounds.window_state,
    });
    let object = value
        .as_object_mut()
        .expect("browser bounds json must be an object");
    if let Some(left) = bounds.left {
        object.insert("left".to_owned(), json!(left));
    }
    if let Some(top) = bounds.top {
        object.insert("top".to_owned(), json!(top));
    }
    if let Some(width) = bounds.width {
        object.insert("width".to_owned(), json!(width));
    }
    if let Some(height) = bounds.height {
        object.insert("height".to_owned(), json!(height));
    }
    value
}

fn get_window_for_target(conn: &mut CdpConnection, cmd: &Cmd<'_>) -> CommandOutputPlan {
    #[derive(Default, Deserialize)]
    #[serde(rename_all = "camelCase")]
    struct Params {
        target_id: Option<String>,
    }
    let params: Params = match cmd.get_params() {
        Ok(params) => params.unwrap_or_default(),
        Err(_) => return CommandOutputPlan::error(-32602, "InvalidParams"),
    };
    let target_id = params
        .target_id
        .or_else(|| {
            conn.target_owner_identity_for_session(cmd.session_id)
                .and_then(|(_, id)| id)
        })
        .unwrap_or_else(|| conn.default_target_id().to_owned());
    let page_target_id = conn
        .primary_page_target_id_for_tab_target_id(&target_id)
        .unwrap_or(&target_id);
    let key = if conn.default_placeholder_is_logically_active(page_target_id) {
        (conn.default_browser_context_id().to_owned(), 0)
    } else if let Some((context, target)) = conn
        .browser_context
        .iter()
        .chain(conn.inactive_browser_contexts.iter())
        .find_map(|context| {
            context
                .page_target(page_target_id)
                .map(|target| (context, target))
        })
    {
        (context.id.clone(), target.window_id)
    } else {
        return CommandOutputPlan::error(-32000, "No browser window found");
    };
    let next_id = DEV_TOOLS_WINDOW_ID + conn.browser_window_ids.len() as u32;
    let window_id = *conn.browser_window_ids.entry(key).or_insert(next_id);
    let bounds = conn
        .browser_window_bounds
        .entry(window_id)
        .or_insert_with(|| conn.window_bounds.clone());
    CommandOutputPlan::result(json!({
        "windowId": window_id,
        "bounds": bounds_json(bounds)
    }))
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct SetDownloadBehaviorParams {
    behavior: String,
    #[serde(default)]
    download_path: Option<String>,
    #[serde(default)]
    events_enabled: bool,
    #[serde(default)]
    browser_context_id: Option<String>,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct SetPermissionParams {
    permission: Value,
    setting: String,
    #[serde(default)]
    origin: Option<String>,
    #[serde(default)]
    embedded_origin: Option<String>,
    #[serde(default)]
    browser_context_id: Option<String>,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct GrantPermissionsParams {
    permissions: Vec<Value>,
    #[serde(default)]
    origin: Option<String>,
    #[serde(default)]
    browser_context_id: Option<String>,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct ResetPermissionsParams {
    #[serde(default)]
    browser_context_id: Option<String>,
}

fn optional_i64_to_i32(value: Option<i64>) -> Result<Option<i32>, ()> {
    value.map(i32::try_from).transpose().map_err(|_| ())
}

fn optional_i64_to_u32(value: Option<i64>) -> Result<Option<u32>, ()> {
    value.map(u32::try_from).transpose().map_err(|_| ())
}

fn set_window_bounds(conn: &mut CdpConnection, cmd: &Cmd<'_>) -> CommandOutputPlan {
    let params: SetWindowBoundsParams = match cmd.get_params() {
        Ok(Some(params)) => params,
        _ => {
            return CommandOutputPlan::error(-32602, "InvalidParams");
        }
    };

    let Ok(window_id) = u32::try_from(*params.window_id.inner()) else {
        return CommandOutputPlan::error(-32602, "InvalidParams");
    };
    let window_is_live = conn
        .browser_window_ids
        .iter()
        .any(|((context_id, local_id), id)| {
            *id == window_id
                && (conn
                    .browser_context_by_id(context_id)
                    .is_some_and(|context| {
                        context
                            .page_targets
                            .iter()
                            .any(|target| target.window_id == *local_id)
                    })
                    || (*local_id == 0
                        && context_id == conn.default_browser_context_id()
                        && conn.default_placeholder_is_logically_active(conn.default_target_id())))
        });
    if !window_is_live {
        return CommandOutputPlan::error(-32000, "Browser window not found");
    }
    let Some(window_bounds) = conn.browser_window_bounds.get_mut(&window_id) else {
        return CommandOutputPlan::error(-32602, "InvalidParams");
    };

    let left = match optional_i64_to_i32(params.bounds.left) {
        Ok(left) => left,
        Err(()) => {
            return CommandOutputPlan::error(-32602, "InvalidParams");
        }
    };
    let top = match optional_i64_to_i32(params.bounds.top) {
        Ok(top) => top,
        Err(()) => {
            return CommandOutputPlan::error(-32602, "InvalidParams");
        }
    };
    let width = match optional_i64_to_u32(params.bounds.width) {
        Ok(width) => width,
        Err(()) => {
            return CommandOutputPlan::error(-32602, "InvalidParams");
        }
    };
    let height = match optional_i64_to_u32(params.bounds.height) {
        Ok(height) => height,
        Err(()) => {
            return CommandOutputPlan::error(-32602, "InvalidParams");
        }
    };
    window_bounds.left = left;
    window_bounds.top = top;
    window_bounds.width = width;
    window_bounds.height = height;
    if let Some(window_state) = params.bounds.window_state {
        window_bounds.window_state = window_state.as_ref().to_owned();
    }

    CommandOutputPlan::success()
}

pub(crate) fn set_download_behavior_command_output_plan(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
) -> CommandOutputPlan {
    let params: SetDownloadBehaviorParams = match cmd.get_params() {
        Ok(Some(params)) => params,
        _ => {
            return CommandOutputPlan::error(-32602, "InvalidParams");
        }
    };

    if let Some(wanted_id) = params.browser_context_id.as_deref()
        && !conn.has_browser_context_id(wanted_id)
    {
        return CommandOutputPlan::error(-31998, "UnknownBrowserContextId");
    }
    if !is_valid_download_behavior(params.behavior.as_str()) {
        return CommandOutputPlan::error(-32602, "InvalidParams");
    }

    match params.browser_context_id {
        Some(browser_context_id) => conn.download_behavior.set_browser_context_policy(
            browser_context_id,
            params.behavior,
            params.download_path,
        ),
        None => conn
            .download_behavior
            .set_global_policy(params.behavior, params.download_path),
    }
    conn.download_behavior
        .set_browser_events_enabled_for_session(cmd.session_id, params.events_enabled);

    CommandOutputPlan::success()
}

pub(crate) fn execute_devtools_browser_command(
    conn: &mut CdpConnection,
    command: AutomationCommand,
) -> Result<AutomationResult, DevToolsError> {
    match command {
        AutomationCommand::SetDownloadBehavior(command) => {
            execute_devtools_set_download_behavior(conn, command)
        }
        _ => Err(DevToolsError::new(
            DevToolsErrorKind::Unsupported,
            "UnsupportedDevToolsCommand",
        )),
    }
}

pub(crate) async fn execute_devtools_browser_command_async(
    conn: &mut CdpConnection,
    command: AutomationCommand,
) -> Result<AutomationResult, DevToolsError> {
    match command {
        AutomationCommand::SetPermission(command) => {
            execute_devtools_set_permission_command_async(conn, command).await
        }
        _ => Err(DevToolsError::new(
            DevToolsErrorKind::Unsupported,
            "UnsupportedDevToolsCommand",
        )),
    }
}

fn execute_devtools_set_download_behavior(
    conn: &mut CdpConnection,
    command: DevToolsSetDownloadBehaviorCommand,
) -> Result<AutomationResult, DevToolsError> {
    let target_contexts = match command.user_contexts {
        Some(user_contexts) => {
            if user_contexts.is_empty() {
                return Err(DevToolsError::new(
                    DevToolsErrorKind::InvalidArgument,
                    "user contexts must not be empty",
                ));
            }
            for browser_context_id in &user_contexts {
                if !conn.has_browser_context_id(browser_context_id.as_str()) {
                    return Err(DevToolsError::new(
                        DevToolsErrorKind::NoSuchTarget,
                        "UnknownBrowserContextId",
                    ));
                }
            }
            Some(user_contexts)
        }
        None => None,
    };

    let Some(behavior) = command.behavior else {
        match target_contexts {
            Some(user_contexts) => {
                for browser_context_id in user_contexts {
                    conn.download_behavior
                        .reset_browser_context(browser_context_id.as_str());
                }
            }
            None => conn.download_behavior.reset_global(),
        }
        return Ok(AutomationResult::Empty);
    };

    if !is_valid_download_behavior(behavior.behavior.as_str()) {
        return Err(DevToolsError::new(
            DevToolsErrorKind::InvalidArgument,
            "download behavior is invalid",
        ));
    }

    match target_contexts {
        Some(user_contexts) => {
            for browser_context_id in user_contexts {
                conn.download_behavior.set_browser_context(
                    browser_context_id.into_string(),
                    behavior.behavior.clone(),
                    behavior.download_path.clone(),
                    behavior.events_enabled,
                );
            }
        }
        None => conn.download_behavior.set_global(
            behavior.behavior,
            behavior.download_path,
            behavior.events_enabled,
        ),
    }
    Ok(AutomationResult::Empty)
}

async fn execute_devtools_set_permission_command_async(
    conn: &mut CdpConnection,
    command: DevToolsSetPermissionCommand,
) -> Result<AutomationResult, DevToolsError> {
    let browser_context_id = command.browser_context_id.as_ref().map(|id| id.as_str());
    if validate_browser_context_id(conn, browser_context_id).is_err() {
        return Err(DevToolsError::new(
            DevToolsErrorKind::NoSuchTarget,
            "UnknownBrowserContextId",
        ));
    }
    let browser_context_id = command
        .browser_context_id
        .map(|browser_context_id| browser_context_id.into_string());

    conn.permission_overrides.retain(|override_entry| {
        override_entry.permission != command.permission
            || override_entry.origin.as_deref() != Some(command.origin.as_str())
            || override_entry.embedded_origin != command.embedded_origin
            || override_entry.browser_context_id != browser_context_id
    });
    conn.permission_overrides
        .push(crate::conn::PermissionOverride {
            permission: command.permission,
            setting: normalize_permission_setting(command.setting),
            origin: Some(command.origin),
            embedded_origin: command.embedded_origin,
            browser_context_id,
        });

    let pending = start_loaded_page_permission_override_commands(conn)
        .map_err(|error| DevToolsError::new(DevToolsErrorKind::Internal, format!("{error:#}")))?;
    if pending.is_empty() {
        return Ok(AutomationResult::Empty);
    }
    let completed = PendingBrowserCommandDispatch {
        command_id: None,
        response_session_id: command
            .context
            .session_id
            .map(|session_id| session_id.into_string()),
        kind: PendingBrowserCommandKind::ApplyPermissionOverrides { pending },
    }
    .wait()
    .await;
    let CompletedBrowserCommandKind::ApplyPermissionOverrides {
        completed: commands,
    } = completed.kind
    else {
        unreachable!("set permission can only wait for permission override commands")
    };
    for command in commands {
        finish_pending_permission_override_command(conn, command).map_err(|error| {
            DevToolsError::new(DevToolsErrorKind::Internal, format!("{error:#}"))
        })?;
    }
    Ok(AutomationResult::Empty)
}

fn cancel_download(conn: &mut CdpConnection, cmd: &Cmd<'_>) -> CommandOutputPlan {
    let params: CancelDownloadParams = match cmd.get_params() {
        Ok(Some(params)) => params,
        _ => {
            return CommandOutputPlan::error(-32602, "InvalidParams");
        }
    };

    match conn.cancel_download(&params.guid) {
        Ok(()) => CommandOutputPlan::success(),
        Err(error) => CommandOutputPlan::error(-32602, error.to_string()),
    }
}

fn start_open_download_as_stream_command(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
) -> BrowserCommandTaskStep {
    let params: CancelDownloadParams = match cmd.get_params() {
        Ok(Some(params)) => params,
        _ => {
            return browser_error_step(-32602, "InvalidParams");
        }
    };

    match conn.start_open_download_as_stream(&params.guid) {
        Ok(pending) => BrowserCommandTaskStep::Pending(PendingBrowserCommandDispatch {
            command_id: cmd.id,
            response_session_id: cmd.session_id.map(str::to_owned),
            kind: PendingBrowserCommandKind::OpenDownloadAsStream { pending },
        }),
        Err(error) => browser_error_step(-32602, error.to_string()),
    }
}

fn validate_browser_context_id(
    conn: &CdpConnection,
    browser_context_id: Option<&str>,
) -> Result<(), ()> {
    if let Some(wanted_id) = browser_context_id
        && !conn.has_browser_context_id(wanted_id)
    {
        return Err(());
    }
    Ok(())
}

fn start_set_permission_command(conn: &mut CdpConnection, cmd: &Cmd<'_>) -> BrowserCommandTaskStep {
    let params: SetPermissionParams = match cmd.get_params() {
        Ok(Some(params)) => params,
        _ => {
            return browser_error_step(-32602, "InvalidParams");
        }
    };
    if validate_browser_context_id(conn, params.browser_context_id.as_deref()).is_err() {
        return browser_error_step(-31998, "UnknownBrowserContextId");
    }

    conn.permission_overrides.retain(|override_entry| {
        override_entry.permission != params.permission
            || override_entry.origin != params.origin
            || override_entry.embedded_origin != params.embedded_origin
            || override_entry.browser_context_id != params.browser_context_id
    });
    conn.permission_overrides
        .push(crate::conn::PermissionOverride {
            permission: params.permission,
            setting: normalize_permission_setting(params.setting),
            origin: params.origin,
            embedded_origin: params.embedded_origin,
            browser_context_id: params.browser_context_id,
        });
    start_apply_permission_overrides_command(conn, cmd)
}

fn start_grant_permissions_command(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
) -> BrowserCommandTaskStep {
    let params: GrantPermissionsParams = match cmd.get_params() {
        Ok(Some(params)) => params,
        _ => {
            return browser_error_step(-32602, "InvalidParams");
        }
    };
    if validate_browser_context_id(conn, params.browser_context_id.as_deref()).is_err() {
        return browser_error_step(-31998, "UnknownBrowserContextId");
    }

    for permission in params.permissions {
        conn.permission_overrides.retain(|override_entry| {
            override_entry.permission != permission
                || override_entry.origin != params.origin
                || override_entry.embedded_origin.is_some()
                || override_entry.browser_context_id != params.browser_context_id
        });
        conn.permission_overrides
            .push(crate::conn::PermissionOverride {
                permission,
                setting: PermissionSetting::Granted.label().to_owned(),
                origin: params.origin.clone(),
                embedded_origin: None,
                browser_context_id: params.browser_context_id.clone(),
            });
    }

    start_apply_permission_overrides_command(conn, cmd)
}

fn start_reset_permissions_command(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
) -> BrowserCommandTaskStep {
    let params: ResetPermissionsParams = match cmd.get_params() {
        Ok(Some(params)) => params,
        Ok(None) => ResetPermissionsParams {
            browser_context_id: None,
        },
        Err(_) => {
            return browser_error_step(-32602, "InvalidParams");
        }
    };
    if validate_browser_context_id(conn, params.browser_context_id.as_deref()).is_err() {
        return browser_error_step(-31998, "UnknownBrowserContextId");
    }

    if let Some(browser_context_id) = params.browser_context_id {
        conn.permission_overrides.retain(|entry| {
            entry.browser_context_id.as_deref() != Some(browser_context_id.as_str())
        });
    } else {
        conn.permission_overrides.clear();
    }

    start_apply_permission_overrides_command(conn, cmd)
}

fn browser_error_step(code: i32, message: impl Into<String>) -> BrowserCommandTaskStep {
    BrowserCommandTaskStep::Complete(CommandOutputPlan::error(code, message))
}

fn browser_success_step() -> BrowserCommandTaskStep {
    BrowserCommandTaskStep::Complete(CommandOutputPlan::success())
}

fn start_apply_permission_overrides_command(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
) -> BrowserCommandTaskStep {
    let pending = match start_loaded_page_permission_override_commands(conn) {
        Ok(pending) => pending,
        Err(error) => return browser_error_step(-32000, format!("{error:#}")),
    };
    if pending.is_empty() {
        return browser_success_step();
    }
    BrowserCommandTaskStep::Pending(PendingBrowserCommandDispatch {
        command_id: cmd.id,
        response_session_id: cmd.session_id.map(str::to_owned),
        kind: PendingBrowserCommandKind::ApplyPermissionOverrides { pending },
    })
}

fn start_loaded_page_permission_override_commands(
    conn: &mut CdpConnection,
) -> anyhow::Result<Vec<PendingBrowserPageCommand>> {
    let all_overrides = conn.permission_overrides.clone();
    let mut pending = Vec::new();
    for browser_context in conn
        .browser_context
        .iter_mut()
        .chain(conn.inactive_browser_contexts.iter_mut())
    {
        let browser_context_id = browser_context.id.clone();
        let effective_overrides = all_overrides
            .iter()
            .filter(|entry| {
                entry.browser_context_id.is_none()
                    || entry.browser_context_id.as_deref() == Some(browser_context_id.as_str())
            })
            .map(|entry| moli_core::page::PermissionOverrideRegistration {
                permission: entry.permission.clone(),
                setting: entry.setting.clone(),
                origin: entry.origin.clone(),
                embedded_origin: entry.embedded_origin.clone(),
            })
            .collect::<Vec<_>>();
        for target in browser_context.page_targets.iter_mut() {
            let target_id = target.target_id().to_owned();
            let Some(page) = target.loaded_page_mut() else {
                continue;
            };
            let page_command = page
                .start_set_permission_overrides(&effective_overrides)
                .context("failed to update page permission overrides")?;
            pending.push(PendingBrowserPageCommand {
                target: PendingBrowserPageTarget {
                    browser_context_id: browser_context_id.clone(),
                    target_id,
                    page_id: page.page_id(),
                    attachment_id: page_command.renderer_agent_attachment_id(),
                },
                pending: page_command,
            });
        }
    }
    Ok(pending)
}

pub(crate) fn complete_pending_browser_command(
    conn: &mut CdpConnection,
    completed: CompletedBrowserCommandDispatch,
) -> CommandOutputPlan {
    match completed.kind {
        CompletedBrowserCommandKind::OpenDownloadAsStream { completed: bytes } => match bytes {
            Ok(bytes) => {
                let stream = conn.finish_open_download_as_stream(bytes);
                CommandOutputPlan::result(json!({ "stream": stream }))
            }
            Err(error) => CommandOutputPlan::error(-32602, format!("{error:#}")),
        },
        CompletedBrowserCommandKind::ApplyPermissionOverrides {
            completed: commands,
        } => {
            for command in commands {
                if let Err(error) = finish_pending_permission_override_command(conn, command) {
                    return CommandOutputPlan::error(-32000, format!("{error:#}"));
                }
            }
            CommandOutputPlan::success()
        }
    }
}

fn finish_pending_permission_override_command(
    conn: &mut CdpConnection,
    command: CompletedBrowserPageCommand,
) -> anyhow::Result<()> {
    let target = command.target;
    let page = conn
        .browser_context_by_id_mut(&target.browser_context_id)
        .and_then(|browser_context| browser_context.page_target_mut(&target.target_id))
        .and_then(|target| target.loaded_page_mut())
        .filter(|page| {
            page.page_id() == target.page_id
                && page.renderer_agent_attachment_id() == target.attachment_id
        });
    if let Some(page) = page {
        let completion = command.completed?;
        return page.finish_set_permission_overrides(completion);
    }

    // Browser policy was committed before dispatch and is replayed when a new
    // Page is installed. A retired projection may finish or be cancelled; it
    // cannot invalidate that policy or install its PageState on a new owner.
    match command.completed {
        Ok(completion) => completion.into_unit_page_command_turn().map(drop),
        Err(_) => Ok(()),
    }
}

// ────────────────────────────────────────────────────────────────────────────

#[cfg(test)]
mod tests;