src/main.rs

@@ -5,7 +5,6 @@ use tokio::sync::Mutex;
 use tracing::{error, Level};
 use tracing_subscriber::FmtSubscriber;
 
-use qobuzd::api::{QobuzApi, TrackStream};
 use qobuzd::auth::QobuzAuth;
 use qobuzd::config::Config;
 use qobuzd::qconnect::QConnect;
@@ -34,23 +33,6 @@ enum Commands {
     },
     Logout,
     Status,
-    User,
-    Search {
-        #[arg(short, long)]
-        query: String,
-        #[arg(short, long, default_value = "albums")]
-        search_type: String,
-    },
-    Album {
-        #[arg(short, long)]
-        album_id: String,
-    },
-    Stream {
-        #[arg(short, long)]
-        track_id: String,
-        #[arg(short, long, default_value = "5")]
-        format_id: u32,
-    },
     Serve,
 }
 
@@ -112,106 +94,6 @@ async fn main() -> Result<()> {
             }
         }
 
-        Commands::User => {
-            let guard = auth.lock().await;
-            let token = guard.get_valid_token().await?;
-            drop(guard);
-            let api = QobuzApi::new(&config);
-            match api.get_user(&token).await {
-                Ok(user) => {
-                    println!("User: {}", user.display_name.unwrap_or_default());
-                    println!("Email: {}", user.email);
-                    if let Some(sub) = &user.subscription {
-                        println!("Subscription: {}", sub.offer);
-                    }
-                }
-                Err(e) => {
-                    error!("Failed: {}", e);
-                    std::process::exit(1);
-                }
-            }
-        }
-
-        Commands::Search { query, search_type } => {
-            let guard = auth.lock().await;
-            let token = guard.get_valid_token().await?;
-            drop(guard);
-            let api = QobuzApi::new(&config);
-            match api.search(&token, &query, &search_type, 10, 0).await {
-                Ok(results) => {
-                    println!("{}", serde_json::to_string_pretty(&results)?);
-                }
-                Err(e) => {
-                    error!("Search failed: {}", e);
-                    std::process::exit(1);
-                }
-            }
-        }
-
-        Commands::Album { album_id } => {
-            let guard = auth.lock().await;
-            let token = guard.get_valid_token().await?;
-            drop(guard);
-            let api = QobuzApi::new(&config);
-            match api.get_album(&token, &album_id).await {
-                Ok(album) => {
-                    println!("Album: {}", album.title);
-                    if let Some(artists) = &album.artists {
-                        if let Some(a) = artists.first() {
-                            println!("Artist: {}", a.name);
-                        }
-                    }
-                    println!("Tracks: {}", album.track_count.unwrap_or(0));
-                }
-                Err(e) => {
-                    error!("Failed: {}", e);
-                    std::process::exit(1);
-                }
-            }
-        }
-
-        Commands::Stream {
-            track_id,
-            format_id,
-        } => {
-            let guard = auth.lock().await;
-            let token = guard.get_valid_token().await?;
-            drop(guard);
-            let api = QobuzApi::new(&config);
-            match api.get_track_stream(&token, &track_id, format_id).await {
-                Ok(TrackStream::DirectUrl { url, .. }) => println!("Stream URL: {}", url),
-                Ok(TrackStream::Segmented {
-                    url_template,
-                    n_segments,
-                    encryption_key_hex,
-                    sampling_rate_hz,
-                    bit_depth,
-                    ..
-                }) => {
-                    println!("Segmented stream template: {}", url_template);
-                    println!("Segments: {}", n_segments);
-                    println!(
-                        "Encrypted: {}",
-                        if encryption_key_hex.is_some() {
-                            "yes"
-                        } else {
-                            "no"
-                        }
-                    );
-                    if let Some(sr) = sampling_rate_hz {
-                        println!("Sampling rate: {} Hz", sr);
-                    }
-                    if let Some(bits) = bit_depth {
-                        println!("Bit depth: {}", bits);
-                    }
-                }
-                Err(e) => {
-                    error!("Failed: {}", e);
-                    std::process::exit(1);
-                }
-            }
-        }
-
         Commands::Serve => {
             let guard = auth.lock().await;
             let token = match guard.get_valid_token().await {