Skip to content

armgit / moli

Public Imported from GitHub
0

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

29.9 KB
Raw Blame
pub(crate) mod native;

use crate::automation::DevToolsDomNodeReference;
use crate::conn::{CdpConnection, Cmd, CommandOwnerScope};
use crate::domains::actions::AccessibilityAction;
use crate::domains::command_output::CommandOutputPlan;
use moli_core::page::{CompletedPageCommand, PendingPageCommand, RendererDomNodeReference};
use serde_json::{Value, json};

mod helpers;
#[cfg(test)]
mod tests;

pub(crate) struct PendingAccessibilityCommandDispatch {
    command_id: Option<u64>,
    owner_scope: CommandOwnerScope,
    kind: PendingAccessibilityCommandKind,
    pending: PendingPageCommand,
}

pub(crate) struct CompletedAccessibilityCommandDispatch {
    command_id: Option<u64>,
    owner_scope: CommandOwnerScope,
    kind: PendingAccessibilityCommandKind,
    completed: Box<Result<CompletedPageCommand, String>>,
}

pub(crate) enum AccessibilityCommandDispatchStep {
    Pending(PendingAccessibilityCommandDispatch),
    Complete(CommandOutputPlan),
}

enum PendingAccessibilityCommandKind {
    TopFrameFullTree {
        max_depth: Option<i32>,
    },
    TopFrameRoot,
    ChildFrameFullTree {
        max_depth: Option<i32>,
    },
    ChildFrameRoot,
    ObjectAccessibilityPayloads {
        frame_id: Option<String>,
        top_frame_id: String,
        operation: AccessibilityNodeOperation,
    },
    NodeAccessibilityPayloads {
        frame_id: String,
        top_frame_id: String,
        operation: AccessibilityNodeOperation,
    },
}

#[derive(Clone)]
enum AccessibilityNodeOperation {
    Children,
    Ancestors,
    Query {
        accessible_name: Option<String>,
        role: Option<String>,
    },
    Partial {
        fetch_relatives: bool,
    },
}

struct PendingAccessibilityCommandStartError {
    code: i32,
    message: String,
}

impl PendingAccessibilityCommandDispatch {
    fn from_command(
        conn: &CdpConnection,
        cmd: &Cmd<'_>,
        kind: PendingAccessibilityCommandKind,
        pending: PendingPageCommand,
    ) -> Self {
        Self {
            command_id: cmd.id,
            owner_scope: CommandOwnerScope::capture(conn, cmd.session_id),
            kind,
            pending,
        }
    }

    pub async fn wait(self) -> CompletedAccessibilityCommandDispatch {
        let completed = Box::new(self.pending.wait().await.map_err(|error| error.to_string()));
        CompletedAccessibilityCommandDispatch {
            command_id: self.command_id,
            owner_scope: self.owner_scope,
            kind: self.kind,
            completed,
        }
    }
}

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

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

impl PendingAccessibilityCommandStartError {
    fn invalid_params() -> Self {
        Self {
            code: -32602,
            message: "InvalidParams".to_owned(),
        }
    }

    fn browser_context_not_loaded() -> Self {
        Self {
            code: -31998,
            message: "BrowserContextNotLoaded".to_owned(),
        }
    }

    fn no_document_loaded() -> Self {
        Self {
            code: -32000,
            message: "NoDocumentLoaded".to_owned(),
        }
    }

    fn node_not_found() -> Self {
        Self {
            code: -32000,
            message: "Could not find node with given id".to_owned(),
        }
    }

    fn document_access_error(message: impl Into<String>) -> Self {
        Self {
            code: -32000,
            message: message.into(),
        }
    }

    fn renderer_error(error: impl std::fmt::Display) -> Self {
        Self {
            code: -32000,
            message: error.to_string(),
        }
    }
}

