agentchrome 1.43.0

A CLI tool for browser automation via the Chrome DevTools Protocol
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

use clap::CommandFactory;

use agentchrome::capabilities::{CapabilitiesManifestListing, build_manifest};
use agentchrome::error::{AppError, ExitCode};

use crate::cli::{CapabilitiesArgs, Cli, GlobalOpts};
use crate::output::{self, print_output};

/// Build the `{subcommand_count, top_level_flags_count}` summary for a
/// `capabilities <command>` detail descriptor offloaded above the threshold.
fn summary_of_capabilities_detail(value: &serde_json::Value) -> serde_json::Value {
    let subcommand_count = value
        .get("subcommands")
        .and_then(serde_json::Value::as_array)
        .map(Vec::len);
    let top_level_flags_count = value
        .get("flags")
        .and_then(serde_json::Value::as_array)
        .map(Vec::len);

    serde_json::json!({
        "subcommand_count": subcommand_count,
        "top_level_flags_count": top_level_flags_count,
    })
}

pub fn execute_capabilities(global: &GlobalOpts, args: &CapabilitiesArgs) -> Result<(), AppError> {
    let cmd = Cli::command();
    let manifest = build_manifest(&cmd, args.compact);

    match &args.command {
        None => {
            // Progressive-disclosure listing — summaries only.
            let listing = CapabilitiesManifestListing::from(&manifest);
            print_output(&listing, &global.output)
        }
        Some(name) => {
            let available: Vec<String> = manifest.commands.iter().map(|c| c.name.clone()).collect();
            let Some(descriptor) = manifest.commands.iter().find(|c| c.name == *name) else {
                return Err(AppError {
                    message: format!(
                        "Unknown command: '{name}'. Available: {}",
                        available.join(", ")
                    ),
                    code: ExitCode::GeneralError,
                    custom_json: None,
                });
            };
            output::emit(descriptor, &global.output, "capabilities", |d| {
                summary_of_capabilities_detail(&serde_json::to_value(d).unwrap_or_default())
            })
        }
    }
}

// =============================================================================
// Tests
// =============================================================================

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

    fn global_opts() -> GlobalOpts {
        GlobalOpts {
            port: None,
            host: "127.0.0.1".into(),
            ws_url: None,
            timeout: None,
            tab: None,
            page_id: None,
            auto_dismiss_dialogs: false,
            config: None,
            keepalive_interval: None,
            no_keepalive: false,
            output: crate::cli::OutputFormat {
                json: false,
                pretty: false,
                plain: false,
                large_response_threshold: None,
            },
        }
    }

    #[test]
    fn execute_capabilities_unknown_command_returns_error() {
        let global = global_opts();
        let args = CapabilitiesArgs {
            command: Some("nonexistent".into()),
            compact: false,
        };
        let result = execute_capabilities(&global, &args);
        assert!(result.is_err());
        let err = result.unwrap_err();
        assert!(err.message.contains("Unknown command"));
        assert!(err.message.contains("nonexistent"));
    }

    #[test]
    fn unknown_command_returns_error_with_available_list() {
        let global = global_opts();
        let args = CapabilitiesArgs {
            command: Some("nonexistent".into()),
            compact: false,
        };
        let err = execute_capabilities(&global, &args).unwrap_err();
        assert!(err.message.contains("Unknown command"));
        let known = ["navigate", "tabs", "page", "dom", "interact"];
        let hit_count = known.iter().filter(|n| err.message.contains(*n)).count();
        assert!(
            hit_count >= 5,
            "expected ≥5 known commands listed in error: {}",
            err.message
        );
    }
}