Many fixes, Last FM integration, Local Files fixes, Remmber Window Size LocationSetting, Search bar in playlist

Author: 2latemc

package-lock.json

@@ -1,7 +1,7 @@
 {
   "name": "just-another-music-client",
   "private": true,
-  "version": "1.2.74",
+  "version": "1.2.80",
   "type": "module",
   "scripts": {
     "dev": "vite",

package.json

@@ -1,6 +1,6 @@
 [package]
 name = "just-another-music-client"
-version = "1.2.74"
+version = "1.2.80"
 description = "A desktop music client"
 authors = ["you"]
 edition = "2021"

src-tauri/Cargo.lock

@@ -28,6 +28,7 @@
 "core:window:allow-outer-size",
 "core:window:allow-current-monitor",
 "core:window:allow-set-position",
+"core:window:allow-set-size",
 "core:window:allow-cursor-position",
 "core:window:allow-set-cursor-icon",
 "core:window:allow-set-ignore-cursor-events"
@@ -67,7 +68,13 @@
       "delete_youtube_credentials",
       "load_youtube_music_cookie",
       "sign_in_youtube_music",
-      "delete_youtube_music_cookie"
+      "delete_youtube_music_cookie",
+      "lastfm_auth_token",
+      "lastfm_complete_auth",
+      "lastfm_disconnect",
+      "lastfm_get_session",
+      "lastfm_scrobble",
+      "lastfm_update_now_playing"
     ]
   }
 }

src-tauri/Cargo.toml

@@ -3,6 +3,8 @@ use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 
 const LASTFM_API_URL: &str = "https://ws.audioscrobbler.com/2.0/";
+const LASTFM_API_KEY: &str = "802624099e59adcc599c9f6e6aa60371";
+const LASTFM_SHARED_SECRET: &str = "186e5d4fa717d145ece7e50aff07757c";
 const LASTFM_KEYRING_USER: &str = "lastfm-session-v1";
 
 #[derive(Serialize, Deserialize)]
@@ -66,20 +68,8 @@ pub struct LastFmScrobbleInput {
     timestamp: u64,
 }
 