pub(crate) fn try_start_accessibility_command_dispatch(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
) -> Option<AccessibilityCommandDispatchStep> {
    match cmd.parse_action::<AccessibilityAction>() {
        Some(AccessibilityAction::Enable | AccessibilityAction::Disable) => Some(
            AccessibilityCommandDispatchStep::Complete(CommandOutputPlan::success()),
        ),
        Some(action) if action.queries_tree() => {
            match start_pending_accessibility_command(conn, cmd, action) {
                Ok(Some(pending)) => Some(AccessibilityCommandDispatchStep::Pending(pending)),
                Ok(None) => Some(AccessibilityCommandDispatchStep::Complete(
                    CommandOutputPlan::error(-32000, "AccessibilityCommandDidNotStart"),
                )),
                Err(error) => Some(AccessibilityCommandDispatchStep::Complete(
                    CommandOutputPlan::error(error.code, error.message),
                )),
            }
        }
        None => Some(AccessibilityCommandDispatchStep::Complete(
            CommandOutputPlan::error(-32601, "UnknownMethod"),
        )),
        Some(_) => Some(AccessibilityCommandDispatchStep::Complete(
            CommandOutputPlan::success(),
        )),
    }
}

fn start_pending_accessibility_command(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
    action: AccessibilityAction,
) -> Result<Option<PendingAccessibilityCommandDispatch>, PendingAccessibilityCommandStartError> {
    match action {
        AccessibilityAction::GetFullAxTree => {
            start_pending_child_frame_full_tree_command(conn, cmd)
        }
        AccessibilityAction::GetRootAxNode => start_pending_child_frame_root_command(conn, cmd),
        AccessibilityAction::GetChildAxNodes => {
            start_pending_child_frame_children_command(conn, cmd)
        }
        AccessibilityAction::GetAxNodeAndAncestors => {
            start_pending_child_frame_ancestors_command(conn, cmd)
        }
        AccessibilityAction::QueryAxTree => start_pending_child_frame_query_command(conn, cmd),
        AccessibilityAction::GetPartialAxTree => {
            start_pending_child_frame_partial_command(conn, cmd)
        }
        AccessibilityAction::Enable | AccessibilityAction::Disable => Ok(None),
    }
}

fn start_pending_child_frame_full_tree_command(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
) -> Result<Option<PendingAccessibilityCommandDispatch>, PendingAccessibilityCommandStartError> {
    let params: helpers::GetFullAxTreeParams = match cmd.get_params() {
        Ok(Some(params)) => params,
        Ok(None) => helpers::GetFullAxTreeParams {
            depth: None,
            frame_id: None,
        },
        Err(_) => return Err(PendingAccessibilityCommandStartError::invalid_params()),
    };
    let max_depth = match params.depth {
        Some(depth) => match i32::try_from(depth) {
            Ok(depth) => (depth >= 0).then_some(depth),
            Err(_) => return Err(PendingAccessibilityCommandStartError::invalid_params()),
        },
        None => None,
    };
    conn.ensure_document_accessible_for_session_owner(cmd.session_id)
        .map_err(PendingAccessibilityCommandStartError::document_access_error)?;
    start_pending_frame_scoped_accessibility_command(
        conn,
        cmd,
        params.frame_id.as_ref().map(AsRef::as_ref),
        PendingAccessibilityCommandKind::TopFrameFullTree { max_depth },
        PendingAccessibilityCommandKind::ChildFrameFullTree { max_depth },
    )
}

fn start_pending_child_frame_root_command(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
) -> Result<Option<PendingAccessibilityCommandDispatch>, PendingAccessibilityCommandStartError> {
    let params: helpers::FrameScopedParams = match cmd.get_params() {
        Ok(Some(params)) => params,
        Ok(None) => helpers::FrameScopedParams { frame_id: None },
        Err(_) => return Err(PendingAccessibilityCommandStartError::invalid_params()),
    };
    start_pending_frame_scoped_accessibility_command(
        conn,
        cmd,
        params.frame_id.as_deref(),
        PendingAccessibilityCommandKind::TopFrameRoot,
        PendingAccessibilityCommandKind::ChildFrameRoot,
    )
}

fn start_pending_child_frame_children_command(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
) -> Result<Option<PendingAccessibilityCommandDispatch>, PendingAccessibilityCommandStartError> {
    let params: helpers::ChildAxNodesParams = match cmd.get_params() {
        Ok(Some(params)) => params,
        _ => return Err(PendingAccessibilityCommandStartError::invalid_params()),
    };
    let Some(backend_node_id) = helpers::parse_ax_backend_node_id(params.id.as_ref()) else {
        return Err(PendingAccessibilityCommandStartError::invalid_params());
    };
    start_pending_node_reference_command(
        conn,
        cmd,
        params.frame_id.as_ref().map(AsRef::as_ref),
        DevToolsDomNodeReference::BackendNodeId(backend_node_id),
        AccessibilityNodeOperation::Children,
    )
}

