sunox 0.0.8

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

use std::time::{Duration, Instant};

use crate::api::SunoClient;
use crate::api::types::Clip;
use crate::core::CliError;

pub fn is_terminal_status(status: &str) -> bool {
    matches!(status, "complete" | "error")
}

pub fn require_found_clips(ids: &[String], clips: Vec<Clip>) -> Result<Vec<Clip>, CliError> {
    let missing = ids
        .iter()
        .filter(|id| !clips.iter().any(|clip| clip.id == **id))
        .cloned()
        .collect::<Vec<_>>();

    if !missing.is_empty() {
        return Err(CliError::NotFound(format!(
            "clip(s): {}",
            missing.join(", ")
        )));
    }

    Ok(clips)
}

pub async fn wait_for_clips(
    client: &SunoClient,
    ids: &[String],
    timeout_secs: u64,
    poll_interval_secs: u64,
) -> Result<Vec<Clip>, CliError> {
    let start = Instant::now();
    let timeout = Duration::from_secs(timeout_secs);
    let mut delay = Duration::from_secs(poll_interval_secs.max(1));

    loop {
        let clips = require_found_clips(ids, client.get_clips(ids).await?)?;
        if clips.iter().all(|clip| is_terminal_status(&clip.status)) {
            return Ok(clips);
        }
        if start.elapsed() >= timeout {
            return Err(CliError::GenerationFailed(format!(
                "generation timed out after {timeout_secs}s for {}",
                ids.join(", ")
            )));
        }
        tokio::time::sleep(delay).await;
        delay = (delay * 2).min(Duration::from_secs(15));
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn clip(id: &str, status: &str) -> Clip {
        Clip {
            id: id.into(),
            title: format!("Clip {id}"),
            status: status.into(),
            model_name: "chirp-fenix".into(),
            audio_url: None,
            video_url: None,
            image_url: None,
            created_at: "2026-06-30T00:00:00Z".into(),
            play_count: 0,
            upvote_count: 0,
            metadata: Default::default(),
        }
    }

    #[test]
    fn complete_and_error_are_terminal_states() {
        assert!(is_terminal_status("complete"));
        assert!(is_terminal_status("error"));
    }

    #[test]
    fn streaming_and_submitted_are_not_terminal_states() {
        assert!(!is_terminal_status("streaming"));
        assert!(!is_terminal_status("submitted"));
    }

    #[test]
    fn found_clips_rejects_empty_response_for_requested_ids() {
        let ids = vec!["clip-missing".to_string()];

        let err = require_found_clips(&ids, Vec::new()).expect_err("missing clip should fail");

        assert!(matches!(err, CliError::NotFound(message) if message.contains("clip-missing")));
    }

    #[test]
    fn found_clips_rejects_partial_response_for_requested_ids() {
        let ids = vec!["clip-a".to_string(), "clip-b".to_string()];

        let err = require_found_clips(&ids, vec![clip("clip-a", "complete")])
            .expect_err("partial clip response should fail");

        assert!(
            matches!(err, CliError::NotFound(message) if message.contains("clip-b") && !message.contains("clip-a"))
        );
    }

    #[test]
    fn found_clips_returns_complete_response() {
        let ids = vec!["clip-a".to_string(), "clip-b".to_string()];
        let clips = vec![clip("clip-a", "complete"), clip("clip-b", "submitted")];

        let clips = require_found_clips(&ids, clips).expect("all requested clips found");

        assert_eq!(clips.len(), 2);
    }
}