rs-suno 0.2.0

A download-only command-line tool for mirroring your Suno.ai library.
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

//! `ls` and `lsjson`: authenticate one account, list its clips, apply the same
//! recency/limit selection the engine uses, and print a table or NDJSON.

use std::collections::HashMap;
use std::io::IsTerminal;

use anyhow::{Context, Result};
use suno_core::select::{RecencySpec, SelectParams, select};
use suno_core::{ClerkAuth, FlagOverrides, SunoClient};

use crate::cli::args::{GlobalArgs, LsArgs, OutputFormat};
use crate::cli::desired::ExitCode;
use crate::cli::output;
use crate::cli::run;
use crate::http::ReqwestHttp;

/// Run `ls` (or `lsjson` when `force_json`).
pub async fn run_ls(global: &GlobalArgs, args: &LsArgs, force_json: bool) -> Result<ExitCode> {
    let env: HashMap<String, String> = std::env::vars().collect();
    let flags = FlagOverrides {
        token: global.token.clone(),
        ..FlagOverrides::default()
    };

    let config = match run::load_config_reported(global.config.as_deref()) {
        Ok(config) => config,
        Err(code) => return Ok(code),
    };
    let (label, settings) = match run::single_account(config.as_ref(), global, &flags, &env) {
        Ok(resolved) => resolved,
        Err(message) => {
            eprintln!("error: {message}");
            return Ok(ExitCode::Config);
        }
    };
    let Some(token) = settings.token else {
        eprintln!("error: no token for account '{label}'; pass --token or set it in config");
        return Ok(ExitCode::Config);
    };

    let since = match args.since.as_deref().map(RecencySpec::parse).transpose() {
        Ok(since) => since,
        Err(message) => {
            eprintln!("error: {message}");
            return Ok(ExitCode::Config);
        }
    };

    let http = ReqwestHttp::new().context("failed to build the HTTP client")?;
    let mut auth = ClerkAuth::new(&token);
    let user_id = match auth.authenticate(&http).await {
        Ok(user_id) => user_id,
        Err(err) => return Ok(run::report_auth_failure(&label, &err)),
    };
    let display_name = auth.display_name().to_owned();
    let mut client = SunoClient::new(auth);

    let (clips, _complete) = match client.list_clips(&http, args.liked, args.limit).await {
        Ok(result) => result,
        Err(err) => return Ok(run::report_listing_failure(&label, &err)),
    };

    let params = SelectParams {
        limit: args.limit,
        since,
        min_newest: settings.min_newest as usize,
        now: run::now_secs(),
        last_run: None,
    };
    let selected = select(&clips, &params);

    let json = force_json || args.format == OutputFormat::Json;
    if json {
        for clip in &selected {
            println!("{}", output::lsjson_line(clip));
        }
    } else {
        if std::io::stdout().is_terminal() {
            println!("{}", output::ls_header());
        }
        for clip in &selected {
            println!("{}", output::ls_row(clip));
        }
    }

    if global.verbosity() >= -1 {
        eprintln!("{display_name} ({user_id}): {} clip(s)", selected.len());
    }
    Ok(ExitCode::Ok)
}