tail-fin-cli 0.5.1

Multi-site browser automation CLI — attaches to Chrome or auto-launches a stealth browser to drive 15+ 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
150

use clap::Subcommand;
use tail_fin_common::TailFinError;

use crate::session::{browser_session, launch_stealth_session, print_json, print_list, Ctx};

#[derive(Subcommand)]
pub enum CoupangAction {
    /// Search for products
    Search {
        /// Search query
        query: String,
        #[arg(long, default_value_t = 20)]
        limit: usize,
        #[arg(long, default_value_t = 1)]
        page: usize,
        #[arg(long)]
        sort: Option<String>,
        #[arg(long)]
        rocket_only: bool,
        #[arg(long)]
        region: Option<String>,
    },
    /// View product details
    Detail {
        /// Product ID
        product_id: String,
        #[arg(long)]
        region: Option<String>,
    },
    /// View shopping cart
    Cart {
        #[arg(long)]
        region: Option<String>,
    },
    /// Add a product to cart (browser mode only)
    AddToCart {
        /// Product ID
        product_id: String,
        #[arg(long)]
        region: Option<String>,
    },
}

/// Get or launch a browser session for Coupang.
///
/// Priority: --connect (existing Chrome) > --cookies (HTTP mode) > auto-launch stealth.
async fn coupang_session(
    ctx: &Ctx,
    region: Option<&str>,
) -> Result<night_fury_core::BrowserSession, TailFinError> {
    let start_url = tail_fin_coupang::base_url_for_region(region);
    if let Some(ref host) = ctx.connect {
        browser_session(host, ctx.headed).await
    } else {
        // Auto-launch stealth Chrome — no --connect needed
        eprintln!("Launching stealth browser for Coupang...");
        launch_stealth_session(&start_url, ctx.headed).await
    }
}

pub async fn run(action: CoupangAction, ctx: &Ctx) -> Result<(), TailFinError> {
    match action {
        CoupangAction::Search {
            query,
            limit,
            page,
            sort,
            rocket_only,
            region,
        } => {
            // Cookie mode: HTTP search
            if let Some(ref cookies_flag) = ctx.cookies {
                let path = if cookies_flag == "auto" {
                    crate::session::default_cookies_path("coupang")
                } else {
                    std::path::PathBuf::from(cookies_flag)
                };
                let client = tail_fin_coupang::CoupangHttpClient::from_cookie_file(
                    &path,
                    region.as_deref(),
                )?;
                let products = client
                    .search(&query, limit, page, sort.as_deref(), rocket_only)
                    .await?;
                print_list("products", &products, products.len())?;
            } else {
                // Browser mode (connect or auto-launch)
                let session = coupang_session(ctx, region.as_deref()).await?;
                let client = tail_fin_coupang::CoupangClient::new(session);
                let products = client
                    .search(&query, limit, page, sort.as_deref(), rocket_only)
                    .await?;
                print_list("products", &products, products.len())?;
            }
        }
        CoupangAction::Detail { product_id, region } => {
            let session = coupang_session(ctx, region.as_deref()).await?;
            let client = tail_fin_coupang::CoupangClient::new(session);
            let detail = client.detail(&product_id).await?;
            print_json(&detail)?;
        }
        CoupangAction::Cart { region } => {
            let session = coupang_session(ctx, region.as_deref()).await?;
            let client = tail_fin_coupang::CoupangClient::new(session);
            let items = client.cart().await?;
            print_list("cart_items", &items, items.len())?;
        }
        CoupangAction::AddToCart { product_id, region } => {
            let session = coupang_session(ctx, region.as_deref()).await?;
            let client = tail_fin_coupang::CoupangClient::new(session);
            let result = client.add_to_cart(&product_id).await?;
            print_json(&result)?;
        }
    }
    Ok(())
}

pub struct Adapter;

impl crate::adapter::CliAdapter for Adapter {
    fn name(&self) -> &'static str {
        "coupang"
    }

    fn about(&self) -> &'static str {
        "Coupang e-commerce operations"
    }

    fn command(&self) -> clap::Command {
        <CoupangAction as clap::Subcommand>::augment_subcommands(
            clap::Command::new("coupang").about("Coupang e-commerce operations"),
        )
    }

    fn dispatch<'a>(
        &'a self,
        matches: &'a clap::ArgMatches,
        ctx: &'a crate::session::Ctx,
    ) -> std::pin::Pin<
        Box<
            dyn std::future::Future<Output = Result<(), tail_fin_common::TailFinError>> + Send + 'a,
        >,
    > {
        Box::pin(async move {
            let action = <CoupangAction as clap::FromArgMatches>::from_arg_matches(matches)
                .map_err(|e| tail_fin_common::TailFinError::Api(e.to_string()))?;
            run(action, ctx).await
        })
    }
}