teasr-core 0.2.0

Core orchestration and capture for teasr
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

use anyhow::{Context, Result};
use chromiumoxide::browser::{Browser, BrowserConfig};
use chromiumoxide::cdp::browser_protocol::page::CaptureScreenshotFormat;
use futures::StreamExt;
use std::path::Path;
use std::time::Duration;

use crate::types::{ActionType, CaptureAction, ViewportConfig};

/// Capture a web page screenshot via CDP.
pub async fn capture(
    page_url: &str,
    viewport: &ViewportConfig,
    actions: &[CaptureAction],
    output_path: &Path,
) -> Result<()> {
    let config = BrowserConfig::builder()
        .window_size(viewport.width, viewport.height)
        .no_sandbox()
        .build()
        .map_err(|e| anyhow::anyhow!("browser config error: {e}"))?;

    let (mut browser, mut handler) = Browser::launch(config)
        .await
        .context("failed to launch browser")?;

    let handle = tokio::spawn(async move {
        while let Some(_event) = handler.next().await {}
    });

    let page = browser
        .new_page("about:blank")
        .await
        .context("failed to create page")?;

    // Navigate and wait with timeout
    page.goto(page_url).await.context("navigation failed")?;
    tokio::time::sleep(Duration::from_millis(1000)).await;

    // Execute actions
    for action in actions {
        execute_action(&page, action).await?;
    }

    let screenshot = page
        .screenshot(
            chromiumoxide::page::ScreenshotParams::builder()
                .format(CaptureScreenshotFormat::Png)
                .full_page(true)
                .build(),
        )
        .await
        .context("failed to take screenshot")?;

    std::fs::write(output_path, &screenshot)
        .with_context(|| format!("failed to write {}", output_path.display()))?;

    browser.close().await.ok();
    handle.await.ok();

    Ok(())
}

async fn execute_action(
    page: &chromiumoxide::Page,
    action: &CaptureAction,
) -> Result<()> {
    if let Some(delay) = action.delay {
        tokio::time::sleep(Duration::from_millis(delay)).await;
    }

    match action.action_type {
        ActionType::Click => {
            if let Some(sel) = &action.selector {
                page.find_element(sel)
                    .await
                    .context("element not found")?
                    .click()
                    .await
                    .context("click failed")?;
            }
        }
        ActionType::Hover => {
            if let Some(sel) = &action.selector {
                page.find_element(sel)
                    .await
                    .context("element not found")?
                    .click()
                    .await
                    .context("hover failed")?;
            }
        }
        ActionType::ScrollTo => {
            if let Some(sel) = &action.selector {
                let js = format!(
                    "document.querySelector('{}').scrollIntoView({{behavior:'smooth'}})",
                    sel.replace('\'', "\\'")
                );
                page.evaluate(js).await.context("scroll failed")?;
                tokio::time::sleep(Duration::from_millis(500)).await;
            }
        }
        ActionType::Wait => {
            let ms = action.delay.unwrap_or(1000);
            tokio::time::sleep(Duration::from_millis(ms)).await;
        }
        ActionType::Screenshot => {
            // Inline screenshot during action sequence
        }
    }

    Ok(())
}