playwright-cdp 0.3.0

Drive Chromium directly via the Chrome DevTools Protocol (CDP) — no Playwright driver required.
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

//! JS dialogs (alert/confirm) + file downloads.
//!
//! Registers `page.on_dialog` (auto-accept) and `page.on_download` handlers
//! before triggering them, then verifies the dialog was accepted and the
//! downloaded file content matches what the server sent.
//!
//! Run: `cargo run --example dialogs_downloads`

use playwright_cdp::options::LaunchOptions;
use playwright_cdp::{Download, Playwright};
use std::sync::Arc;
use tokio::sync::Mutex;

/// A minimal loop-accepting, path-aware HTTP server: serves the demo HTML at
/// `/` and a fixed-body file at `/file`. Returns the base URL.
async fn serve() -> String {
    let l = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    let port = l.local_addr().unwrap().port();
    tokio::spawn(async move {
        loop {
            let Ok((mut s, _)) = l.accept().await else { break };
            tokio::spawn(async move {
                use tokio::io::{AsyncReadExt, AsyncWriteExt};
                let mut buf = [0u8; 4096];
                let _ = s.read(&mut buf).await;
                let req_line = String::from_utf8_lossy(&buf);
                let path = req_line
                    .split_whitespace()
                    .nth(1)
                    .unwrap_or("/")
                    .to_string();
                let (ctype, body) = if path.starts_with("/file") {
                    (
                        "application/octet-stream",
                        "DOWNLOAD-CONTENT" as &'static str,
                    )
                } else {
                    (
                        "text/html",
                        "<!doctype html><html><body>\
                         <button id=\"alert\" onclick=\"alert('hello from page')\">alert</button>\
                         <button id=\"confirm\" onclick=\"window.__conf = confirm('sure?')\">confirm</button>\
                         <a id=\"dl\" href=\"/file\" download>download</a>\
                         </body></html>" as &'static str,
                    )
                };
                let resp = format!(
                    "HTTP/1.1 200 OK\r\nContent-Type: {ctype}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
                    body.len()
                );
                let _ = s.write_all(resp.as_bytes()).await;
                let _ = s.flush().await;
            });
        }
    });
    format!("http://127.0.0.1:{port}/")
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let _ = tracing_subscriber::fmt()
        .with_env_filter(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| "playwright_cdp=info".into()),
        )
        .try_init();

    let browser = Playwright::launch()
        .await?
        .chromium()
        .launch_with_options(LaunchOptions::default())
        .await?;
    println!("browser version: {}", browser.version().await?);

    let base = serve().await;
    println!("serving dialog/download demo page at {base}");

    let page = browser.new_page().await?;

    // --- dialogs: register the auto-accept handler BEFORE navigating ---
    page.on_dialog(|d| {
        println!("dialog: kind={} message={}", d.kind(), d.message());
        async move {
            d.accept(None).await.ok();
        }
    });

    // --- downloads: store the Download handle in a shared slot so main can
    //     read it after the click fires. ---
    let captured: Arc<Mutex<Option<Download>>> = Arc::new(Mutex::new(None));
    let captured_handler = Arc::clone(&captured);
    page.on_download(move |dl| {
        println!("download: url={} name={}", dl.url(), dl.suggested_filename());
        let slot = Arc::clone(&captured_handler);
        async move {
            *slot.lock().await = Some(dl);
        }
    });

    println!("navigating to {base} (handlers armed)...");
    page.goto(&base, None).await?;

    // --- alert: clicking auto-triggers alert(); the handler accepts it. ---
    println!("\nclicking #alert (auto-accepted by on_dialog)...");
    page.locator("#alert").click(None).await?;
    println!("alert dialog handled without blocking the click");

    // --- confirm: clicking sets window.__conf to true (accepted). ---
    println!("\nclicking #confirm (auto-accepted by on_dialog)...");
    page.locator("#confirm").click(None).await?;
    let conf: bool = page.evaluate("window.__conf").await?;
    println!("window.__conf after confirm: {conf}");
    assert!(conf, "confirm should have been accepted -> true");

    // --- download: clicking #dl fetches /file; on_download stores the handle. ---
    println!("\nclicking #dl to start the download...");
    page.locator("#dl").click(None).await?;

    // Poll the shared slot until the handler dropped the Download in.
    let dl = {
        let mut guard = captured.lock().await;
        let mut waited = 0u64;
        while guard.is_none() {
            drop(guard);
            tokio::time::sleep(std::time::Duration::from_millis(50)).await;
            waited += 50;
            if waited > 5000 {
                anyhow::bail!("timed out waiting for on_download to fire");
            }
            guard = captured.lock().await;
        }
        guard.take().unwrap()
    };

    tokio::fs::create_dir_all("examples_out").await?;
    let saved = dl.save_as("examples_out/dl.txt").await?;
    println!("saved download to: {}", saved.display());
    let content = tokio::fs::read_to_string(&saved).await?;
    println!("downloaded file content: {content}");
    assert_eq!(content, "DOWNLOAD-CONTENT");

    println!("\nall dialog + download steps completed.");
    browser.close().await?;
    println!("done.");
    Ok(())
}