tail-fin-cli 0.3.1

Multi-site browser automation CLI — attaches to Chrome or auto-launches a stealth browser to drive 14+ sites
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
144
145
146
147
148
149

use std::path::PathBuf;

use tail_fin_common::TailFinError;

pub struct Ctx {
    pub connect: Option<String>,
    pub cookies: Option<String>,
    pub headed: bool,
}

/// Default cookies path for a given site.
pub fn default_cookies_path(site: &str) -> PathBuf {
    let home = std::env::var("HOME").unwrap_or_else(|_| ".".into());
    PathBuf::from(home)
        .join(".tail-fin")
        .join(format!("{}-cookies.txt", site))
}

/// Resolve the cookies file path from the --cookies flag value.
pub fn resolve_cookies_path(cookies_flag: &str, site: &str) -> PathBuf {
    if cookies_flag == "auto" {
        default_cookies_path(site)
    } else {
        PathBuf::from(cookies_flag)
    }
}

/// Helper: get TwitterHttpClient from cookies flag.
#[cfg(feature = "twitter")]
pub fn twitter_http_client(
    cookies_flag: &str,
) -> Result<tail_fin_twitter::TwitterHttpClient, TailFinError> {
    let path = resolve_cookies_path(cookies_flag, "twitter");
    if !path.exists() {
        eprintln!("Error: Cookie file not found: {}", path.display());
        eprintln!(
            "  Run `tail-fin --connect twitter export-cookies` to export cookies from Chrome."
        );
        std::process::exit(1);
    }
    tail_fin_twitter::TwitterHttpClient::from_cookie_file(
        &path,
    )
}

/// Helper: get BrowserSession from connect flag.
pub async fn browser_session(
    host: &str,
    headed: bool,
) -> Result<night_fury_core::BrowserSession, TailFinError> {
    Ok(night_fury_core::BrowserSession::builder()
        .connect_to(format!("ws://{}", host))
        .headed(headed)
        .build()
        .await?)
}

/// Helper: launch a fresh headless browser (no external Chrome needed).
pub async fn launch_browser(headed: bool) -> Result<night_fury_core::BrowserSession, TailFinError> {
    Ok(night_fury_core::BrowserSession::builder()
        .headed(headed)
        .build()
        .await?)
}

/// Helper: launch a stealth browser navigated to `url` with anti-detection.
pub async fn launch_stealth_session(
    url: &str,
    headed: bool,
) -> Result<night_fury_core::BrowserSession, TailFinError> {
    Ok(night_fury_core::BrowserSession::builder()
        .headed(headed)
        .launch_stealth(url)
        .await?)
}

/// Helper: require browser mode, print error if not available.
pub fn require_browser(connect: &Option<String>, service: &str, action_name: &str) -> String {
    match connect {
        Some(host) => host.clone(),
        None => {
            eprintln!(
                "Error: `{} {}` requires browser mode (--connect).",
                service, action_name
            );
            eprintln!(
                "  Use: tail-fin --connect 127.0.0.1:9222 {} {} ...",
                service, action_name
            );
            std::process::exit(1);
        }
    }
}

/// Browser-only adapter: reject cookies, require --connect, return BrowserSession.
pub async fn require_browser_session(
    ctx: &Ctx,
    service: &str,
) -> Result<night_fury_core::BrowserSession, TailFinError> {
    if ctx.cookies.is_some() {
        eprintln!("Error: {} cookie mode is not supported.", service);
        eprintln!("  Use --connect for browser mode.");
        std::process::exit(1);
    }
    let host = match ctx.connect.as_deref() {
        Some(h) => h,
        None => {
            eprintln!("Error: {} requires --connect.", service);
            eprintln!(
                "  Example: tail-fin --connect 127.0.0.1:9222 {} ...",
                service
            );
            std::process::exit(1);
        }
    };
    browser_session(host, ctx.headed).await
}

/// Print error for no mode specified.
pub fn no_mode_error(service: &str, cmd: &str) -> ! {
    eprintln!("Error: No connection mode specified for {}.", service);
    eprintln!("  Use --connect to use browser mode:");
    eprintln!("    tail-fin --connect 127.0.0.1:9222 {} {}", service, cmd);
    eprintln!("  Or --cookies to use saved cookies:");
    eprintln!("    tail-fin --cookies {} {}", service, cmd);
    std::process::exit(1);
}

/// Print a serializable value as pretty JSON.
pub fn print_json(value: &(impl serde::Serialize + ?Sized)) -> Result<(), TailFinError> {
    println!("{}", serde_json::to_string_pretty(value)?);
    Ok(())
}

/// Print a list result as `{ "key": items, "count": N }`.
pub fn print_list(
    key: &str,
    items: &impl serde::Serialize,
    count: usize,
) -> Result<(), TailFinError> {
    println!(
        "{}",
        serde_json::to_string_pretty(&serde_json::json!({
            key: items,
            "count": count,
        }))?
    );
    Ok(())
}