crawlex 1.0.4

Stealth crawler with Chrome-perfect TLS/H2 fingerprint, render pool, hooks, persistent queue
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

//! `crawlex stealth catalog list [--filter <browser>] [--json]`
//!
//! Adapter port of the legacy `cmd_catalog_list` free fn in `cli/mod.rs`.
//! The logic is identical; this version exposes it through the
//! [`CliCommand`] trait so the dispatch layer can swap in a JSON
//! renderer or a human renderer based on `--json` without the command
//! itself caring about output format.

use async_trait::async_trait;

use crate::cli::command::{CliCommand, CliContext, CliOutput};
use crate::error::Result;
use crate::impersonate::catalog::{all, Browser};

pub struct CatalogListCommand {
    pub filter: Option<String>,
}

#[async_trait]
impl CliCommand for CatalogListCommand {
    fn name(&self) -> &'static str {
        "stealth.catalog.list"
    }

    async fn execute(&self, _ctx: &CliContext) -> Result<CliOutput> {
        let filter = self.filter.as_deref().map(str::to_ascii_lowercase);
        let want = |b: Browser| -> bool {
            match filter.as_deref() {
                None => true,
                Some("chrome") => b == Browser::Chrome,
                Some("chromium") => b == Browser::Chromium,
                Some("firefox") => b == Browser::Firefox,
                Some("edge") => b == Browser::Edge,
                Some("safari") => b == Browser::Safari,
                Some(_) => true,
            }
        };

        let entries: Vec<_> = all().filter(|fp| want(fp.browser)).collect();
        let headers = vec![
            "NAME".into(),
            "BROWSER".into(),
            "MAJOR".into(),
            "OS".into(),
            "CIPHERS".into(),
            "EXT".into(),
            "ECH".into(),
        ];
        let rows: Vec<Vec<String>> = entries
            .iter()
            .map(|fp| {
                vec![
                    fp.name.into(),
                    fp.browser_name.into(),
                    fp.major.to_string(),
                    fp.os_name.into(),
                    fp.ciphers_no_grease().len().to_string(),
                    fp.extension_ids_no_grease().len().to_string(),
                    if fp.has_ech_grease { "yes" } else { "no" }.into(),
                ]
            })
            .collect();
        Ok(CliOutput::Table { headers, rows })
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::cli::render::HumanRenderer;

    fn ctx() -> CliContext {
        CliContext {
            renderer: Box::new(HumanRenderer),
        }
    }

    #[tokio::test]
    async fn lists_at_least_curl_impersonate_baseline() {
        let cmd = CatalogListCommand { filter: None };
        let out = cmd.execute(&ctx()).await.expect("command runs");
        match out {
            CliOutput::Table { rows, .. } => {
                assert!(
                    rows.len() >= 21,
                    "expected >=21 profiles, got {}",
                    rows.len()
                );
            }
            other => panic!("expected Table output, got {other:?}"),
        }
    }

    #[tokio::test]
    async fn filter_narrows_to_one_browser_family() {
        let cmd = CatalogListCommand {
            filter: Some("firefox".into()),
        };
        let out = cmd.execute(&ctx()).await.expect("command runs");
        match out {
            CliOutput::Table { rows, .. } => {
                assert!(rows.iter().all(|r| r[1] == "firefox"));
                assert!(!rows.is_empty());
            }
            other => panic!("expected Table output, got {other:?}"),
        }
    }
}