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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

//! Browser client trait for browser abstraction
//!
//! This trait defines the interface for browser operations, enabling
//! mock implementations for testing and alternative browser backends.

use crate::actor::Page;
use crate::browser::cdp::CdpClient;
use crate::browser::views::{SessionInfo, TabInfo};
use crate::error::Result;
use async_trait::async_trait;
use std::sync::Arc;

/// Trait for browser client operations
///
/// This trait provides a unified interface for browser automation,
/// abstracting over concrete browser implementations.
#[async_trait]
pub trait BrowserClient: Send + Sync {
    /// Start the browser session
    async fn start(&mut self) -> Result<()>;

    /// Stop the browser session and clean up resources gracefully.
    /// Default does nothing (for mocks or external browsers we don't own).
    async fn stop(&mut self) -> Result<()> {
        Ok(())
    }

    /// Navigate to the specified URL
    async fn navigate(&mut self, url: &str) -> Result<()>;

    /// Get the current page URL
    async fn get_current_url(&self) -> Result<String>;

    /// Create a new tab with optional URL
    async fn create_tab(&mut self, url: Option<&str>) -> Result<String>;

    /// Switch to a different tab by target ID
    async fn switch_to_tab(&mut self, target_id: &str) -> Result<()>;

    /// Close a tab by target ID
    async fn close_tab(&mut self, target_id: &str) -> Result<()>;

    /// Get all open tabs
    async fn get_tabs(&self) -> Result<Vec<TabInfo>>;

    /// Get target ID from short tab ID (last 4 characters)
    async fn get_target_id_from_tab_id(&self, tab_id: &str) -> Result<String>;

    /// Get a Page actor for the current session
    fn get_page(&self) -> Result<Page>;

    /// Take a screenshot of the current page
    async fn take_screenshot(&self, path: Option<&str>, full_page: bool) -> Result<Vec<u8>>;

    /// Get the current page title
    #[deprecated(since = "0.1.2", note = "Use get_session_info() instead")]
    async fn get_current_page_title(&self) -> Result<String>;

    /// Get the CDP client for the current session
    fn get_cdp_client(&self) -> Result<Arc<CdpClient>>;

    /// Get a cookie manager for the current browser context
    fn cookie_manager(&self) -> Result<crate::browser::cookies::CookieManager> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::cookies::CookieManager::new(client))
    }

    /// Get a console log manager for the current browser context
    fn console_manager(&self) -> Result<crate::browser::console::ConsoleManager> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::console::ConsoleManager::new(client))
    }

    /// Get a storage manager for the current browser context
    fn storage_manager(&self) -> crate::browser::storage::StorageManager {
        crate::browser::storage::StorageManager::new()
    }

    /// Get a viewport manager for the current browser context
    fn viewport_manager(&self) -> crate::error::Result<crate::browser::viewport::ViewportManager> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::viewport::ViewportManager::new(client))
    }

    /// Get a PDF manager for the current browser context
    fn pdf_manager(&self) -> crate::error::Result<crate::browser::pdf::PdfManager> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::pdf::PdfManager::new(client))
    }

    /// Get a download manager for the current browser context
    fn download_manager(&self) -> crate::error::Result<crate::browser::download::DownloadManager> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::download::DownloadManager::new(client))
    }

    /// Get an auth manager for the current browser context
    fn auth_manager(&self) -> crate::error::Result<crate::browser::auth::AuthManager> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::auth::AuthManager::new(client))
    }

    /// Get a performance manager for the current browser context
    fn performance_manager(&self) -> crate::error::Result<crate::browser::performance::PerformanceManager> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::performance::PerformanceManager::new(client))
    }

    /// Get a HAR manager for the current browser context
    fn har_manager(&self) -> crate::error::Result<crate::browser::har::HarManager> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::har::HarManager::new(client))
    }

    /// Get a coverage manager for the current browser context
    fn coverage_manager(&self) -> crate::error::Result<crate::browser::coverage::CoverageManager> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::coverage::CoverageManager::new(client))
    }

    /// Get a network interceptor for the current browser context
    fn network_interceptor(&self) -> crate::error::Result<crate::browser::interceptor::NetworkInterceptor> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::interceptor::NetworkInterceptor::new(client))
    }

    /// Get a dialog manager for the current browser context
    fn dialog_manager(&self) -> crate::error::Result<crate::browser::dialog::DialogManager> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::dialog::DialogManager::new(client))
    }

    /// Get a file chooser manager for the current browser context
    fn filechooser_manager(&self) -> crate::error::Result<crate::browser::filechooser::FileChooserManager> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::filechooser::FileChooserManager::new(client))
    }

    /// Get a permissions manager for the current browser context
    fn permissions_manager(&self) -> crate::error::Result<crate::browser::permissions::PermissionsManager> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::permissions::PermissionsManager::new(client))
    }

    /// Get a tracing manager for the current browser context
    fn tracing_manager(&self) -> crate::error::Result<crate::browser::tracing::TracingManager> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::tracing::TracingManager::new(client))
    }

    /// Send a raw CDP command directly (power-user access to unwrapped CDP features)
    async fn raw_cdp_command(&self, method: &str, params: serde_json::Value) -> crate::error::Result<serde_json::Value> {
        let client = self.get_cdp_client()?;
        client.send_command(method, params).await
    }

    /// Get a touch manager for the current browser context
    fn touch_manager(&self) -> crate::error::Result<crate::browser::touch::TouchManager> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::touch::TouchManager::new(client))
    }

    /// Get a worker manager for the current browser context
    fn worker_manager(&self) -> crate::error::Result<crate::browser::worker::WorkerManager> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::worker::WorkerManager::new(client))
    }

    /// Get a service worker manager for the current browser context
    fn service_worker_manager(&self) -> crate::error::Result<crate::browser::serviceworker::ServiceWorkerManager> {
        let client = self.get_cdp_client()?;
        Ok(crate::browser::serviceworker::ServiceWorkerManager::new(client))
    }

    /// Get the session ID for the current target
    #[deprecated(since = "0.1.2", note = "Use get_session_info() instead")]
    fn get_session_id(&self) -> Result<String>;

    /// Get the current target ID
    #[deprecated(since = "0.1.2", note = "Use get_session_info() instead")]
    fn get_current_target_id(&self) -> Result<String>;

    /// Get streamlined session information (URL, title, target ID, session ID)
    async fn get_session_info(&self) -> Result<SessionInfo>;
}