Merge branch 'main' into dev

- Cache mode now registers downloaded songs in mappings
- Prevents duplicate downloads in cache mode
- Fixes wasted API calls and duplicate cache files
- Both cache and download modes benefit from deduplication

README.md

@@ -140,7 +140,7 @@ Choose your preferred provider via the `MUSIC_SERVICE` environment variable. Add
   - **Subsonic**: Navidrome or other Subsonic-compatible server
 - Credentials for at least one music provider (IF NOT USING SQUIDWTF):
   - **Deezer**: ARL token from browser cookies
-  - **Qobuz**: User ID + User Auth Token from browser localStorage ([see Wiki guide](https://github.com/V1ck3s/allstarr/wiki/Getting-Qobuz-Credentials-(User-ID-&-Token)))
+  - **Qobuz**: User ID + User Auth Token from browser localStorage ([see Wiki guide](https://github.com/V1ck3s/octo-fiesta/wiki/Getting-Qobuz-Credentials-(User-ID-&-Token)))
 - Docker and Docker Compose (recommended) **or** [.NET 10.0 SDK](https://dotnet.microsoft.com/download/dotnet/10.0) for manual installation
 
 ## Configuration

allstarr/Program.cs

@@ -11,9 +11,30 @@ using allstarr.Services.Common;
 using allstarr.Services.Lyrics;
 using allstarr.Middleware;
 using allstarr.Filters;
+using Microsoft.Extensions.Http;
+using System.Text;
 
 var builder = WebApplication.CreateBuilder(args);
 
+// Decode SquidWTF API base URLs once at startup
+var squidWtfApiUrls = DecodeSquidWtfUrls();
+static List<string> DecodeSquidWtfUrls()
+{
+    var encodedUrls = new[]
+    {
+        "aHR0cHM6Ly90cml0b24uc3F1aWQud3Rm",      // triton
+        "aHR0cHM6Ly93b2xmLnFxZGwuc2l0ZQ==",      // wolf
+        "aHR0cDovL2h1bmQucXFkbC5zaXRl",          // hund
+        "aHR0cHM6Ly9tYXVzLnFxZGwuc2l0ZQ==",      // maus
+        "aHR0cHM6Ly92b2dlbC5xcWRsLnNpdGU=",      // vogel
+        "aHR0cHM6Ly9rYXR6ZS5xcWRsLnNpdGU="       // katze
+    };
+    
+    return encodedUrls
+        .Select(encoded => Encoding.UTF8.GetString(Convert.FromBase64String(encoded)))
+        .ToList();
+}
+
 // Determine backend type FIRST
 var backendType = builder.Configuration.GetValue<BackendType>("Backend:Type");
 
@@ -55,6 +76,17 @@ builder.Services.AddControllers()
     });
     
 builder.Services.AddHttpClient();
+builder.Services.ConfigureAll<HttpClientFactoryOptions>(options =>
+{
+    options.HttpMessageHandlerBuilderActions.Add(builder =>
+    {
+        builder.PrimaryHandler = new HttpClientHandler
+        {
+            AllowAutoRedirect = true,
+            MaxAutomaticRedirections = 5
+        };
+    });
+});
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen();
 builder.Services.AddHttpContextAccessor();
@@ -151,9 +183,26 @@ else if (musicService == MusicService.Deezer)
 }
 else if (musicService == MusicService.SquidWTF)
 {
-    // SquidWTF services
-    builder.Services.AddSingleton<IMusicMetadataService, SquidWTFMetadataService>();
-    builder.Services.AddSingleton<IDownloadService, SquidWTFDownloadService>();
+    // SquidWTF services - pass decoded URLs with fallback support
+    builder.Services.AddSingleton<IMusicMetadataService>(sp => 
+        new SquidWTFMetadataService(
+            sp.GetRequiredService<IHttpClientFactory>(),
+            sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SubsonicSettings>>(),
+            sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SquidWTFSettings>>(),
+            sp.GetRequiredService<ILogger<SquidWTFMetadataService>>(),
+            sp.GetRequiredService<RedisCacheService>(),
+            squidWtfApiUrls));
+    builder.Services.AddSingleton<IDownloadService>(sp =>
+        new SquidWTFDownloadService(
+            sp.GetRequiredService<IHttpClientFactory>(),
+            sp.GetRequiredService<IConfiguration>(),
+            sp.GetRequiredService<ILocalLibraryService>(),
+            sp.GetRequiredService<IMusicMetadataService>(),
+            sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SubsonicSettings>>(),
+            sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SquidWTFSettings>>(),
+            sp,
+            sp.GetRequiredService<ILogger<SquidWTFDownloadService>>(),
+            squidWtfApiUrls));
 }
 
 // Startup validation - register validators based on backend
@@ -168,7 +217,11 @@ else
 
 builder.Services.AddSingleton<IStartupValidator, DeezerStartupValidator>();
 builder.Services.AddSingleton<IStartupValidator, QobuzStartupValidator>();
-builder.Services.AddSingleton<IStartupValidator, SquidWTFStartupValidator>();
+builder.Services.AddSingleton<IStartupValidator>(sp =>
+    new SquidWTFStartupValidator(
+        sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SquidWTFSettings>>(),
+        sp.GetRequiredService<IHttpClientFactory>().CreateClient(),
+        squidWtfApiUrls));
 
 // Register orchestrator as hosted service
 builder.Services.AddHostedService<StartupValidationOrchestrator>();

allstarr/Services/Common/BaseDownloadService.cs

@@ -298,6 +298,9 @@ public abstract class BaseDownloadService : IDownloadService
             
             song.LocalPath = localPath;
             
+            // Register BEFORE releasing lock to prevent race conditions (both cache and download modes)
+            await LocalLibraryService.RegisterDownloadedSongAsync(song, localPath);
+            
             // Check if this track belongs to a playlist and update M3U
             if (PlaylistSyncService != null)
             {
@@ -316,11 +319,9 @@ public abstract class BaseDownloadService : IDownloadService
                 }
             }
             
-            // Only register and scan if NOT in cache mode
+            // Trigger library scan and album download AFTER releasing lock (download mode only)
             if (!isCache)
             {
-                await LocalLibraryService.RegisterDownloadedSongAsync(song, localPath);
-                
                 // Trigger a Subsonic library rescan (with debounce)
                 _ = Task.Run(async () =>
                 {

allstarr/Services/SquidWTF/SquidWTFDownloadService.cs

@@ -26,7 +26,8 @@ public class SquidWTFDownloadService : BaseDownloadService
     private DateTime _lastRequestTime = DateTime.MinValue;
     private readonly int _minRequestIntervalMs = 200;
     
-	private const string SquidWTFApiBase = "https://triton.squid.wtf";
+	private readonly List<string> _apiUrls;
+    private int _currentUrlIndex = 0;
 
     protected override string ProviderName => "squidwtf";
 
@@ -38,29 +39,49 @@ public class SquidWTFDownloadService : BaseDownloadService
         IOptions<SubsonicSettings> subsonicSettings,
         IOptions<SquidWTFSettings> SquidWTFSettings,
 		IServiceProvider serviceProvider,
-        ILogger<SquidWTFDownloadService> logger)
+        ILogger<SquidWTFDownloadService> logger,
+        List<string> apiUrls)
         : base(configuration, localLibraryService, metadataService, subsonicSettings.Value, serviceProvider, logger)
     {
         _httpClient = httpClientFactory.CreateClient();
         _squidwtfSettings = SquidWTFSettings.Value;
+        _apiUrls = apiUrls;
+    }
+    
+    private async Task<T> TryWithFallbackAsync<T>(Func<string, Task<T>> action)
+    {
+        for (int attempt = 0; attempt < _apiUrls.Count; attempt++)
+        {
+            try
+            {
+                var baseUrl = _apiUrls[_currentUrlIndex];
+                return await action(baseUrl);
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning(ex, "Request failed with endpoint {Endpoint}, trying next...", _apiUrls[_currentUrlIndex]);
+                _currentUrlIndex = (_currentUrlIndex + 1) % _apiUrls.Count;
+                
+                if (attempt == _apiUrls.Count - 1)
+                {
+                    Logger.LogError("All SquidWTF endpoints failed");
+                    throw;
+                }
+            }
+        }
+        throw new Exception("All SquidWTF endpoints failed");
     }
 	
     #region BaseDownloadService Implementation
 
     public override async Task<bool> IsAvailableAsync()
     {
-        try
+        return await TryWithFallbackAsync(async (baseUrl) =>
         {
-            // Test connectivity to triton.squid.wtf
-            var response = await _httpClient.GetAsync("https://triton.squid.wtf/");
+            var response = await _httpClient.GetAsync(baseUrl);
 			Console.WriteLine($"Response code from is available async: {response.IsSuccessStatusCode}");
             return response.IsSuccessStatusCode;
-        }
-        catch (Exception ex)
-        {
-            Logger.LogWarning(ex, "SquidWTF service not available");
-            return false;
-        }
+        });
 	}
 
     protected override string? ExtractExternalIdFromAlbumId(string albumId)
@@ -135,6 +156,8 @@ public class SquidWTFDownloadService : BaseDownloadService
 	private async Task<DownloadResult> GetTrackDownloadInfoAsync(string trackId, CancellationToken cancellationToken)
     {
         return await QueueRequestAsync(async () =>
+        {
+            return await TryWithFallbackAsync(async (baseUrl) =>
             {
                 // Map quality settings to Tidal's quality levels
                 var quality = _squidwtfSettings.Quality?.ToUpperInvariant() switch
@@ -147,8 +170,7 @@ public class SquidWTFDownloadService : BaseDownloadService
                     _ => "LOSSLESS" // Default to lossless
                 };
                 
-            // Use the triton.squid.wtf endpoint to get track download info
-            var url = $"https://triton.squid.wtf/track/?id={trackId}&quality={quality}";
+                var url = $"{baseUrl}/track/?id={trackId}&quality={quality}";
 
                 Console.WriteLine($"%%%%%%%%%%%%%%%%%%% URL For downloads??: {url}");
 
@@ -160,7 +182,7 @@ public class SquidWTFDownloadService : BaseDownloadService
                 
                 if (!doc.RootElement.TryGetProperty("data", out var data))
                 {
-                throw new Exception("Invalid response from triton.squid.wtf");
+                    throw new Exception("Invalid response from API");
                 }
                 
                 // Get the manifest (base64 encoded JSON containing the actual CDN URL)
@@ -198,6 +220,7 @@ public class SquidWTFDownloadService : BaseDownloadService
                     AudioQuality = audioQuality ?? "LOSSLESS"
                 };
             });
+        });
     }
 	
 	#endregion

