email-cli 0.6.6

Agent-friendly email CLI for Resend
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

use serde::Serialize;
use std::io::IsTerminal;

use crate::error::CliError;

#[derive(Clone, Copy)]
pub enum Format {
    Json,
    Human,
}

impl Format {
    pub fn detect(json_flag: bool) -> Self {
        if json_flag || !std::io::stdout().is_terminal() {
            Format::Json
        } else {
            Format::Human
        }
    }

    #[allow(dead_code)]
    pub fn is_json(self) -> bool {
        matches!(self, Format::Json)
    }
}

pub fn print_success<T: Serialize>(format: Format, data: &T) {
    if let Format::Json = format {
        let envelope = serde_json::json!({
            "version": "1",
            "status": "success",
            "data": data,
        });
        let output = serde_json::to_string_pretty(&envelope)
            .unwrap_or_else(|_| r#"{"version":"1","status":"error"}"#.to_string());
        println!("{}", output);
    }
}

pub fn print_success_or<T: Serialize, F: FnOnce(&T)>(format: Format, data: &T, human: F) {
    match format {
        Format::Json => print_success(format, data),
        Format::Human => human(data),
    }
}

pub fn print_error(format: Format, err: &CliError) {
    let envelope = serde_json::json!({
        "version": "1",
        "status": "error",
        "error": {
            "code": err.error_code(),
            "message": err.to_string(),
            "suggestion": err.suggestion(),
        },
    });
    match format {
        Format::Json => {
            // JSON errors go to stdout so agents parsing the machine contract
            // always receive the error envelope. stderr is for human diagnostics only.
            let output = serde_json::to_string_pretty(&envelope)
                .unwrap_or_else(|_| r#"{"version":"1","status":"error"}"#.to_string());
            println!("{}", output);
        }
        Format::Human => {
            eprintln!("error: {}", err);
            eprintln!("  {}", err.suggestion());
        }
    }
}

pub fn print_clap_error(format: Format, err: clap::Error) {
    match format {
        Format::Json => {
            let cli_err = CliError::InvalidInput(err.to_string());
            print_error(format, &cli_err);
        }
        Format::Human => {
            let _ = err.print();
        }
    }
}