fn start_pending_child_frame_ancestors_command(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
) -> Result<Option<PendingAccessibilityCommandDispatch>, PendingAccessibilityCommandStartError> {
    let params: helpers::AncestorsParams = match cmd.get_params() {
        Ok(Some(params)) => params,
        _ => return Err(PendingAccessibilityCommandStartError::invalid_params()),
    };
    if params.reference.object_id.is_some() {
        return start_pending_object_reference_command(
            conn,
            cmd,
            params.frame_id.as_deref(),
            params.reference,
            AccessibilityNodeOperation::Ancestors,
        );
    }
    if let Some(backend_node_id) = renderer_backend_node_id_for_reference(&params.reference) {
        return start_pending_node_reference_command(
            conn,
            cmd,
            params.frame_id.as_deref(),
            DevToolsDomNodeReference::BackendNodeId(backend_node_id),
            AccessibilityNodeOperation::Ancestors,
        );
    }
    let Some(frontend_node_id) = params.reference.node_id else {
        return Err(PendingAccessibilityCommandStartError::node_not_found());
    };
    start_pending_node_reference_command(
        conn,
        cmd,
        params.frame_id.as_deref(),
        DevToolsDomNodeReference::FrontendNodeId(frontend_node_id),
        AccessibilityNodeOperation::Ancestors,
    )
}

fn start_pending_child_frame_query_command(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
) -> Result<Option<PendingAccessibilityCommandDispatch>, PendingAccessibilityCommandStartError> {
    let params: helpers::QueryAxTreeParams = match cmd.get_params() {
        Ok(Some(params)) => params,
        _ => return Err(PendingAccessibilityCommandStartError::invalid_params()),
    };
    if params.reference.object_id.is_some() {
        return start_pending_object_reference_command(
            conn,
            cmd,
            params.frame_id.as_deref(),
            params.reference,
            AccessibilityNodeOperation::Query {
                accessible_name: params.accessible_name,
                role: params.role,
            },
        );
    }
    if let Some(backend_node_id) = renderer_backend_node_id_for_reference(&params.reference) {
        return start_pending_node_reference_command(
            conn,
            cmd,
            params.frame_id.as_deref(),
            DevToolsDomNodeReference::BackendNodeId(backend_node_id),
            AccessibilityNodeOperation::Query {
                accessible_name: params.accessible_name,
                role: params.role,
            },
        );
    }
    let Some(frontend_node_id) = params.reference.node_id else {
        return Err(PendingAccessibilityCommandStartError::node_not_found());
    };
    start_pending_node_reference_command(
        conn,
        cmd,
        params.frame_id.as_deref(),
        DevToolsDomNodeReference::FrontendNodeId(frontend_node_id),
        AccessibilityNodeOperation::Query {
            accessible_name: params.accessible_name.clone(),
            role: params.role.clone(),
        },
    )
}

fn start_pending_child_frame_partial_command(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
) -> Result<Option<PendingAccessibilityCommandDispatch>, PendingAccessibilityCommandStartError> {
    let params: helpers::PartialAxTreeParams = match cmd.get_params() {
        Ok(Some(params)) => params,
        _ => return Err(PendingAccessibilityCommandStartError::invalid_params()),
    };
    let fetch_relatives = params.fetch_relatives.unwrap_or(true);
    if params.reference.object_id.is_some() {
        return start_pending_object_reference_command(
            conn,
            cmd,
            params.frame_id.as_deref(),
            params.reference,
            AccessibilityNodeOperation::Partial { fetch_relatives },
        );
    }
    if let Some(backend_node_id) = renderer_backend_node_id_for_reference(&params.reference) {
        return start_pending_node_reference_command(
            conn,
            cmd,
            params.frame_id.as_deref(),
            DevToolsDomNodeReference::BackendNodeId(backend_node_id),
            AccessibilityNodeOperation::Partial { fetch_relatives },
        );
    }
    let Some(frontend_node_id) = params.reference.node_id else {
        return Err(PendingAccessibilityCommandStartError::node_not_found());
    };
    start_pending_node_reference_command(
        conn,
        cmd,
        params.frame_id.as_deref(),
        DevToolsDomNodeReference::FrontendNodeId(frontend_node_id),
        AccessibilityNodeOperation::Partial { fetch_relatives },
    )
}