allstarr/Services/SquidWTF/SquidWTFMetadataService.cs

@@ -21,30 +21,59 @@ public class SquidWTFMetadataService : IMusicMetadataService
     private readonly SubsonicSettings _settings;
     private readonly ILogger<SquidWTFMetadataService> _logger;
     private readonly RedisCacheService _cache;
-    private const string BaseUrl = "https://triton.squid.wtf";
+	private readonly List<string> _apiUrls;
+    private int _currentUrlIndex = 0;
 
     public SquidWTFMetadataService(
         IHttpClientFactory httpClientFactory, 
         IOptions<SubsonicSettings> settings,
         IOptions<SquidWTFSettings> squidwtfSettings,
         ILogger<SquidWTFMetadataService> logger,
-        RedisCacheService cache)
+        RedisCacheService cache,
+        List<string> apiUrls)
     {
         _httpClient = httpClientFactory.CreateClient();
         _settings = settings.Value;
         _logger = logger;
         _cache = cache;
+        _apiUrls = apiUrls;
         
         // 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");
     }
     
-    public async Task<List<Song>> SearchSongsAsync(string query, int limit = 20)
+    private string GetCurrentBaseUrl() => _apiUrls[_currentUrlIndex];
+    
+    private async Task<T> TryWithFallbackAsync<T>(Func<string, Task<T>> action, T defaultValue)
+    {
+        for (int attempt = 0; attempt < _apiUrls.Count; attempt++)
         {
             try
             {
-            var url = $"{BaseUrl}/search/?s={Uri.EscapeDataString(query)}";
+                var baseUrl = _apiUrls[_currentUrlIndex];
+                return await action(baseUrl);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Request failed with endpoint {Endpoint}, trying next...", _apiUrls[_currentUrlIndex]);
+                _currentUrlIndex = (_currentUrlIndex + 1) % _apiUrls.Count;
+                
+                if (attempt == _apiUrls.Count - 1)
+                {
+                    _logger.LogError("All SquidWTF endpoints failed");
+                    return defaultValue;
+                }
+            }
+        }
+        return defaultValue;
+    }
+	
+    public async Task<List<Song>> SearchSongsAsync(string query, int limit = 20)
+    {
+        return await TryWithFallbackAsync(async (baseUrl) =>
+        {
+            var url = $"{baseUrl}/search/?s={Uri.EscapeDataString(query)}";
             var response = await _httpClient.GetAsync(url);
             
             if (!response.IsSuccessStatusCode)
@@ -70,19 +99,14 @@ public class SquidWTFMetadataService : IMusicMetadataService
                 }
             }
             return songs;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to search songs for query: {Query}", query);
-            return new List<Song>();
-        }
+        }, new List<Song>());
     }
 	
     public async Task<List<Album>> SearchAlbumsAsync(string query, int limit = 20)
     {
-        try
+        return await TryWithFallbackAsync(async (baseUrl) =>
         {
-            var url = $"{BaseUrl}/search/?al={Uri.EscapeDataString(query)}";
+            var url = $"{baseUrl}/search/?al={Uri.EscapeDataString(query)}";
             var response = await _httpClient.GetAsync(url);
             
             if (!response.IsSuccessStatusCode)
@@ -109,19 +133,14 @@ public class SquidWTFMetadataService : IMusicMetadataService
             }
             
             return albums;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to search albums for query: {Query}", query);
-            return new List<Album>();
-        }
+        }, new List<Album>());
     }
 
     public async Task<List<Artist>> SearchArtistsAsync(string query, int limit = 20)
     {
-        try
+        return await TryWithFallbackAsync(async (baseUrl) =>
         {
-            var url = $"{BaseUrl}/search/?a={Uri.EscapeDataString(query)}";
+            var url = $"{baseUrl}/search/?a={Uri.EscapeDataString(query)}";
             var response = await _httpClient.GetAsync(url);
             
             if (!response.IsSuccessStatusCode)
@@ -148,19 +167,14 @@ public class SquidWTFMetadataService : IMusicMetadataService
             }
 
             return artists;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to search artists for query: {Query}", query);
-            return new List<Artist>();
-        }
+        }, new List<Artist>());
     }
 	
 	public async Task<List<ExternalPlaylist>> SearchPlaylistsAsync(string query, int limit = 20)
 	{
-		try
+		return await TryWithFallbackAsync(async (baseUrl) =>
 		{
-			var url = $"{BaseUrl}/search/?p={Uri.EscapeDataString(query)}";
+			var url = $"{baseUrl}/search/?p={Uri.EscapeDataString(query)}";
             var response = await _httpClient.GetAsync(url);
             if (!response.IsSuccessStatusCode) return new List<ExternalPlaylist>();
 
@@ -178,13 +192,7 @@ public class SquidWTFMetadataService : IMusicMetadataService
 				}
 			}
 			return playlists;
-		}
-		catch
-		{
-			return new List<ExternalPlaylist>();
-		}
-		
-		
+		}, new List<ExternalPlaylist>());
 	}
 
     public async Task<SearchResult> SearchAllAsync(string query, int songLimit = 20, int albumLimit = 20, int artistLimit = 20)
