browser-use 0.2.3

A lightweight Rust library for browser automation via Chrome DevTools Protocol (CDP), featuring a built-in Model Context Protocol (MCP) server for AI-driven browser automation
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
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388

use browser_use::tools::{
    CloseTabParams, NewTabParams, SwitchTabParams, TabListParams, Tool, ToolContext,
    close_tab::CloseTabTool, new_tab::NewTabTool, switch_tab::SwitchTabTool, tab_list::TabListTool,
};
use browser_use::{BrowserSession, LaunchOptions};
use log::info;

#[test]
#[ignore]
fn test_new_tab() {
    use browser_use::tools::{NewTabParams, Tool, ToolContext, new_tab::NewTabTool};

    let session = BrowserSession::launch(LaunchOptions::new().headless(true))
        .expect("Failed to launch browser");

    // Navigate to initial page
    session
        .navigate("data:text/html,<html><body><h1>First Tab</h1></body></html>")
        .expect("Failed to navigate");

    std::thread::sleep(std::time::Duration::from_millis(500));

    // Get initial tab count
    let initial_tabs = session.get_tabs().expect("Failed to get tabs");
    let initial_count = initial_tabs.len();
    info!("Initial tab count: {}", initial_count);

    // Create tool and context
    let tool = NewTabTool::default();
    let mut context = ToolContext::new(&session);

    // Execute the tool to create a new tab
    let result = tool
        .execute_typed(
            NewTabParams {
                url: "data:text/html,<html><body><h1>Second Tab</h1></body></html>".to_string(),
            },
            &mut context,
        )
        .expect("Failed to execute new_tab tool");

    // Verify the result
    assert!(result.success, "Tool execution should succeed");
    assert!(result.data.is_some());

    let data = result.data.unwrap();
    assert!(
        data["url"].as_str().is_some(),
        "Result should contain url field"
    );
    assert!(
        data["message"].as_str().is_some(),
        "Result should contain message field"
    );

    info!(
        "New tab result: {}",
        serde_json::to_string_pretty(&data).unwrap()
    );

    std::thread::sleep(std::time::Duration::from_millis(500));

    // Verify tab count increased
    let final_tabs = session.get_tabs().expect("Failed to get tabs");
    let final_count = final_tabs.len();
    info!("Final tab count: {}", final_count);

    assert_eq!(
        final_count,
        initial_count + 1,
        "Tab count should increase by 1"
    );
}

#[test]
#[ignore] // Requires Chrome to be installed
fn test_tab_list() {
    let session = BrowserSession::launch(LaunchOptions::new().headless(true))
        .expect("Failed to launch browser");

    // Navigate to a simple page
    session
        .navigate("data:text/html,<html><body><h1>First Tab</h1></body></html>")
        .expect("Failed to navigate");

    std::thread::sleep(std::time::Duration::from_millis(500));

    // Create tool and context
    let tool = TabListTool::default();
    let mut context = ToolContext::new(&session);

    // Execute the tool
    let result = tool
        .execute_typed(TabListParams {}, &mut context)
        .expect("Failed to execute tab_list tool");

    // Verify the result
    assert!(result.success, "Tool execution should succeed");
    assert!(result.data.is_some());

    let data = result.data.unwrap();
    let tab_list = data["tab_list"].as_array().expect("No tab_list field");
    let count = data["count"].as_u64().expect("No count field");

    info!(
        "Tab list: {}",
        serde_json::to_string_pretty(&tab_list).unwrap()
    );

    // Should have at least 1 tab
    assert!(count >= 1, "Expected at least 1 tab");
    assert_eq!(tab_list.len() as u64, count);

    // Check first tab structure
    let first_tab = &tab_list[0];
    assert!(first_tab["index"].is_number(), "Tab should have index");
    assert!(
        first_tab["active"].is_boolean(),
        "Tab should have active flag"
    );
    assert!(first_tab["title"].is_string(), "Tab should have title");
    assert!(first_tab["url"].is_string(), "Tab should have url");
}