fn start_pending_object_reference_command(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
    frame_id: Option<&str>,
    reference: helpers::NodeReferenceParams,
    operation: AccessibilityNodeOperation,
) -> Result<Option<PendingAccessibilityCommandDispatch>, PendingAccessibilityCommandStartError> {
    if conn
        .target_owner_identity_for_session(cmd.session_id)
        .is_none()
        && conn.browser_context.is_none()
    {
        return Err(PendingAccessibilityCommandStartError::browser_context_not_loaded());
    }
    conn.ensure_document_accessible_for_session_owner(cmd.session_id)
        .map_err(PendingAccessibilityCommandStartError::document_access_error)?;
    let Some(top_frame_id) = helpers::top_frame_id_for_session(conn, cmd.session_id) else {
        return Err(PendingAccessibilityCommandStartError::no_document_loaded());
    };
    let Some(object_id) = reference.object_id.as_deref() else {
        return Err(PendingAccessibilityCommandStartError {
            code: -32000,
            message: "Could not find node with given id".to_owned(),
        });
    };
    let inspector_session_id =
        conn.target_renderer_runtime_inspector_session_id_for_session(cmd.session_id);
    let Some(page) = helpers::loaded_page_mut_for_session(conn, cmd.session_id) else {
        return Err(PendingAccessibilityCommandStartError::no_document_loaded());
    };
    let pending =
        start_accessibility_object_page_command(page, inspector_session_id, object_id, &operation)
            .map_err(PendingAccessibilityCommandStartError::renderer_error)?;
    Ok(Some(PendingAccessibilityCommandDispatch::from_command(
        conn,
        cmd,
        PendingAccessibilityCommandKind::ObjectAccessibilityPayloads {
            frame_id: frame_id.map(str::to_owned),
            top_frame_id,
            operation,
        },
        pending,
    )))
}

fn renderer_backend_node_id_for_reference(reference: &helpers::NodeReferenceParams) -> Option<u32> {
    reference.backend_node_id
}

fn start_accessibility_object_page_command(
    page: &mut moli_core::page::Page,
    inspector_session_id: Option<String>,
    object_id: &str,
    operation: &AccessibilityNodeOperation,
) -> anyhow::Result<PendingPageCommand> {
    match operation {
        AccessibilityNodeOperation::Children => Err(anyhow::anyhow!(
            "children accessibility operation requires an AXNodeId"
        )),
        AccessibilityNodeOperation::Ancestors => page
            .start_accessibility_node_and_ancestor_payloads_for_object_id(
                inspector_session_id,
                object_id,
            ),
        AccessibilityNodeOperation::Query { .. } => {
            page.start_accessibility_tree_payloads_for_object_id(inspector_session_id, object_id)
        }
        AccessibilityNodeOperation::Partial { fetch_relatives } => page
            .start_accessibility_partial_tree_payloads_for_object_id(
                inspector_session_id,
                object_id,
                *fetch_relatives,
            ),
    }
}

fn start_pending_node_reference_command(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
    frame_id: Option<&str>,
    reference: DevToolsDomNodeReference,
    operation: AccessibilityNodeOperation,
) -> Result<Option<PendingAccessibilityCommandDispatch>, PendingAccessibilityCommandStartError> {
    if conn
        .target_owner_identity_for_session(cmd.session_id)
        .is_none()
        && conn.browser_context.is_none()
    {
        return Err(PendingAccessibilityCommandStartError::browser_context_not_loaded());
    }
    conn.ensure_document_accessible_for_session_owner(cmd.session_id)
        .map_err(PendingAccessibilityCommandStartError::document_access_error)?;
    let Some(top_frame_id) = helpers::top_frame_id_for_session(conn, cmd.session_id) else {
        return Err(PendingAccessibilityCommandStartError::no_document_loaded());
    };
    let resolved_frame_id = frame_id.unwrap_or(top_frame_id.as_str()).to_owned();
    let session = conn.target_renderer_runtime_inspector_session_id_for_session(cmd.session_id);
    let reference = reference.into_renderer_reference(session);
    let Some(page) = helpers::loaded_page_mut_for_session(conn, cmd.session_id) else {
        return Err(PendingAccessibilityCommandStartError::no_document_loaded());
    };
    let pending = start_accessibility_node_page_command(page, reference, &operation)
        .map_err(PendingAccessibilityCommandStartError::renderer_error)?;
    Ok(Some(PendingAccessibilityCommandDispatch::from_command(
        conn,
        cmd,
        PendingAccessibilityCommandKind::NodeAccessibilityPayloads {
            frame_id: resolved_frame_id,
            top_frame_id,
            operation,
        },
        pending,
    )))
}