-fn configured_credentials() -> Result<(&'static str, &'static str), CommandError> {
-    let api_key = option_env!("LASTFM_API_KEY")
-        .map(str::trim)
-        .filter(|value| !value.is_empty());
-    let shared_secret = option_env!("LASTFM_SHARED_SECRET")
-        .map(str::trim)
-        .filter(|value| !value.is_empty());
-
-    match (api_key, shared_secret) {
-        (Some(api_key), Some(shared_secret)) => Ok((api_key, shared_secret)),
-        _ => Err(CommandError {
-            message: "Last.fm API credentials are not configured for this build.".to_string(),
-        }),
-    }
+fn configured_credentials() -> (&'static str, &'static str) {
+    (LASTFM_API_KEY, LASTFM_SHARED_SECRET)
 }
 
 fn lastfm_keyring_entry() -> Result<keyring::Entry, CommandError> {
@@ -135,7 +125,7 @@ fn api_signature(params: &BTreeMap<String, String>, shared_secret: &str) -> Stri
 async fn signed_lastfm_post<T: for<'de> Deserialize<'de>>(
     mut params: BTreeMap<String, String>,
 ) -> Result<T, CommandError> {
-    let (api_key, shared_secret) = configured_credentials()?;
+    let (api_key, shared_secret) = configured_credentials();
     params.insert("api_key".to_string(), api_key.to_string());
     let signature = api_signature(&params, shared_secret);
     params.insert("api_sig".to_string(), signature);
@@ -194,7 +184,7 @@ fn clean_metadata(value: String, label: &str) -> Result<String, CommandError> {
 
 #[tauri::command]
 pub async fn lastfm_auth_token() -> Result<LastFmAuthStart, CommandError> {
-    let (api_key, _) = configured_credentials()?;
+    let (api_key, _) = configured_credentials();
     let mut params = BTreeMap::new();
     params.insert("method".to_string(), "auth.getToken".to_string());
     let response = signed_lastfm_post::<LastFmTokenResponse>(params).await?;

src-tauri/capabilities/default.json

@@ -9,7 +9,7 @@ use std::fs::{self, File, OpenOptions};
 use std::io::Write;
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 use std::path::{Path, PathBuf};
-use std::sync::{Arc, Mutex, OnceLock};
+use std::sync::{Mutex, OnceLock};
 use std::thread;
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
@@ -62,9 +62,6 @@ const YOUTUBE_COOKIE_CHUNK_SIZE: usize = 900;
 const YOUTUBE_COOKIE_MAX_CHUNKS: usize = 16;
 const DEFAULT_CACHE_MAX_BYTES: u64 = 4 * 1024 * 1024 * 1024;
 const CURRENT_LOG_FILE_NAME: &str = "current.log";
-const MAIN_WEBVIEW_SLEEP_RECOVERY_DELAY_MS: u64 = 900;
-const MAIN_WEBVIEW_RECOVERY_RELOAD_GRACE_MS: u64 = 150;
-const MAIN_WEBVIEW_FOCUS_RECOVERY_IDLE_MS: u64 = 60_000;
 
 static APP_LOG_FILE: OnceLock<Mutex<Option<File>>> = OnceLock::new();
 
@@ -688,34 +685,6 @@ fn quit_app(app: tauri::AppHandle) {
     app.exit(0);
 }
 
-fn schedule_main_webview_recovery(app: tauri::AppHandle, reason: &'static str) {
-    thread::spawn(move || {
-        thread::sleep(Duration::from_millis(MAIN_WEBVIEW_SLEEP_RECOVERY_DELAY_MS));
-
-        let Some(main) = app.get_webview_window("main") else {
-            eprintln!(
-                "[internal][tauri][warn] main webview recovery skipped reason={} cause=missing_window",
-                reason
-            );
-            return;
-        };
-
-        eprintln!(
-            "[internal][tauri][info] main webview recovery reload reason={}",
-            reason
-        );
-        let _ = app.emit("main-window-recovery-reload", reason);
-        thread::sleep(Duration::from_millis(MAIN_WEBVIEW_RECOVERY_RELOAD_GRACE_MS));
-
-        if let Err(error) = main.reload() {
-            eprintln!(
-                "[internal][tauri][warn] main webview recovery reload failed reason={} error={}",
-                reason, error
-            );
-        }
-    });
-}
-
 #[tauri::command]
 fn frontend_log(level: String, context: String, payload: String) {
     eprintln!("[internal][frontend][{}] {} {}", level, context, payload);
@@ -2049,9 +2018,6 @@ pub fn run() {
     #[cfg(target_os = "macos")]
     let builder = builder.manage(macos_media::MacosMediaSession::new());
 
-    let last_main_focus_lost_at = Arc::new(Mutex::new(None::<Instant>));
-    let window_event_last_main_focus_lost_at = Arc::clone(&last_main_focus_lost_at);
-
     builder
         .setup(|app| {
             if let Err(error) = initialize_app_log(app.handle()) {
@@ -2072,11 +2038,6 @@ pub fn run() {
             }
             tauri::WindowEvent::Focused(false) => {
                 if window.label() == "main" {
-                    if let Ok(mut last_focus_lost_at) = window_event_last_main_focus_lost_at.lock()
-                    {
-                        *last_focus_lost_at = Some(Instant::now());
-                    }
-
                     let app = window.app_handle().clone();
                     thread::spawn(move || {
                         thread::sleep(Duration::from_millis(100));
@@ -2099,21 +2060,7 @@ pub fn run() {
             }
             tauri::WindowEvent::Focused(true) => {
                 if window.label() == "main" {
-                    let app = window.app_handle().clone();
-                    let _ = app.emit("window-focused", ());
-
-                    let was_idle_long_enough = window_event_last_main_focus_lost_at
-                        .lock()
-                        .ok()
-                        .and_then(|mut last_focus_lost_at| last_focus_lost_at.take())
-                        .is_some_and(|lost_at| {
-                            lost_at.elapsed()
-                                >= Duration::from_millis(MAIN_WEBVIEW_FOCUS_RECOVERY_IDLE_MS)
-                        });
-
-                    if was_idle_long_enough {
-                        schedule_main_webview_recovery(app, "main-focus-return-after-idle");
-                    }
+                    let _ = window.app_handle().emit("window-focused", ());
                 }
             }
             _ => {}

src-tauri/src/lastfm.rs

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Just Another Music Client",
-  "version": "1.2.74",
+  "version": "1.2.80",
   "identifier": "com.justanothermusicclient.desktop",
   "build": {
     "beforeDevCommand": "npm run dev",

src-tauri/src/lib.rs

@@ -211,6 +211,7 @@ const ARTIST_CACHE_VERSION = "v3";
 const ARTIST_SUBSCRIPTION_OVERRIDE_MS = 60_000;
 const PLAYLIST_PAGE_SESSION_TTL_MS = 10 * 60_000;
 const PLAYLIST_TRACK_CACHE_VERSION = "v4";
+const PLAYLIST_EMPTY_RETRY_DELAYS_MS = [0, 600, 1_500];
 
 class YouTubeMusicAuthError extends Error {
   constructor(message: string) {
@@ -1191,6 +1192,25 @@ export class YouTubeMusicDataSource extends DataSource {
     });
   }
 
+  private async updateCachedAlbumSaved(album: Album, saved: boolean): Promise<void> {
+    const cachedLibrary = await getCachedJson<LibrarySnapshot>(LIBRARY_CACHE_KEY);
+    if (!cachedLibrary) return;
+
+    const sameAlbum = (item: Album) =>
+      item.id === album.id
+      || Boolean(album.playlistId && item.playlistId === album.playlistId)
+      || Boolean(album.playlistId && item.id === album.playlistId)
+      || Boolean(item.playlistId && item.playlistId === album.id);
+    const albums = saved
+      ? [album, ...cachedLibrary.albums.filter((item) => !sameAlbum(item))]
+      : cachedLibrary.albums.filter((item) => !sameAlbum(item));
+
+    await setCachedJson(LIBRARY_CACHE_KEY, {
+      ...cachedLibrary,
+      albums,
+    });
+  }
+
   private getActionableServiceEndpoint(endpoint: RawServiceEndpoint): RawServiceEndpoint {
     const commands = endpoint.commandExecutorCommand?.commands;
     if (!commands?.length) return endpoint;
@@ -1493,6 +1513,39 @@ export class YouTubeMusicDataSource extends DataSource {
     return tracks;
   }
 
+  private async waitForPlaylistEmptyRetry(attempt: number): Promise<void> {
+    const delayMs = PLAYLIST_EMPTY_RETRY_DELAYS_MS[attempt] ?? 0;
+    if (delayMs <= 0) return;
+    await new Promise<void>((resolve) => globalThis.setTimeout(resolve, delayMs));
+  }
+
+  private async collectPlaylistTracksWithEmptyRetries(
+    client: Innertube,
+    playlistId: string,
+    source: string,
+  ): Promise<Track[]> {
+    for (let attempt = 0; attempt < PLAYLIST_EMPTY_RETRY_DELAYS_MS.length; attempt += 1) {
+      await this.waitForPlaylistEmptyRetry(attempt);
+
+      const tracks = await this.collectPlaylistTracks(client, playlistId);
+      if (tracks.length > 0) return tracks;
+
+      const browseId = playlistId.startsWith("VL") ? playlistId : `VL${playlistId}`;
+      logInternalWarn("YouTubeMusicDataSource.collectPlaylistTracksWithEmptyRetries retrying empty response", {
+        playlistId,
+        browseId,
+        source,
+        attempt: attempt + 1,
+      });
+
+      const response = await this.executeMusicBrowse(client, { browseId });
+      const fallbackTracks = await this.collectAllTracks(client, response);
+      if (fallbackTracks.length > 0) return fallbackTracks;
+    }
+
+    return [];
+  }
+
   private createPlaylistPageKey(playlistId: string): string {
     return `${playlistId}:${Date.now()}:${Math.random().toString(36).slice(2)}`;
   }
@@ -2171,6 +2224,7 @@ export class YouTubeMusicDataSource extends DataSource {
             albumPlaylistId,
             saved,
           });
+          await this.updateCachedAlbumSaved(album, saved);
           return;
         } catch (directError) {
           logInternalWarn("YouTubeMusicDataSource.setAlbumSaved direct like command failed", {
@@ -2185,7 +2239,10 @@ export class YouTubeMusicDataSource extends DataSource {
       const rawToggle = this.findRawLibraryToggle(albumResponse);
 
       if (rawToggle) {
-        if (rawToggle.isToggled === saved) return;
+        if (rawToggle.isToggled === saved) {
+          await this.updateCachedAlbumSaved(album, saved);
+          return;
+        }
         const endpoint = saved
           ? rawToggle.defaultServiceEndpoint
           : rawToggle.toggledServiceEndpoint;
@@ -2205,12 +2262,16 @@ export class YouTubeMusicDataSource extends DataSource {
         if (response.success === false) {
           throw new Error(`Album library update returned HTTP ${response.status_code}.`);
         }
+        await this.updateCachedAlbumSaved(album, saved);
         return;
       }
 
       const rawMenuToggle = this.findRawLibraryMenuToggle(albumResponse);
       if (rawMenuToggle) {
-        if (rawMenuToggle.isToggled === saved) return;
+        if (rawMenuToggle.isToggled === saved) {
+          await this.updateCachedAlbumSaved(album, saved);
+          return;
+        }
         const endpoint = saved
           ? rawMenuToggle.defaultServiceEndpoint
           : rawMenuToggle.toggledServiceEndpoint;
@@ -2231,6 +2292,7 @@ export class YouTubeMusicDataSource extends DataSource {
         if (response.success === false) {
           throw new Error(`Album library menu update returned HTTP ${response.status_code}.`);
         }
+        await this.updateCachedAlbumSaved(album, saved);
         return;
       }
 
@@ -2239,7 +2301,10 @@ export class YouTubeMusicDataSource extends DataSource {
       if (!toggle) {
         throw new Error("YouTube Music did not return a library command for this album.");
       }
-      if (toggle.isToggled === saved) return;
+      if (toggle.isToggled === saved) {
+        await this.updateCachedAlbumSaved(album, saved);
+        return;
+      }
 
       const endpoint = saved ? toggle.endpoint : toggle.toggledEndpoint;
       if (!endpoint) {
@@ -2258,6 +2323,7 @@ export class YouTubeMusicDataSource extends DataSource {
       if (response.success === false) {
         throw new Error(`Album library update returned HTTP ${response.status_code}.`);
       }
+      await this.updateCachedAlbumSaved(album, saved);
     } catch (error) {
       logInternalError("YouTubeMusicDataSource.setAlbumSaved failed", error, {
         albumId: album.id,
@@ -2728,7 +2794,11 @@ export class YouTubeMusicDataSource extends DataSource {
         logInternalWarn("YouTubeMusicDataSource.getPlaylistTrackPage verifying empty first page", {
           playlistId: playlist.id,
         });
-        const fallbackTracks = await this.collectPlaylistTracks(client, playlist.id);
+        const fallbackTracks = await this.collectPlaylistTracksWithEmptyRetries(
+          client,
+          playlist.id,
+          "paged-first-load",
+        );
         if (fallbackTracks.length > 0) {
           const cachedFallbackTracks = await this.cachePlaylistTracks(playlist.id, fallbackTracks);
           return { tracks: cachedFallbackTracks, hasMore: false };
@@ -2787,16 +2857,7 @@ export class YouTubeMusicDataSource extends DataSource {
 
   private async fetchPlaylistTracksFresh(playlist: Playlist): Promise<Track[]> {
     const client = await this.getMusicClient();
-    const tracks = await this.collectPlaylistTracks(client, playlist.id);
-    if (tracks.length > 0) return tracks;
-
-    const browseId = playlist.id.startsWith("VL") ? playlist.id : `VL${playlist.id}`;
-    logInternalWarn("YouTubeMusicDataSource.fetchPlaylistTracksFresh retrying empty playlist response", {
-      playlistId: playlist.id,
-      browseId,
-    });
-    const response = await this.executeMusicBrowse(client, { browseId });
-    return this.collectAllTracks(client, response);
+    return this.collectPlaylistTracksWithEmptyRetries(client, playlist.id, "fresh-load");
   }
 
   async addTrackToPlaylist(