10 | {toasts.map((toast) => (
11 |
79 | );
80 | }
--------------------------------------------------------------------------------
/backend/api/services/lyrics.py:
--------------------------------------------------------------------------------
1 | from pathlib import Path
2 | from api.utils.logging import log_info, log_success, log_warning, log_step
3 | import asyncio
4 | import shutil
5 | from lyrics_client import lyrics_client
6 |
7 | async def fetch_and_store_lyrics(filepath: Path, metadata: dict, audio_file=None):
8 | if metadata.get('title') and metadata.get('artist'):
9 | try:
10 | log_info("Fetching lyrics...")
11 | lyrics_result = await lyrics_client.get_lyrics(
12 | track_name=metadata['title'],
13 | artist_name=metadata['artist'],
14 | album_name=metadata.get('album'),
15 | duration=metadata.get('duration')
16 | )
17 |
18 | if lyrics_result:
19 | if lyrics_result.synced_lyrics:
20 | metadata['synced_lyrics'] = lyrics_result.synced_lyrics
21 | log_success("Synced lyrics found (will save to .lrc)")
22 | elif lyrics_result.plain_lyrics:
23 | metadata['plain_lyrics'] = lyrics_result.plain_lyrics
24 | log_success("Plain lyrics found (will save to .txt)")
25 |
26 | except Exception as e:
27 | log_warning(f"Failed to fetch lyrics: {e}")
28 |
29 | if audio_file and metadata.get('synced_lyrics'):
30 | try:
31 | lyrics_text = metadata['synced_lyrics']
32 |
33 | for i, line in enumerate(lyrics_text.split('\n')):
34 | if line.strip():
35 | audio_file[f'LYRICS_LINE_{i+1}'] = line.strip()
36 |
37 | log_success(f"Embedded {len(lyrics_text.splitlines())} lines of lyrics")
38 | except Exception as e:
39 | log_warning(f"Failed to embed lyrics: {e}")
40 |
41 | async def embed_lyrics_with_ffmpeg(filepath: Path, metadata: dict):
42 | """Embed lyrics into the audio file using FFmpeg"""
43 | try:
44 | import subprocess
45 |
46 |
47 | try:
48 | subprocess.run(["ffmpeg", "-version"], check=True, capture_output=True)
49 | except (FileNotFoundError, subprocess.CalledProcessError):
50 | log_warning("FFmpeg not found. Skipping lyrics embedding.")
51 | return
52 |
53 | lyrics = metadata.get('synced_lyrics') or metadata.get('plain_lyrics')
54 | if not lyrics:
55 | log_info("No lyrics found to embed.")
56 | return
57 |
58 | log_step("3.8/4", f"Embedding lyrics with FFmpeg...")
59 |
60 |
61 | lyrics_path = filepath.with_suffix('.lyrics.txt')
62 | with open(lyrics_path, 'w', encoding='utf-8') as f:
63 | f.write(lyrics)
64 |
65 | output_path = filepath.with_suffix('.temp' + filepath.suffix)
66 |
67 |
68 | cmd = [
69 | "ffmpeg", "-y", "-i", str(filepath),
70 | "-map", "0", "-c", "copy",
71 | "-metadata", f"LYRICS={lyrics}",
72 | str(output_path)
73 | ]
74 |
75 |
76 |
77 | process = await asyncio.create_subprocess_exec(
78 | *cmd,
79 | stdout=asyncio.subprocess.PIPE,
80 | stderr=asyncio.subprocess.PIPE
81 | )
82 | stdout, stderr = await process.communicate()
83 |
84 | if process.returncode == 0:
85 |
86 | shutil.move(str(output_path), str(filepath))
87 | log_success("Lyrics embedded with FFmpeg")
88 | else:
89 | log_warning(f"FFmpeg lyrics embedding failed: {stderr.decode()}")
90 | if output_path.exists():
91 | output_path.unlink()
92 |
93 |
94 | if lyrics_path.exists():
95 | lyrics_path.unlink()
96 |
97 | except Exception as e:
98 | log_warning(f"Failed to embed lyrics with FFmpeg: {e}")
99 | import traceback
100 | traceback.print_exc()
101 |
--------------------------------------------------------------------------------
/backend/api/services/beets.py:
--------------------------------------------------------------------------------
1 | from pathlib import Path
2 | import asyncio
3 | import os
4 | import sys
5 | from api.utils.logging import log_info, log_success, log_warning, log_step
6 |
7 | async def run_beets_import(path: Path):
8 | """Run beets import on the downloaded file/directory"""
9 | try:
10 | import subprocess
11 |
12 | # Determine beet executable path
13 | beet_cmd = "beet"
14 |
15 | # Check if beet is in the same directory as python executable (common in venvs)
16 | python_dir = os.path.dirname(sys.executable)
17 | potential_beet = os.path.join(python_dir, "beet")
18 | if os.path.exists(potential_beet):
19 | beet_cmd = potential_beet
20 | elif os.path.exists(potential_beet + ".exe"):
21 | beet_cmd = potential_beet + ".exe"
22 |
23 | # Check if beet is installed/runnable
24 | try:
25 | subprocess.run([beet_cmd, "version"], check=True, capture_output=True)
26 | except (FileNotFoundError, subprocess.CalledProcessError):
27 | log_warning(f"Beets not found (tried '{beet_cmd}'). Skipping import.")
28 | return
29 |
30 | log_step("4/4", f"Running beets import on {path.name}...")
31 |
32 | use_custom_config = False
33 | custom_config_path = Path("tidaloader_beets.yaml").resolve()
34 |
35 | try:
36 | result = subprocess.run([beet_cmd, "config", "-p"], capture_output=True, text=True)
37 | config_path = result.stdout.strip()
38 |
39 | if result.returncode != 0 or not config_path or not os.path.exists(config_path):
40 | log_info("No existing Beets config found. Using auto-generated configuration.")
41 | use_custom_config = True
42 | else:
43 | log_info(f"Using existing Beets config at: {config_path}")
44 |
45 | except Exception as e:
46 | log_warning(f"Error checking Beets config: {e}. Defaulting to auto-generated config.")
47 | use_custom_config = True
48 |
49 | if use_custom_config:
50 | config_content = """
51 | directory: /tmp # Dummy, we don't move files
52 | original_date: no
53 | plugins: chroma fetchart embedart lastgenre
54 | import:
55 | write: yes
56 | copy: no
57 | move: no
58 | autotag: yes
59 | timid: no
60 | resume: ask
61 | incremental: no
62 | quiet_fallback: skip
63 | log: beets_import.log
64 | chroma:
65 | auto: yes
66 | fetchart:
67 | auto: yes
68 | embedart:
69 | auto: yes
70 | lastgenre:
71 | auto: yes
72 | source: artist
73 | musicbrainz:
74 | genres: yes
75 | match:
76 | strong_rec_thresh: 0.10
77 | distance_weights:
78 | missing_tracks: 0.0
79 | unmatched_tracks: 0.0
80 | """
81 | with open(custom_config_path, "w") as f:
82 | f.write(config_content)
83 | log_info("Generated/Updated custom Beets configuration.")
84 |
85 | log_step("4/4", f"Running beets import on {path.name}...")
86 |
87 | cmd = [beet_cmd, "-c", str(custom_config_path), "import", "-q", "-s", str(path)]
88 |
89 | process = await asyncio.create_subprocess_exec(
90 | *cmd,
91 | stdout=asyncio.subprocess.PIPE,
92 | stderr=asyncio.subprocess.PIPE
93 | )
94 | stdout, stderr = await process.communicate()
95 |
96 | stdout_str = stdout.decode()
97 | stderr_str = stderr.decode()
98 |
99 | if process.returncode == 0:
100 | log_success("Beets import completed successfully")
101 | print(f"Beets Output:\n{stdout_str}")
102 | if stderr_str:
103 | print(f"Beets Errors/Warnings:\n{stderr_str}")
104 | else:
105 | log_warning(f"Beets import failed: {stderr_str}")
106 | print(f"Beets Output:\n{stdout_str}")
107 |
108 | except Exception as e:
109 | log_warning(f"Failed to run beets import: {e}")
110 |
--------------------------------------------------------------------------------
/frontend/src/components/ReleaseNotes.jsx:
--------------------------------------------------------------------------------
1 | import { h } from "preact";
2 | import { releaseNotes } from "../data/releaseNotes";
3 |
4 | export function ReleaseNotes({ isOpen, onClose }) {
5 | // If there are no notes, don't render anything
6 | if (releaseNotes.length === 0) return null;
7 |
8 | if (!isOpen) return null;
9 |
10 | return (
11 |
23 |
77 | ))}
78 |
24 | {toast.type === "success" && (
25 |
32 | )}
33 | {toast.type === "error" && (
34 |
41 | )}
42 | {toast.type === "warning" && (
43 |
50 | )}
51 | {toast.type === "info" && (
52 |
59 | )}
60 |
61 | 62 | {toast.message} 63 |
64 | 76 |
12 |
74 | );
75 | }
76 |
--------------------------------------------------------------------------------
/backend/download_state.py:
--------------------------------------------------------------------------------
1 | import json
2 | import time
3 | from pathlib import Path
4 | from typing import Dict, Optional
5 | from datetime import datetime, timedelta
6 |
7 | class DownloadStateManager:
8 |
9 | def __init__(self, state_file: Optional[Path] = None):
10 | if state_file is None:
11 | state_file = Path(__file__).parent / "download_state.json"
12 |
13 | self.state_file = state_file
14 | self.state = self._load_state()
15 | self._cleanup_old_entries()
16 |
17 | def _load_state(self) -> Dict:
18 | if self.state_file.exists():
19 | try:
20 | with open(self.state_file, 'r') as f:
21 | return json.load(f)
22 | except Exception:
23 | pass
24 | return {
25 | "active": {},
26 | "completed": {},
27 | "failed": {}
28 | }
29 |
30 | def _save_state(self):
31 | try:
32 | self.state_file.parent.mkdir(parents=True, exist_ok=True)
33 | with open(self.state_file, 'w') as f:
34 | json.dump(self.state, f, indent=2)
35 | except Exception as e:
36 | print(f"Failed to save download state: {e}")
37 |
38 | def _cleanup_old_entries(self):
39 | current_time = time.time()
40 | max_age = 3600
41 |
42 | for category in ["completed", "failed"]:
43 | expired_keys = [
44 | track_id for track_id, data in self.state[category].items()
45 | if current_time - data.get("timestamp", 0) > max_age
46 | ]
47 | for track_id in expired_keys:
48 | del self.state[category][track_id]
49 |
50 | if expired_keys:
51 | self._save_state()
52 |
53 | def get_download_state(self, track_id: int) -> Optional[Dict]:
54 | track_id_str = str(track_id)
55 |
56 | if track_id_str in self.state["active"]:
57 | return {
58 | "status": "downloading",
59 | **self.state["active"][track_id_str]
60 | }
61 |
62 | if track_id_str in self.state["completed"]:
63 | return {
64 | "status": "completed",
65 | **self.state["completed"][track_id_str]
66 | }
67 |
68 | if track_id_str in self.state["failed"]:
69 | return {
70 | "status": "failed",
71 | **self.state["failed"][track_id_str]
72 | }
73 |
74 | return None
75 |
76 | def set_downloading(self, track_id: int, progress: int = 0, metadata: Optional[Dict] = None):
77 | track_id_str = str(track_id)
78 |
79 | self.state["active"][track_id_str] = {
80 | "progress": progress,
81 | "timestamp": time.time(),
82 | "metadata": metadata or {}
83 | }
84 | self._save_state()
85 |
86 | def update_progress(self, track_id: int, progress: int):
87 | track_id_str = str(track_id)
88 |
89 | if track_id_str in self.state["active"]:
90 | self.state["active"][track_id_str]["progress"] = progress
91 | self.state["active"][track_id_str]["timestamp"] = time.time()
92 | self._save_state()
93 |
94 | def set_completed(self, track_id: int, filename: str, metadata: Optional[Dict] = None):
95 | track_id_str = str(track_id)
96 |
97 | if track_id_str in self.state["active"]:
98 | del self.state["active"][track_id_str]
99 |
100 | self.state["completed"][track_id_str] = {
101 | "filename": filename,
102 | "timestamp": time.time(),
103 | "metadata": metadata or {}
104 | }
105 | self._save_state()
106 |
107 | def set_failed(self, track_id: int, error: str, metadata: Optional[Dict] = None):
108 | track_id_str = str(track_id)
109 |
110 | if track_id_str in self.state["active"]:
111 | del self.state["active"][track_id_str]
112 |
113 | self.state["failed"][track_id_str] = {
114 | "error": error,
115 | "timestamp": time.time(),
116 | "metadata": metadata or {}
117 | }
118 | self._save_state()
119 |
120 | def clear_download(self, track_id: int):
121 | track_id_str = str(track_id)
122 |
123 | for category in ["active", "completed", "failed"]:
124 | if track_id_str in self.state[category]:
125 | del self.state[category][track_id_str]
126 |
127 | self._save_state()
128 |
129 | def get_all_active(self) -> Dict:
130 | return self.state["active"].copy()
131 |
132 | def get_all_completed(self) -> Dict:
133 | return self.state["completed"].copy()
134 |
135 | def get_all_failed(self) -> Dict:
136 | return self.state["failed"].copy()
137 |
138 | download_state_manager = DownloadStateManager()
--------------------------------------------------------------------------------
/backend/lyrics_client.py:
--------------------------------------------------------------------------------
1 | """
2 | LrcLib API Client for fetching song lyrics
3 | """
4 | from typing import Optional, Dict
5 | import aiohttp
6 | import asyncio
7 | from dataclasses import dataclass
8 |
9 | @dataclass
10 | class LyricsResult:
11 | """Container for lyrics data"""
12 | synced_lyrics: Optional[str] = None
13 | plain_lyrics: Optional[str] = None
14 | track_name: Optional[str] = None
15 | artist_name: Optional[str] = None
16 | album_name: Optional[str] = None
17 | duration: Optional[int] = None
18 |
19 | class LyricsClient:
20 | """Async client for LrcLib API"""
21 |
22 | BASE_URL = "https://lrclib.net/api"
23 | USER_AGENT = "tidaloader/1.0.0 (https://github.com/RayZ3R0/tidaloader)"
24 |
25 | def __init__(self):
26 | self.session = None
27 |
28 | async def _get_session(self) -> aiohttp.ClientSession:
29 | """Get or create aiohttp session"""
30 | if self.session is None or self.session.closed:
31 | self.session = aiohttp.ClientSession(
32 | headers={"User-Agent": self.USER_AGENT}
33 | )
34 | return self.session
35 |
36 | async def close(self):
37 | """Close the session"""
38 | if self.session and not self.session.closed:
39 | await self.session.close()
40 |
41 | async def get_lyrics(
42 | self,
43 | track_name: str,
44 | artist_name: str,
45 | album_name: Optional[str] = None,
46 | duration: Optional[int] = None
47 | ) -> Optional[LyricsResult]:
48 | """
49 | Get lyrics for a track
50 |
51 | Args:
52 | track_name: Name of the track
53 | artist_name: Name of the artist
54 | album_name: Name of the album (optional)
55 | duration: Duration in seconds (optional, helps matching)
56 |
57 | Returns:
58 | LyricsResult or None if not found
59 | """
60 | try:
61 | session = await self._get_session()
62 |
63 | params = {
64 | "track_name": track_name,
65 | "artist_name": artist_name,
66 | }
67 |
68 | if album_name:
69 | params["album_name"] = album_name
70 | if duration:
71 | params["duration"] = duration
72 |
73 | async with session.get(
74 | f"{self.BASE_URL}/get",
75 | params=params,
76 | timeout=aiohttp.ClientTimeout(total=10)
77 | ) as response:
78 | if response.status == 404:
79 | print(f" ℹ️ No lyrics found for: {artist_name} - {track_name}")
80 | return None
81 |
82 | if response.status != 200:
83 | print(f" ⚠️ Lyrics API returned {response.status}")
84 | return None
85 |
86 | data = await response.json()
87 |
88 | return LyricsResult(
89 | synced_lyrics=data.get("syncedLyrics"),
90 | plain_lyrics=data.get("plainLyrics"),
91 | track_name=data.get("trackName"),
92 | artist_name=data.get("artistName"),
93 | album_name=data.get("albumName"),
94 | duration=data.get("duration")
95 | )
96 |
97 | except asyncio.TimeoutError:
98 | print(f" ⚠️ Lyrics API timeout for: {track_name}")
99 | return None
100 | except Exception as e:
101 | print(f" ⚠️ Error fetching lyrics: {e}")
102 | return None
103 |
104 | async def search_lyrics(
105 | self,
106 | track_name: Optional[str] = None,
107 | artist_name: Optional[str] = None,
108 | album_name: Optional[str] = None
109 | ) -> list:
110 | """
111 | Search for lyrics
112 |
113 | Returns list of matching tracks
114 | """
115 | try:
116 | session = await self._get_session()
117 |
118 | params = {}
119 | if track_name:
120 | params["track_name"] = track_name
121 | if artist_name:
122 | params["artist_name"] = artist_name
123 | if album_name:
124 | params["album_name"] = album_name
125 |
126 | if not params:
127 | return []
128 |
129 | async with session.get(
130 | f"{self.BASE_URL}/search",
131 | params=params,
132 | timeout=aiohttp.ClientTimeout(total=10)
133 | ) as response:
134 | if response.status != 200:
135 | return []
136 |
137 | return await response.json()
138 |
139 | except Exception as e:
140 | print(f" ⚠️ Error searching lyrics: {e}")
141 | return []
142 |
143 | # Global instance
144 | lyrics_client = LyricsClient()
--------------------------------------------------------------------------------
/backend/api/services/listenbrainz.py:
--------------------------------------------------------------------------------
1 | import asyncio
2 | import json
3 | from api.state import lb_progress_queues
4 | from api.utils.logging import log_info, log_error, log_success
5 | from api.utils.text import fix_unicode
6 | from api.services.search import search_track_with_fallback
7 | from api.clients.listenbrainz import ListenBrainzClient
8 |
9 | async def listenbrainz_generate_with_progress(username: str, playlist_type: str, progress_id: str, validate: bool = True):
10 | queue = asyncio.Queue()
11 | lb_progress_queues[progress_id] = queue
12 |
13 | client = ListenBrainzClient()
14 |
15 | try:
16 | display_name = playlist_type.replace("-", " ").title()
17 | await queue.put({
18 | "type": "info",
19 | "message": f"Fetching {display_name} for {username}...",
20 | "progress": 0,
21 | "total": 0
22 | })
23 |
24 | # Use the requested playlist type
25 | tracks = await client.get_playlist_by_type(username, playlist_type)
26 |
27 | if not tracks:
28 | # Fallback for old 'weekly-jams' request potentially checking exploration?
29 | # No, let's be strict now or the UI selector doesn't mean much.
30 | if playlist_type == "weekly-jams":
31 | # If weekly jams specifically requested and not found, check exploration?
32 | # Nah, let user select it.
33 | pass
34 |
35 | raise Exception(f"No playlist found for type '{display_name}' for this user.")
36 |
37 | for track in tracks:
38 | track.title = fix_unicode(track.title)
39 | track.artist = fix_unicode(track.artist)
40 | if track.album:
41 | track.album = fix_unicode(track.album)
42 |
43 | await queue.put({
44 | "type": "info",
45 | "message": f"Found {len(tracks)} tracks from ListenBrainz",
46 | "progress": 0,
47 | "total": len(tracks)
48 | })
49 |
50 | validated_tracks = []
51 | if validate:
52 | for i, track in enumerate(tracks, 1):
53 | display_text = f"{track.artist} - {track.title}"
54 |
55 | await queue.put({
56 | "type": "validating",
57 | "message": f"Validating: {display_text}",
58 | "progress": i,
59 | "total": len(tracks),
60 | "current_track": {
61 | "artist": track.artist,
62 | "title": track.title
63 | }
64 | })
65 |
66 | log_info(f"[{i}/{len(tracks)}] Validating: {display_text}")
67 |
68 | await search_track_with_fallback(track.artist, track.title, track)
69 |
70 | validated_tracks.append({
71 | "title": track.title,
72 | "artist": track.artist,
73 | "mbid": track.mbid,
74 | "tidal_id": track.tidal_id,
75 | "tidal_artist_id": track.tidal_artist_id,
76 | "tidal_album_id": track.tidal_album_id,
77 | "tidal_exists": track.tidal_exists,
78 | "album": track.album,
79 | "cover": getattr(track, 'cover', None)
80 | })
81 |
82 | await asyncio.sleep(0.1)
83 | else:
84 | for track in tracks:
85 | validated_tracks.append({
86 | "title": track.title,
87 | "artist": track.artist,
88 | "mbid": track.mbid,
89 | "tidal_id": None,
90 | "tidal_artist_id": None,
91 | "tidal_album_id": None,
92 | "tidal_exists": False,
93 | "album": track.album,
94 | "cover": None
95 | })
96 |
97 | await queue.put({
98 | "type": "info",
99 | "message": "Skipping validation as requested.",
100 | "progress": len(tracks),
101 | "total": len(tracks)
102 | })
103 |
104 | found_count = sum(1 for t in validated_tracks if t.get("tidal_exists"))
105 |
106 | log_info(f"Validation complete: {found_count}/{len(validated_tracks)} found on Tidal")
107 |
108 | await queue.put({
109 | "type": "complete",
110 | "message": f"Validation complete: {found_count}/{len(validated_tracks)} found on Tidal",
111 | "progress": len(tracks),
112 | "total": len(tracks),
113 | "tracks": validated_tracks,
114 | "found_count": found_count
115 | })
116 |
117 | except Exception as e:
118 | log_error(f"ListenBrainz generation error: {str(e)}")
119 | await queue.put({
120 | "type": "error",
121 | "message": str(e),
122 | "progress": 0,
123 | "total": 0
124 | })
125 | finally:
126 | await client.close()
127 | await queue.put(None)
128 |
--------------------------------------------------------------------------------
/backend/tests/test_search.py:
--------------------------------------------------------------------------------
1 | from unittest.mock import MagicMock
2 | import os
3 |
4 | # Set dummy auth for tests
5 | os.environ["AUTH_USERNAME"] = "test"
6 | os.environ["AUTH_PASSWORD"] = "test"
7 |
8 | # Mock Authorization header
9 | AUTH_HEADER = {"Authorization": "Basic dGVzdDp0ZXN0"} # test:test
10 |
11 | def test_search_tracks_success(client, mock_tidal_client):
12 | # Setup mock response
13 | mock_tidal_client.search_tracks.return_value = {
14 | "tracks": {
15 | "items": [
16 | {
17 | "id": 123,
18 | "title": "Test Track",
19 | "artist": {"name": "Test Artist"},
20 | "album": {"title": "Test Album", "cover": "abc-123"},
21 | "duration": 300,
22 | "audioQuality": "LOSSLESS"
23 | }
24 | ]
25 | }
26 | }
27 |
28 | response = client.get("/api/search/tracks?q=test", headers=AUTH_HEADER)
29 | assert response.status_code == 200
30 | data = response.json()
31 | assert "items" in data
32 | assert len(data["items"]) == 1
33 | assert data["items"][0]["title"] == "Test Track"
34 | assert data["items"][0]["artist"] == "Test Artist"
35 |
36 | def test_search_tracks_empty(client, mock_tidal_client):
37 | mock_tidal_client.search_tracks.return_value = {}
38 |
39 | response = client.get("/api/search/tracks?q=empty", headers=AUTH_HEADER)
40 | assert response.status_code == 200
41 | data = response.json()
42 | assert data["items"] == []
43 |
44 | def test_search_albums_success(client, mock_tidal_client):
45 | mock_tidal_client.search_albums.return_value = {
46 | "albums": {
47 | "items": [
48 | {"id": 456, "title": "Test Album"}
49 | ]
50 | }
51 | }
52 |
53 | response = client.get("/api/search/albums?q=test", headers=AUTH_HEADER)
54 | assert response.status_code == 200
55 | data = response.json()
56 | assert len(data["items"]) == 1
57 | assert data["items"][0]["title"] == "Test Album"
58 |
59 | def test_search_playlists_success(client, mock_tidal_client):
60 | mock_tidal_client.search_playlists.return_value = {
61 | "playlists": {
62 | "items": [
63 | {
64 | "uuid": "playlist-123",
65 | "title": "My Playlist",
66 | "creator": {"name": "Tester"},
67 | "numberOfTracks": 2,
68 | "image": "abc-123"
69 | }
70 | ]
71 | }
72 | }
73 |
74 | response = client.get("/api/search/playlists?q=test", headers=AUTH_HEADER)
75 | assert response.status_code == 200
76 | data = response.json()
77 | assert len(data["items"]) == 1
78 | assert data["items"][0]["id"] == "playlist-123"
79 | assert data["items"][0]["title"] == "My Playlist"
80 | assert data["items"][0]["cover"] == "abc-123"
81 |
82 |
83 | def test_search_playlists_squareimage_priority(client, mock_tidal_client):
84 | # squareImage should be preferred over image/cover
85 | mock_tidal_client.search_playlists.return_value = {
86 | "playlists": {
87 | "items": [
88 | {
89 | "id": "playlist-xyz",
90 | "title": "Square First",
91 | "image": "image-low",
92 | "cover": "cover-low",
93 | "squareImage": "square-hi"
94 | }
95 | ]
96 | }
97 | }
98 |
99 | response = client.get("/api/search/playlists?q=test", headers=AUTH_HEADER)
100 | assert response.status_code == 200
101 | data = response.json()
102 | assert len(data["items"]) == 1
103 | assert data["items"][0]["cover"] == "square-hi"
104 |
105 | def test_search_unauthorized(client):
106 | response = client.get("/api/search/tracks?q=test")
107 | assert response.status_code == 401
108 |
109 | def test_get_playlist_tracks(client, mock_tidal_client):
110 | mock_tidal_client.get_playlist_tracks.return_value = {
111 | "playlist": {
112 | "uuid": "playlist-123",
113 | "title": "My Playlist"
114 | },
115 | "items": [
116 | {
117 | "item": {
118 | "id": 111,
119 | "title": "Song One",
120 | "artist": {"name": "Artist A"},
121 | "album": {"title": "Album A", "cover": "cov1"},
122 | "duration": 200
123 | }
124 | },
125 | {
126 | "item": {
127 | "id": 222,
128 | "title": "Song Two",
129 | "artist": {"name": "Artist B"},
130 | "album": {"title": "Album B", "cover": "cov2"},
131 | "duration": 180
132 | }
133 | }
134 | ]
135 | }
136 |
137 | response = client.get("/api/playlist/playlist-123", headers=AUTH_HEADER)
138 | assert response.status_code == 200
139 | data = response.json()
140 | assert data["playlist"]["title"] == "My Playlist"
141 | assert len(data["items"]) == 2
142 | assert data["items"][0]["title"] == "Song One"
143 |
--------------------------------------------------------------------------------
/frontend/src/components/Login.jsx:
--------------------------------------------------------------------------------
1 | import { useState } from "preact/hooks";
2 | import { useAuthStore } from "../store/authStore";
3 |
4 | export function Login() {
5 | const [username, setUsername] = useState("");
6 | const [password, setPassword] = useState("");
7 | const [error, setError] = useState("");
8 | const [loading, setLoading] = useState(false);
9 |
10 | const setCredentials = useAuthStore((state) => state.setCredentials);
11 |
12 | const handleSubmit = async (e) => {
13 | e.preventDefault();
14 | setError("");
15 | setLoading(true);
16 |
17 | try {
18 | // Test credentials by making a simple API call
19 | const credentials = btoa(`${username}:${password}`);
20 | const response = await fetch("/api/search/tracks?q=test", {
21 | headers: {
22 | Authorization: `Basic ${credentials}`,
23 | },
24 | });
25 |
26 | if (response.status === 401) {
27 | setError("Invalid username or password");
28 | setLoading(false);
29 | return;
30 | }
31 |
32 | if (!response.ok) {
33 | setError("Failed to authenticate");
34 | setLoading(false);
35 | return;
36 | }
37 |
38 | // Credentials are valid
39 | setCredentials(username, password);
40 | } catch (err) {
41 | setError("Failed to connect to server");
42 | setLoading(false);
43 | }
44 | };
45 |
46 | return (
47 | e.stopPropagation()}
15 | >
16 | {/* Header */}
17 |
73 |
18 |
40 |
41 | {/* Content */}
42 |
62 |
63 | {/* Footer */}
64 |
19 |
33 |
39 |
20 |
27 |
28 |
29 |
32 | What's New
30 |Version {releaseNotes[0].version}
31 |
65 |
71 |
72 |
48 |
146 | );
147 | }
148 |
--------------------------------------------------------------------------------
/backend/api/clients/listenbrainz.py:
--------------------------------------------------------------------------------
1 |
2 | import httpx
3 | from typing import List, Optional, Dict, Any
4 | import logging
5 | from api.models import PlaylistTrack
6 |
7 | logger = logging.getLogger(__name__)
8 |
9 | class ListenBrainzClient:
10 | """Client for ListenBrainz API"""
11 |
12 | BASE_URL = "https://api.listenbrainz.org/1"
13 |
14 | def __init__(self):
15 | self.client = httpx.AsyncClient(timeout=30.0)
16 |
17 | async def close(self):
18 | await self.client.aclose()
19 |
20 | async def get_playlist(self, playlist_id: str) -> Dict[str, Any]:
21 | """Fetch a specific playlist by ID"""
22 | url = f"{self.BASE_URL}/playlist/{playlist_id}"
23 | try:
24 | response = await self.client.get(url)
25 | response.raise_for_status()
26 | return response.json()
27 | except Exception as e:
28 | logger.error(f"Error fetching playlist {playlist_id}: {e}")
29 | raise
30 |
31 | async def get_user_playlists(self, username: str) -> List[Dict[str, Any]]:
32 | """Fetch playlists created for a user (Weekly Jams, etc)"""
33 | url = f"{self.BASE_URL}/user/{username}/playlists/createdfor"
34 | try:
35 | response = await self.client.get(url)
36 | if response.status_code == 404:
37 | logger.warning(f"User {username} not found or has no playlists")
38 | return []
39 |
40 | response.raise_for_status()
41 | data = response.json()
42 | return data.get("playlists", [])
43 | except httpx.HTTPStatusError as e:
44 | logger.error(f"Error fetching playlists for {username}: {e}")
45 | raise
46 | except Exception as e:
47 | import traceback
48 | logger.error(f"Error fetching playlists for {username}: {repr(e)}")
49 | logger.error(traceback.format_exc())
50 | raise
51 |
52 | async def get_playlist_by_type(self, username: str, playlist_type: str) -> List[PlaylistTrack]:
53 | """
54 | Fetch a specific type of playlist for a user.
55 | Supported types: 'weekly-jams', 'weekly-exploration', 'year-in-review-discoveries', 'year-in-review-missed'
56 | """
57 | logger.info(f"Fetching {playlist_type} for {username}")
58 |
59 | playlists = await self.get_user_playlists(username)
60 |
61 | target_playlist = None
62 |
63 | # Define keywords for each type
64 | keywords = {
65 | "weekly-jams": "weekly jams",
66 | "weekly-exploration": "weekly exploration",
67 | "year-in-review-discoveries": "top discoveries",
68 | "year-in-review-missed": "top missed recordings"
69 | }
70 |
71 | search_term = keywords.get(playlist_type)
72 | if not search_term:
73 | logger.error(f"Unknown playlist type: {playlist_type}")
74 | return []
75 |
76 | # Find the latest playlist matching the keyword
77 | # Playlists are usually ordered by date descending from the API, but we'll checking carefully
78 | candidate_playlists = []
79 | for pl_wrapper in playlists:
80 | pl = pl_wrapper.get("playlist", {})
81 | title = pl.get("title", "").lower()
82 | if search_term in title:
83 | candidate_playlists.append(pl)
84 |
85 | # Sort by title (usually contains date/year) to get the latest?
86 | # Actually the API returns them usually sorted, but let's just take the first one found
87 | # which is typically the latest for Weeklys. For yearly, we might want the latest year.
88 | if candidate_playlists:
89 | # Simple heuristic: first one is usually latest
90 | target_playlist = candidate_playlists[0]
91 |
92 | if not target_playlist:
93 | logger.warning(f"No playlist found for type '{playlist_type}' for {username}")
94 | return []
95 |
96 | playlist_id_url = target_playlist.get("identifier")
97 | if not playlist_id_url:
98 | logger.error("Playlist found but has no identifier")
99 | return []
100 |
101 | uuid = playlist_id_url.split('/')[-1]
102 | logger.info(f"Fetching full details for playlist {uuid} ({target_playlist.get('title')})")
103 |
104 | try:
105 | full_playlist_data = await self.get_playlist(uuid)
106 | target_playlist = full_playlist_data.get("playlist", {})
107 | except Exception as e:
108 | logger.error(f"Failed to fetch full playlist {uuid}: {e}")
109 | return []
110 |
111 | tracks_data = target_playlist.get("track", [])
112 |
113 | playlist_tracks = []
114 | for t in tracks_data:
115 | title = t.get("title", "Unknown Title")
116 | artist = t.get("creator", "Unknown Artist")
117 | album = t.get("album")
118 |
119 | mbid = None
120 | identifiers = t.get("identifier", [])
121 | extension = t.get("extension", {})
122 |
123 | if "https://musicbrainz.org/doc/jspf#track" in extension:
124 | meta = extension["https://musicbrainz.org/doc/jspf#track"]
125 | pass
126 |
127 | if isinstance(identifiers, list):
128 | for ident in identifiers:
129 | if "musicbrainz.org/recording/" in ident:
130 | mbid = ident.split("recording/")[-1]
131 | break
132 |
133 | if not mbid and "musicbrainz_track_id" in extension:
134 | mbid = extension["musicbrainz_track_id"]
135 |
136 | playlist_tracks.append(PlaylistTrack(
137 | title=title,
138 | artist=artist,
139 | mbid=mbid,
140 | album=album
141 | ))
142 |
143 | logger.info(f"Found {len(playlist_tracks)} tracks in {playlist_type} for {username}")
144 | return playlist_tracks
145 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Tidaloader
2 |
3 | A full-stack web application for downloading high-quality music from Tidal with intelligent playlist generation via ListenBrainz integration. Features automatic metadata tagging, lyrics fetching, and organized file management.
4 |
5 | Heavily inspired from https://github.com/uimaxbai/tidal-ui and using https://github.com/sachinsenal0x64/hifi
6 |
7 | > [!IMPORTANT]
8 | >
9 | > # Project Terms
10 |
11 | - We do not encourage piracy. This project is made purely for educational and personal use.
12 | If you somehow download copyrighted content, you are solely responsible for complying with the relevant laws in your country.
13 |
14 | - The Tidaloader Project assumes no responsibility for any misuse or legal violations arising from the use of this project.
15 |
16 | - This project does not claim ownership of any music or audio content. All rights remain with their respective copyright holders. Users are **encouraged** to support artists and rights owners by maintaining a valid Tidal subscription. Tidaloader serves solely as a downloading interface for personal, non-commercial use.
17 |
18 | ## Screenshots
19 |
20 |
49 |
145 |
50 |
144 |
51 |
57 |
58 |
143 |
52 | 🦑
53 |
54 | Tidaloader
55 |Sign in to continue
56 |
21 | 
22 | 
23 |
25 | 
26 |
101 |
118 |
119 | Windows
102 | 103 | 1. **Clone**: `git clone https://github.com/RayZ3R0/tidaloader.git` 104 | 2. **Backend**: 105 | ```powershell 106 | cd backend 107 | python -m venv venv; .\venv\Scripts\Activate.ps1 108 | pip install -r requirements.txt 109 | cp .env.example .env # Edit .env with your settings 110 | ``` 111 | 3. **Frontend**: 112 | ```powershell 113 | cd ..\frontend 114 | npm install; npm run build 115 | ``` 116 | 4. **Run**: `cd ..\backend; .\start.ps1` 117 |
120 |
137 |
138 | Linux
121 | 122 | 1. **Clone**: `git clone https://github.com/RayZ3R0/tidaloader.git` 123 | 2. **Backend**: 124 | ```bash 125 | cd backend 126 | python3 -m venv venv; source venv/bin/activate 127 | pip install -r requirements.txt 128 | cp .env.example .env # Edit .env 129 | ``` 130 | 3. **Frontend**: 131 | ```bash 132 | cd ../frontend 133 | npm install; npm run build 134 | ``` 135 | 4. **Run**: `python -m uvicorn api.main:app --host 0.0.0.0 --port 8001` 136 |
139 |
149 |
150 | ## Development
151 |
152 | * **Backend**: `uvicorn api.main:app --reload` (Port 8001)
153 | * **Frontend**: `npm run dev` (Port 5173)
154 |
155 | ## Credits
156 |
157 | Inspired by [tidal-ui](https://github.com/uimaxbai/tidal-ui). Playlist generation by ListenBrainz.
158 |
159 | ## License
160 |
161 | This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
162 |
163 | > **Disclaimer**: This project is for educational purposes only. The developers do not endorse piracy and are not responsible for how this software is used. Please support artists by purchasing their music.
164 |
--------------------------------------------------------------------------------
/backend/api/services/files.py:
--------------------------------------------------------------------------------
1 | from pathlib import Path
2 | import shutil
3 | import aiohttp
4 | from api.utils.logging import log_info, log_success, log_warning
5 | from api.settings import DOWNLOAD_DIR
6 |
7 | def sanitize_path_component(name: str) -> str:
8 | if not name:
9 | return "Unknown"
10 |
11 | invalid_chars = r'<>:"/\\|?*'
12 | for char in invalid_chars:
13 | name = name.replace(char, '_')
14 |
15 | name = name.strip('. ')
16 |
17 | if len(name) > 200:
18 | name = name[:200].strip()
19 |
20 | return name or "Unknown"
21 |
22 | async def organize_file_by_metadata(temp_filepath: Path, metadata: dict, template: str = "{Artist}/{Album}/{TrackNumber} - {Title}", group_compilations: bool = True) -> Path:
23 | try:
24 | artist = metadata.get('album_artist') or metadata.get('artist', 'Unknown Artist')
25 | album = metadata.get('album', 'Unknown Album')
26 | title = metadata.get('title', temp_filepath.stem)
27 | track_number = metadata.get('track_number')
28 | file_ext = metadata.get('file_ext')
29 | if not file_ext:
30 | file_ext = temp_filepath.suffix or '.flac'
31 | file_ext = file_ext if file_ext.startswith('.') else f".{file_ext}"
32 |
33 | s_artist = sanitize_path_component(artist)
34 | s_album = sanitize_path_component(album)
35 | s_title = sanitize_path_component(title)
36 |
37 | is_compilation = artist.lower() in ['various artists', 'various'] or metadata.get('compilation')
38 |
39 | track_str = str(track_number).zfill(2) if track_number else "00"
40 |
41 | template_artist = s_artist
42 | template_album = s_album
43 |
44 | if group_compilations and is_compilation:
45 | template_artist = "Compilations"
46 | if not template_album.startswith("VA - "):
47 | template_album = f"VA - {template_album}"
48 |
49 | template_vars = {
50 | "Artist": template_artist,
51 | "AlbumArtist": s_artist,
52 | "TrackArtist": sanitize_path_component(metadata.get('artist', artist)),
53 | "Album": template_album,
54 | "Title": s_title,
55 | "TrackNumber": track_str,
56 | "Year": str(metadata.get('date', '')).split('-')[0] if metadata.get('date') else "Unknown Year"
57 | }
58 |
59 | try:
60 | clean_template = template.lstrip('/')
61 | relative_path_str = clean_template.format(**template_vars)
62 | except KeyError as e:
63 | log_warning(f"Invalid template key: {e}. Falling back to default.")
64 | relative_path_str = f"{s_artist}/{s_album}/{track_str} - {s_title}"
65 |
66 | if not relative_path_str.endswith(file_ext):
67 | relative_path_str += file_ext
68 |
69 | final_path = DOWNLOAD_DIR / relative_path_str
70 | final_dir = final_path.parent
71 |
72 | final_dir.mkdir(parents=True, exist_ok=True)
73 |
74 | if final_path.exists():
75 | log_warning(f"File already exists at: {final_path}")
76 | if temp_filepath.exists() and temp_filepath != final_path:
77 | try:
78 | temp_filepath.unlink()
79 | temp_lrc = temp_filepath.with_suffix('.lrc')
80 | if temp_lrc.exists():
81 | temp_lrc.unlink()
82 | temp_txt = temp_filepath.with_suffix('.txt')
83 | if temp_txt.exists():
84 | temp_txt.unlink()
85 | except Exception:
86 | pass
87 | return final_path
88 |
89 | if temp_filepath != final_path:
90 | shutil.move(str(temp_filepath), str(final_path))
91 | log_success(f"Organized to: {relative_path_str}")
92 |
93 | temp_lrc_path = temp_filepath.with_suffix('.lrc')
94 | if temp_lrc_path.exists():
95 | final_lrc_path = final_path.with_suffix('.lrc')
96 | shutil.move(str(temp_lrc_path), str(final_lrc_path))
97 | log_success("Moved .lrc file to organized location")
98 |
99 | temp_txt_path = temp_filepath.with_suffix('.txt')
100 | if temp_txt_path.exists():
101 | final_txt_path = final_path.with_suffix('.txt')
102 | shutil.move(str(temp_txt_path), str(final_txt_path))
103 | log_success("Moved .txt file to organized location")
104 |
105 | if metadata.get('synced_lyrics') and metadata.get('target_format') != 'opus':
106 | lrc_path = final_path.with_suffix('.lrc')
107 | try:
108 | with open(lrc_path, 'w', encoding='utf-8') as f:
109 | f.write(metadata['synced_lyrics'])
110 | log_success("Saved synced lyrics to .lrc file")
111 | except Exception as e:
112 | log_warning(f"Failed to save .lrc file: {e}")
113 |
114 | elif metadata.get('plain_lyrics') and metadata.get('target_format') != 'opus':
115 | txt_path = final_path.with_suffix('.txt')
116 | try:
117 | with open(txt_path, 'w', encoding='utf-8') as f:
118 | f.write(metadata['plain_lyrics'])
119 | log_success("Saved plain lyrics to .txt file")
120 | except Exception as e:
121 | log_warning(f"Failed to save .txt file: {e}")
122 |
123 | if metadata.get('target_format') == 'opus' and metadata.get('cover_url'):
124 | cover_path = final_dir / 'cover.jpg'
125 | try:
126 | async with aiohttp.ClientSession() as session:
127 | async with session.get(metadata['cover_url']) as response:
128 | if response.status == 200:
129 | image_data = await response.read()
130 | with open(cover_path, 'wb') as f:
131 | f.write(image_data)
132 | log_success("Saved cover art to cover.jpg")
133 | except Exception as e:
134 | log_warning(f"Failed to save cover art: {e}")
135 |
136 | return final_path
137 |
138 | except Exception as e:
139 | log_warning(f"Failed to organize file: {e}")
140 | import traceback
141 | traceback.print_exc()
142 | return temp_filepath
143 |
--------------------------------------------------------------------------------
/frontend/src/components/LibraryPage.jsx:
--------------------------------------------------------------------------------
1 |
2 | import { h } from "preact";
3 | import { useState, useEffect } from "preact/hooks";
4 | import { api } from "../api/client";
5 | import { useToastStore } from "../stores/toastStore";
6 | import { LibraryArtistPage } from "./LibraryArtistPage";
7 |
8 | export function LibraryPage() {
9 | const [artists, setArtists] = useState([]);
10 | const [loading, setLoading] = useState(true);
11 | const [selectedArtist, setSelectedArtist] = useState(null);
12 | const addToast = useToastStore((state) => state.addToast);
13 |
14 | useEffect(() => {
15 | loadLibrary();
16 | }, []);
17 |
18 | const loadLibrary = async (force = false) => {
19 | setLoading(true);
20 | try {
21 | const result = await api.scanLibrary(force);
22 | // If result is empty or we scanned, fetch the list
23 | const artistsList = await api.getLibraryArtists();
24 | setArtists(artistsList);
25 | if (force) {
26 | addToast("Library scan complete", "success");
27 | }
28 | } catch (err) {
29 | console.error("Failed to load library:", err);
30 | addToast("Failed to load library: " + err.message, "error");
31 | } finally {
32 | setLoading(false);
33 | }
34 | };
35 |
36 | if (selectedArtist) {
37 | return (
38 | Android (Termux)
140 | 141 | 1. Install Termux (F-Droid). 142 | 2. Run Setup: 143 | ```bash 144 | curl -O https://raw.githubusercontent.com/RayZ3R0/tidaloader/main/backend/termux-setup.sh 145 | bash termux-setup.sh 146 | ``` 147 | 3. Start: `./start-service.sh` 148 |
48 |
101 | );
102 | }
103 |
104 | function ArtistCard({ artist, onClick }) {
105 | const [picture, setPicture] = useState(artist.picture);
106 | const [loadingImage, setLoadingImage] = useState(false);
107 |
108 | useEffect(() => {
109 | // Lazy load Tidal picture if missing
110 | if (!picture && !artist.image && artist.tidal_id) {
111 | setLoadingImage(true);
112 | api.getArtist(artist.tidal_id)
113 | .then(details => {
114 | if (details.artist?.picture) {
115 | setPicture(details.artist.picture);
116 | // Persist to backend cache
117 | api.updateLibraryArtist(artist.name, { picture: details.artist.picture })
118 | .catch(e => console.warn("Failed to cache artist picture", e));
119 | }
120 | })
121 | .catch(err => console.debug(`Failed to fetch picture for ${artist.name}`, err))
122 | .finally(() => setLoadingImage(false));
123 | }
124 | }, [artist]);
125 |
126 | // Determine which image to show
127 | // Priority: Tidal Picture (URL) > Local Image (Path)
128 | const imageUrl = picture
129 | ? api.getCoverUrl(picture, 320)
130 | : (artist.image ? api.getLocalCoverUrl(artist.image) : null);
131 |
132 | return (
133 |
49 |
71 |
72 | {loading && artists.length === 0 ? (
73 | Your Library
50 | 70 |
74 |
75 |
77 | ) : artists.length === 0 ? (
78 | Scanning library files...
76 |
79 |
89 | ) : (
90 |
80 |
83 |
84 | Library is Empty
85 |86 | No music files found in your local directory. Download some music from the Search tab to populate your library. 87 |
88 |
91 | {artists.map((artist) => (
92 | setSelectedArtist(artist)}
96 | />
97 | ))}
98 |
99 | )}
100 |
137 |
172 | );
173 | }
174 |
--------------------------------------------------------------------------------
/backend/api/services/download.py:
--------------------------------------------------------------------------------
1 | from pathlib import Path
2 | import asyncio
3 | import aiohttp
4 | import traceback
5 |
6 | from api.state import active_downloads
7 | from download_state import download_state_manager
8 | from api.utils.logging import log_error, log_info, log_step, log_success, log_warning
9 | from api.services.audio import transcode_to_mp3, transcode_to_opus, write_metadata_tags
10 | from api.services.files import organize_file_by_metadata
11 | from api.services.beets import run_beets_import
12 | from api.services.lyrics import embed_lyrics_with_ffmpeg
13 | from queue_manager import queue_manager
14 |
15 | async def download_file_async(
16 | track_id: int,
17 | stream_url: str,
18 | filepath: Path,
19 | filename: str,
20 | metadata: dict = None,
21 | organization_template: str = "{Artist}/{Album}/{TrackNumber} - {Title}",
22 | group_compilations: bool = True,
23 | run_beets: bool = False,
24 | embed_lyrics: bool = False
25 | ):
26 | processed_path = filepath
27 | try:
28 | log_step("3/4", f"Downloading {filename}...")
29 |
30 | if track_id not in active_downloads:
31 | active_downloads[track_id] = {'progress': 0, 'status': 'downloading'}
32 |
33 | download_state_manager.set_downloading(track_id, 0, metadata)
34 |
35 | async with aiohttp.ClientSession() as session:
36 | async with session.get(stream_url, timeout=aiohttp.ClientTimeout(total=300)) as response:
37 | if response.status != 200:
38 | error_msg = f"HTTP {response.status}"
39 | log_error(f"Download failed: {error_msg}")
40 | if track_id in active_downloads:
41 | active_downloads[track_id] = {'progress': 0, 'status': 'failed'}
42 | download_state_manager.set_failed(track_id, error_msg, metadata)
43 | await asyncio.sleep(5)
44 | del active_downloads[track_id]
45 | return
46 |
47 | total_size = int(response.headers.get('content-length', 0))
48 | downloaded = 0
49 |
50 | # Ensure the directory exists
51 | filepath.parent.mkdir(parents=True, exist_ok=True)
52 |
53 | with open(filepath, 'wb') as f:
54 | async for chunk in response.content.iter_chunked(8192):
55 | if chunk:
56 | f.write(chunk)
57 | downloaded += len(chunk)
58 |
59 | if total_size > 0:
60 | progress = int((downloaded / total_size) * 100)
61 | active_downloads[track_id] = {
62 | 'progress': progress,
63 | 'status': 'downloading'
64 | }
65 | download_state_manager.update_progress(track_id, progress)
66 | # Update queue manager for frontend sync
67 | queue_manager.update_active_progress(track_id, progress, 'downloading')
68 |
69 | await asyncio.sleep(0.01)
70 |
71 | if metadata:
72 | if metadata.get('target_format') == 'mp3':
73 | bitrate = metadata.get('bitrate_kbps', 256)
74 | mp3_path = filepath.with_suffix('.mp3')
75 | log_step("3.5/4", f"Transcoding to MP3 ({bitrate} kbps)...")
76 | active_downloads[track_id] = {
77 | 'progress': 95,
78 | 'status': 'transcoding'
79 | }
80 | download_state_manager.update_progress(track_id, 95)
81 | await transcode_to_mp3(filepath, mp3_path, bitrate)
82 | processed_path = mp3_path
83 | metadata['file_ext'] = '.mp3'
84 | try:
85 | filepath.unlink()
86 | except FileNotFoundError:
87 | pass
88 | except Exception as exc:
89 | log_warning(f"Failed to remove intermediate file: {exc}")
90 | elif metadata.get('target_format') == 'opus':
91 | bitrate = metadata.get('bitrate_kbps', 192)
92 | opus_path = filepath.with_suffix('.opus')
93 | log_step("3.5/4", f"Transcoding to Opus ({bitrate} kbps)...")
94 | active_downloads[track_id] = {
95 | 'progress': 95,
96 | 'status': 'transcoding'
97 | }
98 | download_state_manager.update_progress(track_id, 95)
99 | await transcode_to_opus(filepath, opus_path, bitrate)
100 | processed_path = opus_path
101 | metadata['file_ext'] = '.opus'
102 | try:
103 | filepath.unlink()
104 | except FileNotFoundError:
105 | pass
106 | except Exception as exc:
107 | log_warning(f"Failed to remove intermediate file: {exc}")
108 | else:
109 | processed_path = filepath
110 | metadata.setdefault('file_ext', filepath.suffix)
111 |
112 | if metadata:
113 | log_step("4/4", "Writing metadata tags...")
114 | await write_metadata_tags(processed_path, metadata)
115 |
116 | if embed_lyrics:
117 | await embed_lyrics_with_ffmpeg(processed_path, metadata)
118 |
119 | # Organize file
120 | log_step("4/4", "Organizing file...")
121 | final_path = await organize_file_by_metadata(
122 | processed_path,
123 | metadata,
124 | template=organization_template,
125 | group_compilations=group_compilations
126 | )
127 |
128 | # Run beets import if requested
129 | if run_beets:
130 | await run_beets_import(final_path)
131 |
132 | # Update state to completed - store the final path for fast file existence checks
133 | if metadata is None:
134 | metadata = {}
135 | metadata['final_path'] = str(final_path)
136 | download_state_manager.set_completed(track_id, final_path.name, metadata)
137 |
138 | file_size_mb = final_path.stat().st_size / 1024 / 1024
139 | display_name = final_path.name if final_path else filename
140 | log_success(f"Downloaded: {display_name} ({file_size_mb:.2f} MB)")
141 | log_info(f"Location: {final_path}")
142 |
143 | # Invalidate library cache so the new file/tags appear immediately
144 | try:
145 | from api.services.library import library_service
146 | library_service.invalidate_cache()
147 | except Exception as e:
148 | log_warning(f"Failed to invalidate library cache: {e}")
149 |
150 | print(f"{'='*60}\n")
151 |
152 | await asyncio.sleep(5)
153 |
154 | if track_id in active_downloads:
155 | del active_downloads[track_id]
156 |
157 | except Exception as e:
158 | log_error(f"Download error: {e}")
159 | traceback.print_exc()
160 |
161 | if track_id in active_downloads:
162 | active_downloads[track_id] = {'progress': 0, 'status': 'failed'}
163 | download_state_manager.set_failed(track_id, str(e), metadata)
164 | await asyncio.sleep(5)
165 | del active_downloads[track_id]
166 |
167 | if filepath.exists():
168 | try:
169 | filepath.unlink()
170 | log_info(f"Cleaned up partial file: {filename}")
171 | except Exception:
172 | pass
173 |
174 | if processed_path and processed_path != filepath and processed_path.exists():
175 | try:
176 | processed_path.unlink()
177 | log_info(f"Cleaned up partial file: {processed_path.name}")
178 | except Exception:
179 | pass
180 |
--------------------------------------------------------------------------------
/frontend/src/app.jsx:
--------------------------------------------------------------------------------
1 | import { h } from "preact";
2 | import { useState } from "preact/hooks";
3 | import { Router } from "preact-router";
4 | import logo from "./assets/tsunami.svg";
5 | import { useAuthStore } from "./store/authStore";
6 | import { Login } from "./components/Login";
7 | import { SearchBar } from "./components/SearchBar";
8 | import { WeeklyJamsGenerator } from "./components/WeeklyJamsGenerator";
9 | import { DownloadQueuePopout } from "./components/DownloadQueuePopout";
10 | import { SettingsPanel } from "./components/SettingsPanel";
11 | import { LibraryPage } from "./components/LibraryPage";
12 | import { Toast } from "./components/Toast";
13 |
14 | import { ThemePicker } from "./components/ThemePicker";
15 |
16 | import { ReleaseNotes } from "./components/ReleaseNotes";
17 | import { NyanCatEasterEgg } from "./components/NyanCatEasterEgg";
18 | import { releaseNotes } from "./data/releaseNotes";
19 | import { useEffect } from "preact/hooks";
20 |
21 | export function App() {
22 | const isAuthenticated = useAuthStore((state) => state.isAuthenticated);
23 | const clearCredentials = useAuthStore((state) => state.clearCredentials);
24 | const [activeTab, setActiveTab] = useState("search");
25 | const [showSettings, setShowSettings] = useState(false);
26 | const [showReleaseNotes, setShowReleaseNotes] = useState(false);
27 |
28 | useEffect(() => {
29 | try {
30 | if (releaseNotes.length > 0) {
31 | const latestVersion = releaseNotes[0].version;
32 | const lastSeen = localStorage.getItem("last-seen-version");
33 | if (lastSeen !== latestVersion) {
34 | setShowReleaseNotes(true);
35 | }
36 | }
37 | } catch (e) {
38 | console.warn("Failed to check release notes version", e);
39 | }
40 | }, []);
41 |
42 | const handleCloseReleaseNotes = () => {
43 | setShowReleaseNotes(false);
44 | if (releaseNotes.length > 0) {
45 | localStorage.setItem("last-seen-version", releaseNotes[0].version);
46 | }
47 | };
48 |
49 | if (!isAuthenticated) {
50 | return
138 | {imageUrl ? (
139 | 
{
145 | e.target.style.display = 'none';
146 | e.target.nextSibling.style.display = 'flex';
147 | }}
148 | />
149 | ) : null}
150 |
151 | {/* Fallback / Loading State */}
152 |
163 |
156 | {loadingImage ? (
157 |
162 | ⟳
158 | ) : (
159 | artist.name.charAt(0)
160 | )}
161 |
164 |
171 | 165 | {artist.name} 166 |
167 |168 | {artist.album_count} albums • {artist.track_count} tracks 169 |
170 |
55 |
56 |
57 |
102 |
103 |
185 | );
186 | }
187 |
--------------------------------------------------------------------------------
/frontend/src/components/SettingsPanel.jsx:
--------------------------------------------------------------------------------
1 | import { h } from "preact";
2 | import { useDownloadStore } from "../stores/downloadStore";
3 |
4 | const QUALITY_OPTIONS = [
5 | {
6 | value: "HI_RES_LOSSLESS",
7 | label: "Hi-Res FLAC",
8 | description: "Up to 24-bit/192kHz",
9 | },
10 | { value: "LOSSLESS", label: "FLAC", description: "16-bit/44.1kHz" },
11 | { value: "MP3_256", label: "MP3 256kbps", description: "Transcoded MP3 (libmp3lame)" },
12 | { value: "MP3_128", label: "MP3 128kbps", description: "Transcoded MP3 (smaller size)" },
13 | { value: "OPUS_192VBR", label: "Opus 192kbps VBR", description: "Variable bitrate Opus (192kbps target)" },
14 | { value: "HIGH", label: "320kbps AAC", description: "High quality AAC" },
15 | { value: "LOW", label: "96kbps AAC", description: "Low quality AAC" },
16 | ];
17 |
18 | const TEMPLATE_OPTIONS = [
19 | { value: "{Artist}/{Album}/{TrackNumber} - {Title}", label: "Artist/Album/Track - Title (Default)" },
20 | { value: "{Album}/{TrackNumber} - {Title}", label: "Album/Track - Title" },
21 | { value: "{Artist} - {Title}", label: "Artist - Title" },
22 | { value: "{Artist}/{Album}/{Title}", label: "Artist/Album/Title" },
23 | ];
24 |
25 | export function SettingsPanel() {
26 | const quality = useDownloadStore((state) => state.quality);
27 | const setQuality = useDownloadStore((state) => state.setQuality);
28 |
29 | const organizationTemplate = useDownloadStore((state) => state.organizationTemplate);
30 | const setOrganizationTemplate = useDownloadStore((state) => state.setOrganizationTemplate);
31 |
32 | const groupCompilations = useDownloadStore((state) => state.groupCompilations);
33 | const setGroupCompilations = useDownloadStore((state) => state.setGroupCompilations);
34 |
35 | const runBeets = useDownloadStore((state) => state.runBeets);
36 | const setRunBeets = useDownloadStore((state) => state.setRunBeets);
37 |
38 | const embedLyrics = useDownloadStore((state) => state.embedLyrics);
39 | const setEmbedLyrics = useDownloadStore((state) => state.setEmbedLyrics);
40 |
41 | return (
42 |
58 |
101 |
59 |
64 |
60 | 
61 |
62 | Tidaloader
63 |
65 |
79 |
100 |
110 |
111 |
140 |
141 | {showSettings && (
142 |
145 | )}
146 |
147 |
176 |
177 |
178 | {activeTab === "search" &&
182 |
183 | 112 | Tidaloader 113 |
114 | 139 |
43 |
153 | );
154 | }
155 |
--------------------------------------------------------------------------------
/frontend/src/api/client.js:
--------------------------------------------------------------------------------
1 | /**
2 | * API client for Tidaloader backend
3 | */
4 |
5 | import { useAuthStore } from "../store/authStore";
6 |
7 | const API_BASE = "/api";
8 |
9 | class ApiClient {
10 | /**
11 | * Get authorization headers
12 | */
13 | getHeaders() {
14 | const headers = {
15 | "Content-Type": "application/json",
16 | };
17 |
18 | const authHeader = useAuthStore.getState().getAuthHeader();
19 | if (authHeader) {
20 | headers["Authorization"] = authHeader;
21 | }
22 |
23 | return headers;
24 | }
25 |
26 | getAuthHeaders() {
27 | const authHeader = useAuthStore.getState().getAuthHeader();
28 | return authHeader ? { Authorization: authHeader } : {};
29 | }
30 |
31 | /**
32 | * Make GET request with auth
33 | */
34 | async get(path, params = {}) {
35 | const url = new URL(API_BASE + path, window.location.origin);
36 | Object.entries(params).forEach(([key, value]) => {
37 | if (value !== undefined && value !== null) {
38 | url.searchParams.append(key, value);
39 | }
40 | });
41 |
42 | const response = await fetch(url, {
43 | headers: this.getHeaders(),
44 | credentials: "include",
45 | });
46 |
47 | if (response.status === 401) {
48 | useAuthStore.getState().clearCredentials();
49 | throw new Error("Authentication required");
50 | }
51 |
52 | if (!response.ok) {
53 | throw new Error(`HTTP ${response.status}: ${response.statusText}`);
54 | }
55 | return response.json();
56 | }
57 |
58 | /**
59 | * Make POST request with auth
60 | */
61 | async post(path, data = {}) {
62 | const response = await fetch(API_BASE + path, {
63 | method: "POST",
64 | headers: this.getHeaders(),
65 | body: JSON.stringify(data),
66 | credentials: "include",
67 | });
68 |
69 | if (response.status === 401) {
70 | useAuthStore.getState().clearCredentials();
71 | throw new Error("Authentication required");
72 | }
73 |
74 | if (!response.ok) {
75 | const error = await response
76 | .json()
77 | .catch(() => ({ detail: response.statusText }));
78 | throw new Error(error.detail || `HTTP ${response.status}`);
79 | }
80 | return response.json();
81 | }
82 |
83 | /**
84 | * Search for tracks
85 | */
86 | searchTracks(query) {
87 | return this.get("/search/tracks", { q: query });
88 | }
89 |
90 | /**
91 | * Search for albums
92 | */
93 | searchAlbums(query) {
94 | return this.get("/search/albums", { q: query });
95 | }
96 |
97 | /**
98 | * Search for artists
99 | */
100 | searchArtists(query) {
101 | return this.get("/search/artists", { q: query });
102 | }
103 |
104 | /**
105 | * Search for playlists
106 | */
107 | searchPlaylists(query) {
108 | return this.get("/search/playlists", { q: query });
109 | }
110 |
111 | /**
112 | * Get album tracks
113 | */
114 | getAlbumTracks(albumId) {
115 | return this.get(`/album/${albumId}/tracks`);
116 | }
117 |
118 | /**
119 | * Get artist details
120 | */
121 | getArtist(artistId) {
122 | return this.get(`/artist/${artistId}`);
123 | }
124 |
125 | /**
126 | * Get playlist details and tracks
127 | */
128 | getPlaylist(playlistId) {
129 | return this.get(`/playlist/${playlistId}`);
130 | }
131 |
132 | /**
133 | * Get stream URL for track
134 | */
135 | getStreamUrl(trackId, quality = "LOSSLESS") {
136 | return this.get(`/download/stream/${trackId}`, { quality });
137 | }
138 |
139 | /**
140 | * Download track server-side
141 | */
142 | downloadTrack(trackId, artist, title, quality = "LOSSLESS") {
143 | return this.post("/download/track", {
144 | track_id: trackId,
145 | artist,
146 | title,
147 | quality,
148 | });
149 | }
150 |
151 | /**
152 | * Generate ListenBrainz playlist
153 | */
154 | generateListenBrainzPlaylist(username, playlistType = "periodic-jams", shouldValidate = true) {
155 | return this.post("/listenbrainz/generate", {
156 | username,
157 | playlist_type: playlistType,
158 | should_validate: shouldValidate,
159 | });
160 | }
161 |
162 | /**
163 | * Validate a single ListenBrainz track
164 | */
165 | validateListenBrainzTrack(track) {
166 | return this.post("/listenbrainz/validate-track", {
167 | track: track
168 | });
169 | }
170 |
171 | /**
172 | * Create ListenBrainz progress stream
173 | */
174 | createListenBrainzProgressStream(progressId) {
175 | const authHeader = useAuthStore.getState().getAuthHeader();
176 | let urlString = `${API_BASE}/listenbrainz/progress/${progressId}`;
177 |
178 | if (authHeader) {
179 | urlString += `?token=${encodeURIComponent(authHeader)}`;
180 | }
181 |
182 | const url = new URL(urlString, window.location.origin);
183 |
184 | const eventSource = new EventSource(url.toString(), {
185 | withCredentials: true,
186 | });
187 |
188 | return eventSource;
189 | }
190 |
191 | /**
192 | * Create Server-Sent Events stream for download progress
193 | */
194 | createProgressStream(trackId) {
195 | const authHeader = useAuthStore.getState().getAuthHeader();
196 | const url = new URL(
197 | `${API_BASE}/download/progress/${trackId}`,
198 | window.location.origin
199 | );
200 |
201 | return new EventSource(url.toString(), {
202 | withCredentials: true,
203 | });
204 | }
205 |
206 | /**
207 | * Get cover URL from Tidal
208 | */
209 | getCoverUrl(coverId, size = "640") {
210 | const variants = this.getCoverUrlVariants(coverId, [size]);
211 | return variants.length > 0 ? variants[0] : null;
212 | }
213 |
214 | /**
215 | * Return multiple size variants for a cover ID or URL (largest to smallest)
216 | */
217 | getCoverUrlVariants(coverId, sizes = ["640", "320", "160"]) {
218 | if (!coverId) return [];
219 | if (typeof coverId === "string" && coverId.startsWith("http")) {
220 | return [coverId];
221 | }
222 |
223 | const cleanOriginal = String(coverId).replace(/-/g, "/");
224 | const candidates = [
225 | cleanOriginal,
226 | cleanOriginal.toUpperCase(),
227 | cleanOriginal.toLowerCase(),
228 | ].filter(Boolean);
229 |
230 | const urls = [];
231 | for (const id of candidates) {
232 | for (const s of sizes) {
233 | const url = `https://resources.tidal.com/images/${id}/${s}x${s}.jpg`;
234 | if (!urls.includes(url)) {
235 | urls.push(url);
236 | }
237 | }
238 | }
239 | return urls;
240 | }
241 |
242 | get baseUrl() {
243 | return window.location.origin;
244 | }
245 |
246 | // ============================================================================
247 | // LIBRARY API METHODS
248 | // ============================================================================
249 |
250 | /**
251 | * Scan library for changes
252 | */
253 | scanLibrary(force = false) {
254 | return this.get("/library/scan", { force });
255 | }
256 |
257 | /**
258 | * Get all artists in library
259 | */
260 | getLibraryArtists() {
261 | return this.get("/library/artists");
262 | }
263 |
264 | /**
265 | * Get specific artist details from library
266 | */
267 | getLibraryArtist(artistName) {
268 | return this.get(`/library/artist/${encodeURIComponent(artistName)}`);
269 | }
270 |
271 | /**
272 | * Get local cover URL
273 | */
274 | getLocalCoverUrl(path) {
275 | if (!path) return null;
276 | return `${API_BASE}/library/cover?path=${encodeURIComponent(path)}`;
277 | }
278 |
279 | /**
280 | * Update artist metadata (e.g. picture)
281 | */
282 | updateLibraryArtist(artistName, metadata) {
283 | return this.patch(`/library/artist/${encodeURIComponent(artistName)}`, metadata);
284 | }
285 |
286 | /**
287 | * Make PATCH request with auth
288 | */
289 | async patch(path, data = {}) {
290 | const response = await fetch(API_BASE + path, {
291 | method: "PATCH",
292 | headers: this.getHeaders(),
293 | body: JSON.stringify(data),
294 | credentials: "include",
295 | });
296 |
297 | if (response.status === 401) {
298 | useAuthStore.getState().clearCredentials();
299 | throw new Error("Authentication required");
300 | }
301 |
302 | if (!response.ok) {
303 | const error = await response.json().catch(() => ({ detail: response.statusText }));
304 | throw new Error(error.detail || `HTTP ${response.status}`);
305 | }
306 | return response.json();
307 | }
308 |
309 | // ============================================================================
310 | // QUEUE API METHODS
311 | // ============================================================================
312 |
313 | /**
314 | * Get current queue state from server
315 | */
316 | getQueue() {
317 | return this.get("/queue");
318 | }
319 |
320 | /**
321 | * Add tracks to the server queue
322 | */
323 | addToQueue(tracks, options = {}) {
324 | return this.post("/queue/add", { tracks, ...options });
325 | }
326 |
327 | /**
328 | * Remove a track from the queue
329 | */
330 | async removeFromQueue(trackId) {
331 | const response = await fetch(`${API_BASE}/queue/${trackId}`, {
332 | method: "DELETE",
333 | headers: this.getHeaders(),
334 | credentials: "include",
335 | });
336 |
337 | if (!response.ok) {
338 | throw new Error(`Failed to remove from queue: ${response.status}`);
339 | }
340 | return response.json();
341 | }
342 |
343 | /**
344 | * Clear the queue
345 | */
346 | clearQueue() {
347 | return this.post("/queue/clear");
348 | }
349 |
350 | /**
351 | * Clear completed items
352 | */
353 | clearCompleted() {
354 | return this.post("/queue/clear-completed");
355 | }
356 |
357 | /**
358 | * Clear failed items
359 | */
360 | clearFailed() {
361 | return this.post("/queue/clear-failed");
362 | }
363 |
364 | /**
365 | * Retry all failed items
366 | */
367 | retryAllFailed() {
368 | return this.post("/queue/retry-failed");
369 | }
370 |
371 | /**
372 | * Retry a single failed item
373 | */
374 | retryFailed(trackId) {
375 | return this.post(`/queue/retry/${trackId}`);
376 | }
377 |
378 | /**
379 | * Start queue processing (for manual mode)
380 | */
381 | startQueue() {
382 | return this.post("/queue/start");
383 | }
384 |
385 | /**
386 | * Stop queue processing
387 | */
388 | stopQueue() {
389 | return this.post("/queue/stop");
390 | }
391 |
392 | /**
393 | * Get queue settings
394 | */
395 | getQueueSettings() {
396 | return this.get("/queue/settings");
397 | }
398 | }
399 |
400 | export const api = new ApiClient();
401 |
--------------------------------------------------------------------------------
/frontend/src/components/PlaylistPage.jsx:
--------------------------------------------------------------------------------
1 | import { h } from "preact";
2 | import { useEffect, useState } from "preact/hooks";
3 | import { api } from "../api/client";
4 | import { downloadManager } from "../utils/downloadManager";
5 | import { useToastStore } from "../stores/toastStore";
6 |
7 | export function PlaylistPage({ playlistId, onBack }) {
8 | const [loading, setLoading] = useState(true);
9 | const [playlist, setPlaylist] = useState(null);
10 | const [tracks, setTracks] = useState([]);
11 | const [selectedTracks, setSelectedTracks] = useState(new Set());
12 | const [error, setError] = useState(null);
13 |
14 | const addToast = useToastStore((state) => state.addToast);
15 |
16 | useEffect(() => {
17 | loadPlaylistData();
18 | }, [playlistId]);
19 |
20 | const loadPlaylistData = async () => {
21 | setLoading(true);
22 | setError(null);
23 |
24 | try {
25 | const result = await api.getPlaylist(playlistId);
26 |
27 | setPlaylist(
28 | result.playlist || {
29 | id: playlistId,
30 | title: "Unknown Playlist",
31 | }
32 | );
33 |
34 | const items = result.items || [];
35 | setTracks(items);
36 | setSelectedTracks(new Set(items.map((t) => t.id)));
37 | } catch (err) {
38 | setError(err.message);
39 | addToast(`Failed to load playlist: ${err.message}`, "error");
40 | } finally {
41 | setLoading(false);
42 | }
43 | };
44 |
45 | const toggleTrack = (trackId) => {
46 | const updated = new Set(selectedTracks);
47 | if (updated.has(trackId)) {
48 | updated.delete(trackId);
49 | } else {
50 | updated.add(trackId);
51 | }
52 | setSelectedTracks(updated);
53 | };
54 |
55 | const selectAll = () => setSelectedTracks(new Set(tracks.map((t) => t.id)));
56 | const deselectAll = () => setSelectedTracks(new Set());
57 |
58 | const handleDownloadTracks = () => {
59 | const selected = tracks.filter((t) => selectedTracks.has(t.id));
60 |
61 | if (selected.length === 0) {
62 | addToast("No tracks selected", "warning");
63 | return;
64 | }
65 |
66 | const payload = selected.map((t, idx) => ({
67 | tidal_id: t.id,
68 | title: t.title,
69 | artist: t.artist || "Unknown Artist",
70 | album: t.album,
71 | cover: t.cover || playlist?.cover,
72 | track_number: t.track_number || t.trackNumber || idx + 1,
73 | tidal_exists: true,
74 | }));
75 |
76 | downloadManager.addToServerQueue(payload).then((res) => {
77 | addToast(
78 | `Added ${res.added} track${res.added === 1 ? "" : "s"} to queue`,
79 | "success"
80 | );
81 | });
82 | };
83 |
84 | const totalDuration = tracks.reduce((sum, t) => sum + (t.duration || 0), 0);
85 |
86 | if (loading && !playlist) {
87 | return (
88 |
44 | {/* Audio Quality */}
45 |
96 |
97 |
46 |
49 |
61 |
62 |
63 | {/* File Organization */}
64 |
65 |
68 |
83 |
84 | setOrganizationTemplate(e.target.value)}
88 | class="input-field w-full text-sm font-mono"
89 | placeholder="Custom template..."
90 | />
91 |
95 | 92 | Available: {Artist}, {Album}, {Title}, {TrackNumber}, {Year} 93 |
94 |
98 | {/* Toggles */}
99 |
152 |
100 |
114 |
115 |
101 |
102 |
104 |
113 | Put tracks in "Compilations" folder if Various Artists
103 |
116 |
130 |
131 |
117 |
118 |
120 |
129 | Run "beet import" after download (requires beets)
119 |
132 |
151 |
133 |
134 |
140 |
150 | 135 | {quality.startsWith('OPUS') 136 | ? "Not available for Opus format" 137 | : "Use FFmpeg to embed lyrics (resolves sync issues)"} 138 |
139 |
89 |
93 |
102 | );
103 | }
104 |
105 | if (error) {
106 | return (
107 |
94 |
101 |
95 |
96 |
97 | Loading playlist...
98 |
99 |
100 |
108 |
112 |
116 | );
117 | }
118 |
119 | return (
120 |
113 |
115 | {error}
114 |
121 |
125 |
126 |
237 | );
238 | }
239 |
240 | function CoverWithFallback({ cover, title }) {
241 | const variants = api.getCoverUrlVariants(cover);
242 | if (!variants.length) {
243 | return (
244 |
127 | {playlist?.cover ? (
128 |
158 |
159 | {tracks.length > 0 ? (
160 |
131 | {playlist?.title?.charAt(0) || "?"}
132 |
133 | )}
134 |
135 |
136 |
157 | 137 | {playlist?.title || "Playlist"} 138 |
139 | {playlist?.creator && ( 140 |By {playlist.creator}
141 | )} 142 |
143 | {tracks.length > 0 && {tracks.length} tracks}
144 | {totalDuration > 0 && (
145 | <>
146 | •
147 | {formatTotalDuration(totalDuration)}
148 |
149 | )}
150 |
151 | {playlist?.description && (
152 | 153 | {playlist.description} 154 |
155 | )} 156 |
161 |
218 | ) : (
219 |
162 |
177 |
178 |
163 |
166 |
169 |
170 | {selectedTracks.size > 0 && (
171 |
175 | )}
176 |
179 | {tracks.map((track, idx) => {
180 | const isSelected = selectedTracks.has(track.id);
181 | const trackNumber =
182 | track.track_number || track.trackNumber || idx + 1;
183 | return (
184 |
214 | );
215 | })}
216 |
217 |
220 |
233 |
235 | )}
236 | No tracks found for this playlist
234 |
245 | {title?.charAt(0) || "?"}
246 |
247 | );
248 | }
249 |
250 | const handleError = (e) => {
251 | const idx = Number(e.target.dataset.idx || 0);
252 | const next = idx + 1;
253 | if (next < variants.length) {
254 | e.target.dataset.idx = String(next);
255 | e.target.src = variants[next];
256 | }
257 | };
258 |
259 | return (
260 |