Add enhanced logging for lyrics fetching to debug Jellyfin embedded lyrics check

- Log when GetLyrics endpoint is called with itemId
- Log external vs local track determination
- Log Jellyfin lyrics check status code and result
- Will help identify why embedded lyrics aren't being found

.env.example

@@ -18,30 +18,28 @@ SUBSONIC_URL=http://localhost:4533
 # Server URL (required if using Jellyfin backend)
 JELLYFIN_URL=http://localhost:8096
 
-# API key for SERVER-SIDE operations only (get from Jellyfin Dashboard > API Keys)
+# API key for authentication (get from Jellyfin Dashboard > API Keys)
-# This is used by Allstarr to query Jellyfin's library on behalf of the server
-# CLIENT authentication is handled transparently - clients authenticate directly with Jellyfin
 JELLYFIN_API_KEY=
 
-# User ID for SERVER-SIDE library queries (get from Jellyfin Dashboard > Users > click user > check URL)
+# User ID (get from Jellyfin Dashboard > Users > click user > check URL)
-# This determines which user's library Allstarr queries when searching/browsing
 JELLYFIN_USER_ID=
 
 # Music library ID (optional, auto-detected if not set)
-# If you have multiple libraries, set this to filter to music only
 JELLYFIN_LIBRARY_ID=
 
 # ===== MUSIC SOURCE SELECTION =====
 # Music service to use: SquidWTF, Deezer, or Qobuz (default: SquidWTF)
 MUSIC_SERVICE=SquidWTF
 
-# Base directory for all downloads (default: ./downloads)
+# Path where downloaded songs will be stored on the host (only applies if STORAGE_MODE=Permanent)
-# This creates three subdirectories:
-# - downloads/permanent/ - Permanently downloaded tracks (STORAGE_MODE=Permanent)
-# - downloads/cache/ - Temporarily cached tracks (STORAGE_MODE=Cache)
-# - downloads/kept/ - Favorited external tracks (always permanent)
 DOWNLOAD_PATH=./downloads
 
+# Path where favorited external tracks are permanently kept
+KEPT_PATH=./kept
+
+# Path for cache files (Spotify missing tracks, etc.)
+CACHE_PATH=./cache
+
 # ===== SQUIDWTF CONFIGURATION =====
 # Different quality options for SquidWTF. Only FLAC supported right now
 SQUIDWTF_QUALITY=FLAC
@@ -110,14 +108,27 @@ CACHE_DURATION_HOURS=1
 
 # ===== SPOTIFY PLAYLIST INJECTION (JELLYFIN ONLY) =====
 # REQUIRES: Jellyfin Spotify Import Plugin (https://github.com/Viperinius/jellyfin-plugin-spotify-import)
-# This feature intercepts Spotify Import plugin playlists and fills them with tracks from external providers
+# This feature intercepts Spotify Import plugin playlists (Release Radar, Discover Weekly) and fills them
+# with tracks auto-matched from external providers (SquidWTF, Deezer, Qobuz)
 # Uses JELLYFIN_URL and JELLYFIN_API_KEY configured above (no separate credentials needed)
 
 # Enable Spotify playlist injection (optional, default: false)
 SPOTIFY_IMPORT_ENABLED=false
 
+# Sync schedule: When does the Spotify Import plugin run?
+# Set these to match your plugin's sync schedule in Jellyfin
+# Example: If plugin runs daily at 4:15 PM, set HOUR=16 and MINUTE=15
+SPOTIFY_IMPORT_SYNC_START_HOUR=16
+SPOTIFY_IMPORT_SYNC_START_MINUTE=15
+
+# Sync window: How long to search for missing tracks files (in hours)
+# The fetcher will check every 5 minutes within this window
+# Example: If plugin runs at 4:15 PM and window is 2 hours, checks from 4:00 PM to 6:00 PM
+SPOTIFY_IMPORT_SYNC_WINDOW_HOURS=2
+
 # Matching interval: How often to run track matching (in hours)
 # Spotify playlists like Discover Weekly update once per week, Release Radar updates weekly
+# Most playlists don't change frequently, so running once per day is reasonable
 # Set to 0 to only run once on startup (manual trigger via admin UI still works)
 # Default: 24 hours
 SPOTIFY_IMPORT_MATCHING_INTERVAL_HOURS=24

.gitignore

@@ -103,7 +103,4 @@ apis/api-calls/endpoint-usage.json
 originals/
 
 # Sample missing playlists for Spotify integration testing
-sampleMissingPlaylists/
+sampleMissingPlaylists/
-
-# Migration guide (local only)
-MIGRATION.md

README.md

