flexprice-cli 0.1.1

A beautiful terminal CLI for the FlexPrice billing platform
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

use anyhow::Result;
use clap::Subcommand;

use crate::api::client::ApiClient;
use crate::config::{Credentials, DEFAULT_API_URL};
use crate::utils::output;
use crate::utils::spinner;

#[derive(Subcommand)]
pub enum AuthCommands {
    /// Set an API key (validated against the API before saving)
    SetApiKey {
        /// The API key to store
        key: String,
        /// API endpoint URL
        #[arg(long, default_value = DEFAULT_API_URL)]
        api_url: String,
    },
    /// Show current authenticated user and tenant
    Whoami,
    /// Show authentication status
    Status,
    /// Remove stored credentials
    Logout,
}

pub async fn handle(cmd: AuthCommands) -> Result<()> {
    match cmd {
        AuthCommands::SetApiKey { key, api_url } => set_api_key(key, api_url).await,
        AuthCommands::Whoami => whoami().await,
        AuthCommands::Status => status().await,
        AuthCommands::Logout => logout(),
    }
}

async fn set_api_key(key: String, api_url: String) -> Result<()> {
    let sp = spinner::create_spinner("Validating API key...");

    let creds = Credentials {
        api_url: api_url.clone(),
        api_key: Some(key.clone()),
        ..Default::default()
    };

    let client = ApiClient::new(creds.clone())?;
    client.health_check().await?;

    sp.finish_and_clear();

    creds.save()?;

    output::success("API key validated and saved!");
    output::success(&format!("API URL: {}", api_url));
    output::success(&format!(
        "Credentials saved to {}",
        Credentials::credentials_path().display()
    ));

    Ok(())
}

async fn whoami() -> Result<()> {
    let creds = require_auth()?;

    let sp = spinner::create_spinner("Fetching user info...");
    let client = ApiClient::new(creds.clone())?;

    let user_info: serde_json::Value = client.get("/v1/users/me").await?;
    sp.finish_and_clear();

    println!();
    output::info(&format!("API URL:    {}", creds.api_url));
    if let Some(ref eid) = creds.environment_id {
        output::info(&format!("Env ID:     {}", eid));
    }
    output::info("Auth:       API Key");
    println!();

    println!("{}", output::print_detail(&user_info, false));

    Ok(())
}

async fn status() -> Result<()> {
    match Credentials::load_from_file() {
        Ok(creds) => {
            output::success("Credentials found");
            output::info(&format!("API URL:    {}", creds.api_url));
            output::info(&format!("API Key:    {}", creds.masked_api_key()));
            if let Some(ref eid) = creds.environment_id {
                output::info(&format!("Env ID:     {}", eid));
            }

            // Try health check
            let sp = spinner::create_spinner("Testing connection...");
            let client = ApiClient::new(creds)?;
            match client.health_check().await {
                Ok(_) => {
                    sp.finish_and_clear();
                    output::success("API connection OK");
                }
                Err(e) => {
                    sp.finish_and_clear();
                    output::warning(&format!("API unreachable: {}", e));
                }
            }
        }
        Err(_) => {
            output::warning("Not authenticated.");
            output::info(
                "Run `flexprice auth set-api-key <KEY>` or set FLEXPRICE_API_KEY (see `--help`).",
            );
        }
    }
    Ok(())
}

fn logout() -> Result<()> {
    Credentials::delete()?;
    output::success("Credentials removed. You are now logged out.");
    Ok(())
}

/// Require authentication before proceeding. Returns credentials or exits.
pub fn require_auth() -> Result<Credentials> {
    let creds = Credentials::load(None, None)?;
    if !creds.is_authenticated() {
        output::warning(
            "Not authenticated. Run `flexprice auth set-api-key <KEY>` or set FLEXPRICE_API_KEY.",
        );
        std::process::exit(1);
    }
    Ok(creds)
}