browsing 0.1.7

Browser automation: navigate, click, extract, screenshot. Standalone browser control via CDP.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

//! File chooser dialog interception via CDP Page domain

use crate::browser::views::FileChooserInfo;
use crate::error::Result;
use std::collections::VecDeque;
use std::sync::Arc;
use tokio::sync::Mutex;

/// Manages file chooser dialog interception
#[derive(Debug, Clone)]
pub struct FileChooserManager {
    client: Arc<crate::browser::cdp::CdpClient>,
    pending: Arc<Mutex<VecDeque<FileChooserInfo>>>,
}

impl FileChooserManager {
    /// Create a new file chooser manager
    pub fn new(client: Arc<crate::browser::cdp::CdpClient>) -> Self {
        Self {
            client,
            pending: Arc::new(Mutex::new(VecDeque::new())),
        }
    }

    /// Enable file chooser interception.
    /// Subscribes to `Page.fileChooserOpened` events.
    pub async fn enable(&self) -> Result<()> {
        self.client
            .send_command("Page.enable", serde_json::json!({}))
            .await?;
        self.client
            .send_command(
                "Page.setInterceptFileChooserDialog",
                serde_json::json!({ "enabled": true }),
            )
            .await?;

        let pending = Arc::clone(&self.pending);
        let mut rx = self.client.subscribe_events().await?;

        tokio::spawn(async move {
            while let Ok(event) = rx.recv().await {
                if event.method == "Page.fileChooserOpened" {
                    let frame_id = event
                        .params
                        .get("frameId")
                        .and_then(|v| v.as_str())
                        .unwrap_or("")
                        .to_string();
                    let backend_node_id = event
                        .params
                        .get("backendNodeId")
                        .and_then(|v| v.as_u64())
                        .unwrap_or(0) as u32;
                    let multiple = event
                        .params
                        .get("multiple")
                        .and_then(|v| v.as_bool())
                        .unwrap_or(false);

                    let info = FileChooserInfo {
                        frame_id,
                        backend_node_id,
                        multiple,
                    };
                    pending.lock().await.push_back(info);
                }
            }
        });

        Ok(())
    }

    /// Disable file chooser interception
    pub async fn disable(&self) -> Result<()> {
        self.client
            .send_command(
                "Page.setInterceptFileChooserDialog",
                serde_json::json!({ "enabled": false }),
            )
            .await?;
        self.pending.lock().await.clear();
        Ok(())
    }

    /// Set files on the next pending file chooser using DOM.setFileInputFiles
    pub async fn set_files(&self, paths: Vec<String>) -> Result<()> {
        let info = self
            .pending
            .lock()
            .await
            .pop_front()
            .ok_or_else(|| crate::error::BrowsingError::Browser("No pending file chooser".to_string()))?;

        self.client
            .send_command(
                "DOM.setFileInputFiles",
                serde_json::json!({
                    "files": paths,
                    "backendNodeId": info.backend_node_id,
                }),
            )
            .await?;

        Ok(())
    }

    /// Get all pending file choosers
    pub async fn get_pending(&self) -> Vec<FileChooserInfo> {
        self.pending.lock().await.iter().cloned().collect()
    }

    /// Get the next pending file chooser
    pub async fn next(&self) -> Option<FileChooserInfo> {
        self.pending.lock().await.pop_front()
    }

    /// Check if any file chooser is pending
    pub async fn has_pending(&self) -> bool {
        !self.pending.lock().await.is_empty()
    }

    /// Clear pending chooser records without interacting with the browser
    pub async fn clear(&self) {
        self.pending.lock().await.clear();
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_file_chooser_info_creation() {
        let info = FileChooserInfo {
            frame_id: "frame-1".to_string(),
            backend_node_id: 42,
            multiple: true,
        };
        assert_eq!(info.frame_id, "frame-1");
        assert_eq!(info.backend_node_id, 42);
        assert!(info.multiple);
    }

    #[test]
    fn test_file_chooser_info_serialization() {
        let info = FileChooserInfo {
            frame_id: "frame-1".to_string(),
            backend_node_id: 42,
            multiple: false,
        };
        let json = serde_json::to_string(&info).unwrap();
        assert!(json.contains("frame-1"));
        assert!(json.contains("42"));
    }
}