@@ -5,7 +5,11 @@
 [![Docker Image](https://img.shields.io/badge/docker-ghcr.io%2Fsopat712%2Fallstarr-blue)](https://github.com/SoPat712/allstarr/pkgs/container/allstarr)
 [![License](https://img.shields.io/badge/license-GPL--3.0-green)](LICENSE)
 
-A media server proxy that integrates music streaming providers with your local library. Works with **Jellyfin** and **Subsonic-compatible** servers. When a song isn't in your local library, it gets fetched from your configured provider, downloaded, and served to your client. The downloaded song then lives in your library for next time.
+A media server proxy that integrates music streaming providers with your local library. Works with **Jellyfin** and **Subsonic-compatible** servers (Navidrome). When a song isn't in your local library, it gets fetched from your configured provider, downloaded, and served to your client. The downloaded song then lives in your library for next time.
+
+**THIS IS UNDER ACTIVE DEVELOPMENT**
+
+Please report all bugs as soon as possible, as the Jellyfin addition is entirely a test at this point
 
 ## Quick Start
 
@@ -36,15 +40,15 @@ The proxy will be available at `http://localhost:5274`.
 
 ## Web Dashboard
 
-Allstarr includes a web UI for easy configuration and playlist management, accessible at `http://localhost:5275`
+Allstarr includes a web-based dashboard for easy configuration and playlist management, accessible at `http://localhost:5275` (internal port, not exposed through reverse proxy).
 
 ### Features
 
-- **Playlist Management**: Link Jellyfin playlists to Spotify playlists with just a few clicks
+- **Real-time Status**: Monitor Spotify authentication, cookie age, and playlist sync status
-- **Provider Matching**: It should fill in the gaps of your Jellyfin library with tracks from your selected provider
+- **Playlist Management**: Link Jellyfin playlists to Spotify playlists with a few clicks
-- **WebUI**: Update settings without manually editing .env files
+- **Configuration Editor**: Update settings without manually editing .env files
-- **Music**: Using multiple sources for music (optimized for SquidWTF right now, though)
+- **Track Viewer**: Browse tracks in your configured playlists
-- **Lyrics**: Using multiple sources for lyrics, first Jellyfin Lyrics, then Spotify Lyrics, then LrcLib as a last resort
+- **Cache Management**: Clear cached data and restart the container
 
 ### Quick Setup with Web UI
 
@@ -61,20 +65,18 @@ Allstarr includes a web UI for easy configuration and playlist management, acces
      - `37i9dQZF1DXcBWIGoYBM5M` (just the ID)
      - `spotify:playlist:37i9dQZF1DXcBWIGoYBM5M` (Spotify URI)
      - `https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M` (full URL)
-4. **Restart** to apply changes (should be a banner)
+4. **Restart** to apply changes (button in Configuration tab)
 
-Then, proceeed to **Active Playlists**, which shows you which Spotify playlists are currently being monitored and filled with tracks, and lets you do a bunch of useful operations on them.
+### Why Two Playlist Tabs?
+
+- **Link Playlists**: Shows all Jellyfin playlists and lets you connect them to Spotify
+- **Active Playlists**: Shows which Spotify playlists are currently being monitored and filled with tracks
 
 ### Configuration Persistence
 
 The web UI updates your `.env` file directly. Changes persist across container restarts, but require a restart to take effect. In development mode, the `.env` file is in your project root. In Docker, it's at `/app/.env`.
 
-There's an environment variable to modify this.
+**Recommended workflow**: Use the `sp_dc` cookie method (simpler and more reliable than the Jellyfin Spotify Import plugin).
-
-
-**Recommended workflow**: Use the `sp_dc` cookie method alongside the [Spotify Import Plugin](https://github.com/Viperinius/jellyfin-plugin-spotify-import?tab=readme-ov-file).
-
-
 
 ### Nginx Proxy Setup (Required)
 
@@ -140,7 +142,6 @@ This project brings together all the music streaming providers into one unified
 
 - [Feishin](https://github.com/jeffvli/feishin) (Mac/Windows/Linux)
 - [Musiver](https://music.aqzscn.cn/en/) (Android/IOS/Windows/Android)
-- [Finamp](https://github.com/jmshrv/finamp) ()
 
 _Working on getting more currently_
 
@@ -334,7 +335,7 @@ Subsonic__EnableExternalPlaylists=false
 
 ### Spotify Playlist Injection (Jellyfin Only)
 
-Allstarr automatically fills your Spotify playlists (like Release Radar and Discover Weekly) with tracks from your configured streaming provider (SquidWTF, Deezer, or Qobuz). This works by intercepting playlists created by the Jellyfin Spotify Import plugin and matching missing tracks with your streaming service.
+Allstarr can automatically fill your Spotify playlists (like Release Radar and Discover Weekly) with tracks from your configured streaming provider (SquidWTF, Deezer, or Qobuz). This feature works by intercepting playlists created by the Jellyfin Spotify Import plugin and matching missing tracks with your streaming service.
 
 #### Prerequisites
 
@@ -348,112 +349,136 @@ Allstarr automatically fills your Spotify playlists (like Release Radar and Disc
    - Go to Jellyfin Dashboard → Plugins → Spotify Import
    - Connect your Spotify account
    - Select which playlists to sync (e.g., Release Radar, Discover Weekly)
-   - Set a sync schedule (the plugin will create playlists in Jellyfin)
+   - Set a daily sync schedule (e.g., 4:15 PM daily)
+   - The plugin will create playlists in Jellyfin and generate "missing tracks" files for songs not in your library
 
 3. **Configure Allstarr**
-   - Enable Spotify Import in Allstarr (see configuration below)
+   - Allstarr needs to know when the plugin runs and which playlists to intercept
-   - Link your Jellyfin playlists to Spotify playlists via the Web UI
+   - Uses your existing `JELLYFIN_URL` and `JELLYFIN_API_KEY` settings (no additional credentials needed)
-   - Uses your existing `JELLYFIN_URL` and `JELLYFIN_API_KEY` settings
 
 #### Configuration
 
 | Setting | Description |
 |---------|-------------|
 | `SpotifyImport:Enabled` | Enable Spotify playlist injection (default: `false`) |
-| `SpotifyImport:MatchingIntervalHours` | How often to run track matching in hours (default: 24, set to 0 for startup only) |
+| `SpotifyImport:SyncStartHour` | Hour when the Spotify Import plugin runs (24-hour format, 0-23) |
-| `SpotifyImport:Playlists` | JSON array of playlists (managed via Web UI) |
+| `SpotifyImport:SyncStartMinute` | Minute when the plugin runs (0-59) |
+| `SpotifyImport:SyncWindowHours` | Hours to search for missing tracks files after sync time (default: 2) |
+| `SpotifyImport:PlaylistIds` | Comma-separated Jellyfin playlist IDs to intercept |
+| `SpotifyImport:PlaylistNames` | Comma-separated playlist names (must match order of IDs) |
 
 **Environment variables example:**
 ```bash
 # Enable the feature
 SPOTIFY_IMPORT_ENABLED=true
 
-# Matching interval (24 hours = once per day)
+# Sync window settings (optional - used to prevent fetching too frequently)
-SPOTIFY_IMPORT_MATCHING_INTERVAL_HOURS=24
+# The fetcher searches backwards from current time for the last 48 hours
+SPOTIFY_IMPORT_SYNC_START_HOUR=16
+SPOTIFY_IMPORT_SYNC_START_MINUTE=15
+SPOTIFY_IMPORT_SYNC_WINDOW_HOURS=2
 
-# Playlists (use Web UI to manage instead of editing manually)
+# Get playlist IDs from Jellyfin URLs: https://jellyfin.example.com/web/#/details?id=PLAYLIST_ID
-SPOTIFY_IMPORT_PLAYLISTS=[["Discover Weekly","37i9dQZEVXcV6s7Dm7RXsU","first"],["Release Radar","37i9dQZEVXbng2vDHnfQlC","first"]]
+SPOTIFY_IMPORT_PLAYLIST_IDS=ba50e26c867ec9d57ab2f7bf24cfd6b0,4383a46d8bcac3be2ef9385053ea18df
+
+# Names must match exactly as they appear in Jellyfin (used to find missing tracks files)
+SPOTIFY_IMPORT_PLAYLIST_NAMES=Release Radar,Discover Weekly
 ```
 
 #### How It Works
 
-1. **Spotify Import Plugin Runs**
+1. **Spotify Import Plugin Runs** (e.g., daily at 4:15 PM)
    - Plugin fetches your Spotify playlists
    - Creates/updates playlists in Jellyfin with tracks already in your library
    - Generates "missing tracks" JSON files for songs not found locally
+   - Files are named like: `Release Radar_missing_2026-02-01_16-15.json`
 
-2. **Allstarr Matches Tracks** (on startup + every 24 hours by default)
+2. **Allstarr Fetches Missing Tracks** (within sync window)
-   - Reads missing tracks files from the Jellyfin plugin
+   - Searches for missing tracks files from the Jellyfin plugin
+   - Searches **+24 hours forward first** (newest files), then **-48 hours backward** if not found
+   - This efficiently finds the most recent file regardless of timezone differences
+   - Example: Server time 12 PM EST, file timestamped 9 PM UTC (same day) → Found in forward search
+   - Caches the list of missing tracks in Redis + file cache
+   - Runs automatically on startup (if needed) and every 5 minutes during the sync window
+
+3. **Allstarr Matches Tracks** (2 minutes after startup, then configurable interval)
    - For each missing track, searches your streaming provider (SquidWTF, Deezer, or Qobuz)
    - Uses fuzzy matching to find the best match (title + artist similarity)
    - Rate-limited to avoid overwhelming the service (150ms delay between searches)
-   - Pre-builds playlist cache for instant loading
+   - Caches matched results for 1 hour
+   - **Pre-builds playlist items cache** for instant serving (no "on the fly" building)
+   - Default interval: 24 hours (configurable via `SPOTIFY_IMPORT_MATCHING_INTERVAL_HOURS`)
+   - Set to 0 to only run once on startup (manual trigger via admin UI still works)
 
-3. **You Open the Playlist in Jellyfin**
+4. **You Open the Playlist in Jellyfin**
    - Allstarr intercepts the request
    - Returns a merged list: local tracks + matched streaming tracks
-   - Loads instantly from cache!
+   - Loads instantly from cache (no searching needed!)
 
-4. **You Play a Track**
+5. **You Play a Track**
-   - Local tracks stream from Jellyfin normally
+   - If it's a local track, streams from Jellyfin normally
-   - Matched tracks download from streaming provider on-demand
+   - If it's a matched track, downloads from streaming provider on-demand
    - Downloaded tracks are saved to your library for future use
 
-#### Manual API Triggers
+#### Manual Triggers
 
-You can manually trigger operations via the admin API:
+You can manually trigger syncing and matching via API:
 
 ```bash
-# Get API key from your .env file
-API_KEY="your-api-key-here"
-
 # Fetch missing tracks from Jellyfin plugin
-curl "http://localhost:5274/spotify/sync?api_key=$API_KEY"
+curl "https://your-jellyfin-proxy.com/spotify/sync?api_key=YOUR_API_KEY"
 
 # Trigger track matching (searches streaming provider)
-curl "http://localhost:5274/spotify/match?api_key=$API_KEY"
+curl "https://your-jellyfin-proxy.com/spotify/match?api_key=YOUR_API_KEY"
 
-# Match all playlists (refresh all matches)
+# Clear cache to force re-matching
-curl "http://localhost:5274/spotify/match-all?api_key=$API_KEY"
+curl "https://your-jellyfin-proxy.com/spotify/clear-cache?api_key=YOUR_API_KEY"
-
-# Clear cache and rebuild
-curl "http://localhost:5274/spotify/clear-cache?api_key=$API_KEY"
-
-# Refresh specific playlist
-curl "http://localhost:5274/spotify/refresh-playlist?playlistId=PLAYLIST_ID&api_key=$API_KEY"
 ```
 
-#### Web UI Management
+#### Startup Behavior
 
-The easiest way to manage Spotify playlists is through the Web UI at `http://localhost:5275`:
+When Allstarr starts with Spotify Import enabled:
 
-1. **Link Playlists Tab**: Link Jellyfin playlists to Spotify playlists
+**Smart Cache Check:**
-2. **Active Playlists Tab**: View status, trigger matching, and manage playlists
+- Checks if today's sync window has passed (e.g., if sync is at 4 PM + 2 hour window = 6 PM)
-3. **Configuration Tab**: Enable/disable Spotify Import and adjust settings
+- If before 6 PM and yesterday's cache exists → **Skips fetch** (cache is still current)
+- If after 6 PM or no cache exists → **Fetches missing tracks** from Jellyfin plugin
+
+**Track Matching:**
+- **T+2min**: Matches tracks with streaming provider (with rate limiting)
+- Only matches playlists that don't already have cached matches
+- **Result**: Playlists load instantly when you open them!
+
+**Example Timeline:**
+- Plugin runs daily at 4:15 PM, creates files at ~4:16 PM
+- You restart Allstarr at 12:00 PM (noon) the next day
+- Startup check: "Today's sync window ends at 6 PM, and I have yesterday's 4:16 PM file"
+- **Decision**: Skip fetch, use existing cache
+- At 6:01 PM: Next scheduled check will search for new files
 
 #### Troubleshooting
 
 **Playlists are empty:**
 - Check that the Spotify Import plugin is running and creating playlists
-- Verify playlists are linked in the Web UI
+- Verify `SPOTIFY_IMPORT_PLAYLIST_IDS` match your Jellyfin playlist IDs
 - Check logs: `docker-compose logs -f allstarr | grep -i spotify`
 
 **Tracks aren't matching:**
 - Ensure your streaming provider is configured (`MUSIC_SERVICE`, credentials)
-- Manually trigger matching via Web UI or API
+- Check that playlist names in `SPOTIFY_IMPORT_PLAYLIST_NAMES` match exactly
-- Check that the Jellyfin plugin generated missing tracks files
+- Manually trigger matching: `curl "https://your-proxy.com/spotify/match?api_key=KEY"`
 
-**Performance:**
+**Sync timing issues:**
-- Matching runs in background with rate limiting (150ms between searches)
+- Set `SPOTIFY_IMPORT_SYNC_START_HOUR/MINUTE` to match your plugin schedule
-- First match may take a few minutes for large playlists
+- Increase `SPOTIFY_IMPORT_SYNC_WINDOW_HOURS` if files aren't being found
-- Subsequent loads are instant (served from cache)
+- Check Jellyfin plugin logs to confirm when it runs
 
 #### Notes
 
-- Uses your existing `JELLYFIN_URL` and `JELLYFIN_API_KEY` settings
+- This feature uses your existing `JELLYFIN_URL` and `JELLYFIN_API_KEY` settings
-- Matched tracks cached for fast loading
+- Matched tracks are cached for 1 hour to avoid repeated searches
-- Missing tracks cache persists across restarts (Redis + file cache)
+- Missing tracks cache persists across restarts (stored in Redis + file cache)
-- Rate limiting prevents overwhelming your streaming provider
+- Rate limiting prevents overwhelming your streaming provider (150ms between searches)
 - Only works with Jellyfin backend (not Subsonic/Navidrome)
 
 ### Getting Credentials
@@ -567,46 +592,9 @@ If you prefer to run Allstarr without Docker:
 
 ## API Endpoints
 
-### Jellyfin Backend (Primary Focus)
-
-The proxy provides comprehensive Jellyfin API support with streaming provider integration:
-
-| Endpoint | Description |
-|----------|-------------|
-| `GET /Items` | Search and browse library items (local + streaming providers) |
-| `GET /Artists` | Browse artists with merged results from local + streaming |
-| `GET /Artists/AlbumArtists` | Album artists with streaming provider results |
-| `GET /Users/{userId}/Items` | User library items with external content |
-| `GET /Audio/{id}/stream` | Stream audio, downloading from provider on-demand |
-| `GET /Audio/{id}/Lyrics` | Lyrics from Jellyfin, Spotify, or LRCLib |
-| `GET /Items/{id}/Images/{type}` | Proxy cover art for external content |
-| `GET /Playlists/{id}/Items` | Playlist items (Spotify Import integration) |
-| `POST /UserFavoriteItems/{id}` | Favorite items; copies external tracks to kept folder |
-| `DELETE /UserFavoriteItems/{id}` | Unfavorite items |
-| `POST /Sessions/Playing` | Playback reporting for external tracks |
-| `POST /Sessions/Playing/Progress` | Playback progress tracking |
-| `POST /Sessions/Playing/Stopped` | Playback stopped reporting |
-| `WebSocket /socket` | Real-time session management and remote control |
-
-**Admin API (Port 5275):**
-| Endpoint | Description |
-|----------|-------------|
-| `GET /api/config` | Get current configuration |
-| `POST /api/config` | Update configuration |
-| `GET /api/playlists` | List Spotify Import playlists |
-| `POST /api/playlists/link` | Link Jellyfin playlist to Spotify |
-| `DELETE /api/playlists/{id}` | Unlink playlist |
-| `POST /spotify/sync` | Fetch missing tracks from Jellyfin plugin |
-| `POST /spotify/match` | Trigger track matching |
-| `POST /spotify/match-all` | Match all playlists |
-| `POST /spotify/clear-cache` | Clear playlist cache |
-| `POST /spotify/refresh-playlist` | Refresh specific playlist |
-
-All other Jellyfin API endpoints are passed through unchanged.
-
 ### Subsonic Backend
 
-The proxy implements the Subsonic API with streaming provider integration:
+The proxy implements the Subsonic API and adds transparent streaming provider integration:
 
 | Endpoint | Description |
 |----------|-------------|
@@ -620,6 +608,20 @@ The proxy implements the Subsonic API with streaming provider integration:
 
 All other Subsonic API endpoints are passed through to Navidrome unchanged.
 
+### Jellyfin Backend
+
+The proxy implements a subset of the Jellyfin API:
+
+| Endpoint | Description |
+|----------|-------------|
+| `GET /Items` | Search and browse library items |
+| `GET /Artists` | Browse artists with streaming provider results |
+| `GET /Audio/{id}/stream` | Stream audio, downloading from provider if needed |
+| `GET /Items/{id}/Images/{type}` | Proxy cover art for external content |
+| `POST /UserFavoriteItems/{id}` | Favorite items; triggers playlist download |
+
+All other Jellyfin API endpoints are passed through unchanged.
+
 ## External ID Format
 
 External (streaming provider) content uses typed IDs:
@@ -634,37 +636,25 @@ Legacy format `ext-deezer-{id}` is also supported (assumes song type).
 
 ## Download Folder Structure
 
-All downloads are organized under a single base directory (default: `./downloads`):
+Downloaded music is organized as:
-
 ```
 downloads/
-├── permanent/                    # Permanent downloads (STORAGE_MODE=Permanent)
+├── Artist Name/
-│   ├── Artist Name/
+│   ├── Album Title/
-│   │   ├── Album Title/
+│   │   ├── 01 - Track One.mp3
-│   │   │   ├── 01 - Track One.flac
+│   │   ├── 02 - Track Two.mp3
-│   │   │   ├── 02 - Track Two.flac
+│   │   └── ...
-│   │   │   └── ...
+│   └── Another Album/
-│   │   └── Another Album/
+│       └── ...
-│   │       └── ...
+├── Another Artist/
-│   └── playlists/
+│   └── ...
-│       ├── My Favorite Songs.m3u
+└── playlists/
-│       └── Chill Vibes.m3u
+    ├── My Favorite Songs.m3u
-├── cache/                        # Temporary cache (STORAGE_MODE=Cache)
+    ├── Chill Vibes.m3u
-│   └── Artist Name/
+    └── ...
-│       └── Album Title/
-│           └── Track.flac
-└── kept/                         # Favorited external tracks (always permanent)
-    └── Artist Name/
-        └── Album Title/
-            └── Track.flac
 ```
 
-**Storage modes:**
+Playlists are stored as M3U files with relative paths to downloaded tracks, making them portable and compatible with most music players.
-- **Permanent** (`downloads/permanent/`): Files saved permanently and registered in your media server
-- **Cache** (`downloads/cache/`): Temporary files, auto-cleaned after `CACHE_DURATION_HOURS`
-- **Kept** (`downloads/kept/`): External tracks you've favorited - always permanent, separate from cache
-
-Playlists are stored as M3U files with relative paths, making them portable and compatible with most music players.
 
 ## Metadata Embedding
 
@@ -695,17 +685,10 @@ dotnet test
 ```
 allstarr/
 ├── Controllers/
-│   ├── AdminController.cs                 # Admin dashboard API
+│   ├── JellyfinController.cs              # Jellyfin API controller (registered when Backend:Type=Jellyfin)
-│   ├── JellyfinController.cs              # Jellyfin API controller
+│   └── SubsonicController.cs              # Subsonic API controller (registered when Backend:Type=Subsonic)
-│   └── SubsonicController.cs              # Subsonic API controller
-├── Filters/
-│   ├── AdminPortFilter.cs                 # Admin port access control
-│   ├── ApiKeyAuthFilter.cs                # API key authentication
-│   └── JellyfinAuthFilter.cs              # Jellyfin authentication
 ├── Middleware/
-│   ├── AdminStaticFilesMiddleware.cs      # Admin UI static file serving
+│   └── GlobalExceptionHandler.cs          # Global error handling
-│   ├── GlobalExceptionHandler.cs          # Global error handling
-│   └── WebSocketProxyMiddleware.cs        # WebSocket proxying for Jellyfin
 ├── Models/
 │   ├── Domain/                            # Domain entities
 │   │   ├── Song.cs
@@ -714,39 +697,18 @@ allstarr/
 │   ├── Settings/                          # Configuration models
 │   │   ├── SubsonicSettings.cs
 │   │   ├── DeezerSettings.cs
-│   │   ├── QobuzSettings.cs
+│   │   └── QobuzSettings.cs
-│   │   ├── SquidWTFSettings.cs
-│   │   ├── SpotifyApiSettings.cs
-│   │   ├── SpotifyImportSettings.cs
-│   │   ├── MusicBrainzSettings.cs
-│   │   └── RedisSettings.cs
 │   ├── Download/                          # Download-related models
 │   │   ├── DownloadInfo.cs
 │   │   └── DownloadStatus.cs
-│   ├── Lyrics/
-│   │   └── LyricsInfo.cs
 │   ├── Search/
 │   │   └── SearchResult.cs
-│   ├── Spotify/
-│   │   ├── MissingTrack.cs
-│   │   └── SpotifyPlaylistTrack.cs
 │   └── Subsonic/
-│       ├── ExternalPlaylist.cs
 │       └── ScanStatus.cs
 ├── Services/
 │   ├── Common/                            # Shared services
 │   │   ├── BaseDownloadService.cs         # Template method base class
-│   │   ├── CacheCleanupService.cs         # Cache cleanup background service
-│   │   ├── CacheWarmingService.cs         # Startup cache warming
-│   │   ├── EndpointBenchmarkService.cs    # Endpoint performance benchmarking
-│   │   ├── FuzzyMatcher.cs                # Fuzzy string matching
-│   │   ├── GenreEnrichmentService.cs      # MusicBrainz genre enrichment
-│   │   ├── OdesliService.cs               # Odesli/song.link conversion
-│   │   ├── ParallelMetadataService.cs     # Parallel metadata fetching
 │   │   ├── PathHelper.cs                  # Path utilities
-│   │   ├── PlaylistIdHelper.cs            # Playlist ID helpers
-│   │   ├── RedisCacheService.cs           # Redis caching
-│   │   ├── RoundRobinFallbackHelper.cs    # Load balancing and failover
 │   │   ├── Result.cs                      # Result<T> pattern
 │   │   └── Error.cs                       # Error types
 │   ├── Deezer/                            # Deezer provider
@@ -758,35 +720,12 @@ allstarr/
 │   │   ├── QobuzMetadataService.cs
 │   │   ├── QobuzBundleService.cs
 │   │   └── QobuzStartupValidator.cs
-│   ├── SquidWTF/                          # SquidWTF provider
-│   │   ├── SquidWTFDownloadService.cs
-│   │   ├── SquidWTFMetadataService.cs
-│   │   └── SquidWTFStartupValidator.cs
-│   ├── Jellyfin/                          # Jellyfin integration
-│   │   ├── JellyfinModelMapper.cs         # Model mapping
-│   │   ├── JellyfinProxyService.cs        # Request proxying
-│   │   ├── JellyfinResponseBuilder.cs     # Response building
-│   │   ├── JellyfinSessionManager.cs      # Session management
-│   │   └── JellyfinStartupValidator.cs    # Startup validation
-│   ├── Lyrics/                            # Lyrics services
-│   │   ├── LrclibService.cs               # LRCLIB lyrics
-│   │   ├── LyricsPrefetchService.cs       # Background lyrics prefetching
-│   │   ├── LyricsStartupValidator.cs      # Lyrics validation
-│   │   └── SpotifyLyricsService.cs        # Spotify lyrics
-│   ├── MusicBrainz/
-│   │   └── MusicBrainzService.cs          # MusicBrainz metadata
-│   ├── Spotify/                           # Spotify integration
-│   │   ├── SpotifyApiClient.cs            # Spotify API client
-│   │   ├── SpotifyMissingTracksFetcher.cs # Missing tracks fetcher
-│   │   ├── SpotifyPlaylistFetcher.cs      # Playlist fetcher
-│   │   └── SpotifyTrackMatchingService.cs # Track matching
 │   ├── Local/                             # Local library
 │   │   ├── ILocalLibraryService.cs
 │   │   └── LocalLibraryService.cs
 │   ├── Subsonic/                          # Subsonic API logic
-│   │   ├── PlaylistSyncService.cs         # Playlist synchronization
-│   │   ├── SubsonicModelMapper.cs         # Model mapping
 │   │   ├── SubsonicProxyService.cs        # Request proxying
+│   │   ├── SubsonicModelMapper.cs         # Model mapping
 │   │   ├── SubsonicRequestParser.cs       # Request parsing
 │   │   └── SubsonicResponseBuilder.cs     # Response building
 │   ├── Validation/                        # Startup validation
@@ -798,17 +737,13 @@ allstarr/
 │   ├── IDownloadService.cs                # Download interface
 │   ├── IMusicMetadataService.cs           # Metadata interface
 │   └── StartupValidationService.cs
-├── wwwroot/                               # Admin UI static files
-│   ├── index.html                         # Admin dashboard
-│   └── placeholder.png                    # Placeholder image
 ├── Program.cs                             # Application entry point
 └── appsettings.json                       # Configuration
 
 allstarr.Tests/
 ├── DeezerDownloadServiceTests.cs          # Deezer download tests
 ├── DeezerMetadataServiceTests.cs          # Deezer metadata tests
-├── JellyfinResponseStructureTests.cs      # Jellyfin response tests
+├── QobuzDownloadServiceTests.cs           # Qobuz download tests (127 tests)
-├── QobuzDownloadServiceTests.cs           # Qobuz download tests
 ├── LocalLibraryServiceTests.cs            # Local library tests
 ├── SubsonicModelMapperTests.cs            # Model mapping tests
 ├── SubsonicProxyServiceTests.cs           # Proxy service tests
@@ -882,7 +817,7 @@ We welcome contributions! Here's how to get started:
 - Follow existing code patterns and conventions
 - Add tests for new features
 - Update documentation as needed
-- Keep commits feature focused
+- Keep commits focused and atomic
 
 ### Testing
 
@@ -904,14 +839,8 @@ GPL-3.0
 
 ## Acknowledgments
 
-- [octo-fiesta](https://github.com/V1ck3s/octo-fiesta) - The original
-- [octo-fiestarr](https://github.com/bransoned/octo-fiestarr) - The fork that introduced me to this idea based on the above
-- [Jellyfin Spotify Import Plugin](https://github.com/Viperinius/jellyfin-plugin-spotify-import?tab=readme-ov-file) - The plugin that I **strongly** recommend using alongside this repo
-- [Jellyfin](https://jellyfin.org/) - The free and open-source media server
 - [Navidrome](https://www.navidrome.org/) - The excellent self-hosted music server
-- [Subsonic API](http://www.subsonic.org/pages/api.jsp) - The API specification
+- [Jellyfin](https://jellyfin.org/) - The free and open-source media server
-- [Hi-Fi API](https://github.com/binimum/hifi-api) - These people do some great work, and you should thank them for this even existing!
 - [Deezer](https://www.deezer.com/) - Music streaming service
 - [Qobuz](https://www.qobuz.com/) - Hi-Res music streaming service
-- [spotify-lyrics-api](https://github.com/akashrchandran/spotify-lyrics-api) - Thank them for the fact that we have access to Spotify's lyrics!
+- [Subsonic API](http://www.subsonic.org/pages/api.jsp) - The API specification
-- [LRCLIB](https://github.com/tranxuanthang/lrclib) - The GOATS for giving us a free api for lyrics! They power LRCGET, which I'm sure some of you have heard of

allstarr/Controllers/AdminController.cs

@@ -166,7 +166,8 @@ public class AdminController : ControllerBase
             spotifyImport = new
             {
                 enabled = _spotifyImportSettings.Enabled,
-                matchingIntervalHours = _spotifyImportSettings.MatchingIntervalHours,
+                syncTime = $"{_spotifyImportSettings.SyncStartHour:D2}:{_spotifyImportSettings.SyncStartMinute:D2}",
+                syncWindowHours = _spotifyImportSettings.SyncWindowHours,
                 playlistCount = _spotifyImportSettings.Playlists.Count
             },
             deezer = new
@@ -1391,7 +1392,9 @@ public class AdminController : ControllerBase
             spotifyImport = new
             {
                 enabled = _spotifyImportSettings.Enabled,
-                matchingIntervalHours = _spotifyImportSettings.MatchingIntervalHours,
+                syncStartHour = _spotifyImportSettings.SyncStartHour,
+                syncStartMinute = _spotifyImportSettings.SyncStartMinute,
+                syncWindowHours = _spotifyImportSettings.SyncWindowHours,
                 playlists = _spotifyImportSettings.Playlists.Select(p => new
                 {
                     name = p.Name,
@@ -1409,9 +1412,9 @@ public class AdminController : ControllerBase
             library = new
             {
                 downloadPath = _subsonicSettings.StorageMode == StorageMode.Cache 
-                    ? Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "cache")
+                    ? Path.Combine("cache", "Music")
-                    : Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "permanent"),
+                    : (_configuration["Library:DownloadPath"] ?? "./downloads"),
-                keptPath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept"),
+                keptPath = _configuration["Library:KeptPath"] ?? "/app/kept",
                 storageMode = _subsonicSettings.StorageMode.ToString(),
                 cacheDurationHours = _subsonicSettings.CacheDurationHours,
                 downloadMode = _subsonicSettings.DownloadMode.ToString()
@@ -3306,7 +3309,7 @@ public class LinkPlaylistRequest
     {
         try
         {
-            var keptPath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept");
+            var keptPath = _configuration["Library:KeptPath"] ?? "/app/kept";
             
             _logger.LogInformation("📂 Checking kept folder: {Path}", keptPath);
             _logger.LogInformation("📂 Directory exists: {Exists}", Directory.Exists(keptPath));
@@ -3389,7 +3392,7 @@ public class LinkPlaylistRequest
                 return BadRequest(new { error = "Path is required" });
             }
             
-            var keptPath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept");
+            var keptPath = _configuration["Library:KeptPath"] ?? "/app/kept";
             var fullPath = Path.Combine(keptPath, path);
             
             _logger.LogInformation("🗑️ Delete request for: {Path}", fullPath);
@@ -3453,7 +3456,7 @@ public class LinkPlaylistRequest
                 return BadRequest(new { error = "Path is required" });
             }
             
-            var keptPath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept");
+            var keptPath = _configuration["Library:KeptPath"] ?? "/app/kept";
             var fullPath = Path.Combine(keptPath, path);
             
             // Security: Ensure the path is within the kept directory

allstarr/Controllers/JellyfinController.cs

@@ -2183,7 +2183,7 @@ public class JellyfinController : ControllerBase
             var method = Request.Method;
             var queryString = Request.QueryString.HasValue ? Request.QueryString.Value : "";
             
-            _logger.LogDebug("📡 Session capabilities reported - Method: {Method}, Query: {Query}", method, queryString);
+            _logger.LogInformation("📡 Session capabilities reported - Method: {Method}, Query: {Query}", method, queryString);
             _logger.LogInformation("Headers: {Headers}", 
                 string.Join(", ", Request.Headers.Where(h => h.Key.Contains("Auth", StringComparison.OrdinalIgnoreCase) || h.Key.Contains("Device", StringComparison.OrdinalIgnoreCase) || h.Key.Contains("Client", StringComparison.OrdinalIgnoreCase))
                     .Select(h => $"{h.Key}={h.Value}")));
@@ -2208,11 +2208,7 @@ public class JellyfinController : ControllerBase
             
             if (statusCode == 204 || statusCode == 200)
             {
-                _logger.LogDebug("✓ Session capabilities forwarded to Jellyfin ({StatusCode})", statusCode);
+                _logger.LogInformation("✓ Session capabilities forwarded to Jellyfin ({StatusCode})", statusCode);
-            }
-            else if (statusCode == 401)
-            {
-                _logger.LogDebug("⚠ Jellyfin returned 401 for capabilities (token expired)");
             }
             else
             {
@@ -2246,7 +2242,7 @@ public class JellyfinController : ControllerBase
             }
             Request.Body.Position = 0;
 
-            _logger.LogDebug("📻 Playback START reported");
+            _logger.LogInformation("📻 Playback START reported");
 
             // Parse the body to check if it's an external track
             var doc = JsonDocument.Parse(body);
@@ -2322,7 +2318,7 @@ public class JellyfinController : ControllerBase
                     
                     if (ghostStatusCode == 204 || ghostStatusCode == 200)
                     {
-                        _logger.LogDebug("✓ Ghost playback start forwarded to Jellyfin for external track ({StatusCode})", ghostStatusCode);
+                        _logger.LogInformation("✓ Ghost playback start forwarded to Jellyfin for external track ({StatusCode})", ghostStatusCode);
                     }
                     else
                     {
@@ -2350,7 +2346,7 @@ public class JellyfinController : ControllerBase
             }
 
             // For local tracks, forward playback start to Jellyfin FIRST
-            _logger.LogDebug("Forwarding playback start to Jellyfin...");
+            _logger.LogInformation("Forwarding playback start to Jellyfin...");
             
             // Fetch full item details to include in playback report
             try
@@ -2376,7 +2372,7 @@ public class JellyfinController : ControllerBase
                     
                     if (statusCode == 204 || statusCode == 200)
                     {
-                        _logger.LogDebug("✓ Playback start forwarded to Jellyfin ({StatusCode})", statusCode);
+                        _logger.LogInformation("✓ Playback start forwarded to Jellyfin ({StatusCode})", statusCode);
                         
                         // NOW ensure session exists with capabilities (after playback is reported)
                         if (!string.IsNullOrEmpty(deviceId))
@@ -2384,7 +2380,7 @@ public class JellyfinController : ControllerBase
                             var sessionCreated = await _sessionManager.EnsureSessionAsync(deviceId, client ?? "Unknown", device ?? "Unknown", version ?? "1.0", Request.Headers);
                             if (sessionCreated)
                             {
-                                _logger.LogDebug("✓ SESSION: Session ensured for device {DeviceId} after playback start", deviceId);
+                                _logger.LogWarning("✓ SESSION: Session ensured for device {DeviceId} after playback start", deviceId);
                             }
                             else
                             {
@@ -2408,7 +2404,7 @@ public class JellyfinController : ControllerBase
                     var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing", body, Request.Headers);
                     if (statusCode == 204 || statusCode == 200)
                     {
-                        _logger.LogDebug("✓ Basic playback start forwarded to Jellyfin ({StatusCode})", statusCode);
+                        _logger.LogInformation("✓ Basic playback start forwarded to Jellyfin ({StatusCode})", statusCode);
                     }
                 }
             }
@@ -2521,7 +2517,7 @@ public class JellyfinController : ControllerBase
                     // Only log at 10-second intervals
                     if (position.Seconds % 10 == 0 && position.Milliseconds < 500)
                     {
-                        _logger.LogDebug("▶️ Progress: {Position:mm\\:ss} for item {ItemId}", position, itemId);
+                        _logger.LogInformation("▶️ Progress: {Position:mm\\:ss} for item {ItemId}", position, itemId);
                     }
                 }
             }
@@ -2561,7 +2557,7 @@ public class JellyfinController : ControllerBase
             }
             Request.Body.Position = 0;
 
-            _logger.LogDebug("⏹️  Playback STOPPED reported");
+            _logger.LogInformation("⏹️  Playback STOPPED reported");
 
             // Parse the body to check if it's an external track
             var doc = JsonDocument.Parse(body);
@@ -2619,7 +2615,7 @@ public class JellyfinController : ControllerBase
                     
                     if (stopStatusCode == 204 || stopStatusCode == 200)
                     {
-                        _logger.LogDebug("✓ Ghost playback stop forwarded to Jellyfin ({StatusCode})", stopStatusCode);
+                        _logger.LogInformation("✓ Ghost playback stop forwarded to Jellyfin ({StatusCode})", stopStatusCode);
                     }
                     
                     return NoContent();
@@ -2630,7 +2626,7 @@ public class JellyfinController : ControllerBase
             }
 
             // For local tracks, forward to Jellyfin
-            _logger.LogDebug("Forwarding playback stop to Jellyfin...");
+            _logger.LogInformation("Forwarding playback stop to Jellyfin...");
             
             // Log the body being sent for debugging
             _logger.LogInformation("📤 Sending playback stop body: {Body}", body);
@@ -2653,11 +2649,7 @@ public class JellyfinController : ControllerBase
             
             if (statusCode == 204 || statusCode == 200)
             {
-                _logger.LogDebug("✓ Playback stop forwarded to Jellyfin ({StatusCode})", statusCode);
+                _logger.LogInformation("✓ Playback stop forwarded to Jellyfin ({StatusCode})", statusCode);
-            }
-            else if (statusCode == 401)
-            {
-                _logger.LogDebug("Playback stop returned 401 (token expired)");
             }
             else
             {
@@ -2716,7 +2708,7 @@ public class JellyfinController : ControllerBase
             var queryString = Request.QueryString.HasValue ? Request.QueryString.Value : "";
             var endpoint = string.IsNullOrEmpty(path) ? $"Sessions{queryString}" : $"Sessions/{path}{queryString}";
             
-            _logger.LogDebug("🔄 Proxying session request: {Method} {Endpoint}", method, endpoint);
+            _logger.LogInformation("🔄 Proxying session request: {Method} {Endpoint}", method, endpoint);
             _logger.LogDebug("Session proxy headers: {Headers}", 
                 string.Join(", ", Request.Headers.Where(h => h.Key.Contains("Auth", StringComparison.OrdinalIgnoreCase))
                     .Select(h => $"{h.Key}={h.Value}")));
@@ -2746,11 +2738,11 @@ public class JellyfinController : ControllerBase
             
             if (result != null)
             {
-                _logger.LogDebug("✓ Session request proxied successfully ({StatusCode})", statusCode);
+                _logger.LogInformation("✓ Session request proxied successfully ({StatusCode})", statusCode);
                 return new JsonResult(result.RootElement.Clone());
             }
             
-            _logger.LogDebug("✓ Session request proxied ({StatusCode}, no body)", statusCode);
+            _logger.LogInformation("✓ Session request proxied ({StatusCode}, no body)", statusCode);
             return StatusCode(statusCode);
         }
         catch (Exception ex)
@@ -2808,7 +2800,7 @@ public class JellyfinController : ControllerBase
         if (path.Contains("session", StringComparison.OrdinalIgnoreCase) || 
             path.Contains("capabilit", StringComparison.OrdinalIgnoreCase))
         {
-            _logger.LogDebug("🔍 SESSION/CAPABILITY REQUEST: {Method} /{Path}{Query}", Request.Method, path, Request.QueryString);
+            _logger.LogWarning("🔍 SESSION/CAPABILITY REQUEST: {Method} /{Path}{Query}", Request.Method, path, Request.QueryString);
         }
         else
         {
@@ -3916,7 +3908,7 @@ public class JellyfinController : ControllerBase
             }
 
             // Build kept folder path: Artist/Album/
-            var keptBasePath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept");
+            var keptBasePath = _configuration["Library:KeptPath"] ?? "/app/kept";
             var keptArtistPath = Path.Combine(keptBasePath, PathHelper.SanitizeFileName(song.Artist));
             var keptAlbumPath = Path.Combine(keptArtistPath, PathHelper.SanitizeFileName(song.Album));
             
@@ -4212,7 +4204,7 @@ public class JellyfinController : ControllerBase
             var song = await _metadataService.GetSongAsync(provider!, externalId!);
             if (song == null) return;
 
-            var keptBasePath = Path.Combine(_configuration["Library:DownloadPath"] ?? "./downloads", "kept");
+            var keptBasePath = _configuration["Library:KeptPath"] ?? "/app/kept";
             var keptArtistPath = Path.Combine(keptBasePath, PathHelper.SanitizeFileName(song.Artist));
             var keptAlbumPath = Path.Combine(keptArtistPath, PathHelper.SanitizeFileName(song.Album));
             

allstarr/Filters/JellyfinAuthFilter.cs

@@ -2,44 +2,239 @@ using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Filters;
 using Microsoft.Extensions.Options;
 using allstarr.Models.Settings;
+using System.Text.Json;
+using System.Text.RegularExpressions;
 
 namespace allstarr.Filters;
 
 /// <summary>
-/// REMOVED: Authentication filter for Jellyfin API endpoints.
+/// Authentication filter for Jellyfin API endpoints.
-/// 
+/// Validates client credentials against configured username and API key.
-/// This filter has been removed because Allstarr acts as a TRANSPARENT PROXY.
+/// Clients can authenticate via:
-/// Clients authenticate directly with Jellyfin through the proxy, not with the proxy itself.
+/// - Authorization header: MediaBrowser Token="apikey"
-/// 
+/// - X-Emby-Token header
-/// Authentication flow:
+/// - Query parameter: api_key
-/// 1. Client sends credentials to /Users/AuthenticateByName
+/// - JSON body (for login endpoints): Username/Pw fields
-/// 2. Proxy forwards request to Jellyfin (no validation)
-/// 3. Jellyfin validates credentials and returns AccessToken
-/// 4. Client uses AccessToken in subsequent requests
-/// 5. Proxy forwards token to Jellyfin for validation
-/// 
-/// The proxy NEVER validates credentials or tokens - that's Jellyfin's job.
-/// The proxy only forwards authentication headers transparently.
-/// 
-/// If you need to restrict access to the proxy itself, use network-level controls
-/// (firewall, VPN, reverse proxy with auth) instead of application-level auth.
 /// </summary>
-public class JellyfinAuthFilter : IAsyncActionFilter
+public partial class JellyfinAuthFilter : IAsyncActionFilter
 {
+    private readonly JellyfinSettings _settings;
     private readonly ILogger<JellyfinAuthFilter> _logger;
 
-    public JellyfinAuthFilter(ILogger<JellyfinAuthFilter> logger)
+    public JellyfinAuthFilter(
+        IOptions<JellyfinSettings> settings,
+        ILogger<JellyfinAuthFilter> logger)
     {
+        _settings = settings.Value;
         _logger = logger;
     }
 
     public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
     {
-        // This filter is now a no-op - all authentication is handled by Jellyfin
+        // Skip auth if no credentials configured (open mode)
-        // Keeping the class for backwards compatibility but it does nothing
+        if (string.IsNullOrEmpty(_settings.ClientUsername) || string.IsNullOrEmpty(_settings.ApiKey))
-        
+        {
-        _logger.LogTrace("JellyfinAuthFilter: Transparent proxy mode - no authentication check");
+            _logger.LogDebug("Auth skipped - no client credentials configured");
+            await next();
+            return;
+        }
+
+        var request = context.HttpContext.Request;
         
+        // Try to extract credentials from various sources
+        var (username, token) = await ExtractCredentialsAsync(request);
+
+        // Validate credentials
+        if (!ValidateCredentials(username, token))
+        {
+            _logger.LogWarning("Authentication failed for user '{Username}' from {IP}", 
+                username ?? "unknown", 
+                context.HttpContext.Connection.RemoteIpAddress);
+            
+            context.Result = new UnauthorizedObjectResult(new
+            {
+                error = "Invalid credentials",
+                message = "Authentication required. Provide valid username and API key."
+            });
+            return;
+        }
+
+        _logger.LogDebug("Authentication successful for user '{Username}'", username);
         await next();
     }
+
+    private async Task<(string? username, string? token)> ExtractCredentialsAsync(HttpRequest request)
+    {
+        string? username = null;
+        string? token = null;
+
+        // 1. Check Authorization header (MediaBrowser format)
+        if (request.Headers.TryGetValue("Authorization", out var authHeader))
+        {
+            var authValue = authHeader.ToString();
+            
+            // Parse MediaBrowser auth header: MediaBrowser Client="...", Token="..."
+            if (authValue.StartsWith("MediaBrowser", StringComparison.OrdinalIgnoreCase))
+            {
+                token = ExtractTokenFromMediaBrowser(authValue);
+                username = ExtractUserIdFromMediaBrowser(authValue);
+            }
+            // Basic auth: Basic base64(username:password)
+            else if (authValue.StartsWith("Basic ", StringComparison.OrdinalIgnoreCase))
+            {
+                (username, token) = ParseBasicAuth(authValue);
+            }
+        }
+
+        // 2. Check X-Emby-Token header
+        if (string.IsNullOrEmpty(token) && request.Headers.TryGetValue("X-Emby-Token", out var embyToken))
+        {
+            token = embyToken.ToString();
+        }
+
+        // 3. Check X-MediaBrowser-Token header
+        if (string.IsNullOrEmpty(token) && request.Headers.TryGetValue("X-MediaBrowser-Token", out var mbToken))
+        {
+            token = mbToken.ToString();
+        }
+
+        // 4. Check X-Emby-Authorization header (alternative format)
+        if (string.IsNullOrEmpty(token) && request.Headers.TryGetValue("X-Emby-Authorization", out var embyAuth))
+        {
+            token = ExtractTokenFromMediaBrowser(embyAuth.ToString());
+            if (string.IsNullOrEmpty(username))
+            {
+                username = ExtractUserIdFromMediaBrowser(embyAuth.ToString());
+            }
+        }
+
+        // 5. Check query parameters
+        if (string.IsNullOrEmpty(token))
+        {
+            token = request.Query["api_key"].FirstOrDefault() 
+                 ?? request.Query["ApiKey"].FirstOrDefault()
+                 ?? request.Query["X-Emby-Token"].FirstOrDefault();
+        }
+
+        if (string.IsNullOrEmpty(username))
+        {
+            username = request.Query["userId"].FirstOrDefault()
+                    ?? request.Query["UserId"].FirstOrDefault()
+                    ?? request.Query["u"].FirstOrDefault();
+        }
+
+        // 6. Check JSON body for login endpoints (Jellyfin: Username/Pw, Navidrome: username/password)
+        if ((string.IsNullOrEmpty(username) || string.IsNullOrEmpty(token)) && 
+            request.ContentType?.Contains("application/json", StringComparison.OrdinalIgnoreCase) == true &&
+            request.ContentLength > 0)
+        {
+            var (bodyUsername, bodyPassword) = await ExtractCredentialsFromBodyAsync(request);
+            if (string.IsNullOrEmpty(username)) username = bodyUsername;
+            if (string.IsNullOrEmpty(token)) token = bodyPassword;
+        }
+
+        return (username, token);
+    }
+
+    private async Task<(string? username, string? password)> ExtractCredentialsFromBodyAsync(HttpRequest request)
+    {
+        try
+        {
+            request.EnableBuffering();
+            request.Body.Position = 0;
+            
+            using var reader = new StreamReader(request.Body, leaveOpen: true);
+            var body = await reader.ReadToEndAsync();
+            request.Body.Position = 0;
+
+            if (string.IsNullOrEmpty(body)) return (null, null);
+
+            using var doc = JsonDocument.Parse(body);
+            var root = doc.RootElement;
+
+            // Try Jellyfin format: Username, Pw
+            string? username = null;
+            string? password = null;
+
+            if (root.TryGetProperty("Username", out var usernameProp))
+                username = usernameProp.GetString();
+            else if (root.TryGetProperty("username", out var usernameLowerProp))
+                username = usernameLowerProp.GetString();
+
+            if (root.TryGetProperty("Pw", out var pwProp))
+                password = pwProp.GetString();
+            else if (root.TryGetProperty("pw", out var pwLowerProp))
+                password = pwLowerProp.GetString();
+            else if (root.TryGetProperty("Password", out var passwordProp))
+                password = passwordProp.GetString();
+            else if (root.TryGetProperty("password", out var passwordLowerProp))
+                password = passwordLowerProp.GetString();
+
+            return (username, password);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "Failed to parse credentials from request body");
+            return (null, null);
+        }
+    }
+
+    private string? ExtractTokenFromMediaBrowser(string header)
+    {
+        var match = TokenRegex().Match(header);
+        return match.Success ? match.Groups[1].Value : null;
+    }
+
+    private string? ExtractUserIdFromMediaBrowser(string header)
+    {
+        var match = UserIdRegex().Match(header);
+        return match.Success ? match.Groups[1].Value : null;
+    }
+
+    private static (string? username, string? password) ParseBasicAuth(string authHeader)
+    {
+        try
+        {
+            var base64 = authHeader["Basic ".Length..].Trim();
+            var bytes = Convert.FromBase64String(base64);
+            var credentials = System.Text.Encoding.UTF8.GetString(bytes);
+            var parts = credentials.Split(':', 2);
+            
+            return parts.Length == 2 ? (parts[0], parts[1]) : (null, null);
+        }
+        catch
+        {
+            return (null, null);
+        }
+    }
+
+    private bool ValidateCredentials(string? username, string? token)
+    {
+        // Must have token (API key used as password)
+        if (string.IsNullOrEmpty(token))
+        {
+            return false;
+        }
+
+        // Token must match API key
+        if (!string.Equals(token, _settings.ApiKey, StringComparison.Ordinal))
+        {
+            return false;
+        }
+
+        // If username provided, it must match configured client username
+        if (!string.IsNullOrEmpty(username) && 
+            !string.Equals(username, _settings.ClientUsername, StringComparison.OrdinalIgnoreCase))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    [GeneratedRegex(@"Token=""([^""]+)""", RegexOptions.IgnoreCase)]
+    private static partial Regex TokenRegex();
+
+    [GeneratedRegex(@"UserId=""([^""]+)""", RegexOptions.IgnoreCase)]
+    private static partial Regex UserIdRegex();
 }

allstarr/Middleware/WebSocketProxyMiddleware.cs

@@ -54,7 +54,7 @@ public class WebSocketProxyMiddleware
         if (context.Request.Path.StartsWithSegments("/socket", StringComparison.OrdinalIgnoreCase) &&
             context.WebSockets.IsWebSocketRequest)
         {
-            _logger.LogDebug("🔌 WEBSOCKET: WebSocket connection request received from {RemoteIp}", 
+            _logger.LogInformation("🔌 WEBSOCKET: WebSocket connection request received from {RemoteIp}", 
                 context.Connection.RemoteIpAddress);
 
             await HandleWebSocketProxyAsync(context);
@@ -142,7 +142,7 @@ public class WebSocketProxyMiddleware
             serverWebSocket.Options.SetRequestHeader("User-Agent", "Allstarr/1.0");
 
             await serverWebSocket.ConnectAsync(new Uri(jellyfinWsUrl), context.RequestAborted);
-            _logger.LogDebug("✓ WEBSOCKET: Connected to Jellyfin WebSocket");
+            _logger.LogInformation("✓ WEBSOCKET: Connected to Jellyfin WebSocket");
 
             // Start bidirectional proxying
             var clientToServer = ProxyMessagesAsync(clientWebSocket, serverWebSocket, "Client→Server", context.RequestAborted);
@@ -155,15 +155,7 @@ public class WebSocketProxyMiddleware
         }
         catch (WebSocketException wsEx)
         {
-            // 403 is expected when tokens expire or session ends - don't spam logs
+            _logger.LogWarning(wsEx, "⚠️ WEBSOCKET: WebSocket error: {Message}", wsEx.Message);
-            if (wsEx.Message.Contains("403"))
-            {
-                _logger.LogDebug("WEBSOCKET: Connection rejected with 403 (token expired or session ended)");
-            }
-            else
-            {
-                _logger.LogWarning(wsEx, "⚠️ WEBSOCKET: WebSocket error: {Message}", wsEx.Message);
-            }
         }
         catch (Exception ex)
         {
@@ -202,7 +194,7 @@ public class WebSocketProxyMiddleware
             // CRITICAL: Notify session manager that client disconnected
             if (!string.IsNullOrEmpty(deviceId))
             {
-                _logger.LogDebug("🧹 WEBSOCKET: Client disconnected, removing session for device {DeviceId}", deviceId);
+                _logger.LogInformation("🧹 WEBSOCKET: Client disconnected, removing session for device {DeviceId}", deviceId);
                 await _sessionManager.RemoveSessionAsync(deviceId);
             }
 
@@ -247,7 +239,7 @@ public class WebSocketProxyMiddleware
                     if (direction == "Server→Client")
                     {
                         var messageText = System.Text.Encoding.UTF8.GetString(messageBytes);
-                        _logger.LogTrace("📥 WEBSOCKET {Direction}: {Preview}",
+                        _logger.LogInformation("📥 WEBSOCKET {Direction}: {Preview}",
                             direction,
                             messageText.Length > 500 ? messageText[..500] + "..." : messageText);
                     }
@@ -282,7 +274,7 @@ public class WebSocketProxyMiddleware
         }
         catch (Exception ex)
         {
-            _logger.LogDebug(ex, "WEBSOCKET {Direction}: Error proxying messages (connection closed)", direction);
+            _logger.LogWarning(ex, "⚠️ WEBSOCKET {Direction}: Error proxying messages", direction);
         }
     }
 }

allstarr/Models/Settings/SpotifyImportSettings.cs

@@ -59,6 +59,27 @@ public class SpotifyImportSettings
     /// </summary>
     public bool Enabled { get; set; }
     
+    /// <summary>
+    /// Hour when Spotify Import plugin runs (24-hour format, 0-23)
+    /// NOTE: This setting is now optional and only used for the sync window check.
+    /// The fetcher will search backwards from current time for the last 48 hours,
+    /// so timezone confusion is avoided.
+    /// </summary>
+    public int SyncStartHour { get; set; } = 16;
+    
+    /// <summary>
+    /// Minute when Spotify Import plugin runs (0-59)
+    /// NOTE: This setting is now optional and only used for the sync window check.
+    /// </summary>
+    public int SyncStartMinute { get; set; } = 15;
+    
+    /// <summary>
+    /// How many hours to search for missing tracks files after sync start time
+    /// This prevents the fetcher from running too frequently.
+    /// Set to 0 to disable the sync window check and always search on startup.
+    /// </summary>
+    public int SyncWindowHours { get; set; } = 2;
+    
     /// <summary>
     /// How often to run track matching in hours.
     /// Spotify playlists like Discover Weekly update once per week, Release Radar updates weekly.

allstarr/Program.cs

@@ -22,21 +22,16 @@ static List<string> DecodeSquidWtfUrls()
 {
     var encodedUrls = new[]
     {
-        "aHR0cHM6Ly90cml0b24uc3F1aWQud3Rm",                      // triton.squid.wtf
+        "aHR0cHM6Ly90cml0b24uc3F1aWQud3Rm",                      // triton
-        "aHR0cHM6Ly90aWRhbC1hcGkuYmluaW11bS5vcmc=",              // tidal-api.binimum.org
+        "aHR0cHM6Ly90aWRhbC1hcGkuYmluaW11bS5vcmc=",              // binimum
-        "aHR0cHM6Ly90aWRhbC5raW5vcGx1cy5vbmxpbmU=",              // tidal.kinoplus.online
+        "aHR0cHM6Ly90aWRhbC5raW5vcGx1cy5vbmxpbmU=",              // kinoplus
-        "aHR0cHM6Ly9oaWZpLXR3by5zcG90aXNhdmVyLm5ldA==",          // hifi-two.spotisaver.net
+        "aHR0cHM6Ly9oaWZpLXR3by5zcG90aXNhdmVyLm5ldA==",          // spoti-2
-        "aHR0cHM6Ly9oaWZpLW9uZS5zcG90aXNhdmVyLm5ldA==",          // hifi-one.spotisaver.net
+        "aHR0cHM6Ly9oaWZpLW9uZS5zcG90aXNhdmVyLm5ldA==",          // spoti-1
-        "aHR0cHM6Ly93b2xmLnFxZGwuc2l0ZQ==",                      // wolf.qqdl.site
+        "aHR0cHM6Ly93b2xmLnFxZGwuc2l0ZQ==",                      // wolf
-        "aHR0cDovL2h1bmQucXFkbC5zaXRl",                          // hund.qqdl.site (http)
+        "aHR0cDovL2h1bmQucXFkbC5zaXRl",                          // hund
-        "aHR0cHM6Ly9rYXR6ZS5xcWRsLnNpdGU=",                      // katze.qqdl.site
+        "aHR0cHM6Ly9rYXR6ZS5xcWRsLnNpdGU=",                      // katze
-        "aHR0cHM6Ly92b2dlbC5xcWRsLnNpdGU=",                      // vogel.qqdl.site
+        "aHR0cHM6Ly92b2dlbC5xcWRsLnNpdGU=",                      // vogel
-        "aHR0cHM6Ly9tYXVzLnFxZGwuc2l0ZQ==",                      // maus.qqdl.site
+        "aHR0cHM6Ly9tYXVzLnFxZGwuc2l0ZQ=="                       // maus
-        "aHR0cHM6Ly9ldS1jZW50cmFsLm1vbm9jaHJvbWUudGY=",          // eu-central.monochrome.tf
-        "aHR0cHM6Ly91cy13ZXN0Lm1vbm9jaHJvbWUudGY=",              // us-west.monochrome.tf
-        "aHR0cHM6Ly9hcnJhbi5tb25vY2hyb21lLnRm",                  // arran.monochrome.tf
-        "aHR0cHM6Ly9hcGkubW9ub2Nocm9tZS50Zg==",                  // api.monochrome.tf
-        "aHR0cHM6Ly9odW5kLnFxZGwuc2l0ZQ=="                       // hund.qqdl.site (https)
     };
     
     return encodedUrls
@@ -358,7 +353,7 @@ builder.Services.Configure<SpotifyImportSettings>(options =>
     }
     
     // Log configuration at startup
-    Console.WriteLine($"Spotify Import: Enabled={options.Enabled}, MatchingInterval={options.MatchingIntervalHours}h");
+    Console.WriteLine($"Spotify Import: Enabled={options.Enabled}, SyncHour={options.SyncStartHour}:{options.SyncStartMinute:D2}, WindowHours={options.SyncWindowHours}");
     Console.WriteLine($"Spotify Import Playlists: {options.Playlists.Count} configured");
     foreach (var playlist in options.Playlists)
     {

allstarr/Services/Common/BaseDownloadService.cs

@@ -95,88 +95,22 @@ public abstract class BaseDownloadService : IDownloadService
     
     public async Task<Stream> DownloadAndStreamAsync(string externalProvider, string externalId, CancellationToken cancellationToken = default)
     {
-        var startTime = DateTime.UtcNow;
-        
         // Check if already downloaded locally
         var localPath = await LocalLibraryService.GetLocalPathForExternalSongAsync(externalProvider, externalId);
         if (localPath != null && IOFile.Exists(localPath))
         {
-            var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
+            Logger.LogInformation("Streaming from local cache: {Path}", localPath);
-            Logger.LogInformation("Streaming from local cache ({ElapsedMs}ms): {Path}", elapsed, localPath);
-            
-            // Update access time for cache cleanup
-            if (SubsonicSettings.StorageMode == StorageMode.Cache)
-            {
-                IOFile.SetLastAccessTime(localPath, DateTime.UtcNow);
-            }
-            
-            // Start background Odesli conversion for lyrics (if not already cached)
-            StartBackgroundOdesliConversion(externalProvider, externalId);
-            
             return IOFile.OpenRead(localPath);
         }
 
-        // Download to disk first to ensure complete file with metadata
+        // For on-demand streaming, download to disk first to ensure complete file
         // This is necessary because:
         // 1. Clients may seek to arbitrary positions (requires full file)
         // 2. Metadata embedding requires complete file
         // 3. Caching for future plays
         Logger.LogInformation("Downloading song for streaming: {Provider}:{ExternalId}", externalProvider, externalId);
-        
+        localPath = await DownloadSongInternalAsync(externalProvider, externalId, triggerAlbumDownload: true, cancellationToken);
-        try
+        return IOFile.OpenRead(localPath);
-        {
-            localPath = await DownloadSongInternalAsync(externalProvider, externalId, triggerAlbumDownload: true, cancellationToken);
-            var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
-            Logger.LogInformation("Download completed, starting stream ({ElapsedMs}ms total): {Path}", elapsed, localPath);
-            
-            // Start background Odesli conversion for lyrics (after stream starts)
-            StartBackgroundOdesliConversion(externalProvider, externalId);
-            
-            return IOFile.OpenRead(localPath);
-        }
-        catch (OperationCanceledException)
-        {
-            var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
-            Logger.LogWarning("Download cancelled by client after {ElapsedMs}ms for {Provider}:{ExternalId}", elapsed, externalProvider, externalId);
-            throw;
-        }
-        catch (Exception ex)
-        {
-            var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
-            Logger.LogError(ex, "Download failed after {ElapsedMs}ms for {Provider}:{ExternalId}", elapsed, externalProvider, externalId);
-            throw;
-        }
-    }
-    
-    /// <summary>
-    /// Starts background Odesli conversion for lyrics support.
-    /// This is called AFTER streaming starts so it doesn't block the client.
-    /// </summary>
-    private void StartBackgroundOdesliConversion(string externalProvider, string externalId)
-    {
-        _ = Task.Run(async () =>
-        {
-            try
-            {
-                // Provider-specific conversion (override in subclasses if needed)
-                await ConvertToSpotifyIdAsync(externalProvider, externalId);
-            }
-            catch (Exception ex)
-            {
-                Logger.LogDebug(ex, "Background Spotify ID conversion failed for {Provider}:{ExternalId}", externalProvider, externalId);
-            }
-        });
-    }
-    
-    /// <summary>
-    /// Converts external track ID to Spotify ID for lyrics support.
-    /// Override in provider-specific services if needed.
-    /// </summary>
-    protected virtual Task ConvertToSpotifyIdAsync(string externalProvider, string externalId)
-    {
-        // Default implementation does nothing
-        // Provider-specific services can override this
-        return Task.CompletedTask;
     }
     
     public DownloadInfo? GetDownloadStatus(string songId)
@@ -285,26 +219,21 @@ public abstract class BaseDownloadService : IDownloadService
             // Check if download in progress
             if (ActiveDownloads.TryGetValue(songId, out var activeDownload) && activeDownload.Status == DownloadStatus.InProgress)
             {
-                Logger.LogDebug("Download already in progress for {SongId}, waiting for completion...", songId);
+                Logger.LogInformation("Download already in progress for {SongId}, waiting...", songId);
                 // Release lock while waiting
                 DownloadLock.Release();
                 
-                // Wait for download to complete, checking every 100ms (faster than 500ms)
-                // Also respect cancellation token so client timeouts are handled immediately
                 while (ActiveDownloads.TryGetValue(songId, out activeDownload) && activeDownload.Status == DownloadStatus.InProgress)
                 {
-                    cancellationToken.ThrowIfCancellationRequested();
+                    await Task.Delay(500, cancellationToken);
-                    await Task.Delay(100, cancellationToken);
                 }
                 
                 if (activeDownload?.Status == DownloadStatus.Completed && activeDownload.LocalPath != null)
                 {
-                    Logger.LogDebug("Download completed while waiting, returning path: {Path}", activeDownload.LocalPath);
                     return activeDownload.LocalPath;
                 }
                 
-                // Download failed or was cancelled
+                throw new Exception(activeDownload?.ErrorMessage ?? "Download failed");
-                throw new Exception(activeDownload?.ErrorMessage ?? "Download failed while waiting");
             }
 
             // Get metadata

allstarr/Services/Common/RoundRobinFallbackHelper.cs

@@ -11,12 +11,6 @@ public class RoundRobinFallbackHelper
     private readonly object _urlIndexLock = new object();
     private readonly ILogger _logger;
     private readonly string _serviceName;
-    private readonly HttpClient _healthCheckClient;
-    
-    // Cache health check results for 30 seconds to avoid excessive checks
-    private readonly Dictionary<string, (bool isHealthy, DateTime checkedAt)> _healthCache = new();
-    private readonly object _healthCacheLock = new object();
-    private readonly TimeSpan _healthCacheExpiry = TimeSpan.FromSeconds(30);
 
     public int EndpointCount => _apiUrls.Count;
 
@@ -30,91 +24,6 @@ public class RoundRobinFallbackHelper
         {
             throw new ArgumentException("API URLs list cannot be empty", nameof(apiUrls));
         }
-        
-        // Create a dedicated HttpClient for health checks with short timeout
-        _healthCheckClient = new HttpClient
-        {
-            Timeout = TimeSpan.FromSeconds(3) // Quick health check timeout
-        };
-    }
-
-    /// <summary>
-    /// Quickly checks if an endpoint is healthy (responds within 3 seconds).
-    /// Results are cached for 30 seconds to avoid excessive health checks.
-    /// </summary>
-    private async Task<bool> IsEndpointHealthyAsync(string baseUrl)
-    {
-        // Check cache first
-        lock (_healthCacheLock)
-        {
-            if (_healthCache.TryGetValue(baseUrl, out var cached))
-            {
-                if (DateTime.UtcNow - cached.checkedAt < _healthCacheExpiry)
-                {
-                    return cached.isHealthy;
-                }
-            }
-        }
-        
-        // Perform health check
-        try
-        {
-            var response = await _healthCheckClient.GetAsync(baseUrl, HttpCompletionOption.ResponseHeadersRead);
-            var isHealthy = response.IsSuccessStatusCode;
-            
-            // Cache result
-            lock (_healthCacheLock)
-            {
-                _healthCache[baseUrl] = (isHealthy, DateTime.UtcNow);
-            }
-            
-            if (!isHealthy)
-            {
-                _logger.LogDebug("{Service} endpoint {Endpoint} health check failed: {StatusCode}", 
-                    _serviceName, baseUrl, response.StatusCode);
-            }
-            
-            return isHealthy;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogDebug(ex, "{Service} endpoint {Endpoint} health check failed", _serviceName, baseUrl);
-            
-            // Cache as unhealthy
-            lock (_healthCacheLock)
-            {
-                _healthCache[baseUrl] = (false, DateTime.UtcNow);
-            }
-            
-            return false;
-        }
-    }
-    
-    /// <summary>
-    /// Gets a list of healthy endpoints, checking them in parallel.
-    /// Falls back to all endpoints if none are healthy.
-    /// </summary>
-    private async Task<List<string>> GetHealthyEndpointsAsync()
-    {
-        var healthCheckTasks = _apiUrls.Select(async url => new
-        {
-            Url = url,
-            IsHealthy = await IsEndpointHealthyAsync(url)
-        }).ToList();
-        
-        var results = await Task.WhenAll(healthCheckTasks);
-        var healthyEndpoints = results.Where(r => r.IsHealthy).Select(r => r.Url).ToList();
-        
-        if (healthyEndpoints.Count == 0)
-        {
-            _logger.LogWarning("{Service} health check: no healthy endpoints found, will try all", _serviceName);
-            return _apiUrls;
-        }
-        
-        _logger.LogDebug("{Service} health check: {Healthy}/{Total} endpoints healthy", 
-            _serviceName, healthyEndpoints.Count, _apiUrls.Count);
-        
-        return healthyEndpoints;
     }
 
     /// <summary>
@@ -145,14 +54,10 @@ public class RoundRobinFallbackHelper
     /// <summary>
     /// Tries the request with the next provider in round-robin, then falls back to others on failure.
     /// This distributes load evenly across all providers while maintaining reliability.
-    /// Performs quick health checks first to avoid wasting time on dead endpoints.
     /// Throws exception if all endpoints fail.
     /// </summary>
     public async Task<T> TryWithFallbackAsync<T>(Func<string, Task<T>> action)
     {
-        // Get healthy endpoints first (with caching to avoid excessive checks)
-        var healthyEndpoints = await GetHealthyEndpointsAsync();
-        
         // Start with the next URL in round-robin to distribute load
         var startIndex = 0;
         lock (_urlIndexLock)
@@ -161,21 +66,16 @@ public class RoundRobinFallbackHelper
             _currentUrlIndex = (_currentUrlIndex + 1) % _apiUrls.Count;
         }
         
-        // Try healthy endpoints first, then fall back to all if needed
-        var endpointsToTry = healthyEndpoints.Count < _apiUrls.Count 
-            ? healthyEndpoints.Concat(_apiUrls.Except(healthyEndpoints)).ToList()
-            : healthyEndpoints;
-        
         // Try all URLs starting from the round-robin selected one
-        for (int attempt = 0; attempt < endpointsToTry.Count; attempt++)
+        for (int attempt = 0; attempt < _apiUrls.Count; attempt++)
         {
-            var urlIndex = (startIndex + attempt) % endpointsToTry.Count;
+            var urlIndex = (startIndex + attempt) % _apiUrls.Count;
-            var baseUrl = endpointsToTry[urlIndex];
+            var baseUrl = _apiUrls[urlIndex];
             
             try
             {
                 _logger.LogDebug("Trying {Service} endpoint {Endpoint} (attempt {Attempt}/{Total})", 
-                    _serviceName, baseUrl, attempt + 1, endpointsToTry.Count);
+                    _serviceName, baseUrl, attempt + 1, _apiUrls.Count);
                 return await action(baseUrl);
             }
             catch (Exception ex)
@@ -183,15 +83,9 @@ public class RoundRobinFallbackHelper
                 _logger.LogWarning(ex, "{Service} request failed with endpoint {Endpoint}, trying next...", 
                     _serviceName, baseUrl);
                 
-                // Mark as unhealthy in cache
+                if (attempt == _apiUrls.Count - 1)
-                lock (_healthCacheLock)
                 {
-                    _healthCache[baseUrl] = (false, DateTime.UtcNow);
+                    _logger.LogError("All {Count} {Service} endpoints failed", _apiUrls.Count, _serviceName);
-                }
-                
-                if (attempt == endpointsToTry.Count - 1)
-                {
-                    _logger.LogError("All {Count} {Service} endpoints failed", endpointsToTry.Count, _serviceName);
                     throw;
                 }
             }
@@ -256,14 +150,10 @@ public class RoundRobinFallbackHelper
 
     /// <summary>
     /// Tries the request with the next provider in round-robin, then falls back to others on failure.
-    /// Performs quick health checks first to avoid wasting time on dead endpoints.
     /// Returns default value if all endpoints fail (does not throw).
     /// </summary>
     public async Task<T> TryWithFallbackAsync<T>(Func<string, Task<T>> action, T defaultValue)
     {
-        // Get healthy endpoints first (with caching to avoid excessive checks)
-        var healthyEndpoints = await GetHealthyEndpointsAsync();
-        
         // Start with the next URL in round-robin to distribute load
         var startIndex = 0;
         lock (_urlIndexLock)
@@ -272,21 +162,16 @@ public class RoundRobinFallbackHelper
             _currentUrlIndex = (_currentUrlIndex + 1) % _apiUrls.Count;
         }
         
-        // Try healthy endpoints first, then fall back to all if needed
-        var endpointsToTry = healthyEndpoints.Count < _apiUrls.Count 
-            ? healthyEndpoints.Concat(_apiUrls.Except(healthyEndpoints)).ToList()
-            : healthyEndpoints;
-        
         // Try all URLs starting from the round-robin selected one
-        for (int attempt = 0; attempt < endpointsToTry.Count; attempt++)
+        for (int attempt = 0; attempt < _apiUrls.Count; attempt++)
         {
-            var urlIndex = (startIndex + attempt) % endpointsToTry.Count;
+            var urlIndex = (startIndex + attempt) % _apiUrls.Count;
-            var baseUrl = endpointsToTry[urlIndex];
+            var baseUrl = _apiUrls[urlIndex];
             
             try
             {
                 _logger.LogDebug("Trying {Service} endpoint {Endpoint} (attempt {Attempt}/{Total})", 
-                    _serviceName, baseUrl, attempt + 1, endpointsToTry.Count);
+                    _serviceName, baseUrl, attempt + 1, _apiUrls.Count);
                 return await action(baseUrl);
             }
             catch (Exception ex)
@@ -294,16 +179,10 @@ public class RoundRobinFallbackHelper
                 _logger.LogWarning(ex, "{Service} request failed with endpoint {Endpoint}, trying next...", 
                     _serviceName, baseUrl);
                 
-                // Mark as unhealthy in cache
+                if (attempt == _apiUrls.Count - 1)
-                lock (_healthCacheLock)
-                {
-                    _healthCache[baseUrl] = (false, DateTime.UtcNow);
-                }
-                
-                if (attempt == endpointsToTry.Count - 1)
                 {
                     _logger.LogError("All {Count} {Service} endpoints failed, returning default value", 
-                        endpointsToTry.Count, _serviceName);
+                        _apiUrls.Count, _serviceName);
                     return defaultValue;
                 }
             }

allstarr/Services/Deezer/DeezerDownloadService.cs

@@ -107,10 +107,10 @@ public class DeezerDownloadService : BaseDownloadService
 
         // Build organized folder structure: Artist/Album/Track using AlbumArtist (fallback to Artist for singles)
         var artistForPath = song.AlbumArtist ?? song.Artist;
-        // Cache mode uses downloads/cache/ folder, Permanent mode uses downloads/permanent/
+        // Cache mode uses cache/Music folder (cleaned up after 24h), Permanent mode uses downloads folder
         var basePath = SubsonicSettings.StorageMode == StorageMode.Cache 
-            ? Path.Combine("downloads", "cache")
+            ? Path.Combine("cache", "Music")
-            : Path.Combine("downloads", "permanent");
+            : "downloads";
         var outputPath = PathHelper.BuildTrackPath(basePath, artistForPath, song.Album, song.Title, song.Track, extension);
         
         // Create directories if they don't exist

allstarr/Services/Jellyfin/JellyfinProxyService.cs

@@ -168,11 +168,6 @@ public class JellyfinProxyService
                                                               (h.Value.ToString().Contains("image", StringComparison.OrdinalIgnoreCase) ||
                                                                h.Value.ToString().Contains("document", StringComparison.OrdinalIgnoreCase))) == true);
         
-        // Check if this is a public endpoint that doesn't require authentication
-        bool isPublicEndpoint = url.Contains("/System/Info/Public", StringComparison.OrdinalIgnoreCase) ||
-                               url.Contains("/Branding/", StringComparison.OrdinalIgnoreCase) ||
-                               url.Contains("/Startup/", StringComparison.OrdinalIgnoreCase);
-        
         // Forward authentication headers from client if provided
         if (clientHeaders != null && clientHeaders.Count > 0)
         {
@@ -184,27 +179,11 @@ public class JellyfinProxyService
                     var headerValue = header.Value.ToString();
                     request.Headers.TryAddWithoutValidation("X-Emby-Authorization", headerValue);
                     authHeaderAdded = true;
-                    _logger.LogTrace("Forwarded X-Emby-Authorization header");
+                    _logger.LogInformation("✓ Forwarded X-Emby-Authorization: {Value}", headerValue);
                     break;
                 }
             }
             
-            // Try X-Emby-Token (simpler format used by some clients)
-            if (!authHeaderAdded)
-            {
-                foreach (var header in clientHeaders)
-                {
-                    if (header.Key.Equals("X-Emby-Token", StringComparison.OrdinalIgnoreCase))
-                    {
-                        var headerValue = header.Value.ToString();
-                        request.Headers.TryAddWithoutValidation("X-Emby-Token", headerValue);
-                        authHeaderAdded = true;
-                        _logger.LogTrace("Forwarded X-Emby-Token header");
-                        break;
-                    }
-                }
-            }
-            
             // If no X-Emby-Authorization, check if Authorization header contains MediaBrowser format
             // Some clients send it as "Authorization" instead of "X-Emby-Authorization"
             if (!authHeaderAdded)
@@ -222,32 +201,37 @@ public class JellyfinProxyService
                             // Forward as X-Emby-Authorization (Jellyfin's expected header)
                             request.Headers.TryAddWithoutValidation("X-Emby-Authorization", headerValue);
                             authHeaderAdded = true;
-                            _logger.LogTrace("Converted Authorization to X-Emby-Authorization");
+                            _logger.LogInformation("✓ Converted Authorization to X-Emby-Authorization: {Value}", headerValue);
                         }
                         else
                         {
                             // Standard Bearer token - forward as-is
                             request.Headers.TryAddWithoutValidation("Authorization", headerValue);
                             authHeaderAdded = true;
-                            _logger.LogTrace("Forwarded Authorization header");
+                            _logger.LogInformation("✓ Forwarded Authorization (Bearer): {Value}", headerValue);
                         }
                         break;
                     }
                 }
             }
             
-            // Check for api_key query parameter (some clients use this)
+            // Only log warnings for non-browser static requests
-            if (!authHeaderAdded && url.Contains("api_key=", StringComparison.OrdinalIgnoreCase))
+            if (!authHeaderAdded && !isBrowserStaticRequest)
             {
-                authHeaderAdded = true; // It's in the URL, no need to add header
+                _logger.LogWarning("✗ No auth header found. Available headers: {Headers}", 
-                _logger.LogTrace("Using api_key from query string");
+                    string.Join(", ", clientHeaders.Select(h => $"{h.Key}={h.Value}")));
             }
         }
-        
+        else if (!isBrowserStaticRequest)
-        // Only log warnings for non-public, non-browser requests without auth
-        if (!authHeaderAdded && !isBrowserStaticRequest && !isPublicEndpoint)
         {
-            _logger.LogDebug("No client auth provided for {Url} - Jellyfin will handle authentication", url);
+            _logger.LogWarning("✗ No client headers provided for {Url}", url);
+        }
+        
+        // DO NOT use server API key as fallback - let Jellyfin handle unauthenticated requests
+        // If client doesn't provide auth, they get what they deserve (401 from Jellyfin)
+        if (!authHeaderAdded && !isBrowserStaticRequest)
+        {
+            _logger.LogInformation("No client auth provided for {Url} - forwarding without auth", url);
         }
         
         request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
@@ -264,28 +248,14 @@ public class JellyfinProxyService
         {
             if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
             {
-                // 401 means token expired or invalid - client needs to re-authenticate
+                _logger.LogWarning("Jellyfin returned 401 Unauthorized for {Url} - passing through to client", url);
-                _logger.LogInformation("Jellyfin returned 401 Unauthorized for {Url} - client should re-authenticate", url);
             }
-            else if (!isBrowserStaticRequest && !isPublicEndpoint)
+            else if (!isBrowserStaticRequest) // Don't log 404s for browser static requests
             {
                 _logger.LogWarning("Jellyfin request failed: {StatusCode} for {Url}", response.StatusCode, url);
             }
             
-            // Try to parse error response to pass through to client
+            // Return null body with the actual status code
-            if (!string.IsNullOrWhiteSpace(content))
-            {
-                try
-                {
-                    var errorDoc = JsonDocument.Parse(content);
-                    return (errorDoc, statusCode);
-                }
-                catch
-                {
-                    // Not valid JSON, return null
-                }
-            }
-            
             return (null, statusCode);
         }
 
@@ -327,10 +297,8 @@ public class JellyfinProxyService
         request.Content = new StringContent(bodyToSend, System.Text.Encoding.UTF8, "application/json");
         
         bool authHeaderAdded = false;
-        bool isAuthEndpoint = endpoint.Contains("Authenticate", StringComparison.OrdinalIgnoreCase);
         
         // Forward authentication headers from client (case-insensitive)
-        // Try X-Emby-Authorization first
         foreach (var header in clientHeaders)
         {
             if (header.Key.Equals("X-Emby-Authorization", StringComparison.OrdinalIgnoreCase))
@@ -338,28 +306,11 @@ public class JellyfinProxyService
                 var headerValue = header.Value.ToString();
                 request.Headers.TryAddWithoutValidation("X-Emby-Authorization", headerValue);
                 authHeaderAdded = true;
-                _logger.LogTrace("Forwarded X-Emby-Authorization header");
+                _logger.LogDebug("Forwarded X-Emby-Authorization from client");
                 break;
             }
         }
         
-        // Try X-Emby-Token
-        if (!authHeaderAdded)
-        {
-            foreach (var header in clientHeaders)
-            {
-                if (header.Key.Equals("X-Emby-Token", StringComparison.OrdinalIgnoreCase))
-                {
-                    var headerValue = header.Value.ToString();
-                    request.Headers.TryAddWithoutValidation("X-Emby-Token", headerValue);
-                    authHeaderAdded = true;
-                    _logger.LogTrace("Forwarded X-Emby-Token header");
-                    break;
-                }
-            }
-        }
-        
-        // Try Authorization header
         if (!authHeaderAdded)
         {
             foreach (var header in clientHeaders)
@@ -374,13 +325,13 @@ public class JellyfinProxyService
                     {
                         // Forward as X-Emby-Authorization
                         request.Headers.TryAddWithoutValidation("X-Emby-Authorization", headerValue);
-                        _logger.LogTrace("Converted Authorization to X-Emby-Authorization");
+                        _logger.LogDebug("Converted Authorization to X-Emby-Authorization");
                     }
                     else
                     {
                         // Standard Bearer token
                         request.Headers.TryAddWithoutValidation("Authorization", headerValue);
-                        _logger.LogTrace("Forwarded Authorization header");
+                        _logger.LogDebug("Forwarded Authorization header");
                     }
                     authHeaderAdded = true;
                     break;
@@ -388,23 +339,30 @@ public class JellyfinProxyService
             }
         }
         
-        // For authentication endpoints, credentials are in the body, not headers
+        // DO NOT use server credentials as fallback
-        // For other endpoints without auth, let Jellyfin reject the request
+        // Exception: For auth endpoints, client provides their own credentials in the body
-        if (!authHeaderAdded && !isAuthEndpoint)
+        // For all other endpoints, if client doesn't provide auth, let Jellyfin reject it
+        if (!authHeaderAdded)
         {
-            _logger.LogDebug("No client auth provided for POST {Url} - Jellyfin will handle authentication", url);
+            _logger.LogInformation("No client auth provided for POST {Url} - forwarding without auth", url);
         }
         
         request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
 
         // DO NOT log the body for auth endpoints - it contains passwords!
-        if (isAuthEndpoint)
+        if (endpoint.Contains("Authenticate", StringComparison.OrdinalIgnoreCase))
         {
             _logger.LogDebug("POST to Jellyfin: {Url} (auth request - body not logged)", url);
         }
         else
         {
-            _logger.LogTrace("POST to Jellyfin: {Url}, body length: {Length} bytes", url, bodyToSend.Length);
+            _logger.LogInformation("POST to Jellyfin: {Url}, body length: {Length} bytes", url, bodyToSend.Length);
+            
+            // Log body content for playback endpoints to debug
+            if (endpoint.Contains("Playing", StringComparison.OrdinalIgnoreCase))
+            {
+                _logger.LogInformation("Sending body to Jellyfin: {Body}", bodyToSend);
+            }
         }
         
         var response = await _httpClient.SendAsync(request);
@@ -414,17 +372,8 @@ public class JellyfinProxyService
         if (!response.IsSuccessStatusCode)
         {
             var errorContent = await response.Content.ReadAsStringAsync();
-            
+            _logger.LogWarning("❌ SESSION: Jellyfin POST request failed: {StatusCode} for {Url}. Response: {Response}", 
-            // 401 is expected when tokens expire - don't spam logs
+                response.StatusCode, url, errorContent);
-            if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
-            {
-                _logger.LogInformation("Jellyfin POST returned 401 for {Url} - client should re-authenticate", url);
-            }
-            else
-            {
-                _logger.LogWarning("Jellyfin POST request failed: {StatusCode} for {Url}. Response: {Response}", 
-                    response.StatusCode, url, errorContent.Length > 200 ? errorContent[..200] + "..." : errorContent);
-            }
             
             // Try to parse error response as JSON to pass through to client
             if (!string.IsNullOrWhiteSpace(errorContent))
@@ -446,7 +395,7 @@ public class JellyfinProxyService
         // Log successful session-related responses
         if (endpoint.Contains("Sessions", StringComparison.OrdinalIgnoreCase))
         {
-            _logger.LogTrace("Jellyfin responded {StatusCode} for {Endpoint}", statusCode, endpoint);
+            _logger.LogWarning("✓ SESSION: Jellyfin responded {StatusCode} for {Endpoint}", statusCode, endpoint);
         }
 
         // Handle 204 No Content responses (e.g., /sessions/playing, /sessions/playing/progress)
@@ -463,6 +412,13 @@ public class JellyfinProxyService
             return (null, statusCode);
         }
         
+        // Log response content for session endpoints
+        if (endpoint.Contains("Sessions", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(responseContent))
+        {
+            var preview = responseContent.Length > 200 ? responseContent[..200] + "..." : responseContent;
+            _logger.LogWarning("📥 SESSION: Jellyfin response body: {Body}", preview);
+        }
+        
         return (JsonDocument.Parse(responseContent), statusCode);
     }
 

allstarr/Services/Jellyfin/JellyfinSessionManager.cs

@@ -38,13 +38,12 @@ public class JellyfinSessionManager : IDisposable
 
     /// <summary>
     /// Ensures a session exists for the given device. Creates one if needed.
-    /// Returns false if token is expired (401), indicating client needs to re-authenticate.
     /// </summary>
     public async Task<bool> EnsureSessionAsync(string deviceId, string client, string device, string version, IHeaderDictionary headers)
     {
         if (string.IsNullOrEmpty(deviceId))
         {
-            _logger.LogWarning("Cannot create session - no device ID");
+            _logger.LogWarning("⚠️ SESSION: Cannot create session - no device ID");
             return false;
         }
 
@@ -52,37 +51,25 @@ public class JellyfinSessionManager : IDisposable
         if (_sessions.TryGetValue(deviceId, out var existingSession))
         {
             existingSession.LastActivity = DateTime.UtcNow;
-            _logger.LogTrace("Session already exists for device {DeviceId}", deviceId);
+            _logger.LogDebug("✓ SESSION: Session already exists for device {DeviceId}", deviceId);
             
             // Refresh capabilities to keep session alive
-            // If this returns false (401), the token expired and client needs to re-auth
+            await PostCapabilitiesAsync(headers);
-            var success = await PostCapabilitiesAsync(headers);
-            if (!success)
-            {
-                // Token expired - remove the stale session
-                _logger.LogInformation("Token expired for device {DeviceId} - removing session", deviceId);
-                await RemoveSessionAsync(deviceId);
-                return false;
-            }
-            
             return true;
         }
 
-        _logger.LogDebug("Creating new session for device: {DeviceId} ({Client} on {Device})", deviceId, client, device);
+        _logger.LogInformation("🔧 SESSION: Creating new session for device: {DeviceId} ({Client} on {Device})", deviceId, client, device);
+        
+        // Log the headers we received for debugging
+        _logger.LogDebug("🔍 SESSION: Headers received for session creation: {Headers}", 
+            string.Join(", ", headers.Select(h => $"{h.Key}={h.Value.ToString().Substring(0, Math.Min(30, h.Value.ToString().Length))}...")));
 
         try
         {
             // Post session capabilities to Jellyfin - this creates the session
-            var success = await PostCapabilitiesAsync(headers);
+            await PostCapabilitiesAsync(headers);
-            
-            if (!success)
-            {
-                // Token expired or invalid - client needs to re-authenticate
-                _logger.LogInformation("Failed to create session for {DeviceId} - token may be expired", deviceId);
-                return false;
-            }
 
-            _logger.LogDebug("Session created for {DeviceId}", deviceId);
+            _logger.LogInformation("✓ SESSION: Session created for {DeviceId}", deviceId);
 
             // Track this session
             _sessions[deviceId] = new SessionInfo
@@ -102,16 +89,15 @@ public class JellyfinSessionManager : IDisposable
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Error creating session for {DeviceId}", deviceId);
+            _logger.LogError(ex, "❌ SESSION: Error creating session for {DeviceId}", deviceId);
             return false;
         }
     }
 
     /// <summary>
     /// Posts session capabilities to Jellyfin.
-    /// Returns true if successful, false if token expired (401).
     /// </summary>
-    private async Task<bool> PostCapabilitiesAsync(IHeaderDictionary headers)
+    private async Task PostCapabilitiesAsync(IHeaderDictionary headers)
     {
         var capabilities = new
         {
@@ -132,19 +118,12 @@ public class JellyfinSessionManager : IDisposable
 
         if (statusCode == 204 || statusCode == 200)
         {
-            _logger.LogTrace("Posted capabilities successfully ({StatusCode})", statusCode);
+            _logger.LogDebug("✓ SESSION: Posted capabilities successfully ({StatusCode})", statusCode);
-            return true;
-        }
-        else if (statusCode == 401)
-        {
-            // Token expired - this is expected, client needs to re-authenticate
-            _logger.LogDebug("Capabilities returned 401 (token expired) - client should re-authenticate");
-            return false;
         }
         else
         {
-            _logger.LogDebug("Capabilities post returned {StatusCode}", statusCode);
+            // 401 is common when cached headers have expired - not a critical error
-            return false;
+            _logger.LogDebug("SESSION: Capabilities post returned {StatusCode} (may be expected if token expired)", statusCode);
         }
     }
 
@@ -199,7 +178,7 @@ public class JellyfinSessionManager : IDisposable
                 if (_sessions.TryGetValue(deviceId, out var currentSession) && 
                     currentSession.LastActivity <= markedTime)
                 {
-                    _logger.LogDebug("🧹 SESSION: Auto-removing inactive session {DeviceId} after playback stop", deviceId);
+                    _logger.LogInformation("🧹 SESSION: Auto-removing inactive session {DeviceId} after playback stop", deviceId);
                     await RemoveSessionAsync(deviceId);
                 }
                 else
@@ -244,7 +223,7 @@ public class JellyfinSessionManager : IDisposable
     {
         if (_sessions.TryRemove(deviceId, out var session))
         {
-            _logger.LogDebug("🗑️ SESSION: Removing session for device {DeviceId}", deviceId);
+            _logger.LogInformation("🗑️ SESSION: Removing session for device {DeviceId}", deviceId);
 
             // Close WebSocket if it exists
             if (session.WebSocket != null && session.WebSocket.State == WebSocketState.Open)
@@ -256,7 +235,7 @@ public class JellyfinSessionManager : IDisposable
                 }
                 catch (Exception ex)
                 {
-                    _logger.LogDebug(ex, "WEBSOCKET: Error closing WebSocket for {DeviceId}", deviceId);
+                    _logger.LogWarning(ex, "⚠️ WEBSOCKET: Error closing WebSocket for {DeviceId}", deviceId);
                 }
                 finally
                 {
@@ -276,7 +255,7 @@ public class JellyfinSessionManager : IDisposable
                     };
                     var stopJson = JsonSerializer.Serialize(stopPayload);
                     await _proxyService.PostJsonAsync("Sessions/Playing/Stopped", stopJson, session.Headers);
-                    _logger.LogDebug("🛑 SESSION: Reported playback stopped for {DeviceId} (ItemId: {ItemId}, Position: {Position})", 
+                    _logger.LogInformation("🛑 SESSION: Reported playback stopped for {DeviceId} (ItemId: {ItemId}, Position: {Position})", 
                         deviceId, session.LastPlayingItemId, session.LastPlayingPositionTicks);
                 }
                 
@@ -360,11 +339,11 @@ public class JellyfinSessionManager : IDisposable
                 if (!string.IsNullOrEmpty(_settings.ApiKey))
                 {
                     jellyfinWsUrl += $"?api_key={_settings.ApiKey}";
-                    _logger.LogDebug("WEBSOCKET: No client auth found in headers, falling back to server API key for {DeviceId}", deviceId);
+                    _logger.LogWarning("⚠️ WEBSOCKET: No client auth found in headers, falling back to server API key for {DeviceId}", deviceId);
                 }
                 else
                 {
-                    _logger.LogWarning("❌ WEBSOCKET: No authentication available for {DeviceId} - WebSocket will fail", deviceId);
+                    _logger.LogWarning("❌ WEBSOCKET: No authentication available for {DeviceId}!", deviceId);
                 }
             }
 
@@ -375,7 +354,7 @@ public class JellyfinSessionManager : IDisposable
 
             // Connect to Jellyfin
             await webSocket.ConnectAsync(new Uri(jellyfinWsUrl), CancellationToken.None);
-            _logger.LogDebug("✓ WEBSOCKET: Connected to Jellyfin for device {DeviceId}", deviceId);
+            _logger.LogInformation("✓ WEBSOCKET: Connected to Jellyfin for device {DeviceId}", deviceId);
 
             // CRITICAL: Send ForceKeepAlive message to initialize session in Jellyfin
             // This tells Jellyfin to create/show the session in the dashboard
@@ -431,8 +410,8 @@ public class JellyfinSessionManager : IDisposable
                             }
                             else
                             {
-                                // Log other message types at trace level
+                                // Log other message types at info level
-                                _logger.LogTrace("📥 WEBSOCKET: {DeviceId}: {Message}", 
+                                _logger.LogInformation("📥 WEBSOCKET: {DeviceId}: {Message}", 
                                     deviceId, message.Length > 100 ? message[..100] + "..." : message);
                             }
                         }
@@ -454,7 +433,7 @@ public class JellyfinSessionManager : IDisposable
                 }
                 catch (WebSocketException wsEx)
                 {
-                    _logger.LogDebug(wsEx, "WEBSOCKET: Connection closed for device {DeviceId}", deviceId);
+                    _logger.LogWarning(wsEx, "⚠️ WEBSOCKET: WebSocket error for device {DeviceId}", deviceId);
                     break;
                 }
             }
@@ -490,7 +469,6 @@ public class JellyfinSessionManager : IDisposable
     /// <summary>
     /// Periodically pings Jellyfin to keep sessions alive.
     /// Note: This is a backup mechanism. The WebSocket connection is the primary keep-alive.
-    /// Removes sessions with expired tokens (401 responses).
     /// </summary>
     private async void KeepSessionsAlive(object? state)
     {
@@ -502,43 +480,29 @@ public class JellyfinSessionManager : IDisposable
             return;
         }
 
-        _logger.LogTrace("Keeping {Count} sessions alive", activeSessions.Count);
+        _logger.LogDebug("💓 SESSION: Keeping {Count} sessions alive", activeSessions.Count);
-
-        var expiredSessions = new List<string>();
 
         foreach (var session in activeSessions)
         {
             try
             {
                 // Post capabilities again to keep session alive
-                // If this returns false (401), the token has expired
+                // Note: This may fail with 401 if the client's token has expired
-                var success = await PostCapabilitiesAsync(session.Headers);
+                // That's okay - the WebSocket connection keeps the session alive anyway
-                
+                await PostCapabilitiesAsync(session.Headers);
-                if (!success)
-                {
-                    _logger.LogInformation("Token expired for device {DeviceId} during keep-alive - marking for removal", session.DeviceId);
-                    expiredSessions.Add(session.DeviceId);
-                }
             }
             catch (Exception ex)
             {
-                _logger.LogDebug(ex, "Error keeping session alive for {DeviceId}", session.DeviceId);
+                _logger.LogDebug(ex, "SESSION: Error keeping session alive for {DeviceId} (WebSocket still active)", session.DeviceId);
             }
         }
 
-        // Remove sessions with expired tokens
-        foreach (var deviceId in expiredSessions)
-        {
-            _logger.LogInformation("Removing session with expired token: {DeviceId}", deviceId);
-            await RemoveSessionAsync(deviceId);
-        }
-
         // Clean up stale sessions after 3 minutes of inactivity
         // This balances cleaning up finished sessions with allowing brief pauses/network issues
         var staleSessions = _sessions.Where(kvp => now - kvp.Value.LastActivity > TimeSpan.FromMinutes(3)).ToList();
         foreach (var stale in staleSessions)
         {
-            _logger.LogDebug("Removing stale session for {DeviceId} (inactive for {Minutes:F1} minutes)", 
+            _logger.LogInformation("🧹 SESSION: Removing stale session for {DeviceId} (inactive for {Minutes:F1} minutes)", 
                 stale.Key, (now - stale.Value.LastActivity).TotalMinutes);
             await RemoveSessionAsync(stale.Key);
         }

allstarr/Services/Qobuz/QobuzDownloadService.cs

@@ -110,10 +110,10 @@ public class QobuzDownloadService : BaseDownloadService
 
         // Build organized folder structure using AlbumArtist (fallback to Artist for singles)
         var artistForPath = song.AlbumArtist ?? song.Artist;
-        // Cache mode uses downloads/cache/ folder, Permanent mode uses downloads/permanent/
+        // Cache mode uses cache/Music folder (cleaned up after 24h), Permanent mode uses downloads folder
         var basePath = SubsonicSettings.StorageMode == StorageMode.Cache 
-            ? Path.Combine(DownloadPath, "cache")
+            ? Path.Combine("cache", "Music")
-            : Path.Combine(DownloadPath, "permanent");
+            : "downloads";
         var outputPath = PathHelper.BuildTrackPath(basePath, artistForPath, song.Album, song.Title, song.Track, extension);
         
         var albumFolder = Path.GetDirectoryName(outputPath)!;

allstarr/Services/Spotify/SpotifyMissingTracksFetcher.cs

@@ -44,7 +44,7 @@ public class SpotifyMissingTracksFetcher : BackgroundService
     public async Task TriggerFetchAsync()
     {
         _logger.LogInformation("Manual fetch triggered");
-        await FetchMissingTracksAsync(CancellationToken.None);
+        await FetchMissingTracksAsync(CancellationToken.None, bypassSyncWindowCheck: true);
     }
 
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
@@ -84,7 +84,20 @@ public class SpotifyMissingTracksFetcher : BackgroundService
 
         _logger.LogInformation("Spotify Import ENABLED");
         _logger.LogInformation("Configured Playlists: {Count}", _spotifySettings.Value.Playlists.Count);
-        _logger.LogInformation("Background check interval: 5 minutes");
+        
+        // Log the search schedule
+        var settings = _spotifySettings.Value;
+        var syncTime = DateTime.Today
+            .AddHours(settings.SyncStartHour)
+            .AddMinutes(settings.SyncStartMinute);
+        var syncEndTime = syncTime.AddHours(settings.SyncWindowHours);
+        
+        _logger.LogInformation("Search Schedule:");
+        _logger.LogInformation("  Plugin sync time: {Time:HH:mm} UTC (configured)", syncTime);
+        _logger.LogInformation("  Search window: {Start:HH:mm} - {End:HH:mm} UTC ({Hours}h window)", 
+            syncTime, syncEndTime, settings.SyncWindowHours);
+        _logger.LogInformation("  Will search for new files once per day after sync window ends");
+        _logger.LogInformation("  Background check interval: 5 minutes");
         
         // Fetch playlist names from Jellyfin
         await LoadPlaylistNamesAsync();
@@ -96,7 +109,7 @@ public class SpotifyMissingTracksFetcher : BackgroundService
         }
         _logger.LogInformation("========================================");
 
-        // Run on startup if we don't have cache
+        // Check if we should run on startup
         if (!_hasRunOnce)
         {
             var shouldRun = await ShouldRunOnStartupAsync();
@@ -105,7 +118,7 @@ public class SpotifyMissingTracksFetcher : BackgroundService
                 _logger.LogInformation("Running initial fetch on startup");
                 try
                 {
-                    await FetchMissingTracksAsync(stoppingToken);
+                    await FetchMissingTracksAsync(stoppingToken, bypassSyncWindowCheck: true);
                     _hasRunOnce = true;
                 }
                 catch (Exception ex)
@@ -115,20 +128,21 @@ public class SpotifyMissingTracksFetcher : BackgroundService
             }
             else
             {
-                _logger.LogInformation("Skipping startup fetch - already have cached files");
+                _logger.LogInformation("Skipping startup fetch - already have current files");
                 _hasRunOnce = true;
             }
         }
 
-        // Background loop - check for new files every 5 minutes
         while (!stoppingToken.IsCancellationRequested)
         {
             try
             {
+                // Only fetch if we're past today's sync window AND we haven't fetched today yet
                 var shouldFetch = await ShouldFetchNowAsync();
                 if (shouldFetch)
                 {
                     await FetchMissingTracksAsync(stoppingToken);
+                    _hasRunOnce = true;
                 }
             }
             catch (Exception ex)
@@ -142,29 +156,42 @@ public class SpotifyMissingTracksFetcher : BackgroundService
 
     private async Task<bool> ShouldFetchNowAsync()
     {
-        // Check if we have recent cache files (within last 24 hours)
+        var settings = _spotifySettings.Value;
         var now = DateTime.UtcNow;
-        var cacheThreshold = now.AddHours(-24);
         
+        // Calculate today's sync window
+        var todaySync = now.Date
+            .AddHours(settings.SyncStartHour)
+            .AddMinutes(settings.SyncStartMinute);
+        var todaySyncEnd = todaySync.AddHours(settings.SyncWindowHours);
+        
+        // Only fetch if we're past today's sync window
+        if (now < todaySyncEnd)
+        {
+            return false;
+        }
+        
+        // Check if we already have today's files
         foreach (var playlistName in _playlistIdToName.Values)
         {
             var filePath = GetCacheFilePath(playlistName);
             
-            if (!File.Exists(filePath))
+            if (File.Exists(filePath))
             {
-                // Missing cache file for this playlist
+                var fileTime = File.GetLastWriteTimeUtc(filePath);
-                return true;
+                
+                // If file is from today's sync or later, we already have it
+                if (fileTime >= todaySync)
+                {
+                    continue;
+                }
             }
             
-            var fileTime = File.GetLastWriteTimeUtc(filePath);
+            // Missing today's file for this playlist
-            if (fileTime < cacheThreshold)
+            return true;
-            {
-                // Cache file is older than 24 hours
-                return true;
-            }
         }
         
-        // All playlists have recent cache files
+        // All playlists have today's files
         return false;
     }
 
@@ -183,43 +210,120 @@ public class SpotifyMissingTracksFetcher : BackgroundService
     {
         _logger.LogInformation("=== STARTUP CACHE CHECK ===");
         
-        var allPlaylistsHaveCache = true;
+        var settings = _spotifySettings.Value;
+        var now = DateTime.UtcNow;
         
-        foreach (var playlistName in _playlistIdToName.Values)
+        // Calculate today's sync window
+        var todaySync = now.Date
+            .AddHours(settings.SyncStartHour)
+            .AddMinutes(settings.SyncStartMinute);
+        var todaySyncEnd = todaySync.AddHours(settings.SyncWindowHours);
+        
+        _logger.LogInformation("Today's sync window: {Start:yyyy-MM-dd HH:mm} - {End:yyyy-MM-dd HH:mm} UTC", 
+            todaySync, todaySyncEnd);
+        _logger.LogInformation("Current time: {Now:yyyy-MM-dd HH:mm} UTC", now);
+        
+        // If we're still before today's sync window end, we should have yesterday's or today's file
+        // Don't search again until after today's sync window ends
+        if (now < todaySyncEnd)
         {
-            var filePath = GetCacheFilePath(playlistName);
+            _logger.LogInformation("We're before today's sync window end - checking if we have recent cache...");
-            var cacheKey = $"spotify:missing:{playlistName}";
             
-            // Check file cache
+            var allPlaylistsHaveCache = true;
-            if (File.Exists(filePath))
+            
+            foreach (var playlistName in _playlistIdToName.Values)
             {
-                var fileAge = DateTime.UtcNow - File.GetLastWriteTimeUtc(filePath);
+                var filePath = GetCacheFilePath(playlistName);
-                _logger.LogInformation("  {Playlist}: Found file cache (age: {Age:F1}h)", playlistName, fileAge.TotalHours);
+                var cacheKey = $"spotify:missing:{playlistName}";
                 
-                // Load into Redis if not already there
+                // Check file cache
-                if (!await _cache.ExistsAsync(cacheKey))
+                if (File.Exists(filePath))
                 {
-                    await LoadFromFileCache(playlistName);
+                    var fileAge = DateTime.UtcNow - File.GetLastWriteTimeUtc(filePath);
+                    _logger.LogInformation("  {Playlist}: Found file cache (age: {Age:F1}h)", playlistName, fileAge.TotalHours);
+                    
+                    // Load into Redis if not already there
+                    if (!await _cache.ExistsAsync(cacheKey))
+                    {
+                        await LoadFromFileCache(playlistName);
+                    }
+                    continue;
                 }
-                continue;
+                
+                // Check Redis cache
+                if (await _cache.ExistsAsync(cacheKey))
+                {
+                    _logger.LogInformation("  {Playlist}: Found in Redis cache", playlistName);
+                    continue;
+                }
+                
+                // No cache found for this playlist
+                _logger.LogInformation("  {Playlist}: No cache found", playlistName);
+                allPlaylistsHaveCache = false;
             }
             
-            // Check Redis cache
+            if (allPlaylistsHaveCache)
-            if (await _cache.ExistsAsync(cacheKey))
             {
-                _logger.LogInformation("  {Playlist}: Found in Redis cache", playlistName);
+                _logger.LogInformation("=== ALL PLAYLISTS HAVE CACHE - SKIPPING STARTUP FETCH ===");
-                continue;
+                _logger.LogInformation("Will search again after {Time:yyyy-MM-dd HH:mm} UTC", todaySyncEnd);
+                return false;
             }
-            
-            // No cache found for this playlist
-            _logger.LogInformation("  {Playlist}: No cache found", playlistName);
-            allPlaylistsHaveCache = false;
         }
         
-        if (allPlaylistsHaveCache)
+        // If we're after today's sync window end, check if we already have today's file
+        if (now >= todaySyncEnd)
         {
-            _logger.LogInformation("=== ALL PLAYLISTS HAVE CACHE - SKIPPING STARTUP FETCH ===");
+            _logger.LogInformation("We're after today's sync window end - checking if we already fetched today's files...");
-            return false;
+            
+            var allPlaylistsHaveTodaysFile = true;
+            
+            foreach (var playlistName in _playlistIdToName.Values)
+            {
+                var filePath = GetCacheFilePath(playlistName);
+                var cacheKey = $"spotify:missing:{playlistName}";
+                
+                // Check if file exists and was created today (after sync start)
+                if (File.Exists(filePath))
+                {
+                    var fileTime = File.GetLastWriteTimeUtc(filePath);
+                    
+                    // File should be from today's sync window or later
+                    if (fileTime >= todaySync)
+                    {
+                        var fileAge = DateTime.UtcNow - fileTime;
+                        _logger.LogInformation("  {Playlist}: Have today's file (created {Time:yyyy-MM-dd HH:mm}, age: {Age:F1}h)", 
+                            playlistName, fileTime, fileAge.TotalHours);
+                        
+                        // Load into Redis if not already there
+                        if (!await _cache.ExistsAsync(cacheKey))
+                        {
+                            await LoadFromFileCache(playlistName);
+                        }
+                        continue;
+                    }
+                    else
+                    {
+                        _logger.LogInformation("  {Playlist}: File is old (from {Time:yyyy-MM-dd HH:mm}, before today's sync)", 
+                            playlistName, fileTime);
+                    }
+                }
+                else
+                {
+                    _logger.LogInformation("  {Playlist}: No file found", playlistName);
+                }
+                
+                allPlaylistsHaveTodaysFile = false;
+            }
+            
+            if (allPlaylistsHaveTodaysFile)
+            {
+                _logger.LogInformation("=== ALL PLAYLISTS HAVE TODAY'S FILES - SKIPPING STARTUP FETCH ===");
+                
+                // Calculate when to search next (tomorrow after sync window)
+                var tomorrowSyncEnd = todaySyncEnd.AddDays(1);
+                _logger.LogInformation("Will search again after {Time:yyyy-MM-dd HH:mm} UTC", tomorrowSyncEnd);
+                return false;
+            }
         }
         
         _logger.LogInformation("=== WILL FETCH ON STARTUP ===");
@@ -276,9 +380,32 @@ public class SpotifyMissingTracksFetcher : BackgroundService
         }
     }
 
-    private async Task FetchMissingTracksAsync(CancellationToken cancellationToken)
+    private async Task FetchMissingTracksAsync(CancellationToken cancellationToken, bool bypassSyncWindowCheck = false)
     {
-        _logger.LogInformation("=== FETCHING MISSING TRACKS ===");
+        var settings = _spotifySettings.Value;
+        var now = DateTime.UtcNow;
+        var syncStart = now.Date
+            .AddHours(settings.SyncStartHour)
+            .AddMinutes(settings.SyncStartMinute);
+        var syncEnd = syncStart.AddHours(settings.SyncWindowHours);
+
+        // Only run after the sync window has passed (unless bypassing for startup)
+        if (!bypassSyncWindowCheck && now < syncEnd)
+        {
+            _logger.LogInformation("Skipping fetch - sync window not passed yet (now: {Now}, window ends: {End})", 
+                now, syncEnd);
+            return;
+        }
+
+        if (bypassSyncWindowCheck)
+        {
+            _logger.LogInformation("=== FETCHING MISSING TRACKS (STARTUP MODE) ===");
+        }
+        else
+        {
+            _logger.LogInformation("=== FETCHING MISSING TRACKS (SYNC WINDOW PASSED) ===");
+        }
+
         _logger.LogInformation("Processing {Count} playlists", _playlistIdToName.Count);
         
         // Track when we find files to optimize search for other playlists

allstarr/Services/SquidWTF/SquidWTFDownloadService.cs

@@ -7,7 +7,6 @@ using allstarr.Models.Search;
 using allstarr.Models.Subsonic;
 using allstarr.Services.Local;
 using allstarr.Services.Common;
-using allstarr.Services.Lyrics;
 using Microsoft.Extensions.Options;
 using IOFile = System.IO.File;
 using Microsoft.Extensions.Logging;
@@ -56,7 +55,6 @@ public class SquidWTFDownloadService : BaseDownloadService
     private readonly SquidWTFSettings _squidwtfSettings;
     private readonly OdesliService _odesliService;
     private readonly RoundRobinFallbackHelper _fallbackHelper;
-    private readonly IServiceProvider _serviceProvider;
 
     protected override string ProviderName => "squidwtf";
 
@@ -77,10 +75,6 @@ public class SquidWTFDownloadService : BaseDownloadService
         _squidwtfSettings = SquidWTFSettings.Value;
         _odesliService = odesliService;
         _fallbackHelper = new RoundRobinFallbackHelper(apiUrls, logger, "SquidWTF");
-        _serviceProvider = serviceProvider;
-        
-        // Increase timeout for large downloads and slow endpoints
-        _httpClient.Timeout = TimeSpan.FromMinutes(5);
     }
     
 	
@@ -114,6 +108,9 @@ public class SquidWTFDownloadService : BaseDownloadService
         Logger.LogInformation("Track download URL obtained from hifi-api: {Url}", downloadInfo.DownloadUrl);
         Logger.LogInformation("Using format: {Format} (Quality: {Quality})", downloadInfo.MimeType, downloadInfo.AudioQuality);
 
+        // Start Spotify ID conversion in parallel with download (don't await yet)
+        var spotifyIdTask = _odesliService.ConvertTidalToSpotifyIdAsync(trackId, cancellationToken);
+
         // Determine extension from MIME type
         var extension = downloadInfo.MimeType?.ToLower() switch
         {
@@ -125,10 +122,10 @@ public class SquidWTFDownloadService : BaseDownloadService
 		
         // Build organized folder structure: Artist/Album/Track using AlbumArtist (fallback to Artist for singles)
         var artistForPath = song.AlbumArtist ?? song.Artist;
-        // Cache mode uses downloads/cache/ folder, Permanent mode uses downloads/permanent/
+        // Cache mode uses cache/Music folder (cleaned up after 24h), Permanent mode uses downloads folder
         var basePath = SubsonicSettings.StorageMode == StorageMode.Cache 
-            ? Path.Combine("downloads", "cache")
+            ? Path.Combine("cache", "Music")
-            : Path.Combine("downloads", "permanent");
+            : "downloads";
         var outputPath = PathHelper.BuildTrackPath(basePath, artistForPath, song.Album, song.Title, song.Track, extension);
         
         // Create directories if they don't exist
@@ -202,26 +199,14 @@ public class SquidWTFDownloadService : BaseDownloadService
         // Close file before writing metadata
         await outputFile.DisposeAsync();
         
-		// Start Spotify ID conversion in background (for lyrics support)
+		// Wait for Spotify ID conversion to complete and update song metadata
-		// This doesn't block streaming - lyrics endpoint will fetch it on-demand if needed
+		var spotifyId = await spotifyIdTask;
-		_ = Task.Run(async () =>
+		if (!string.IsNullOrEmpty(spotifyId))
 		{
-			try
+			song.SpotifyId = spotifyId;
-			{
+		}
-				var spotifyId = await _odesliService.ConvertTidalToSpotifyIdAsync(trackId, CancellationToken.None);
-				if (!string.IsNullOrEmpty(spotifyId))
-				{
-					Logger.LogDebug("Background Spotify ID obtained for Tidal/{TrackId}: {SpotifyId}", trackId, spotifyId);
-					// Spotify ID is cached by Odesli service for future lyrics requests
-				}
-			}
-			catch (Exception ex)
-			{
-				Logger.LogDebug(ex, "Background Spotify ID conversion failed for Tidal/{TrackId}", trackId);
-			}
-		});
 
-        // Write metadata and cover art (without Spotify ID - it's only needed for lyrics)
+        // Write metadata and cover art
         await WriteMetadataAsync(outputPath, song, cancellationToken);
 
         return outputPath;
@@ -314,53 +299,6 @@ public class SquidWTFDownloadService : BaseDownloadService
 	
     #region Utility Methods
 
-    /// <summary>
-    /// Converts Tidal track ID to Spotify ID for lyrics support.
-    /// Called in background after streaming starts.
-    /// Also prefetches lyrics immediately after conversion.
-    /// </summary>
-    protected override async Task ConvertToSpotifyIdAsync(string externalProvider, string externalId)
-    {
-        if (externalProvider != "squidwtf")
-        {
-            return;
-        }
-
-        var spotifyId = await _odesliService.ConvertTidalToSpotifyIdAsync(externalId, CancellationToken.None);
-        if (!string.IsNullOrEmpty(spotifyId))
-        {
-            Logger.LogDebug("Background Spotify ID obtained for Tidal/{TrackId}: {SpotifyId}", externalId, spotifyId);
-            
-            // Immediately prefetch lyrics now that we have the Spotify ID
-            // This ensures lyrics are cached and ready when the client requests them
-            _ = Task.Run(async () =>
-            {
-                try
-                {
-                    using var scope = _serviceProvider.CreateScope();
-                    var spotifyLyricsService = scope.ServiceProvider.GetService<SpotifyLyricsService>();
-                    
-                    if (spotifyLyricsService != null)
-                    {
-                        var lyrics = await spotifyLyricsService.GetLyricsByTrackIdAsync(spotifyId);
-                        if (lyrics != null && lyrics.Lines.Count > 0)
-                        {
-                            Logger.LogDebug("Background lyrics prefetched for Spotify/{SpotifyId}: {LineCount} lines", 
-                                spotifyId, lyrics.Lines.Count);
-                        }
-                        else
-                        {
-                            Logger.LogDebug("No lyrics available for Spotify/{SpotifyId}", spotifyId);
-                        }
-                    }
-                }
-                catch (Exception ex)
-                {
-                    Logger.LogDebug(ex, "Background lyrics prefetch failed for Spotify/{SpotifyId}", spotifyId);
-                }
-            });
-        }
-    }
 
     #endregion
 

allstarr/Services/SquidWTF/SquidWTFMetadataService.cs

@@ -74,9 +74,6 @@ public class SquidWTFMetadataService : IMusicMetadataService
         // Set up default headers
         _httpClient.DefaultRequestHeaders.Add("User-Agent", 
             "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0");
-        
-        // Increase timeout for large artist/album responses (some artists have 100+ albums)
-        _httpClient.Timeout = TimeSpan.FromMinutes(5);
     }