Skip to main content

browser_control/cli/
targets.rs

1//! `browser-control targets` — list page targets in the active browser.
2
3use anyhow::Result;
4
5use crate::cli::mcp::resolve_browser;
6use crate::cli::output::{print_json, print_table};
7use crate::session::targets::{self, TargetInfo};
8
9pub async fn run(browser: Option<String>, url: Option<String>, json: bool) -> Result<()> {
10    let resolved = resolve_browser(browser).await?;
11    let targets = targets::list(&resolved.endpoint, resolved.engine, url.as_deref()).await?;
12    let mut out = std::io::stdout();
13    if json {
14        print_json(&mut out, &targets)?;
15    } else {
16        let headers = ["KIND", "ID", "URL", "TITLE"];
17        let rows = table_rows(&targets);
18        print_table(&mut out, &headers, &rows)?;
19    }
20    Ok(())
21}
22
23fn table_rows(targets: &[TargetInfo]) -> Vec<Vec<String>> {
24    targets
25        .iter()
26        .map(|t| vec![t.kind.clone(), t.id.clone(), t.url.clone(), t.title.clone()])
27        .collect()
28}
29
30#[cfg(test)]
31mod tests {
32    use super::*;
33    use crate::detect::Engine;
34    use futures_util::{SinkExt, StreamExt};
35    use serde_json::{json, Value};
36    use tokio_tungstenite::tungstenite::Message;
37
38    async fn spawn_cdp_mock(targets: Vec<Value>) -> String {
39        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
40        let addr = listener.local_addr().unwrap();
41        tokio::spawn(async move {
42            let (stream, _) = listener.accept().await.unwrap();
43            let mut ws = tokio_tungstenite::accept_async(stream).await.unwrap();
44            while let Some(Ok(Message::Text(t))) = ws.next().await {
45                let req: Value = serde_json::from_str(&t).unwrap();
46                let id = req["id"].as_u64().unwrap();
47                let method = req["method"].as_str().unwrap_or("");
48                let result = if method == "Target.getTargets" {
49                    json!({"targetInfos": targets.clone()})
50                } else {
51                    json!({})
52                };
53                let resp = json!({"id": id, "result": result});
54                ws.send(Message::Text(resp.to_string())).await.unwrap();
55            }
56        });
57        format!("ws://{addr}")
58    }
59
60    #[test]
61    fn table_rows_have_kind_id_url_title_in_order() {
62        let t = vec![TargetInfo {
63            id: "abc".into(),
64            url: "https://example.com/".into(),
65            title: "Example".into(),
66            kind: "page".into(),
67        }];
68        let rows = table_rows(&t);
69        assert_eq!(rows.len(), 1);
70        assert_eq!(
71            rows[0],
72            vec!["page", "abc", "https://example.com/", "Example"]
73        );
74    }
75
76    #[tokio::test]
77    async fn lists_targets_against_cdp_mock_json_and_table() {
78        let endpoint = spawn_cdp_mock(vec![
79            json!({"targetId":"a","type":"page","url":"https://example.com/","title":"Ex"}),
80            json!({"targetId":"b","type":"page","url":"https://other.test/","title":"Other"}),
81        ])
82        .await;
83
84        let targets = targets::list(&endpoint, Engine::Cdp, None).await.unwrap();
85        assert_eq!(targets.len(), 2);
86
87        let mut buf: Vec<u8> = Vec::new();
88        print_json(&mut buf, &targets).unwrap();
89        let v: Value = serde_json::from_slice(&buf).unwrap();
90        for i in 0..2 {
91            for key in ["id", "url", "title", "kind"] {
92                assert!(v[i].get(key).is_some(), "missing {key} in {v:?}");
93            }
94        }
95        assert_eq!(v[0]["url"], "https://example.com/");
96
97        let headers = ["KIND", "ID", "URL", "TITLE"];
98        let rows = table_rows(&targets);
99        let mut tbuf: Vec<u8> = Vec::new();
100        print_table(&mut tbuf, &headers, &rows).unwrap();
101        let text = String::from_utf8(tbuf).unwrap();
102        assert!(text.contains("https://example.com/"));
103        assert!(text.contains("KIND"));
104        assert!(text.contains("page"));
105    }
106}