From eefec87d9103a5ceb81e21bd73aa86e8ba96351a Mon Sep 17 00:00:00 2001 From: vicrodh <103399283+vicrodh@users.noreply.github.com> Date: Mon, 12 Jan 2026 11:52:18 -0600 Subject: [PATCH] feat: add API Keys settings section for user-provided credentials - Add api_keys module with store for user-provided credentials (Spotify, Tidal, Discogs) - Add commands to get/set/clear credentials for each provider - Update providers to check user credentials first (priority: user > embedded > env) - Add collapsible API Keys section to SettingsView - Show status badges (Active, Custom, Not configured) for each provider - Store user credentials in localStorage with backend sync --- src-tauri/src/api_keys.rs | 174 ++++++ src-tauri/src/commands/playlist_import.rs | 56 +- src-tauri/src/discogs/mod.rs | 19 +- src-tauri/src/lib.rs | 15 + src-tauri/src/library/commands.rs | 37 +- src-tauri/src/playlist_import/importer.rs | 14 +- src-tauri/src/playlist_import/mod.rs | 1 + .../src/playlist_import/providers/mod.rs | 22 +- .../src/playlist_import/providers/spotify.rs | 24 +- .../src/playlist_import/providers/tidal.rs | 24 +- src/lib/components/views/SettingsView.svelte | 512 +++++++++++++++++- 11 files changed, 861 insertions(+), 37 deletions(-) create mode 100644 src-tauri/src/api_keys.rs diff --git a/src-tauri/src/api_keys.rs b/src-tauri/src/api_keys.rs new file mode 100644 index 000000000..d77ec69b6 --- /dev/null +++ b/src-tauri/src/api_keys.rs @@ -0,0 +1,174 @@ +//! User-provided API credentials store +//! +//! Manages runtime credentials that override embedded (build-time) credentials. +//! Users can provide their own API keys if the embedded ones stop working. + +use std::sync::Arc; +use tokio::sync::Mutex; + +/// Credentials for a specific provider +#[derive(Debug, Clone, Default)] +pub struct ProviderCredentials { + pub client_id: Option, + pub client_secret: Option, +} + +impl ProviderCredentials { + pub fn is_set(&self) -> bool { + self.client_id.is_some() && self.client_secret.is_some() + } +} + +/// Store for all user-provided API credentials +#[derive(Debug, Default)] +pub struct ApiKeysStore { + pub spotify: ProviderCredentials, + pub tidal: ProviderCredentials, + pub discogs: ProviderCredentials, +} + +impl ApiKeysStore { + pub fn new() -> Self { + Self::default() + } +} + +/// Thread-safe wrapper for the API keys store +pub type ApiKeysState = Arc>; + +pub fn create_api_keys_state() -> ApiKeysState { + Arc::new(Mutex::new(ApiKeysStore::new())) +} + +// Tauri commands + +/// Set Spotify credentials +#[tauri::command] +pub async fn set_spotify_credentials( + client_id: String, + client_secret: String, + state: tauri::State<'_, ApiKeysState>, +) -> Result<(), String> { + log::info!("Setting user-provided Spotify credentials"); + let mut store = state.lock().await; + store.spotify = ProviderCredentials { + client_id: Some(client_id), + client_secret: Some(client_secret), + }; + Ok(()) +} + +/// Clear Spotify credentials +#[tauri::command] +pub async fn clear_spotify_credentials( + state: tauri::State<'_, ApiKeysState>, +) -> Result<(), String> { + log::info!("Clearing user-provided Spotify credentials"); + let mut store = state.lock().await; + store.spotify = ProviderCredentials::default(); + Ok(()) +} + +/// Check if Spotify has user-provided credentials +#[tauri::command] +pub async fn has_spotify_user_credentials( + state: tauri::State<'_, ApiKeysState>, +) -> Result { + let store = state.lock().await; + Ok(store.spotify.is_set()) +} + +/// Set Tidal credentials +#[tauri::command] +pub async fn set_tidal_credentials( + client_id: String, + client_secret: String, + state: tauri::State<'_, ApiKeysState>, +) -> Result<(), String> { + log::info!("Setting user-provided Tidal credentials"); + let mut store = state.lock().await; + store.tidal = ProviderCredentials { + client_id: Some(client_id), + client_secret: Some(client_secret), + }; + Ok(()) +} + +/// Clear Tidal credentials +#[tauri::command] +pub async fn clear_tidal_credentials( + state: tauri::State<'_, ApiKeysState>, +) -> Result<(), String> { + log::info!("Clearing user-provided Tidal credentials"); + let mut store = state.lock().await; + store.tidal = ProviderCredentials::default(); + Ok(()) +} + +/// Check if Tidal has user-provided credentials +#[tauri::command] +pub async fn has_tidal_user_credentials( + state: tauri::State<'_, ApiKeysState>, +) -> Result { + let store = state.lock().await; + Ok(store.tidal.is_set()) +} + +/// Set Discogs credentials +#[tauri::command] +pub async fn set_discogs_credentials( + consumer_key: String, + consumer_secret: String, + state: tauri::State<'_, ApiKeysState>, +) -> Result<(), String> { + log::info!("Setting user-provided Discogs credentials"); + let mut store = state.lock().await; + store.discogs = ProviderCredentials { + client_id: Some(consumer_key), + client_secret: Some(consumer_secret), + }; + Ok(()) +} + +/// Clear Discogs credentials +#[tauri::command] +pub async fn clear_discogs_credentials( + state: tauri::State<'_, ApiKeysState>, +) -> Result<(), String> { + log::info!("Clearing user-provided Discogs credentials"); + let mut store = state.lock().await; + store.discogs = ProviderCredentials::default(); + Ok(()) +} + +/// Check if Discogs has user-provided credentials +#[tauri::command] +pub async fn has_discogs_user_credentials( + state: tauri::State<'_, ApiKeysState>, +) -> Result { + let store = state.lock().await; + Ok(store.discogs.is_set()) +} + +/// Check which providers have embedded credentials available +#[tauri::command] +pub fn get_embedded_credentials_status() -> EmbeddedCredentialsStatus { + EmbeddedCredentialsStatus { + spotify: option_env!("SPOTIFY_API_CLIENT_ID").is_some() + && option_env!("SPOTIFY_API_CLIENT_SECRET").is_some(), + tidal: option_env!("TIDAL_API_CLIENT_ID").is_some() + && option_env!("TIDAL_API_CLIENT_SECRET").is_some(), + discogs: option_env!("DISCOGS_API_CLIENT_KEY").is_some() + && option_env!("DISCOGS_API_CLIENT_SECRET").is_some(), + lastfm: option_env!("LAST_FM_API_KEY").is_some() + && option_env!("LAST_FM_API_SHARED_SECRET").is_some(), + } +} + +#[derive(serde::Serialize)] +pub struct EmbeddedCredentialsStatus { + pub spotify: bool, + pub tidal: bool, + pub discogs: bool, + pub lastfm: bool, +} diff --git a/src-tauri/src/commands/playlist_import.rs b/src-tauri/src/commands/playlist_import.rs index c0bc4906a..68f4db7f0 100644 --- a/src-tauri/src/commands/playlist_import.rs +++ b/src-tauri/src/commands/playlist_import.rs @@ -2,14 +2,41 @@ use tauri::State; -use crate::playlist_import::{import_public_playlist, preview_public_playlist, ImportPlaylist, ImportSummary}; +use crate::api_keys::ApiKeysState; +use crate::playlist_import::{ + import_public_playlist, preview_public_playlist, ImportPlaylist, ImportSummary, + ProviderCredentials, +}; use crate::AppState; #[tauri::command] -pub async fn playlist_import_preview(url: String) -> Result { +pub async fn playlist_import_preview( + url: String, + api_keys: State<'_, ApiKeysState>, +) -> Result { log::info!("Command: playlist_import_preview {}", url); - preview_public_playlist(&url) + // Get user-provided credentials from state + let keys = api_keys.lock().await; + let spotify_creds = if keys.spotify.is_set() { + Some(ProviderCredentials { + client_id: keys.spotify.client_id.clone(), + client_secret: keys.spotify.client_secret.clone(), + }) + } else { + None + }; + let tidal_creds = if keys.tidal.is_set() { + Some(ProviderCredentials { + client_id: keys.tidal.client_id.clone(), + client_secret: keys.tidal.client_secret.clone(), + }) + } else { + None + }; + drop(keys); + + preview_public_playlist(&url, spotify_creds, tidal_creds) .await .map_err(|e| e.to_string()) } @@ -20,15 +47,38 @@ pub async fn playlist_import_execute( name_override: Option, is_public: Option, state: State<'_, AppState>, + api_keys: State<'_, ApiKeysState>, ) -> Result { log::info!("Command: playlist_import_execute {}", url); + // Get user-provided credentials from state + let keys = api_keys.lock().await; + let spotify_creds = if keys.spotify.is_set() { + Some(ProviderCredentials { + client_id: keys.spotify.client_id.clone(), + client_secret: keys.spotify.client_secret.clone(), + }) + } else { + None + }; + let tidal_creds = if keys.tidal.is_set() { + Some(ProviderCredentials { + client_id: keys.tidal.client_id.clone(), + client_secret: keys.tidal.client_secret.clone(), + }) + } else { + None + }; + drop(keys); + let client = state.client.lock().await; import_public_playlist( &url, &client, name_override.as_deref(), is_public.unwrap_or(false), + spotify_creds, + tidal_creds, ) .await .map_err(|e| e.to_string()) diff --git a/src-tauri/src/discogs/mod.rs b/src-tauri/src/discogs/mod.rs index 6c1808b47..f4f392e3a 100644 --- a/src-tauri/src/discogs/mod.rs +++ b/src-tauri/src/discogs/mod.rs @@ -37,13 +37,22 @@ const EMBEDDED_CONSUMER_SECRET: Option<&str> = option_env!("DISCOGS_API_CLIENT_S impl DiscogsClient { /// Create a new Discogs client with optional credentials - /// Tries embedded credentials first, falls back to runtime env vars + /// Priority: user-provided > embedded > runtime env vars pub fn new() -> Self { - let consumer_key = EMBEDDED_CONSUMER_KEY - .map(String::from) + Self::with_user_credentials(None, None) + } + + /// Create a new Discogs client with user-provided credentials (override) + pub fn with_user_credentials( + user_key: Option, + user_secret: Option, + ) -> Self { + // Priority: user-provided > embedded > runtime env vars + let consumer_key = user_key + .or_else(|| EMBEDDED_CONSUMER_KEY.map(String::from)) .or_else(|| std::env::var("DISCOGS_API_CLIENT_KEY").ok()); - let consumer_secret = EMBEDDED_CONSUMER_SECRET - .map(String::from) + let consumer_secret = user_secret + .or_else(|| EMBEDDED_CONSUMER_SECRET.map(String::from)) .or_else(|| std::env::var("DISCOGS_API_CLIENT_SECRET").ok()); let client = Client::builder() diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index 8113027f4..135ef7a73 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -5,6 +5,7 @@ pub mod api; pub mod api_cache; +pub mod api_keys; pub mod cache; pub mod cast; pub mod commands; @@ -136,6 +137,8 @@ pub fn run() { // Initialize audio settings state let audio_settings_state = config::audio_settings::AudioSettingsState::new() .expect("Failed to initialize audio settings"); + // Initialize API keys state (for user-provided credentials) + let api_keys_state = api_keys::create_api_keys_state(); // Read saved audio device setting for player initialization let saved_device = audio_settings_state @@ -214,6 +217,7 @@ pub fn run() { .manage(api_cache_state) .manage(session_store_state) .manage(audio_settings_state) + .manage(api_keys_state) .invoke_handler(tauri::generate_handler![ // Auth commands commands::init_client, @@ -417,6 +421,17 @@ pub fn run() { config::audio_settings::set_audio_exclusive_mode, config::audio_settings::set_audio_dac_passthrough, config::audio_settings::set_audio_sample_rate, + // API keys commands (user-provided credentials) + api_keys::set_spotify_credentials, + api_keys::clear_spotify_credentials, + api_keys::has_spotify_user_credentials, + api_keys::set_tidal_credentials, + api_keys::clear_tidal_credentials, + api_keys::has_tidal_user_credentials, + api_keys::set_discogs_credentials, + api_keys::clear_discogs_credentials, + api_keys::has_discogs_user_credentials, + api_keys::get_embedded_credentials_status, ]) .run(tauri::generate_context!()) .expect("error while running tauri application"); diff --git a/src-tauri/src/library/commands.rs b/src-tauri/src/library/commands.rs index 7e244caa4..730244220 100644 --- a/src-tauri/src/library/commands.rs +++ b/src-tauri/src/library/commands.rs @@ -5,6 +5,7 @@ use std::sync::Arc; use tauri::State; use tokio::sync::Mutex; +use crate::api_keys::ApiKeysState; use crate::discogs::DiscogsClient; use crate::library::{ cue_to_tracks, get_artwork_cache_dir, CueParser, LibraryDatabase, LibraryScanner, LibraryStats, @@ -584,11 +585,21 @@ pub async fn playlist_increment_play_count( // === Discogs Artwork === -/// Check if Discogs credentials are configured +/// Check if Discogs credentials are configured (embedded or user-provided) #[tauri::command] -pub fn discogs_has_credentials() -> bool { +pub async fn discogs_has_credentials( + api_keys: State<'_, ApiKeysState>, +) -> Result { + // Check user-provided credentials first + let keys = api_keys.lock().await; + if keys.discogs.is_set() { + return Ok(true); + } + drop(keys); + + // Fall back to embedded/env credentials let client = DiscogsClient::new(); - client.has_credentials() + Ok(client.has_credentials()) } /// Fetch missing artwork from Discogs for albums without artwork @@ -596,10 +607,18 @@ pub fn discogs_has_credentials() -> bool { #[tauri::command] pub async fn library_fetch_missing_artwork( state: State<'_, LibraryState>, + api_keys: State<'_, ApiKeysState>, ) -> Result { log::info!("Command: library_fetch_missing_artwork"); - let discogs = DiscogsClient::new(); + // Get user-provided credentials if available + let keys = api_keys.lock().await; + let discogs = DiscogsClient::with_user_credentials( + keys.discogs.client_id.clone(), + keys.discogs.client_secret.clone(), + ); + drop(keys); + if !discogs.has_credentials() { return Err("Discogs credentials not configured".to_string()); } @@ -641,10 +660,18 @@ pub async fn library_fetch_album_artwork( artist: String, album: String, state: State<'_, LibraryState>, + api_keys: State<'_, ApiKeysState>, ) -> Result, String> { log::info!("Command: library_fetch_album_artwork {} - {}", artist, album); - let discogs = DiscogsClient::new(); + // Get user-provided credentials if available + let keys = api_keys.lock().await; + let discogs = DiscogsClient::with_user_credentials( + keys.discogs.client_id.clone(), + keys.discogs.client_secret.clone(), + ); + drop(keys); + if !discogs.has_credentials() { return Err("Discogs credentials not configured".to_string()); } diff --git a/src-tauri/src/playlist_import/importer.rs b/src-tauri/src/playlist_import/importer.rs index 21ce91453..5fe78c948 100644 --- a/src-tauri/src/playlist_import/importer.rs +++ b/src-tauri/src/playlist_import/importer.rs @@ -4,13 +4,17 @@ use crate::api::QobuzClient; use crate::playlist_import::errors::PlaylistImportError; use crate::playlist_import::match_qobuz::match_tracks; use crate::playlist_import::models::{ImportPlaylist, ImportSummary}; -use crate::playlist_import::providers::{detect_provider, fetch_playlist}; +use crate::playlist_import::providers::{detect_provider, fetch_playlist, ProviderCredentials}; const ADD_CHUNK_SIZE: usize = 50; -pub async fn preview_public_playlist(url: &str) -> Result { +pub async fn preview_public_playlist( + url: &str, + spotify_creds: Option, + tidal_creds: Option, +) -> Result { let provider = detect_provider(url)?; - fetch_playlist(provider).await + fetch_playlist(provider, spotify_creds, tidal_creds).await } pub async fn import_public_playlist( @@ -18,8 +22,10 @@ pub async fn import_public_playlist( client: &QobuzClient, name_override: Option<&str>, is_public: bool, + spotify_creds: Option, + tidal_creds: Option, ) -> Result { - let playlist = preview_public_playlist(url).await?; + let playlist = preview_public_playlist(url, spotify_creds, tidal_creds).await?; let matches = match_tracks(client, &playlist.tracks).await?; let mut matched_track_ids = Vec::new(); diff --git a/src-tauri/src/playlist_import/mod.rs b/src-tauri/src/playlist_import/mod.rs index 8ae7ae207..d56fb9d9a 100644 --- a/src-tauri/src/playlist_import/mod.rs +++ b/src-tauri/src/playlist_import/mod.rs @@ -9,3 +9,4 @@ pub mod providers; pub use errors::PlaylistImportError; pub use importer::{import_public_playlist, preview_public_playlist}; pub use models::{ImportPlaylist, ImportProvider, ImportSummary, ImportTrack, TrackMatch}; +pub use providers::ProviderCredentials; diff --git a/src-tauri/src/playlist_import/providers/mod.rs b/src-tauri/src/playlist_import/providers/mod.rs index f162c754e..29ce197d6 100644 --- a/src-tauri/src/playlist_import/providers/mod.rs +++ b/src-tauri/src/playlist_import/providers/mod.rs @@ -8,6 +8,13 @@ pub mod tidal; use crate::playlist_import::errors::PlaylistImportError; use crate::playlist_import::models::ImportPlaylist; +/// User-provided credentials for a provider +#[derive(Debug, Clone, Default)] +pub struct ProviderCredentials { + pub client_id: Option, + pub client_secret: Option, +} + #[derive(Debug, Clone, PartialEq, Eq)] pub enum ProviderKind { Spotify { playlist_id: String }, @@ -33,13 +40,22 @@ pub fn detect_provider(url: &str) -> Result { Err(PlaylistImportError::UnsupportedProvider(url.to_string())) } -pub async fn fetch_playlist(kind: ProviderKind) -> Result { +/// Fetch playlist with optional user-provided credentials +pub async fn fetch_playlist( + kind: ProviderKind, + spotify_creds: Option, + tidal_creds: Option, +) -> Result { match kind { - ProviderKind::Spotify { playlist_id } => spotify::fetch_playlist(&playlist_id).await, + ProviderKind::Spotify { playlist_id } => { + spotify::fetch_playlist(&playlist_id, spotify_creds).await + } ProviderKind::AppleMusic { storefront, playlist_id } => { apple::fetch_playlist(&storefront, &playlist_id).await } - ProviderKind::Tidal { playlist_id } => tidal::fetch_playlist(&playlist_id).await, + ProviderKind::Tidal { playlist_id } => { + tidal::fetch_playlist(&playlist_id, tidal_creds).await + } ProviderKind::Deezer { playlist_id } => deezer::fetch_playlist(&playlist_id).await, } } diff --git a/src-tauri/src/playlist_import/providers/spotify.rs b/src-tauri/src/playlist_import/providers/spotify.rs index 9354d7c44..8b0928536 100644 --- a/src-tauri/src/playlist_import/providers/spotify.rs +++ b/src-tauri/src/playlist_import/providers/spotify.rs @@ -8,6 +8,7 @@ use serde_json::Value; use crate::playlist_import::errors::PlaylistImportError; use crate::playlist_import::models::{ImportPlaylist, ImportProvider, ImportTrack}; +use crate::playlist_import::providers::ProviderCredentials; const SPOTIFY_TOKEN_URL: &str = "https://accounts.spotify.com/api/token"; const SPOTIFY_API_BASE: &str = "https://api.spotify.com/v1"; @@ -42,8 +43,11 @@ pub fn parse_playlist_id(url: &str) -> Option { None } -pub async fn fetch_playlist(playlist_id: &str) -> Result { - if let Ok(token) = get_app_token().await { +pub async fn fetch_playlist( + playlist_id: &str, + user_creds: Option, +) -> Result { + if let Ok(token) = get_app_token(user_creds).await { if let Ok(playlist) = fetch_playlist_with_token(playlist_id, &token).await { return Ok(playlist); } @@ -252,14 +256,18 @@ async fn fetch_playlist_from_embed(playlist_id: &str) -> Result Result { - // Try embedded credentials first, fall back to runtime env vars - let client_id = EMBEDDED_CLIENT_ID - .map(String::from) +async fn get_app_token(user_creds: Option) -> Result { + // Priority: user-provided > embedded > runtime env vars + let client_id = user_creds + .as_ref() + .and_then(|c| c.client_id.clone()) + .or_else(|| EMBEDDED_CLIENT_ID.map(String::from)) .or_else(|| env::var("SPOTIFY_API_CLIENT_ID").ok()) .ok_or_else(|| PlaylistImportError::MissingCredentials("SPOTIFY_API_CLIENT_ID".to_string()))?; - let client_secret = EMBEDDED_CLIENT_SECRET - .map(String::from) + let client_secret = user_creds + .as_ref() + .and_then(|c| c.client_secret.clone()) + .or_else(|| EMBEDDED_CLIENT_SECRET.map(String::from)) .or_else(|| env::var("SPOTIFY_API_CLIENT_SECRET").ok()) .ok_or_else(|| PlaylistImportError::MissingCredentials("SPOTIFY_API_CLIENT_SECRET".to_string()))?; diff --git a/src-tauri/src/playlist_import/providers/tidal.rs b/src-tauri/src/playlist_import/providers/tidal.rs index 306df3dfc..d2b9133f1 100644 --- a/src-tauri/src/playlist_import/providers/tidal.rs +++ b/src-tauri/src/playlist_import/providers/tidal.rs @@ -10,6 +10,7 @@ use tokio::time::sleep; use crate::playlist_import::errors::PlaylistImportError; use crate::playlist_import::models::{ImportPlaylist, ImportProvider, ImportTrack}; +use crate::playlist_import::providers::ProviderCredentials; const RATE_LIMIT_DELAY_MS: u64 = 200; // Delay between API calls to avoid 429 @@ -41,8 +42,11 @@ pub fn parse_playlist_id(url: &str) -> Option { None } -pub async fn fetch_playlist(playlist_id: &str) -> Result { - let token = get_app_token().await?; +pub async fn fetch_playlist( + playlist_id: &str, + user_creds: Option, +) -> Result { + let token = get_app_token(user_creds).await?; let country_code = env::var("TIDAL_COUNTRY_CODE").unwrap_or_else(|_| "US".to_string()); let client = reqwest::Client::new(); @@ -332,14 +336,18 @@ fn parse_duration_ms(value: &str) -> Option { } } -async fn get_app_token() -> Result { - // Try embedded credentials first, fall back to runtime env vars - let client_id = EMBEDDED_CLIENT_ID - .map(String::from) +async fn get_app_token(user_creds: Option) -> Result { + // Priority: user-provided > embedded > runtime env vars + let client_id = user_creds + .as_ref() + .and_then(|c| c.client_id.clone()) + .or_else(|| EMBEDDED_CLIENT_ID.map(String::from)) .or_else(|| env::var("TIDAL_API_CLIENT_ID").ok()) .ok_or_else(|| PlaylistImportError::MissingCredentials("TIDAL_API_CLIENT_ID".to_string()))?; - let client_secret = EMBEDDED_CLIENT_SECRET - .map(String::from) + let client_secret = user_creds + .as_ref() + .and_then(|c| c.client_secret.clone()) + .or_else(|| EMBEDDED_CLIENT_SECRET.map(String::from)) .or_else(|| env::var("TIDAL_API_CLIENT_SECRET").ok()) .ok_or_else(|| PlaylistImportError::MissingCredentials("TIDAL_API_CLIENT_SECRET".to_string()))?; diff --git a/src/lib/components/views/SettingsView.svelte b/src/lib/components/views/SettingsView.svelte index bbb67809c..749be6758 100644 --- a/src/lib/components/views/SettingsView.svelte +++ b/src/lib/components/views/SettingsView.svelte @@ -1,7 +1,7 @@