fn start_accessibility_node_page_command(
    page: &mut moli_core::page::Page,
    reference: RendererDomNodeReference,
    operation: &AccessibilityNodeOperation,
) -> anyhow::Result<PendingPageCommand> {
    match operation {
        AccessibilityNodeOperation::Children => {
            page.start_accessibility_child_node_payloads_for_node(reference)
        }
        AccessibilityNodeOperation::Ancestors => {
            page.start_accessibility_node_and_ancestor_payloads_for_node(reference)
        }
        AccessibilityNodeOperation::Query { .. } => {
            page.start_accessibility_tree_payloads_for_node(reference, None)
        }
        AccessibilityNodeOperation::Partial { fetch_relatives } => {
            page.start_accessibility_partial_tree_payloads_for_node(reference, *fetch_relatives)
        }
    }
}

fn start_top_frame_accessibility_page_command(
    page: &mut moli_core::page::Page,
    kind: &PendingAccessibilityCommandKind,
) -> anyhow::Result<PendingPageCommand> {
    match kind {
        PendingAccessibilityCommandKind::TopFrameFullTree { max_depth } => {
            page.start_accessibility_tree_payloads_for_document(*max_depth)
        }
        PendingAccessibilityCommandKind::TopFrameRoot => {
            page.start_accessibility_node_payload_for_document()
        }
        _ => unreachable!("top-frame accessibility kind must use a top-frame variant"),
    }
}

fn start_pending_frame_scoped_accessibility_command(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
    frame_id: Option<&str>,
    top_frame_kind: PendingAccessibilityCommandKind,
    child_frame_kind: PendingAccessibilityCommandKind,
) -> Result<Option<PendingAccessibilityCommandDispatch>, PendingAccessibilityCommandStartError> {
    if conn
        .target_owner_identity_for_session(cmd.session_id)
        .is_none()
        && conn.browser_context.is_none()
    {
        return Err(PendingAccessibilityCommandStartError::browser_context_not_loaded());
    }
    conn.ensure_document_accessible_for_session_owner(cmd.session_id)
        .map_err(PendingAccessibilityCommandStartError::document_access_error)?;
    let Some(top_frame_id) = helpers::top_frame_id_for_session(conn, cmd.session_id) else {
        return Err(PendingAccessibilityCommandStartError::no_document_loaded());
    };
    let resolved_frame_id = frame_id.unwrap_or(top_frame_id.as_str());
    let Some(page) = helpers::loaded_page_mut_for_session(conn, cmd.session_id) else {
        return Err(PendingAccessibilityCommandStartError::no_document_loaded());
    };
    let (kind, pending) = if resolved_frame_id == top_frame_id {
        let pending = start_top_frame_accessibility_page_command(page, &top_frame_kind)
            .map_err(PendingAccessibilityCommandStartError::renderer_error)?;
        (top_frame_kind, pending)
    } else {
        let pending = start_child_frame_accessibility_page_command(
            page,
            resolved_frame_id,
            &child_frame_kind,
        )
        .map_err(PendingAccessibilityCommandStartError::renderer_error)?;
        (child_frame_kind, pending)
    };
    Ok(Some(PendingAccessibilityCommandDispatch::from_command(
        conn, cmd, kind, pending,
    )))
}