@@ -210,10 +218,9 @@ public class SquidWTFMetadataService : IMusicMetadataService
     {
         if (externalProvider != "squidwtf") return null;
         
-        try
+        return await TryWithFallbackAsync(async (baseUrl) =>
         {
-            // Use the /info endpoint for full track metadata
-            var url = $"{BaseUrl}/info/?id={externalId}";
+            var url = $"{baseUrl}/info/?id={externalId}";
 						
             var response = await _httpClient.GetAsync(url);
             if (!response.IsSuccessStatusCode) return null;
@@ -225,12 +232,7 @@ public class SquidWTFMetadataService : IMusicMetadataService
 				return null;
 
 			return ParseTidalTrackFull(track);
-        }
-        catch (Exception ex)
-        {
-			_logger.LogWarning(ex, "GetSongAsync Exception");
-            return null;
-        }
+        }, (Song?)null);
     }
 
     public async Task<Album?> GetAlbumAsync(string externalProvider, string externalId)
@@ -242,10 +244,9 @@ public class SquidWTFMetadataService : IMusicMetadataService
         var cached = await _cache.GetAsync<Album>(cacheKey);
         if (cached != null) return cached;
         
-        try
+        return await TryWithFallbackAsync(async (baseUrl) =>
         {
-            // Use the /info endpoint for full track metadata
-            var url = $"{BaseUrl}/album/?id={externalId}";
+            var url = $"{baseUrl}/album/?id={externalId}";
 			
             var response = await _httpClient.GetAsync(url);
             if (!response.IsSuccessStatusCode) return null;
@@ -279,12 +280,7 @@ public class SquidWTFMetadataService : IMusicMetadataService
 			await _cache.SetAsync(cacheKey, album, TimeSpan.FromHours(24));
 			
 			return album;	
-		}
-        catch (Exception ex)
-        {
-			_logger.LogWarning(ex, "GetAlbumAsync Exception");
-            return null;
-        }
+		}, (Album?)null);
     }
 	
     public async Task<Artist?> GetArtistAsync(string externalProvider, string externalId)
