chromewright 0.2.3

Browser automation MCP server and Rust library via Chrome DevTools Protocol (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

use std::path::PathBuf;

/// Options for launching a new browser instance
#[derive(Debug, Clone)]
pub struct LaunchOptions {
    /// Whether to run browser in headless mode (default: true)
    pub headless: bool,

    /// Custom Chrome/Chromium binary path
    pub chrome_path: Option<PathBuf>,

    /// Browser window width (default: 1280)
    pub window_width: u32,

    /// Browser window height (default: 720)
    pub window_height: u32,

    /// User data directory for browser profile
    pub user_data_dir: Option<PathBuf>,

    /// DevTools debugging port for the launched browser.
    /// If not provided, the library chooses an available local port.
    pub debug_port: Option<u16>,

    /// Enable sandbox mode (default: true)
    pub sandbox: bool,

    /// Timeout for browser launch in milliseconds (default: 30000)
    pub launch_timeout: u64,
}

impl Default for LaunchOptions {
    fn default() -> Self {
        Self {
            headless: true,
            chrome_path: None,
            window_width: 1280,
            window_height: 720,
            user_data_dir: None,
            debug_port: None,
            sandbox: true,
            launch_timeout: 30000,
        }
    }
}

impl LaunchOptions {
    /// Create new LaunchOptions with default values
    pub fn new() -> Self {
        Self::default()
    }

    /// Builder method: set headless mode
    pub fn headless(mut self, headless: bool) -> Self {
        self.headless = headless;
        self
    }

    /// Builder method: set Chrome binary path
    pub fn chrome_path(mut self, path: PathBuf) -> Self {
        self.chrome_path = Some(path);
        self
    }

    /// Builder method: set window dimensions
    pub fn window_size(mut self, width: u32, height: u32) -> Self {
        self.window_width = width;
        self.window_height = height;
        self
    }

    /// Builder method: set user data directory
    pub fn user_data_dir(mut self, dir: PathBuf) -> Self {
        self.user_data_dir = Some(dir);
        self
    }

    /// Builder method: set DevTools debugging port
    pub fn debug_port(mut self, port: u16) -> Self {
        self.debug_port = Some(port);
        self
    }

    /// Builder method: enable/disable sandbox
    pub fn sandbox(mut self, sandbox: bool) -> Self {
        self.sandbox = sandbox;
        self
    }

    /// Builder method: set launch timeout
    pub fn launch_timeout(mut self, timeout_ms: u64) -> Self {
        self.launch_timeout = timeout_ms;
        self
    }
}

/// Options for connecting to an existing browser instance
#[derive(Debug, Clone)]
pub struct ConnectionOptions {
    /// WebSocket URL for Chrome DevTools Protocol
    pub ws_url: String,

    /// Connection timeout in milliseconds (default: 10000)
    pub timeout: u64,
}

impl ConnectionOptions {
    /// Create new ConnectionOptions with WebSocket URL
    pub fn new<S: Into<String>>(ws_url: S) -> Self {
        Self {
            ws_url: ws_url.into(),
            timeout: 10000,
        }
    }

    /// Builder method: set connection timeout
    pub fn timeout(mut self, timeout_ms: u64) -> Self {
        self.timeout = timeout_ms;
        self
    }
}

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

    #[test]
    fn test_launch_options_default() {
        let opts = LaunchOptions::default();
        assert!(opts.headless);
        assert_eq!(opts.window_width, 1280);
        assert_eq!(opts.window_height, 720);
        assert_eq!(opts.debug_port, None);
        assert!(opts.sandbox);
        assert_eq!(opts.launch_timeout, 30000);
    }

    #[test]
    fn test_launch_options_builder() {
        let opts = LaunchOptions::new()
            .headless(false)
            .window_size(1920, 1080)
            .debug_port(9222)
            .sandbox(false)
            .launch_timeout(60000);

        assert!(!opts.headless);
        assert_eq!(opts.window_width, 1920);
        assert_eq!(opts.window_height, 1080);
        assert_eq!(opts.debug_port, Some(9222));
        assert!(!opts.sandbox);
        assert_eq!(opts.launch_timeout, 60000);
    }

    #[test]
    fn test_connection_options() {
        let opts = ConnectionOptions::new("ws://localhost:9222").timeout(5000);

        assert_eq!(opts.ws_url, "ws://localhost:9222");
        assert_eq!(opts.timeout, 5000);
    }
}