fn start_child_frame_accessibility_page_command(
    page: &mut moli_core::page::Page,
    frame_id: &str,
    kind: &PendingAccessibilityCommandKind,
) -> anyhow::Result<PendingPageCommand> {
    match kind {
        PendingAccessibilityCommandKind::ChildFrameFullTree { max_depth } => {
            page.start_child_frame_accessibility_tree_payloads(frame_id, *max_depth)
        }
        PendingAccessibilityCommandKind::ChildFrameRoot => {
            page.start_child_frame_accessibility_node_payload(frame_id)
        }
        _ => unreachable!("child-frame accessibility dispatch only accepts child-frame commands"),
    }
}

pub(crate) async fn complete_pending_accessibility_command(
    conn: &mut CdpConnection,
    completed: CompletedAccessibilityCommandDispatch,
) -> AccessibilityCommandDispatchStep {
    let CompletedAccessibilityCommandDispatch {
        command_id: _,
        owner_scope,
        kind,
        completed,
    } = completed;
    let completed = *completed;

    if let Err(message) = conn.ensure_document_accessible_for_owner(&owner_scope) {
        return AccessibilityCommandDispatchStep::Complete(CommandOutputPlan::error(
            -32000, message,
        ));
    }
    let Some(page) = conn
        .loaded_page_mut_for_protocol_access_for_owner(&owner_scope)
        .ok()
    else {
        return AccessibilityCommandDispatchStep::Complete(CommandOutputPlan::error(
            -32000,
            "NoDocumentLoaded",
        ));
    };
    let completion = match completed {
        Ok(completion) => completion,
        Err(error) => {
            return AccessibilityCommandDispatchStep::Complete(CommandOutputPlan::error(
                -32000, error,
            ));
        }
    };
    let plan = match kind {
        PendingAccessibilityCommandKind::TopFrameFullTree { .. } => {
            match page.finish_accessibility_tree_payloads_optional(completion) {
                Ok(Some(nodes)) => CommandOutputPlan::result(json!({ "nodes": nodes })),
                Ok(None) => CommandOutputPlan::error(-32000, "NoDocumentLoaded"),
                Err(error) => CommandOutputPlan::error(
                    -32000,
                    format!("Could not build accessibility tree: {error}"),
                ),
            }
        }
        PendingAccessibilityCommandKind::TopFrameRoot => {
            match page.finish_accessibility_node_payload(completion) {
                Ok(Some(node)) => CommandOutputPlan::result(json!({ "node": node })),
                Ok(None) => CommandOutputPlan::error(-32000, "NoDocumentLoaded"),
                Err(error) => CommandOutputPlan::error(
                    -32000,
                    format!("Could not build root accessibility node: {error}"),
                ),
            }
        }
        PendingAccessibilityCommandKind::ChildFrameFullTree { max_depth } => {
            let _ = max_depth;
            match finish_child_frame_accessibility_nodes_for_protocol(
                page,
                completion,
                "Could not build accessibility tree for frame",
            ) {
                Ok(nodes) => CommandOutputPlan::result(json!({ "nodes": nodes })),
                Err(plan) => plan,
            }
        }
        PendingAccessibilityCommandKind::ChildFrameRoot => {
            match finish_child_frame_accessibility_nodes_for_protocol(
                page,
                completion,
                "Could not build root accessibility node for frame",
            ) {
                Ok(mut nodes) => match nodes.is_empty() {
                    false => CommandOutputPlan::result(json!({ "node": nodes.remove(0) })),
                    true => CommandOutputPlan::error(-32000, "Could not find node with given id"),
                },
                Err(plan) => plan,
            }
        }
        PendingAccessibilityCommandKind::ObjectAccessibilityPayloads {
            frame_id,
            top_frame_id,
            operation,
        } => {
            return AccessibilityCommandDispatchStep::Complete(
                complete_object_accessibility_payloads_command(
                    page,
                    completion,
                    frame_id,
                    top_frame_id,
                    operation,
                ),
            );
        }
        PendingAccessibilityCommandKind::NodeAccessibilityPayloads {
            frame_id,
            top_frame_id,
            operation,
        } => {
            return AccessibilityCommandDispatchStep::Complete(
                complete_node_accessibility_payloads_command(
                    page,
                    completion,
                    frame_id,
                    top_frame_id,
                    operation,
                ),
            );
        }
    };
    AccessibilityCommandDispatchStep::Complete(plan)
}

