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

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

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

#[derive(Subcommand)]
pub enum BloombergAction {
    /// Homepage top stories
    Main {
        #[arg(long, default_value_t = 20)]
        limit: usize,
    },
    /// Markets section headlines
    Markets {
        #[arg(long, default_value_t = 20)]
        limit: usize,
    },
    /// Economics section headlines
    Economics {
        #[arg(long, default_value_t = 20)]
        limit: usize,
    },
    /// Industries section headlines
    Industries {
        #[arg(long, default_value_t = 20)]
        limit: usize,
    },
    /// Technology section headlines
    Tech {
        #[arg(long, default_value_t = 20)]
        limit: usize,
    },
    /// Politics section headlines
    Politics {
        #[arg(long, default_value_t = 20)]
        limit: usize,
    },
    /// Businessweek section headlines
    Businessweek {
        #[arg(long, default_value_t = 20)]
        limit: usize,
    },
    /// List available RSS feed aliases
    Feeds,
    /// Extract article from a Bloomberg story page (browser mode)
    News {
        /// Bloomberg article URL
        url: String,
    },
}

pub async fn run(action: BloombergAction, ctx: &Ctx) -> Result<(), TailFinError> {
    match action {
        BloombergAction::Feeds => {
            let feeds = tail_fin_bloomberg::BloombergClient::feeds();
            print_list("feeds", &feeds, feeds.len())?;
        }
        BloombergAction::News { url } => {
            let host = ctx.connect.as_deref().ok_or_else(|| {
                TailFinError::Api("news requires --connect for browser mode".into())
            })?;
            let session = browser_session(host, ctx.headed).await?;
            let client = tail_fin_bloomberg::BloombergClient::with_session(session);
            let article = client.news(&url).await?;
            print_json(&article)?;
        }
        _ => {
            let feed_name = match &action {
                BloombergAction::Main { .. } => "main",
                BloombergAction::Markets { .. } => "markets",
                BloombergAction::Economics { .. } => "economics",
                BloombergAction::Industries { .. } => "industries",
                BloombergAction::Tech { .. } => "tech",
                BloombergAction::Politics { .. } => "politics",
                BloombergAction::Businessweek { .. } => "businessweek",
                _ => unreachable!(),
            };
            let limit = match &action {
                BloombergAction::Main { limit }
                | BloombergAction::Markets { limit }
                | BloombergAction::Economics { limit }
                | BloombergAction::Industries { limit }
                | BloombergAction::Tech { limit }
                | BloombergAction::Politics { limit }
                | BloombergAction::Businessweek { limit } => *limit,
                _ => unreachable!(),
            };
            let client = tail_fin_bloomberg::BloombergClient::without_session();
            let items = client.fetch_feed(feed_name, limit).await?;
            print_list("items", &items, items.len())?;
        }
    }
    Ok(())
}

pub struct Adapter;

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

    fn about(&self) -> &'static str {
        "Bloomberg news operations"
    }

    fn command(&self) -> clap::Command {
        <BloombergAction as clap::Subcommand>::augment_subcommands(
            clap::Command::new("bloomberg").about("Bloomberg news 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 = <BloombergAction as clap::FromArgMatches>::from_arg_matches(matches)
                .map_err(|e| tail_fin_common::TailFinError::Api(e.to_string()))?;
            run(action, ctx).await
        })
    }
}