elevenlabs-cli 0.1.8

Unofficial CLI for ElevenLabs text-to-speech API
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

use crate::cli::{UserArgs, UserCommands};
use crate::errors::print_subscription_info;
use crate::output::{print_info, print_success};
use anyhow::Result;
use colored::*;
use elevenlabs_rs::{
    endpoints::admin::user::{GetUserInfo, GetUserSubscriptionInfo},
    ElevenLabsClient,
};

pub async fn execute(args: UserArgs, api_key: &str) -> Result<()> {
    let client = ElevenLabsClient::new(api_key);

    match args.command {
        UserCommands::Info => get_user_info(&client).await?,
        UserCommands::Subscription => get_subscription(&client).await?,
        UserCommands::Perms => get_permissions(&client).await?,
    }

    Ok(())
}

async fn get_user_info(client: &ElevenLabsClient) -> Result<()> {
    print_info("Fetching user information...");

    let endpoint = GetUserInfo;
    let user = client.hit(endpoint).await.map_err(|e| anyhow::anyhow!(e))?;

    println!("\n{}", "User Information:".bold().underline());
    println!("  User ID: {}", user.user_id.cyan());
    println!("  Subscription: {}", user.subscription.tier.yellow());
    println!(
        "  Character count: {}",
        user.subscription.character_count.to_string().green()
    );
    println!(
        "  Character limit: {}",
        user.subscription.character_limit.to_string().green()
    );

    if user.subscription.character_limit > 0 {
        let percentage = (user.subscription.character_count as f64
            / user.subscription.character_limit as f64)
            * 100.0;
        println!("  Usage: {:.1}%", percentage);
    }

    if user.subscription.next_character_count_reset_unix > 0 {
        println!(
            "  Next reset: {}s",
            user.subscription
                .next_character_count_reset_unix
                .to_string()
                .dimmed()
        );
    }

    print_success("User information retrieved");
    Ok(())
}

async fn get_subscription(client: &ElevenLabsClient) -> Result<()> {
    print_info("Fetching subscription details...");

    let endpoint = GetUserSubscriptionInfo;
    let subscription = client.hit(endpoint).await.map_err(|e| anyhow::anyhow!(e))?;

    println!("\n{}", "Subscription Details:".bold().underline());
    println!("  Tier: {}", subscription.tier.yellow());
    println!(
        "  Character count: {}",
        subscription.character_count.to_string().green()
    );
    println!(
        "  Character limit: {}",
        subscription.character_limit.to_string().green()
    );

    if subscription.character_limit > 0 {
        let percentage =
            (subscription.character_count as f64 / subscription.character_limit as f64) * 100.0;
        println!("  Usage: {:.1}%", percentage);
    }

    if subscription.voice_limit > 0 {
        println!("  Voice limit: {}", subscription.voice_limit);
    }

    if subscription.professional_voice_limit > 0 {
        println!(
            "  Professional voices limit: {}",
            subscription.professional_voice_limit
        );
    }

    if subscription.next_character_count_reset_unix > 0 {
        println!(
            "  Next character reset: {}s",
            subscription
                .next_character_count_reset_unix
                .to_string()
                .dimmed()
        );
    }

    print_success("Subscription details retrieved");
    Ok(())
}

async fn get_permissions(client: &ElevenLabsClient) -> Result<()> {
    print_info("Checking API permissions and feature availability...");

    // Get user info to determine subscription tier
    let endpoint = GetUserInfo;
    let user = client.hit(endpoint).await.map_err(|e| anyhow::anyhow!(e))?;

    let tier = &user.subscription.tier;

    println!();
    println!("{}", "API Key Permissions:".bold().underline());
    println!("  User ID: {}", user.user_id.cyan());
    println!("  Subscription: {}", tier.yellow());
    println!();

    // Use the helper to print feature availability
    print_subscription_info(tier);

    print_success("Permissions check complete");
    Ok(())
}