#[test]
#[ignore]
fn test_new_tab_and_switch() {
    let session = BrowserSession::launch(LaunchOptions::new().headless(true))
        .expect("Failed to launch browser");

    // Navigate to initial page
    session
        .navigate("data:text/html,<html><body><h1>First Tab</h1></body></html>")
        .expect("Failed to navigate");

    std::thread::sleep(std::time::Duration::from_millis(500));

    // Create a new tab
    let new_tab_tool = NewTabTool::default();
    let mut context = ToolContext::new(&session);

    let result = new_tab_tool
        .execute_typed(
            NewTabParams {
                url: "data:text/html,<html><body><h1>Second Tab</h1></body></html>".to_string(),
            },
            &mut context,
        )
        .expect("Failed to execute new_tab tool");

    assert!(result.success, "New tab creation should succeed");

    std::thread::sleep(std::time::Duration::from_millis(500));

    // List tabs to verify count increased by 1
    let tab_list_tool = TabListTool::default();
    let mut context = ToolContext::new(&session);

    let result = tab_list_tool
        .execute_typed(TabListParams {}, &mut context)
        .expect("Failed to execute tab_list tool");

    assert!(result.success);
    let data = result.data.unwrap();
    let count = data["count"].as_u64().expect("No count field");

    info!("Tab count after creating new tab: {}", count);
    assert!(count >= 2, "Should have at least 2 tabs, got {}", count);

    // Switch to first tab (index 0)
    let switch_tab_tool = SwitchTabTool::default();
    let mut context = ToolContext::new(&session);

    let result = switch_tab_tool
        .execute_typed(SwitchTabParams { index: 0 }, &mut context)
        .expect("Failed to execute switch_tab tool");

    assert!(result.success, "Switch tab should succeed");

    let data = result.data.unwrap();
    assert_eq!(data["index"].as_u64(), Some(0));
    info!(
        "Switched to tab: {}",
        serde_json::to_string_pretty(&data).unwrap()
    );
}

#[test]
#[ignore]
fn test_switch_tab_invalid_index() {
    let session = BrowserSession::launch(LaunchOptions::new().headless(true))
        .expect("Failed to launch browser");

    session
        .navigate("data:text/html,<html><body><h1>Tab</h1></body></html>")
        .expect("Failed to navigate");

    std::thread::sleep(std::time::Duration::from_millis(500));

    // Try to switch to invalid index
    let switch_tab_tool = SwitchTabTool::default();
    let mut context = ToolContext::new(&session);

    let result = switch_tab_tool
        .execute_typed(SwitchTabParams { index: 999 }, &mut context)
        .expect("Failed to execute switch_tab tool");

    // Should fail gracefully
    assert!(!result.success, "Should fail for invalid index");
    assert!(result.error.is_some());
    info!("Expected error: {}", result.error.unwrap());
}

#[test]
#[ignore]
fn test_close_tab() {
    let session = BrowserSession::launch(LaunchOptions::new().headless(true))
        .expect("Failed to launch browser");

    // Create two tabs
    session
        .navigate("data:text/html,<html><body><h1>First Tab</h1></body></html>")
        .expect("Failed to navigate");

    std::thread::sleep(std::time::Duration::from_millis(500));

    let new_tab_tool = NewTabTool::default();
    let mut context = ToolContext::new(&session);

    new_tab_tool
        .execute_typed(
            NewTabParams {
                url: "data:text/html,<html><body><h1>Second Tab</h1></body></html>".to_string(),
            },
            &mut context,
        )
        .expect("Failed to create new tab");

    std::thread::sleep(std::time::Duration::from_millis(500));

    // Verify we have at least 2 tabs
    let tab_list_tool = TabListTool::default();
    let mut context = ToolContext::new(&session);

    let result = tab_list_tool
        .execute_typed(TabListParams {}, &mut context)
        .expect("Failed to execute tab_list tool");

    let count_before = result.data.unwrap()["count"].as_u64().unwrap();
    info!("Tab count before closing: {}", count_before);
    assert!(
        count_before >= 2,
        "Should have at least 2 tabs before closing, got {}",
        count_before
    );

    // Close the active tab (second tab)
    let close_tab_tool = CloseTabTool::default();
    let mut context = ToolContext::new(&session);

    let result = close_tab_tool
        .execute_typed(CloseTabParams {}, &mut context)
        .expect("Failed to execute close_tab tool");

    assert!(result.success, "Close tab should succeed");
    info!(
        "Closed tab: {}",
        serde_json::to_string_pretty(&result.data.unwrap()).unwrap()
    );

    std::thread::sleep(std::time::Duration::from_millis(500));

    // Verify we now have one less tab
    let mut context = ToolContext::new(&session);
    let result = tab_list_tool
        .execute_typed(TabListParams {}, &mut context)
        .expect("Failed to execute tab_list tool");

    let count_after = result.data.unwrap()["count"].as_u64().unwrap();
    info!("Tab count after closing: {}", count_after);
    assert_eq!(
        count_after,
        count_before - 1,
        "Should have one less tab after closing"
    );
}