@@ -302,10 +298,9 @@ public class SquidWTFMetadataService : IMusicMetadataService
             return cached;
         }
   
-        try
+        return await TryWithFallbackAsync(async (baseUrl) =>
         {
-            // Use the /info endpoint for full track metadata
-            var url = $"{BaseUrl}/artist/?f={externalId}"; 
+            var url = $"{baseUrl}/artist/?f={externalId}"; 
             _logger.LogInformation("Fetching artist from {Url}", url);
 
             var response = await _httpClient.GetAsync(url);
@@ -366,25 +361,18 @@ public class SquidWTFMetadataService : IMusicMetadataService
 			await _cache.SetAsync(cacheKey, artist, TimeSpan.FromHours(24));
 			
 			return artist;
-
-        }
-        catch (Exception ex)
-        {
-			_logger.LogWarning(ex, "GetArtistAsync Exception.");
-            return null;
-        }
+        }, (Artist?)null);
     }
 
     public async Task<List<Album>> GetArtistAlbumsAsync(string externalProvider, string externalId)
-    {
-
-		try
     {
 		if (externalProvider != "squidwtf") return new List<Album>();
 		
+		return await TryWithFallbackAsync(async (baseUrl) =>
+		{
             _logger.LogInformation("GetArtistAlbumsAsync called for SquidWTF artist {ExternalId}", externalId);
             
-			var url = $"{BaseUrl}/artist/?f={externalId}";
+			var url = $"{baseUrl}/artist/?f={externalId}";
 			_logger.LogInformation("Fetching artist albums from URL: {Url}", url);
 			var response = await _httpClient.GetAsync(url);
 			
@@ -418,21 +406,16 @@ public class SquidWTFMetadataService : IMusicMetadataService
             }
 			
 			return albums;
-		}
-		catch (Exception ex)
-		{
-			_logger.LogError(ex, "Failed to get SquidWTF artist albums for {ExternalId}", externalId);
-			return new List<Album>();
-		}
+		}, new List<Album>());
 	}
 
     public async Task<ExternalPlaylist?> GetPlaylistAsync(string externalProvider, string externalId)
 	{
 		if (externalProvider != "squidwtf") return null;
 		
-		try
+		return await TryWithFallbackAsync(async (baseUrl) =>
 		{
-			var url = $"{BaseUrl}/playlist/?id={externalId}";
+			var url = $"{baseUrl}/playlist/?id={externalId}";
 			var response = await _httpClient.GetAsync(url);
 			if (!response.IsSuccessStatusCode) return null;
 			
@@ -442,21 +425,16 @@ public class SquidWTFMetadataService : IMusicMetadataService
             if (playlistElement.TryGetProperty("error", out _)) return null;
             
 			return ParseTidalPlaylist(playlistElement);
-		}
-		catch
-		{
-			return null;
-		}
-		
+		}, (ExternalPlaylist?)null);
 	}
 	
     public async Task<List<Song>> GetPlaylistTracksAsync(string externalProvider, string externalId)
 	{
 		if (externalProvider != "squidwtf") return new List<Song>();
 		
-		try
+		return await TryWithFallbackAsync(async (baseUrl) =>
 		{
-			var url = $"{BaseUrl}/playlist/?id={externalId}";
+			var url = $"{baseUrl}/playlist/?id={externalId}";
 			var response = await _httpClient.GetAsync(url);
 			if (!response.IsSuccessStatusCode) return new List<Song>();
 			
@@ -507,12 +485,7 @@ public class SquidWTFMetadataService : IMusicMetadataService
 				}
 			}
 			return songs;
-		}
-		catch
-		{
-			return new List<Song>();
-		}
-		
+		}, new List<Song>());
 	}
 
 	// --- Parser functions start here ---