fn complete_object_accessibility_payloads_command(
    page: &mut moli_core::page::Page,
    completion: CompletedPageCommand,
    frame_id: Option<String>,
    top_frame_id: String,
    operation: AccessibilityNodeOperation,
) -> CommandOutputPlan {
    let payloads = match page.finish_accessibility_payloads_for_object_id(completion) {
        Ok(Some(payloads)) => payloads,
        Ok(None) => {
            return CommandOutputPlan::error(-32000, "Could not find node with given id");
        }
        Err(error) => {
            return CommandOutputPlan::error(
                -32000,
                format!("Could not build accessibility payload for node: {error}"),
            );
        }
    };
    let object_frame_id = payloads
        .frame_id
        .as_deref()
        .unwrap_or(top_frame_id.as_str());
    // Object IDs identify their own frame unless the caller explicitly constrains it.
    if frame_id
        .as_deref()
        .is_some_and(|frame_id| object_frame_id != frame_id)
    {
        return CommandOutputPlan::error(-32000, "Could not find node with given id");
    }
    let Some(mut nodes) = payloads.payloads else {
        return CommandOutputPlan::error(-32000, "Could not find node with given id");
    };
    if let AccessibilityNodeOperation::Query {
        accessible_name,
        role,
    } = operation
    {
        retain_matching_accessibility_nodes(
            &mut nodes,
            accessible_name.as_deref(),
            role.as_deref(),
        );
    }
    CommandOutputPlan::result(json!({ "nodes": nodes }))
}

fn finish_child_frame_accessibility_nodes_for_protocol(
    page: &mut moli_core::page::Page,
    completion: CompletedPageCommand,
    error_prefix: &str,
) -> Result<Vec<Value>, CommandOutputPlan> {
    let payloads = match page.finish_child_frame_accessibility_payloads(completion) {
        Ok(Some(payloads)) => payloads,
        Ok(None) => {
            return Err(CommandOutputPlan::error(
                -32000,
                "Frame with the given id does not belong to the target.",
            ));
        }
        Err(error) => {
            return Err(CommandOutputPlan::error(
                -32000,
                format!("{error_prefix}: {error}"),
            ));
        }
    };
    payloads
        .payloads
        .ok_or_else(|| CommandOutputPlan::error(-32000, "Could not find node with given id"))
}

fn complete_node_accessibility_payloads_command(
    page: &mut moli_core::page::Page,
    completion: CompletedPageCommand,
    frame_id: String,
    top_frame_id: String,
    operation: AccessibilityNodeOperation,
) -> CommandOutputPlan {
    let payloads = match page.finish_accessibility_payloads_for_backend_node_id(completion) {
        Ok(Some(payloads)) => payloads,
        Ok(None) => {
            return CommandOutputPlan::error(-32000, "Could not find node with given id");
        }
        Err(error) => {
            return CommandOutputPlan::error(
                -32000,
                format!("Could not build accessibility payload for node: {error}"),
            );
        }
    };
    let object_frame_id = payloads
        .frame_id
        .as_deref()
        .unwrap_or(top_frame_id.as_str());
    if object_frame_id != frame_id {
        return CommandOutputPlan::error(-32000, "Could not find node with given id");
    }
    let Some(mut nodes) = payloads.payloads else {
        return CommandOutputPlan::error(-32000, "Could not find node with given id");
    };
    if let AccessibilityNodeOperation::Query {
        accessible_name,
        role,
    } = operation
    {
        retain_matching_accessibility_nodes(
            &mut nodes,
            accessible_name.as_deref(),
            role.as_deref(),
        );
    }
    CommandOutputPlan::result(json!({ "nodes": nodes }))
}

fn retain_matching_accessibility_nodes(
    nodes: &mut Vec<Value>,
    accessible_name: Option<&str>,
    role: Option<&str>,
) {
    nodes.retain(|node| {
        let node_role = node["role"]["value"].as_str().unwrap_or_default();
        let node_name = node["name"]["value"].as_str().unwrap_or_default();
        role.is_none_or(|expected| expected == node_role)
            && accessible_name.is_none_or(|expected| expected == node_name)
    });
}