#[test]
#[ignore]
fn test_tab_workflow() {
    // Test a complete workflow: create multiple tabs, switch between them, list them, and close one
    let session = BrowserSession::launch(LaunchOptions::new().headless(true))
        .expect("Failed to launch browser");

    // Start with first tab
    session
        .navigate("data:text/html,<html><body><h1>Tab 1</h1></body></html>")
        .expect("Failed to navigate");

    std::thread::sleep(std::time::Duration::from_millis(300));

    // Create second tab
    let new_tab_tool = NewTabTool::default();
    let mut context = ToolContext::new(&session);

    new_tab_tool
        .execute_typed(
            NewTabParams {
                url: "data:text/html,<html><body><h1>Tab 2</h1></body></html>".to_string(),
            },
            &mut context,
        )
        .expect("Failed to create tab 2");

    std::thread::sleep(std::time::Duration::from_millis(300));

    // Create third tab
    let mut context = ToolContext::new(&session);
    new_tab_tool
        .execute_typed(
            NewTabParams {
                url: "data:text/html,<html><body><h1>Tab 3</h1></body></html>".to_string(),
            },
            &mut context,
        )
        .expect("Failed to create tab 3");

    std::thread::sleep(std::time::Duration::from_millis(300));

    // List all tabs
    let tab_list_tool = TabListTool::default();
    let mut context = ToolContext::new(&session);

    let result = tab_list_tool
        .execute_typed(TabListParams {}, &mut context)
        .expect("Failed to list tabs");

    let count = result.data.as_ref().unwrap()["count"].as_u64().unwrap();
    info!("Total tabs: {}", count);
    assert!(count >= 3, "Should have at least 3 tabs, got {}", count);
    info!(
        "All tabs: {}",
        result.data.unwrap()["summary"].as_str().unwrap()
    );

    // Switch to second tab (index 1)
    let switch_tab_tool = SwitchTabTool::default();
    let mut context = ToolContext::new(&session);

    let result = switch_tab_tool
        .execute_typed(SwitchTabParams { index: 1 }, &mut context)
        .expect("Failed to switch to tab 1");

    assert!(result.success);
    assert_eq!(result.data.unwrap()["index"].as_u64(), Some(1));

    std::thread::sleep(std::time::Duration::from_millis(300));

    // Close the current tab (tab 2, index 1)
    let close_tab_tool = CloseTabTool::default();
    let mut context = ToolContext::new(&session);

    let result = close_tab_tool
        .execute_typed(CloseTabParams {}, &mut context)
        .expect("Failed to close tab");

    assert!(result.success);
    info!(
        "Closed: {}",
        result.data.unwrap()["message"].as_str().unwrap()
    );

    std::thread::sleep(std::time::Duration::from_millis(300));

    // List tabs again to verify we have 2 tabs left
    let mut context = ToolContext::new(&session);
    let result = tab_list_tool
        .execute_typed(TabListParams {}, &mut context)
        .expect("Failed to list tabs");

    let final_count = result.data.unwrap()["count"].as_u64().unwrap();
    info!("Final tab count: {}", final_count);
    assert_eq!(
        final_count,
        count - 1,
        "Should have one less tab after closing"
    );
}