cmd-usage 0.5.5

use serde::{Deserialize, Serialize};

const API_BASE: &str = "https://api.commandcode.ai";

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Credits {
    pub monthly_credits: f64,
    #[serde(default)]
    pub purchased_credits: f64,
    #[serde(default)]
    pub free_credits: f64,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Window {
    pub used: f64,
    pub cap: f64,
    #[serde(default)]
    pub exceeded: bool,
    #[serde(default)]
    pub reset_at: Option<f64>,
}

#[derive(Deserialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct WindowLimits {
    #[serde(default)]
    pub five_hour: Option<Window>,
    #[serde(default)]
    pub weekly: Option<Window>,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CreditsResp {
    pub credits: Credits,
    #[serde(default)]
    pub window_limits: WindowLimits,
}

#[derive(Deserialize)]
struct SubscriptionsResp {
    #[serde(default)]
    data: Option<SubData>,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SubData {
    #[serde(default)]
    pub status: String,
    #[serde(default)]
    pub plan_id: String,
    #[serde(default)]
    pub current_period_end: Option<String>,
    #[serde(default)]
    pub current_period_start: Option<String>,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UsageSummary {
    #[serde(default)]
    pub total_count: u64,
    #[serde(default)]
    pub total_cost: f64,
    #[serde(default)]
    pub success_rate: f64,
    #[serde(default)]
    pub total_tokens_in: u64,
    #[serde(default)]
    pub total_tokens_out: u64,
}

pub fn api_key() -> std::io::Result<String> {
    // CMD_API_KEY override: use any account key without touching auth.json
    // (multi-account / testing)
    if let Ok(k) = std::env::var("CMD_API_KEY") {
        if !k.is_empty() {
            return Ok(k);
        }
    }
    let path = home().join(".commandcode/auth.json");
    let text = std::fs::read_to_string(path)?;
    let v: serde_json::Value = serde_json::from_str(&text)
        .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
    v["apiKey"]
        .as_str()
        .map(|s| s.to_string())
        .ok_or_else(|| std::io::Error::new(std::io::ErrorKind::NotFound, "no apiKey"))
}

fn home() -> std::path::PathBuf {
    std::env::var("HOME").unwrap_or_else(|_| "/".into()).into()
}

fn get(path: &str, key: &str) -> Result<Vec<u8>, String> {
    const MAX_RETRIES: u32 = 5;
    const BASE_DELAY_MS: u64 = 1000;
    const MAX_DELAY_MS: u64 = 8000;

    let mut last_err = String::new();
    for attempt in 0..=MAX_RETRIES {
        let resp = ureq::get(&format!("{API_BASE}{path}"))
            .set("Authorization", &format!("Bearer {key}"))
            .timeout(std::time::Duration::from_secs(15))
            .call();

        match resp {
            Ok(resp) => {
                let mut buf = Vec::new();
                match resp.into_reader()
                    .take(10 * 1024 * 1024)
                    .read_to_end(&mut buf) {
                    Ok(_) => return Ok(buf),
                    Err(e) => last_err = format!("{path}: read error: {e}"),
                }
            }
            Err(e) => {
                last_err = format!("{path}: {e}");
                let err_str = e.to_string().to_lowercase();
                let is_transient = err_str.contains("tls")
                    || err_str.contains("connection")
                    || err_str.contains("timeout")
                    || err_str.contains("unexpected end of file")
                    || err_str.contains("connection reset")
                    || err_str.contains("broken pipe")
                    || err_str.contains("eof")
                    || err_str.contains("handshake")
                    || err_str.contains("certificate")
                    // HTTP 429 (rate limit) and 5xx (server/upstream blip)
                    // are retried; 4xx client errors are not.
                    || err_str.contains("status code 429")
                    || err_str.contains("status code 5");
                if !is_transient || attempt == MAX_RETRIES {
                    break;
                }
            }
        }

        if attempt < MAX_RETRIES {
            let delay = std::cmp::min(BASE_DELAY_MS * (1u64 << attempt), MAX_DELAY_MS);
            let jitter = fastrand::u64(0..500);
            std::thread::sleep(std::time::Duration::from_millis(delay + jitter));
        }
    }
    Err(last_err)
}

use std::io::Read;

pub fn subscriptions(key: &str) -> Result<SubData, String> {
    let d: SubscriptionsResp = serde_json::from_slice(&get("/alpha/billing/subscriptions", key)?)
        .map_err(|e| format!("subscriptions: {e}"))?;
    Ok(d.data.unwrap_or(SubData {
        status: "none".into(),
        plan_id: "free".into(),
        current_period_end: None,
            current_period_start: None,
    }))
}

pub fn credits(key: &str) -> Result<CreditsResp, String> {
    serde_json::from_slice(&get("/alpha/billing/credits", key)?)
        .map_err(|e| format!("credits: {e}"))
}

pub fn summary(key: &str) -> Result<UsageSummary, String> {
    serde_json::from_slice(&get("/alpha/usage/summary", key)?)
        .map_err(|e| format!("summary: {e}"))
}

/// Fetch `/alpha/usage/summary?since=<ISO>` and return parsed summary.
/// Retries on transient errors (uses same logic as `get`).
pub fn summary_since(since: &str, key: &str) -> Result<UsageSummary, String> {
    serde_json::from_slice(&get(&format!("/alpha/usage/summary?since={since}"), key)?)
        .map_err(|e| format!("summary since={since}: {e}"))
}

#[derive(Deserialize, Serialize)]
pub struct ModelInfo {
    pub id: String,
    #[serde(default)]
    pub name: Option<String>,
    #[serde(default)]
    pub context_length: Option<u64>,
    #[serde(default)]
    pub owned_by: Option<String>,
}

#[derive(Deserialize)]
struct ModelsResp {
    #[serde(default)]
    data: Vec<ModelInfo>,
}

/// Live model list from the provider endpoint (/provider/v1/models) — the
/// same list the opencode plugin gates per plan. Raw here, no plan filter.
pub fn models(key: &str) -> Result<Vec<ModelInfo>, String> {
    let r: ModelsResp =
        serde_json::from_slice(&get("/provider/v1/models", key)?).map_err(|e| e.to_string())?;
    Ok(r.data)
}