sunox 0.0.16

Generate AI music from your terminal via direct Suno web workflows
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
135

use std::collections::HashSet;

use crate::api::types::FeedFilters;
use crate::app::AppContext;
use crate::cli::{InfoArgs, ListArgs, ListSort, SearchArgs, StatusArgs};
use crate::core::{CliError, ensure_clip_ids};
use crate::output::{self, OutputFormat};
use crate::workflow::tasks;

pub async fn list(args: ListArgs, ctx: &AppContext) -> Result<(), CliError> {
    if args.limit == Some(0) {
        return Err(CliError::Config("--limit must be greater than 0".into()));
    }
    let filters = list_filters(&args);
    let feed = ctx
        .client()
        .await?
        .feed(args.cursor, args.limit, filters)
        .await?;
    match ctx.fmt {
        OutputFormat::Json => output::json::success(&feed),
        OutputFormat::Table => {
            output::table::clips(&feed.clips);
            if let Some(cursor) = &feed.next_cursor {
                eprintln!("Next cursor: {cursor}");
            }
            if feed.has_more && feed.next_cursor.is_none() {
                eprintln!("More results available");
            }
        }
    }
    Ok(())
}

pub async fn search(args: SearchArgs, ctx: &AppContext) -> Result<(), CliError> {
    if args.limit == Some(0) {
        return Err(CliError::Config("--limit must be greater than 0".into()));
    }
    let client = ctx.client().await?;
    let mut feed = client
        .search_page(&args.query, args.cursor.clone(), args.limit)
        .await?;
    if args.all {
        let mut seen = HashSet::new();
        if let Some(cursor) = args.cursor {
            seen.insert(cursor);
        }
        while feed.has_more {
            let cursor = feed.next_cursor.clone().ok_or_else(|| CliError::Api {
                code: "pagination_error",
                message: "Suno reported more search results without a next cursor".into(),
            })?;
            if !seen.insert(cursor.clone()) {
                return Err(CliError::Api {
                    code: "pagination_error",
                    message: "Suno repeated a search pagination cursor".into(),
                });
            }
            let page = client
                .search_page(&args.query, Some(cursor), args.limit)
                .await?;
            feed.clips.extend(page.clips);
            feed.next_cursor = page.next_cursor;
            feed.has_more = page.has_more;
        }
    }
    match ctx.fmt {
        OutputFormat::Json => output::json::success(&feed),
        OutputFormat::Table => {
            if feed.clips.is_empty() {
                eprintln!("No clips matching \"{}\"", args.query);
            } else {
                output::table::clips(&feed.clips);
            }
            if let Some(cursor) = &feed.next_cursor {
                eprintln!("Next cursor: {cursor}");
            } else if feed.has_more {
                eprintln!("More results available, but Suno did not return a cursor");
            }
        }
    }
    Ok(())
}

pub async fn info(args: InfoArgs, ctx: &AppContext) -> Result<(), CliError> {
    let client = ctx.client().await?;
    let clips = client.get_clips(std::slice::from_ref(&args.id)).await?;
    if clips.is_empty() {
        return Err(CliError::NotFound(format!("clip: {}", args.id)));
    }
    let info = client.clip_info(clips[0].clone()).await?;
    match ctx.fmt {
        OutputFormat::Json => output::json::success(&info),
        OutputFormat::Table => output::table::clip_detail(&info),
    }
    Ok(())
}

pub async fn status(args: StatusArgs, ctx: &AppContext) -> Result<(), CliError> {
    ensure_clip_ids(&args.ids)?;
    let clips =
        tasks::require_found_clips(&args.ids, ctx.client().await?.get_clips(&args.ids).await?)?;
    match ctx.fmt {
        OutputFormat::Json => output::json::success(&clips),
        OutputFormat::Table => output::table::clips(&clips),
    }
    Ok(())
}

fn list_filters(args: &ListArgs) -> FeedFilters {
    let mut filters = if args.trashed {
        FeedFilters::trashed()
    } else {
        FeedFilters::default_workspace()
    };
    if args.public {
        filters = filters.with_public();
    }
    if args.liked {
        filters = filters.with_liked();
    }
    if args.upload {
        filters = filters.with_upload();
    }
    if args.cover {
        filters = filters.with_cover();
    }
    if args.extend {
        filters = filters.with_extend();
    }
    if matches!(args.sort, Some(ListSort::Popular)) {
        filters = filters.with_popular_sort();
    }
    filters
}