chrome-agent 0.16.0

Web tasks that compile. Browser automation that reads the page back after every action and reports what actually happened, in JSON. Single binary, CDP direct to Chrome.
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

//! Relationships between typed pipe fields that serde cannot express.

use crate::pipe_command::{EmulateArgs, PipeCommand, WaitArgs};

pub fn validate(command: &PipeCommand) -> Result<(), crate::BoxError> {
    match command {
        PipeCommand::Click(args) | PipeCommand::Dblclick(args) => {
            exactly_one(
                command.name(),
                &[
                    args.uid.is_some(),
                    args.selector.is_some(),
                    args.xy.is_some(),
                ],
                "\"uid\", \"selector\", or \"xy\"",
            )?;
            on_intercept(args.on_intercept.as_deref())?;
        }
        PipeCommand::Fill(args) => exactly_one(
            command.name(),
            &[args.uid.is_some(), args.selector.is_some()],
            "\"uid\" or \"selector\"",
        )?,
        PipeCommand::Select(args) => exactly_one(
            command.name(),
            &[args.uid.is_some(), args.selector.is_some()],
            "\"uid\" or \"selector\"",
        )?,
        PipeCommand::Check(args) => {
            exactly_one(
                command.name(),
                &[args.uid.is_some(), args.selector.is_some()],
                "\"uid\" or \"selector\"",
            )?;
            on_intercept(args.on_intercept.as_deref())?;
        }
        PipeCommand::Uncheck(args) => {
            exactly_one(
                command.name(),
                &[args.uid.is_some(), args.selector.is_some()],
                "\"uid\" or \"selector\"",
            )?;
            on_intercept(args.on_intercept.as_deref())?;
        }
        PipeCommand::Upload(args) => exactly_one(
            command.name(),
            &[args.uid.is_some(), args.selector.is_some()],
            "\"uid\" or \"selector\"",
        )?,
        PipeCommand::Text(args) => at_most_one(
            command.name(),
            &[args.uid.is_some(), args.selector.is_some()],
            "\"uid\" or \"selector\"",
        )?,
        PipeCommand::Screenshot(args) => at_most_one(
            command.name(),
            &[args.uid.is_some(), args.selector.is_some()],
            "\"uid\" or \"selector\"",
        )?,
        PipeCommand::Download(args) => {
            exactly_one(
                command.name(),
                &[
                    args.url.is_some(),
                    args.uid.is_some(),
                    args.selector.is_some(),
                ],
                "\"url\", \"uid\", or \"selector\"",
            )?;
            on_intercept(args.on_intercept.as_deref())?;
        }
        PipeCommand::FillAndSubmit(args) => on_intercept(args.on_intercept.as_deref())?,
        PipeCommand::Wait(args) => wait_shape(args)?,
        PipeCommand::Emulate(args) => emulate_shape(args)?,
        _ => {}
    }
    Ok(())
}

fn exactly_one(name: &str, present: &[bool], choices: &str) -> Result<(), crate::BoxError> {
    if present.iter().filter(|&&set| set).count() == 1 {
        Ok(())
    } else {
        Err(format!("{name}: provide exactly one of {choices}").into())
    }
}

fn at_most_one(name: &str, present: &[bool], choices: &str) -> Result<(), crate::BoxError> {
    if present.iter().filter(|&&set| set).count() <= 1 {
        Ok(())
    } else {
        Err(format!("{name}: provide at most one of {choices}").into())
    }
}

fn on_intercept(value: Option<&str>) -> Result<(), crate::BoxError> {
    value.map_or(Ok(()), |value| {
        crate::hit_test::OnIntercept::parse(value)
            .map(|_| ())
            .map_err(Into::into)
    })
}

fn wait_shape(args: &WaitArgs) -> Result<(), crate::BoxError> {
    let explicit = args.what.is_some() || args.pattern.is_some();
    let shortcuts = [
        args.text.is_some(),
        args.url.is_some(),
        args.selector.is_some(),
    ]
    .into_iter()
    .filter(|set| *set)
    .count();
    if args.pattern.is_some() && args.what.is_none() {
        return Err("wait: \"pattern\" requires \"what\"".into());
    }
    if shortcuts > 1 || (explicit && shortcuts != 0) {
        return Err("wait: provide either \"what\"/\"pattern\" or one shorthand target".into());
    }
    Ok(())
}

fn emulate_shape(args: &EmulateArgs) -> Result<(), crate::BoxError> {
    let device_fields = [
        args.label.is_some(),
        args.width.is_some(),
        args.height.is_some(),
        args.dpr.is_some(),
        args.mobile.is_some(),
        args.touch.is_some(),
        args.orientation.is_some(),
    ];
    if matches!(args.action.as_deref(), Some("status" | "reset"))
        && device_fields.into_iter().any(|set| set)
    {
        return Err(format!(
            "emulate {}: device fields are only valid for action \"device\"",
            args.action.as_deref().unwrap_or_default()
        )
        .into());
    }
    Ok(())
}