allstarr/Services/SquidWTF/SquidWTFStartupValidator.cs

@@ -12,13 +12,39 @@ namespace allstarr.Services.SquidWTF;
 public class SquidWTFStartupValidator : BaseStartupValidator
 {
     private readonly SquidWTFSettings _settings;
+	private readonly List<string> _apiUrls;
+    private int _currentUrlIndex = 0;
 
     public override string ServiceName => "SquidWTF";
 
-    public SquidWTFStartupValidator(IOptions<SquidWTFSettings> settings, HttpClient httpClient)
+    public SquidWTFStartupValidator(IOptions<SquidWTFSettings> settings, HttpClient httpClient, List<string> apiUrls)
         : base(httpClient)
     {
         _settings = settings.Value;
+        _apiUrls = apiUrls;
+    }
+    
+    private async Task<T> TryWithFallbackAsync<T>(Func<string, Task<T>> action, T defaultValue)
+    {
+        for (int attempt = 0; attempt < _apiUrls.Count; attempt++)
+        {
+            try
+            {
+                var baseUrl = _apiUrls[_currentUrlIndex];
+                return await action(baseUrl);
+            }
+            catch
+            {
+                WriteDetail($"Endpoint {_apiUrls[_currentUrlIndex]} failed, trying next...");
+                _currentUrlIndex = (_currentUrlIndex + 1) % _apiUrls.Count;
+                
+                if (attempt == _apiUrls.Count - 1)
+                {
+                    return defaultValue;
+                }
+            }
+        }
+        return defaultValue;
     }	
 	
     public override async Task<ValidationResult> ValidateAsync(CancellationToken cancellationToken)
@@ -37,54 +63,36 @@ public class SquidWTFStartupValidator : BaseStartupValidator
 
         WriteStatus("SquidWTF Quality", quality, ConsoleColor.Cyan);
 
-        // Test connectivity to triton.squid.wtf
-        try
+        // Test connectivity with fallback
+        var result = await TryWithFallbackAsync(async (baseUrl) =>
         {
-            var response = await _httpClient.GetAsync("https://triton.squid.wtf/", cancellationToken);
+            var response = await _httpClient.GetAsync(baseUrl, cancellationToken);
 
             if (response.IsSuccessStatusCode)
             {
-                WriteStatus("SquidWTF API", "REACHABLE", ConsoleColor.Green);
+                WriteStatus("SquidWTF API", $"REACHABLE ({baseUrl})", ConsoleColor.Green);
                 WriteDetail("No authentication required - powered by Tidal");
                 
                 // Try a test search to verify functionality
-                await ValidateSearchFunctionality(cancellationToken);
+                await ValidateSearchFunctionality(baseUrl, cancellationToken);
                 
                 return ValidationResult.Success("SquidWTF validation completed");
             }
             else
             {
-                WriteStatus("SquidWTF API", $"HTTP {(int)response.StatusCode}", ConsoleColor.Yellow);
-                WriteDetail("Service may be temporarily unavailable");
-			return ValidationResult.Failure($"{response.StatusCode}", "SquidWTF returned code");
-            }
-        }
-        catch (TaskCanceledException)
-        {
-            WriteStatus("SquidWTF API", "TIMEOUT", ConsoleColor.Yellow);
-            WriteDetail("Could not reach service within timeout period");
-            return ValidationResult.Failure("-1", "SquidWTF connection timeout");
-        }
-        catch (HttpRequestException ex)
-        {
-            WriteStatus("SquidWTF API", "UNREACHABLE", ConsoleColor.Red);
-            WriteDetail(ex.Message);
-            return ValidationResult.Failure("-1", $"Cannot connect to SquidWTF: {ex.Message}");
-        }
-        catch (Exception ex)
-        {
-            WriteStatus("SquidWTF API", "ERROR", ConsoleColor.Red);
-            WriteDetail(ex.Message);
-            return ValidationResult.Failure("-1", $"Validation error: {ex.Message}");
+                throw new HttpRequestException($"HTTP {(int)response.StatusCode}");
             }
+        }, ValidationResult.Failure("-1", "All SquidWTF endpoints failed"));
+
+        return result;
     }
 
-    private async Task ValidateSearchFunctionality(CancellationToken cancellationToken)
+    private async Task ValidateSearchFunctionality(string baseUrl, CancellationToken cancellationToken)
     {
         try
         {
             // Test search with a simple query
-            var searchUrl = "https://triton.squid.wtf/search/?s=Taylor%20Swift";
+            var searchUrl = $"{baseUrl}/search/?s=Taylor%20Swift";
             var searchResponse = await _httpClient.GetAsync(searchUrl, cancellationToken);
 
             if (searchResponse.IsSuccessStatusCode)