slack-cli 0.1.1

slack cli Project homepage: https://github.com/isaacadams/slack-api-client 
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

use clap::{Args, Parser, Subcommand, ValueEnum};
use std::str::FromStr;

/// Send messages to Slack using this CLI tool. It allows you to send various types of messages, including text, blocks, and attachments, to specific Slack channels.
#[derive(Debug, Parser)]
#[command(name = "slack")]
#[command(
    about = "Send messages to Slack\ne.g. slack send --kind text --chanel general \"hello world\"",
    long_about = "This CLI tool enables users to send messages to Slack channels. You can specify the type of message (text, block, or attachment) and provide the necessary details like the channel and message content. It's a convenient way to interact with the Slack API directly from the command line."
)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Debug, Subcommand)]
enum Commands {
    Send(SendArgs),
}

#[derive(Debug, Args)]
struct SendArgs {
    /// Slack channel to send the message to. Accepts either the channel name (e.g., 'general') or the channel ID.
    #[arg(short, long)]
    channel: String,

    /// Type of message to send. Valid kinds include:
    /// - `Text`: Plain text message.
    /// - `Block`: A block-based message structure (JSON object).
    /// - `Attachment`: An attachment message (JSON object).
    #[arg(short, long)]
    kind: MessageKind,

    /// The content of the message to send. The expected JSON structure depends on the message kind:
    /// - `Text`: A plain string (e.g., "Hello, world!").
    /// - `Block`: A JSON object representing a Slack block kit layout (e.g., {"type": "section", "text": {"type": "mrkdwn", "text": "Hello, world!"}}).
    /// - `Attachment`: A JSON object representing a Slack message attachment (e.g., {"fallback": "Required plain-text summary", "text": "Optional text to appear in the attachment"}).
    message: String,
}

#[derive(Clone, Debug, ValueEnum)]
pub enum MessageKind {
    Text,
    Block,
    Attachment,
}

#[tokio::main]
pub async fn main() {
    env_logger::init();

    let token = match dotenvy::var("SLACK_TOKEN") {
        Ok(val) => val,
        Err(_) => {
            eprintln!(
                "Error: SLACK_TOKEN is not set. Please set it in your environment variables."
            );
            std::process::exit(1);
        }
    };

    let cli = Cli::parse();

    let client = slack_api_client::SlackClient::new(token);

    match cli.command {
        Commands::Send(args) => {
            let message = match args.kind {
                MessageKind::Text => slack_api_client::CreateMessage::Text(args.message),
                MessageKind::Block => {
                    let message = match serde_json::Value::from_str(&args.message) {
                        Ok(m) => m,
                        Err(e) => {
                            eprintln!("{}", e);
                            std::process::exit(1);
                        }
                    };
                    if !message.is_array() {
                        eprintln!("a message of kind `Block` must be a json array");
                        std::process::exit(1);
                    }
                    log::debug!("{:#?}", message);
                    slack_api_client::CreateMessage::Blocks(message)
                }
                MessageKind::Attachment => {
                    let message = match serde_json::Value::from_str(&args.message) {
                        Ok(m) => m,
                        Err(e) => {
                            eprintln!("{}", e);
                            std::process::exit(1);
                        }
                    };
                    if !message.is_array() {
                        eprintln!("a message of kind `Attachment` must be a json array");
                        std::process::exit(1);
                    }
                    slack_api_client::CreateMessage::Attachments(message)
                }
            };

            let response = message
                .send_to_channel(&client, args.channel.trim().trim_matches('#').to_string())
                .await;

            match response {
                Ok(ok) => {
                    log::debug!("{:#?}", ok);
                    match ok.text().await {
                        Ok(ok) => log::debug!("{:#}", ok),
                        Err(error) => eprintln!("{}", error),
                    };
                }
                Err(error) => eprintln!("{:#?}", error),
            }
        }
    }
}