sunox 0.0.11

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
136
137
138

use super::SunoClient;
use super::types::{
    Clip, ClipAttribution, ClipComments, ClipInfo, ClipInfoSupplementalError,
    DirectChildrenCountResponse, SimilarClipsResponse,
};
use crate::core::CliError;

impl SunoClient {
    /// Fetch the attribution block shown on the Suno song page.
    /// GET /api/clips/{clip_id}/attribution
    pub async fn clip_attribution(&self, clip_id: &str) -> Result<ClipAttribution, CliError> {
        self.with_auth_retry(|| async {
            let resp = self
                .get(&format!("/api/clips/{clip_id}/attribution"))
                .send()
                .await?;
            let resp = self.check_response(resp).await?;
            Ok(resp.json().await?)
        })
        .await
    }

    /// Fetch the first page of comments shown on the Suno song page.
    /// GET /api/gen/{clip_id}/comments?order=most_liked
    pub async fn clip_comments(&self, clip_id: &str) -> Result<ClipComments, CliError> {
        self.with_auth_retry(|| async {
            let resp = self
                .get(&format!("/api/gen/{clip_id}/comments"))
                .query(&[("order", "most_liked")])
                .send()
                .await?;
            let resp = self.check_response(resp).await?;
            Ok(resp.json().await?)
        })
        .await
    }

    /// Fetch the number of direct children derived from a clip.
    /// GET /api/clips/direct_children_count?clip_id={clip_id}
    pub async fn direct_children_count(&self, clip_id: &str) -> Result<u64, CliError> {
        self.with_auth_retry(|| async {
            let resp = self
                .get("/api/clips/direct_children_count")
                .query(&[("clip_id", clip_id)])
                .send()
                .await?;
            let resp = self.check_response(resp).await?;
            let body: DirectChildrenCountResponse = resp.json().await?;
            Ok(body.count)
        })
        .await
    }

    /// Fetch similar clips shown on the Suno song page.
    /// GET /api/clips/get_similar/?id={clip_id}
    pub async fn similar_clips(&self, clip_id: &str) -> Result<Vec<Clip>, CliError> {
        self.with_auth_retry(|| async {
            let resp = self
                .get("/api/clips/get_similar/")
                .query(&[("id", clip_id)])
                .send()
                .await?;
            let resp = self.check_response(resp).await?;
            let body: SimilarClipsResponse = resp.json().await?;
            Ok(body.similar_clips)
        })
        .await
    }

    /// Compose the main feed clip with song-page enrichment reads.
    pub async fn clip_info(&self, clip: Clip) -> Result<ClipInfo, CliError> {
        let clip_id = clip.id.as_str();
        let mut supplemental_errors = Vec::new();
        let attribution = match self.clip_attribution(clip_id).await {
            Ok(value) => value,
            Err(error) => {
                if should_abort_supplemental_error(&error) {
                    return Err(error);
                }
                supplemental_errors.push(supplemental_error("attribution", error));
                ClipAttribution::default()
            }
        };
        let comments = match self.clip_comments(clip_id).await {
            Ok(value) => value,
            Err(error) => {
                if should_abort_supplemental_error(&error) {
                    return Err(error);
                }
                supplemental_errors.push(supplemental_error("comments", error));
                ClipComments::default()
            }
        };
        let direct_children_count = match self.direct_children_count(clip_id).await {
            Ok(value) => value,
            Err(error) => {
                if should_abort_supplemental_error(&error) {
                    return Err(error);
                }
                supplemental_errors.push(supplemental_error("direct_children_count", error));
                0
            }
        };
        let similar_clips = match self.similar_clips(clip_id).await {
            Ok(value) => value,
            Err(error) => {
                if should_abort_supplemental_error(&error) {
                    return Err(error);
                }
                supplemental_errors.push(supplemental_error("similar_clips", error));
                Vec::new()
            }
        };
        Ok(ClipInfo {
            clip,
            attribution,
            comments,
            direct_children_count,
            similar_clips,
            supplemental_errors,
        })
    }
}

fn should_abort_supplemental_error(error: &CliError) -> bool {
    matches!(
        error,
        CliError::AuthMissing | CliError::AuthExpired | CliError::RateLimited
    )
}

fn supplemental_error(field: &str, error: CliError) -> ClipInfoSupplementalError {
    ClipInfoSupplementalError {
        field: field.to_string(),
        code: error.error_code().to_string(),
        message: error.to_string(),
    }
}