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

//! Browser permissions management via CDP Browser domain

use crate::browser::views::PermissionType;
use crate::error::Result;
use std::sync::Arc;

/// Manages browser permissions (camera, microphone, notifications, etc.)
#[derive(Debug, Clone)]
pub struct PermissionsManager {
    client: Arc<crate::browser::cdp::CdpClient>,
}

impl PermissionsManager {
    /// Create a new permissions manager
    pub fn new(client: Arc<crate::browser::cdp::CdpClient>) -> Self {
        Self { client }
    }

    /// Grant permissions for a specific origin.
    /// Common permissions: videoCapture, audioCapture, geolocation, notifications, clipboardReadWrite, displayCapture, sensors, etc.
    pub async fn grant(&self, origin: &str, permissions: Vec<PermissionType>) -> Result<()> {
        let perms: Vec<String> = permissions
            .into_iter()
            .map(|p| serde_json::to_string(&p).unwrap().trim_matches('"').to_string())
            .collect();

        self.client
            .send_command(
                "Browser.grantPermissions",
                serde_json::json!({
                    "origin": origin,
                    "permissions": perms,
                }),
            )
            .await?;
        Ok(())
    }

    /// Reset all permissions for a specific origin
    pub async fn reset(&self, origin: &str) -> Result<()> {
        self.client
            .send_command(
                "Browser.resetPermissions",
                serde_json::json!({ "origin": origin }),
            )
            .await?;
        Ok(())
    }

    /// Convenience: grant camera permission
    pub async fn grant_camera(&self, origin: &str) -> Result<()> {
        self.grant(origin, vec![PermissionType::VideoCapture]).await
    }

    /// Convenience: grant microphone permission
    pub async fn grant_microphone(&self, origin: &str) -> Result<()> {
        self.grant(origin, vec![PermissionType::AudioCapture]).await
    }

    /// Convenience: grant camera + microphone permissions
    pub async fn grant_camera_and_microphone(&self, origin: &str) -> Result<()> {
        self.grant(origin, vec![PermissionType::VideoCapture, PermissionType::AudioCapture])
            .await
    }

    /// Convenience: grant notifications permission
    pub async fn grant_notifications(&self, origin: &str) -> Result<()> {
        self.grant(origin, vec![PermissionType::Notifications]).await
    }

    /// Convenience: grant geolocation permission
    pub async fn grant_geolocation(&self, origin: &str) -> Result<()> {
        self.grant(origin, vec![PermissionType::Geolocation]).await
    }

    /// Convenience: grant clipboard access
    pub async fn grant_clipboard(&self, origin: &str) -> Result<()> {
        self.grant(origin, vec![PermissionType::ClipboardReadWrite]).await
    }

    /// Convenience: grant all common permissions for an origin
    pub async fn grant_all_common(&self, origin: &str) -> Result<()> {
        self.grant(
            origin,
            vec![
                PermissionType::VideoCapture,
                PermissionType::AudioCapture,
                PermissionType::Geolocation,
                PermissionType::Notifications,
                PermissionType::ClipboardReadWrite,
                PermissionType::DisplayCapture,
                PermissionType::Sensors,
            ],
        )
        .await
    }
}

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

    #[test]
    fn test_permission_type_serialization() {
        let perm = PermissionType::VideoCapture;
        let json = serde_json::to_string(&perm).unwrap();
        assert_eq!(json, "\"videoCapture\"");

        let perm = PermissionType::AudioCapture;
        let json = serde_json::to_string(&perm).unwrap();
        assert_eq!(json, "\"audioCapture\"");
    }

    #[test]
    fn test_permission_types_roundtrip() {
        let types = vec![
            PermissionType::VideoCapture,
            PermissionType::AudioCapture,
            PermissionType::Geolocation,
            PermissionType::Notifications,
            PermissionType::ClipboardReadWrite,
            PermissionType::DisplayCapture,
            PermissionType::Sensors,
            PermissionType::Nfc,
            PermissionType::Midi,
            PermissionType::MidiSysex,
            PermissionType::WakeLockScreen,
            PermissionType::WakeLockSystem,
            PermissionType::StorageAccess,
            PermissionType::WindowManagement,
            PermissionType::BackgroundSync,
            PermissionType::PaymentHandler,
        ];
        for t in types {
            let json = serde_json::to_string(&t).unwrap();
            assert!(!json.is_empty());
        }
    }
}