Small general fixes (#257)

* renamed ContentBlocker into MalwareBlocker in the logs

* fixed "Delete Private" input description

.github/workflows/build-docker.yml

@@ -29,6 +29,8 @@ jobs:
           githubHeadRef=${{ env.githubHeadRef }}
           latestDockerTag=""
           versionDockerTag=""
+          majorVersionDockerTag=""
+          minorVersionDockerTag=""
           version="0.0.1"
 
           if [[ "$githubRef" =~ ^"refs/tags/" ]]; then
@@ -36,6 +38,12 @@ jobs:
             latestDockerTag="latest"
             versionDockerTag=${branch#v}
             version=${branch#v}
+            
+            # Extract major and minor versions for additional tags
+            if [[ "$versionDockerTag" =~ ^([0-9]+)\.([0-9]+)\.([0-9]+) ]]; then
+              majorVersionDockerTag="${BASH_REMATCH[1]}"
+              minorVersionDockerTag="${BASH_REMATCH[1]}.${BASH_REMATCH[2]}"
+            fi
           else
             # Determine if this run is for the main branch or another branch
             if [[ -z "$githubHeadRef" ]]; then
@@ -58,6 +66,12 @@ jobs:
           if [ -n "$versionDockerTag" ]; then
             githubTags="$githubTags,ghcr.io/cleanuparr/cleanuparr:$versionDockerTag"
           fi
+          if [ -n "$minorVersionDockerTag" ]; then
+            githubTags="$githubTags,ghcr.io/cleanuparr/cleanuparr:$minorVersionDockerTag"
+          fi
+          if [ -n "$majorVersionDockerTag" ]; then
+            githubTags="$githubTags,ghcr.io/cleanuparr/cleanuparr:$majorVersionDockerTag"
+          fi
 
           # set env vars
           echo "branch=$branch" >> $GITHUB_ENV

.github/workflows/build-executable.yml

@@ -134,22 +134,4 @@ jobs:
             ./artifacts/*.zip
           retention-days: 30
 
-      - name: Release
-        if: startsWith(github.ref, 'refs/tags/')
-        id: release
-        uses: softprops/action-gh-release@v2
-        with:
-          name: ${{ env.releaseVersion }}
-          tag_name: ${{ env.releaseVersion }}
-          repository: ${{ env.githubRepository }}
-          token: ${{ env.REPO_READONLY_PAT }}
-          make_latest: true
-          fail_on_unmatched_files: true
-          target_commitish: main
-          generate_release_notes: true
-          files: |
-            ./artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-win-amd64.zip
-            ./artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-linux-amd64.zip
-            ./artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-linux-arm64.zip
-            ./artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-osx-amd64.zip
-            ./artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-osx-arm64.zip
+      # Removed individual release step - handled by main release workflow

.github/workflows/build-macos-arm-installer.yml

@@ -363,14 +363,4 @@ jobs:
           path: '${{ env.pkgName }}'
           retention-days: 30
 
-      - name: Release
-        if: startsWith(github.ref, 'refs/tags/')
-        uses: softprops/action-gh-release@v2
-        with:
-          name: ${{ env.releaseVersion }}
-          tag_name: ${{ env.releaseVersion }}
-          repository: ${{ env.githubRepository }}
-          token: ${{ env.REPO_READONLY_PAT }}
-          make_latest: true
-          files: |
-            ${{ env.pkgName }} 
+      # Removed individual release step - handled by main release workflow 

.github/workflows/build-macos-intel-installer.yml

@@ -363,14 +363,4 @@ jobs:
           path: '${{ env.pkgName }}'
           retention-days: 30
 
-      - name: Release
-        if: startsWith(github.ref, 'refs/tags/')
-        uses: softprops/action-gh-release@v2
-        with:
-          name: ${{ env.releaseVersion }}
-          tag_name: ${{ env.releaseVersion }}
-          repository: ${{ env.githubRepository }}
-          token: ${{ env.REPO_READONLY_PAT }}
-          make_latest: true
-          files: |
-            ${{ env.pkgName }} 
+      # Removed individual release step - handled by main release workflow 

.github/workflows/build-windows-installer.yml

@@ -88,19 +88,6 @@ jobs:
         run: |
           dotnet publish code/backend/${{ env.executableName }}/${{ env.executableName }}.csproj -c Release --runtime win-x64 --self-contained -o dist /p:PublishSingleFile=true /p:Version=${{ env.appVersion }} /p:DebugType=None /p:DebugSymbols=false
 
-      - name: Create sample configuration
-        shell: pwsh
-        run: |
-          # Create config directory
-          New-Item -ItemType Directory -Force -Path "config"
-          
-          $config = @{
-            "HTTP_PORTS" = 11011
-            "BASE_PATH" = "/"
-          }
-          
-          $config | ConvertTo-Json | Out-File -FilePath "config/cleanuparr.json" -Encoding UTF8
-
       - name: Setup Inno Setup
         shell: pwsh
         run: |
@@ -158,14 +145,4 @@ jobs:
           path: installer/${{ env.installerName }}
           retention-days: 30
 
-      - name: Release
-        if: startsWith(github.ref, 'refs/tags/')
-        uses: softprops/action-gh-release@v2
-        with:
-          name: ${{ env.releaseVersion }}
-          tag_name: ${{ env.releaseVersion }}
-          repository: ${{ env.githubRepository }}
-          token: ${{ env.REPO_READONLY_PAT }}
-          make_latest: true
-          files: |
-            installer/${{ env.installerName }} 
+      # Removed individual release step - handled by main release workflow 

.github/workflows/cloudflare-pages.yml

@@ -0,0 +1,36 @@
+name: Deploy to Cloudflare Pages
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'Cloudflare/**'
+      - 'blacklist'
+      - 'blacklist_permissive'
+      - 'whitelist'
+      - 'whitelist_with_subtitles'
+  workflow_dispatch:
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    name: Deploy to Cloudflare Pages
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      
+      - name: Copy root static files to Cloudflare static directory
+        run: |
+          cp blacklist Cloudflare/static/
+          cp blacklist_permissive Cloudflare/static/
+          cp whitelist Cloudflare/static/
+          cp whitelist_with_subtitles Cloudflare/static/
+      
+      - name: Deploy to Cloudflare Pages
+        uses: cloudflare/wrangler-action@v3
+        with:
+          apiToken: ${{ secrets.CLOUDFLARE_PAGES_TOKEN }}
+          workingDirectory: "Cloudflare"
+          command: pages deploy . --project-name=cleanuparr

.github/workflows/release.yml

@@ -106,7 +106,7 @@ jobs:
       - name: Create release
         uses: softprops/action-gh-release@v2
         with:
-          name: Cleanuparr ${{ needs.validate.outputs.release_version }}
+          name: ${{ needs.validate.outputs.release_version }}
           tag_name: ${{ needs.validate.outputs.release_version }}
           token: ${{ env.REPO_READONLY_PAT }}
           make_latest: true

Cloudflare/_headers

@@ -0,0 +1,3 @@
+# Cache static files for 5 minutes
+/static/*
+  Cache-Control: public, max-age=300, s-maxage=300

Cloudflare/static/known_malware_file_name_patterns

@@ -0,0 +1,2 @@
+thepirateheaven.org
+RARBG.work

README.md

@@ -12,34 +12,70 @@ Cleanuparr was created primarily to address malicious files, such as `*.lnk` or
 > **Features:**
 > - Strike system to mark bad downloads.
 > - Remove and block downloads that reached a maximum number of strikes.
-> - Remove and block downloads that are **failing to be imported** by the arrs. [configuration](https://cleanuparr.github.io/Cleanuparr/docs/configuration/queue-cleaner#failed-import-max-strikes)
-> - Remove and block downloads that are **stalled** or in **metadata downloading** state. [configuration](https://cleanuparr.github.io/Cleanuparr/docs/configuration/queue-cleaner#stalled-max-strikes)
-> - Remove and block downloads that have a **low download speed** or **high estimated completion time**. [configuration](https://cleanuparr.github.io/Cleanuparr/docs/configuration/queue-cleaner#slow-max-strikes)
-> - Remove and block downloads blocked by qBittorrent or by Cleanuparr's **Content Blocker**. [configuration](https://cleanuparr.github.io/Cleanuparr/docs/configuration/content-blocker)
+> - Remove and block downloads that are **failing to be imported** by the arrs.
+> - Remove and block downloads that are **stalled** or in **metadata downloading** state.
+> - Remove and block downloads that have a **low download speed** or **high estimated completion time**.
+> - Remove and block downloads blocked by qBittorrent or by Cleanuparr's **Content Blocker**.
 > - Automatically trigger a search for downloads removed from the arrs.
-> - Clean up downloads that have been **seeding** for a certain amount of time. [configuration](https://cleanuparr.github.io/Cleanuparr/docs/configuration/download-cleaner#seeding-settings)
-> - Remove downloads that are **orphaned**/have no **hardlinks**/are not referenced by the arrs anymore (with [cross-seed](https://www.cross-seed.org/) support). [configuration](https://cleanuparr.github.io/Cleanuparr/docs/configuration/download-cleaner#enable-unlinked-downloads-management)
-> - Notify on strike or download removal. [configuration](https://cleanuparr.github.io/Cleanuparr/docs/configuration/notifications)
+> - Clean up downloads that have been **seeding** for a certain amount of time.
+> - Remove downloads that are **orphaned**/have no **hardlinks**/are not referenced by the arrs anymore (with [cross-seed](https://www.cross-seed.org/) support).
+> - Notify on strike or download removal.
 > - Ignore certain torrent hashes, categories, tags or trackers from being processed by Cleanuparr.
 
-Cleanuparr supports both qBittorrent's built-in exclusion features and its own blocklist-based system. Binaries for all platforms are provided, along with Docker images for easy deployment.
+## 🎯 Supported Applications
 
-## Quick Start
+### *Arr Applications
+- **Sonarr**
+- **Radarr**
+- **Lidarr**
+- **Readarr**
+- **Whisparr**
 
-> [!NOTE]
->
-> 1. **Docker (Recommended)**  
-> Pull the Docker image from `ghcr.io/cleanuparr/cleanuparr:latest`.
->
-> 2. **Unraid (for Unraid users)**  
-> Use the Unraid Community App.
->
-> 3. **Manual Installation (if you're not using Docker)**  
-> Go to [Windows](#windows), [Linux](#linux) or [MacOS](#macos).
+### Download Clients
+- **qBittorrent**
+- **Transmission**
+- **Deluge**
+- **µTorrent**
 
-# Docs
+### Platforms
+- **Docker**
+- **Windows**
+- **macOS**
+- **Linux**
+- **Unraid**
 
-Docs can be found [here](https://cleanuparr.github.io/Cleanuparr/).
+## 🚀 Quick Start
+
+```bash
+docker run -d --name cleanuparr \
+  --restart unless-stopped \
+  -p 11011:11011 \
+  -v /path/to/config:/config \
+  -e PORT=11011 \
+  -e PUID=1000 \
+  -e PGID=1000 \
+  -e TZ=Etc/UTC \
+  ghcr.io/cleanuparr/cleanuparr:latest
+```
+
+For Docker Compose, health checks, and other installation methods, see the [Complete Installation Guide](https://cleanuparr.github.io/Cleanuparr/docs/installation/detailed).
+
+### 🌐 Access the Web Interface
+
+After installation, open your browser and navigate to:
+```
+http://localhost:11011
+```
+
+**Next Steps:** Check out the [📖 Complete Documentation](https://cleanuparr.github.io/Cleanuparr/) for detailed configuration guides and setup instructions.
+
+## 📖 Documentation & Support
+
+- **📚 [Complete Documentation](https://cleanuparr.github.io/Cleanuparr/)** - Installation guides, configuration, and troubleshooting
+- **⚙️ [Configuration Guide](https://cleanuparr.github.io/Cleanuparr/docs/category/configuration)** - Set up download clients, *arr apps, and features
+- **🔧 [Setup Scenarios](https://cleanuparr.github.io/Cleanuparr/docs/category/setup-scenarios)** - Common use cases and examples
+- **💬 [Discord Community](https://discord.gg/SCtMCgtsc4)** - Get help and discuss with other users
+- **🔗 [GitHub Releases](https://github.com/Cleanuparr/Cleanuparr/releases)** - Download binaries and view changelog
 
 # <img style="vertical-align: middle;" width="24px" src="./Logo/256.png" alt="Cleanuparr"> <span style="vertical-align: middle;">Cleanuparr</span> <img src="https://raw.githubusercontent.com/FortAwesome/Font-Awesome/6.x/svgs/solid/x.svg" height="24px" width="30px" style="vertical-align: middle;"> <span style="vertical-align: middle;">Huntarr</span> <img style="vertical-align: middle;" width="24px" src="https://github.com/plexguide/Huntarr.io/blob/main/frontend/static/logo/512.png?raw=true" alt Huntarr></img>
 

code/Dockerfile

@@ -45,6 +45,7 @@ FROM mcr.microsoft.com/dotnet/aspnet:9.0-bookworm-slim
 
 # Install required packages for user management and timezone support
 RUN apt-get update && apt-get install -y \
+    curl \
     tzdata \
     gosu \
     && rm -rf /var/lib/apt/lists/*

code/backend/Cleanuparr.Api/Controllers/ConfigurationController.cs

@@ -3,10 +3,10 @@ using Cleanuparr.Application.Features.Arr.Dtos;
 using Cleanuparr.Application.Features.DownloadClient.Dtos;
 using Cleanuparr.Domain.Enums;
 using Cleanuparr.Domain.Exceptions;
-using Cleanuparr.Infrastructure.Helpers;
 using Cleanuparr.Infrastructure.Http.DynamicHttpClientSystem;
 using Cleanuparr.Infrastructure.Logging;
 using Cleanuparr.Infrastructure.Models;
+using Cleanuparr.Infrastructure.Services.Interfaces;
 using Cleanuparr.Infrastructure.Utilities;
 using Cleanuparr.Persistence;
 using Cleanuparr.Persistence.Models.Configuration;
@@ -16,7 +16,6 @@ using Cleanuparr.Persistence.Models.Configuration.DownloadCleaner;
 using Cleanuparr.Persistence.Models.Configuration.General;
 using Cleanuparr.Persistence.Models.Configuration.Notification;
 using Cleanuparr.Persistence.Models.Configuration.QueueCleaner;
-using Infrastructure.Services.Interfaces;
 using Mapster;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
@@ -309,6 +308,42 @@ public class ConfigurationController : ControllerBase
         }
     }
 
+    [HttpGet("readarr")]
+    public async Task<IActionResult> GetReadarrConfig()
+    {
+        await DataContext.Lock.WaitAsync();
+        try
+        {
+            var config = await _dataContext.ArrConfigs
+                .Include(x => x.Instances)
+                .AsNoTracking()
+                .FirstAsync(x => x.Type == InstanceType.Readarr);
+            return Ok(config.Adapt<ArrConfigDto>());
+        }
+        finally
+        {
+            DataContext.Lock.Release();
+        }
+    }
+
+    [HttpGet("whisparr")]
+    public async Task<IActionResult> GetWhisparrConfig()
+    {
+        await DataContext.Lock.WaitAsync();
+        try
+        {
+            var config = await _dataContext.ArrConfigs
+                .Include(x => x.Instances)
+                .AsNoTracking()
+                .FirstAsync(x => x.Type == InstanceType.Whisparr);
+            return Ok(config.Adapt<ArrConfigDto>());
+        }
+        finally
+        {
+            DataContext.Lock.Release();
+        }
+    }
+
     [HttpGet("notifications")]
     public async Task<IActionResult> GetNotificationsConfig()
     {
@@ -460,7 +495,7 @@ public class ConfigurationController : ControllerBase
             // Validate cron expression if present
             if (!string.IsNullOrEmpty(newConfig.CronExpression))
             {
-                CronValidationHelper.ValidateCronExpression(newConfig.CronExpression, JobType.ContentBlocker);
+                CronValidationHelper.ValidateCronExpression(newConfig.CronExpression, JobType.MalwareBlocker);
             }
 
             // Get existing config
@@ -478,7 +513,7 @@ public class ConfigurationController : ControllerBase
             await _dataContext.SaveChangesAsync();
 
             // Update the scheduler based on configuration changes
-            await UpdateJobSchedule(oldConfig, JobType.ContentBlocker);
+            await UpdateJobSchedule(oldConfig, JobType.MalwareBlocker);
 
             return Ok(new { Message = "ContentBlocker configuration updated successfully" });
         }
@@ -773,6 +808,68 @@ public class ConfigurationController : ControllerBase
             DataContext.Lock.Release();
         }
     }
+
+    [HttpPut("readarr")]
+    public async Task<IActionResult> UpdateReadarrConfig([FromBody] UpdateReadarrConfigDto newConfigDto)
+    {
+        await DataContext.Lock.WaitAsync();
+        try
+        {
+            // Get existing config
+            var config = await _dataContext.ArrConfigs
+                .FirstAsync(x => x.Type == InstanceType.Readarr);
+
+            config.FailedImportMaxStrikes = newConfigDto.FailedImportMaxStrikes;
+
+            // Validate the configuration
+            config.Validate();
+
+            // Persist the configuration
+            await _dataContext.SaveChangesAsync();
+
+            return Ok(new { Message = "Readarr configuration updated successfully" });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to save Readarr configuration");
+            throw;
+        }
+        finally
+        {
+            DataContext.Lock.Release();
+        }
+    }
+
+    [HttpPut("whisparr")]
+    public async Task<IActionResult> UpdateWhisparrConfig([FromBody] UpdateWhisparrConfigDto newConfigDto)
+    {
+        await DataContext.Lock.WaitAsync();
+        try
+        {
+            // Get existing config
+            var config = await _dataContext.ArrConfigs
+                .FirstAsync(x => x.Type == InstanceType.Whisparr);
+
+            config.FailedImportMaxStrikes = newConfigDto.FailedImportMaxStrikes;
+
+            // Validate the configuration
+            config.Validate();
+
+            // Persist the configuration
+            await _dataContext.SaveChangesAsync();
+
+            return Ok(new { Message = "Whisparr configuration updated successfully" });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to save Whisparr configuration");
+            throw;
+        }
+        finally
+        {
+            DataContext.Lock.Release();
+        }
+    }
     
     /// <summary>
     /// Updates a job schedule based on configuration changes
@@ -1137,4 +1234,224 @@ public class ConfigurationController : ControllerBase
             DataContext.Lock.Release();
         }
     }
+
+    [HttpPost("readarr/instances")]
+    public async Task<IActionResult> CreateReadarrInstance([FromBody] CreateArrInstanceDto newInstance)
+    {
+        await DataContext.Lock.WaitAsync();
+        try
+        {
+            // Get the Readarr config to add the instance to
+            var config = await _dataContext.ArrConfigs
+                .FirstAsync(x => x.Type == InstanceType.Readarr);
+
+            // Create the new instance
+            var instance = new ArrInstance
+            {
+                Enabled = newInstance.Enabled,
+                Name = newInstance.Name,
+                Url = new Uri(newInstance.Url),
+                ApiKey = newInstance.ApiKey,
+                ArrConfigId = config.Id,
+            };
+            
+            // Add to the config's instances collection
+            await _dataContext.ArrInstances.AddAsync(instance);
+            // Save changes
+            await _dataContext.SaveChangesAsync();
+
+            return CreatedAtAction(nameof(GetReadarrConfig), new { id = instance.Id }, instance.Adapt<ArrInstanceDto>());
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to create Readarr instance");
+            throw;
+        }
+        finally
+        {
+            DataContext.Lock.Release();
+        }
+    }
+
+    [HttpPut("readarr/instances/{id}")]
+    public async Task<IActionResult> UpdateReadarrInstance(Guid id, [FromBody] CreateArrInstanceDto updatedInstance)
+    {
+        await DataContext.Lock.WaitAsync();
+        try
+        {
+            // Get the Readarr config and find the instance
+            var config = await _dataContext.ArrConfigs
+                .Include(c => c.Instances)
+                .FirstAsync(x => x.Type == InstanceType.Readarr);
+
+            var instance = config.Instances.FirstOrDefault(i => i.Id == id);
+            if (instance == null)
+            {
+                return NotFound($"Readarr instance with ID {id} not found");
+            }
+
+            // Update the instance properties
+            instance.Enabled = updatedInstance.Enabled;
+            instance.Name = updatedInstance.Name;
+            instance.Url = new Uri(updatedInstance.Url);
+            instance.ApiKey = updatedInstance.ApiKey;
+
+            await _dataContext.SaveChangesAsync();
+
+            return Ok(instance.Adapt<ArrInstanceDto>());
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to update Readarr instance with ID {Id}", id);
+            throw;
+        }
+        finally
+        {
+            DataContext.Lock.Release();
+        }
+    }
+
+    [HttpDelete("readarr/instances/{id}")]
+    public async Task<IActionResult> DeleteReadarrInstance(Guid id)
+    {
+        await DataContext.Lock.WaitAsync();
+        try
+        {
+            // Get the Readarr config and find the instance
+            var config = await _dataContext.ArrConfigs
+                .Include(c => c.Instances)
+                .FirstAsync(x => x.Type == InstanceType.Readarr);
+
+            var instance = config.Instances.FirstOrDefault(i => i.Id == id);
+            if (instance == null)
+            {
+                return NotFound($"Readarr instance with ID {id} not found");
+            }
+
+            // Remove the instance
+            config.Instances.Remove(instance);
+            await _dataContext.SaveChangesAsync();
+
+            return NoContent();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to delete Readarr instance with ID {Id}", id);
+            throw;
+        }
+        finally
+        {
+            DataContext.Lock.Release();
+        }
+    }
+
+    [HttpPost("whisparr/instances")]
+    public async Task<IActionResult> CreateWhisparrInstance([FromBody] CreateArrInstanceDto newInstance)
+    {
+        await DataContext.Lock.WaitAsync();
+        try
+        {
+            // Get the Whisparr config to add the instance to
+            var config = await _dataContext.ArrConfigs
+                .FirstAsync(x => x.Type == InstanceType.Whisparr);
+
+            // Create the new instance
+            var instance = new ArrInstance
+            {
+                Enabled = newInstance.Enabled,
+                Name = newInstance.Name,
+                Url = new Uri(newInstance.Url),
+                ApiKey = newInstance.ApiKey,
+                ArrConfigId = config.Id,
+            };
+            
+            // Add to the config's instances collection
+            await _dataContext.ArrInstances.AddAsync(instance);
+            // Save changes
+            await _dataContext.SaveChangesAsync();
+
+            return CreatedAtAction(nameof(GetWhisparrConfig), new { id = instance.Id }, instance.Adapt<ArrInstanceDto>());
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to create Whisparr instance");
+            throw;
+        }
+        finally
+        {
+            DataContext.Lock.Release();
+        }
+    }
+
+    [HttpPut("whisparr/instances/{id}")]
+    public async Task<IActionResult> UpdateWhisparrInstance(Guid id, [FromBody] CreateArrInstanceDto updatedInstance)
+    {
+        await DataContext.Lock.WaitAsync();
+        try
+        {
+            // Get the Whisparr config and find the instance
+            var config = await _dataContext.ArrConfigs
+                .Include(c => c.Instances)
+                .FirstAsync(x => x.Type == InstanceType.Whisparr);
+
+            var instance = config.Instances.FirstOrDefault(i => i.Id == id);
+            if (instance == null)
+            {
+                return NotFound($"Whisparr instance with ID {id} not found");
+            }
+
+            // Update the instance properties
+            instance.Enabled = updatedInstance.Enabled;
+            instance.Name = updatedInstance.Name;
+            instance.Url = new Uri(updatedInstance.Url);
+            instance.ApiKey = updatedInstance.ApiKey;
+
+            await _dataContext.SaveChangesAsync();
+
+            return Ok(instance.Adapt<ArrInstanceDto>());
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to update Whisparr instance with ID {Id}", id);
+            throw;
+        }
+        finally
+        {
+            DataContext.Lock.Release();
+        }
+    }
+
+    [HttpDelete("whisparr/instances/{id}")]
+    public async Task<IActionResult> DeleteWhisparrInstance(Guid id)
+    {
+        await DataContext.Lock.WaitAsync();
+        try
+        {
+            // Get the Whisparr config and find the instance
+            var config = await _dataContext.ArrConfigs
+                .Include(c => c.Instances)
+                .FirstAsync(x => x.Type == InstanceType.Whisparr);
+
+            var instance = config.Instances.FirstOrDefault(i => i.Id == id);
+            if (instance == null)
+            {
+                return NotFound($"Whisparr instance with ID {id} not found");
+            }
+
+            // Remove the instance
+            config.Instances.Remove(instance);
+            await _dataContext.SaveChangesAsync();
+
+            return NoContent();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to delete Whisparr instance with ID {Id}", id);
+            throw;
+        }
+        finally
+        {
+            DataContext.Lock.Release();
+        }
+    }
 }

code/backend/Cleanuparr.Api/Controllers/HealthController.cs

@@ -0,0 +1,125 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+
+namespace Cleanuparr.Api.Controllers;
+
+/// <summary>
+/// Health check endpoints for Docker and Kubernetes
+/// </summary>
+[ApiController]
+[Route("[controller]")]
+public class HealthController : ControllerBase
+{
+    private readonly HealthCheckService _healthCheckService;
+    private readonly ILogger<HealthController> _logger;
+
+    public HealthController(HealthCheckService healthCheckService, ILogger<HealthController> logger)
+    {
+        _healthCheckService = healthCheckService;
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Basic liveness probe - checks if the application is running
+    /// Used by Docker HEALTHCHECK and Kubernetes liveness probes
+    /// </summary>
+    [HttpGet]
+    [Route("/health")]
+    public async Task<IActionResult> GetHealth()
+    {
+        try
+        {
+            var result = await _healthCheckService.CheckHealthAsync(
+                registration => registration.Tags.Contains("liveness"));
+            
+            return result.Status == HealthStatus.Healthy 
+                ? Ok(new { status = "healthy", timestamp = DateTime.UtcNow })
+                : StatusCode(503, new { status = "unhealthy", timestamp = DateTime.UtcNow });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Health check failed");
+            return StatusCode(503, new { status = "unhealthy", error = "Health check failed", timestamp = DateTime.UtcNow });
+        }
+    }
+
+    /// <summary>
+    /// Readiness probe - checks if the application is ready to serve traffic
+    /// Used by Kubernetes readiness probes
+    /// </summary>
+    [HttpGet]
+    [Route("/health/ready")]
+    public async Task<IActionResult> GetReadiness()
+    {
+        try
+        {
+            var result = await _healthCheckService.CheckHealthAsync(
+                registration => registration.Tags.Contains("readiness"));
+            
+            if (result.Status == HealthStatus.Healthy)
+            {
+                return Ok(new { status = "ready", timestamp = DateTime.UtcNow });
+            }
+            
+            // For readiness, we consider degraded as not ready
+            return StatusCode(503, new { 
+                status = "not_ready", 
+                timestamp = DateTime.UtcNow,
+                details = result.Entries.Where(e => e.Value.Status != HealthStatus.Healthy)
+                    .ToDictionary(e => e.Key, e => new { 
+                        status = e.Value.Status.ToString().ToLowerInvariant(),
+                        description = e.Value.Description 
+                    })
+            });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Readiness check failed");
+            return StatusCode(503, new { status = "not_ready", error = "Readiness check failed", timestamp = DateTime.UtcNow });
+        }
+    }
+
+    /// <summary>
+    /// Detailed health status - for monitoring and debugging
+    /// </summary>
+    [HttpGet]
+    [Route("/health/detailed")]
+    public async Task<IActionResult> GetDetailedHealth()
+    {
+        try
+        {
+            var result = await _healthCheckService.CheckHealthAsync();
+            
+            var response = new
+            {
+                status = result.Status.ToString().ToLowerInvariant(),
+                timestamp = DateTime.UtcNow,
+                totalDuration = result.TotalDuration.TotalMilliseconds,
+                entries = result.Entries.ToDictionary(
+                    e => e.Key,
+                    e => new
+                    {
+                        status = e.Value.Status.ToString().ToLowerInvariant(),
+                        description = e.Value.Description,
+                        duration = e.Value.Duration.TotalMilliseconds,
+                        tags = e.Value.Tags,
+                        data = e.Value.Data,
+                        exception = e.Value.Exception?.Message
+                    })
+            };
+
+            return result.Status == HealthStatus.Healthy 
+                ? Ok(response)
+                : StatusCode(503, response);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Detailed health check failed");
+            return StatusCode(503, new { 
+                status = "unhealthy", 
+                error = "Detailed health check failed", 
+                timestamp = DateTime.UtcNow 
+            });
+        }
+    }
+} 

code/backend/Cleanuparr.Api/Controllers/JobsController.cs

@@ -1,6 +1,6 @@
 using Cleanuparr.Api.Models;
 using Cleanuparr.Infrastructure.Models;
-using Infrastructure.Services.Interfaces;
+using Cleanuparr.Infrastructure.Services.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 
 namespace Cleanuparr.Api.Controllers;

code/backend/Cleanuparr.Api/Controllers/StatusController.cs

@@ -52,6 +52,10 @@ public class StatusController : ControllerBase
                 .Include(x => x.Instances)
                 .AsNoTracking()
                 .FirstAsync(x => x.Type == InstanceType.Lidarr);
+            var readarrConfig = await _dataContext.ArrConfigs
+                .Include(x => x.Instances)
+                .AsNoTracking()
+                .FirstAsync(x => x.Type == InstanceType.Readarr);
             
             var status = new
             {
@@ -80,6 +84,10 @@ public class StatusController : ControllerBase
                     Lidarr = new
                     {
                         InstanceCount = lidarrConfig.Instances.Count
+                    },
+                    Readarr = new
+                    {
+                        InstanceCount = readarrConfig.Instances.Count
                     }
                 }
             };

code/backend/Cleanuparr.Api/DependencyInjection/ApiDI.cs

@@ -40,9 +40,6 @@ public static class ApiDI
         // Add health status broadcaster
         services.AddHostedService<HealthStatusBroadcaster>();
         
-        // Add logging initializer service
-        services.AddHostedService<LoggingInitializer>();
-        
         services.AddSwaggerGen(options =>
         {
             options.SwaggerDoc("v1", new OpenApiInfo
@@ -142,6 +139,38 @@ public static class ApiDI
         // Map SignalR hubs
         app.MapHub<HealthStatusHub>("/api/hubs/health");
         app.MapHub<AppHub>("/api/hubs/app");
+        
+        app.MapGet("/manifest.webmanifest", (HttpContext context) =>
+        {
+            var basePath = context.Request.PathBase.HasValue
+                ? context.Request.PathBase.Value
+                : "/";
+
+            var manifest = new
+            {
+                name = "Cleanuparr",
+                short_name = "Cleanuparr",
+                start_url = basePath,
+                display = "standalone",
+                background_color = "#ffffff",
+                theme_color = "#ffffff",
+                icons = new[]
+                {
+                    new {
+                        src = "assets/icons/icon-192x192.png",
+                        sizes = "192x192",
+                        type = "image/png"
+                    },
+                    new {
+                        src = "assets/icons/icon-512x512.png",
+                        sizes = "512x512",
+                        type = "image/png"
+                    }
+                }
+            };
+
+            return Results.Json(manifest, contentType: "application/manifest+json");
+        });
 
         return app;
     }

code/backend/Cleanuparr.Api/DependencyInjection/LoggingDI.cs

@@ -27,7 +27,7 @@ public static class LoggingDI
         const string fileOutputTemplate = $"{{@t:yyyy-MM-dd HH:mm:ss.fff zzz}} [{{@l:u3}}]{jobNameTemplate}{categoryTemplate} {{@m:lj}}\n{{@x}}";
 
         // Determine job name padding
-        List<string> jobNames = [nameof(JobType.QueueCleaner), nameof(JobType.ContentBlocker), nameof(JobType.DownloadCleaner)];
+        List<string> jobNames = [nameof(JobType.QueueCleaner), nameof(JobType.MalwareBlocker), nameof(JobType.DownloadCleaner)];
         int jobPadding = jobNames.Max(x => x.Length) + 2;
 
         // Determine instance name padding

code/backend/Cleanuparr.Api/DependencyInjection/MainDI.cs

@@ -1,11 +1,13 @@
 using System.Text.Json.Serialization;
+using Cleanuparr.Domain.Entities.Arr;
+using Cleanuparr.Infrastructure.Features.DownloadHunter.Consumers;
 using Cleanuparr.Infrastructure.Features.DownloadRemover.Consumers;
 using Cleanuparr.Infrastructure.Features.Notifications.Consumers;
+using Cleanuparr.Infrastructure.Features.Notifications.Models;
 using Cleanuparr.Infrastructure.Health;
 using Cleanuparr.Infrastructure.Http;
 using Cleanuparr.Infrastructure.Http.DynamicHttpClientSystem;
 using Data.Models.Arr;
-using Infrastructure.Verticals.Notifications.Models;
 using MassTransit;
 using Microsoft.Extensions.Caching.Memory;
 
@@ -26,7 +28,9 @@ public static class MainDI
             .AddMassTransit(config =>
             {
                 config.AddConsumer<DownloadRemoverConsumer<SearchItem>>();
-                config.AddConsumer<DownloadRemoverConsumer<SonarrSearchItem>>();
+                config.AddConsumer<DownloadRemoverConsumer<SeriesSearchItem>>();
+                config.AddConsumer<DownloadHunterConsumer<SearchItem>>();
+                config.AddConsumer<DownloadHunterConsumer<SeriesSearchItem>>();
                 
                 config.AddConsumer<NotificationConsumer<FailedImportStrikeNotification>>();
                 config.AddConsumer<NotificationConsumer<StalledStrikeNotification>>();
@@ -48,7 +52,15 @@ public static class MainDI
                     cfg.ReceiveEndpoint("download-remover-queue", e =>
                     {
                         e.ConfigureConsumer<DownloadRemoverConsumer<SearchItem>>(context);
-                        e.ConfigureConsumer<DownloadRemoverConsumer<SonarrSearchItem>>(context);
+                        e.ConfigureConsumer<DownloadRemoverConsumer<SeriesSearchItem>>(context);
+                        e.ConcurrentMessageLimit = 2;
+                        e.PrefetchCount = 2;
+                    });
+                    
+                    cfg.ReceiveEndpoint("download-hunter-queue", e =>
+                    {
+                        e.ConfigureConsumer<DownloadHunterConsumer<SearchItem>>(context);
+                        e.ConfigureConsumer<DownloadHunterConsumer<SeriesSearchItem>>(context);
                         e.ConcurrentMessageLimit = 1;
                         e.PrefetchCount = 1;
                     });
@@ -83,9 +95,17 @@ public static class MainDI
     /// </summary>
     private static IServiceCollection AddHealthServices(this IServiceCollection services) =>
         services
-            // Register the health check service
+            // Register the existing health check service for download clients
             .AddSingleton<IHealthCheckService, HealthCheckService>()
             
             // Register the background service for periodic health checks
-            .AddHostedService<HealthCheckBackgroundService>();
+            .AddHostedService<HealthCheckBackgroundService>()
+            
+            // Add ASP.NET Core health checks
+            .AddHealthChecks()
+                .AddCheck<ApplicationHealthCheck>("application", tags: ["liveness"])
+                .AddCheck<DatabaseHealthCheck>("database", tags: ["readiness"])
+                .AddCheck<FileSystemHealthCheck>("filesystem", tags: ["readiness"])
+                .AddCheck<DownloadClientsHealthCheck>("download_clients", tags: ["readiness"])
+            .Services;
 }

code/backend/Cleanuparr.Api/DependencyInjection/ServicesDI.cs

@@ -5,6 +5,8 @@ using Cleanuparr.Infrastructure.Events;
 using Cleanuparr.Infrastructure.Features.Arr;
 using Cleanuparr.Infrastructure.Features.ContentBlocker;
 using Cleanuparr.Infrastructure.Features.DownloadClient;
+using Cleanuparr.Infrastructure.Features.DownloadHunter;
+using Cleanuparr.Infrastructure.Features.DownloadHunter.Interfaces;
 using Cleanuparr.Infrastructure.Features.DownloadRemover;
 using Cleanuparr.Infrastructure.Features.DownloadRemover.Interfaces;
 using Cleanuparr.Infrastructure.Features.Files;
@@ -12,9 +14,9 @@ using Cleanuparr.Infrastructure.Features.ItemStriker;
 using Cleanuparr.Infrastructure.Features.Security;
 using Cleanuparr.Infrastructure.Interceptors;
 using Cleanuparr.Infrastructure.Services;
+using Cleanuparr.Infrastructure.Services.Interfaces;
 using Cleanuparr.Persistence;
 using Infrastructure.Interceptors;
-using Infrastructure.Services.Interfaces;
 using Infrastructure.Verticals.Files;
 
 namespace Cleanuparr.Api.DependencyInjection;
@@ -23,31 +25,32 @@ public static class ServicesDI
 {
     public static IServiceCollection AddServices(this IServiceCollection services) =>
         services
-            .AddSingleton<IEncryptionService, AesEncryptionService>()
-            .AddTransient<SensitiveDataJsonConverter>()
-            .AddTransient<EventsContext>()
-            .AddTransient<DataContext>()
-            .AddTransient<EventPublisher>()
+            .AddScoped<IEncryptionService, AesEncryptionService>()
+            .AddScoped<SensitiveDataJsonConverter>()
+            .AddScoped<EventsContext>()
+            .AddScoped<DataContext>()
+            .AddScoped<EventPublisher>()
             .AddHostedService<EventCleanupService>()
-            // API services
+            .AddScoped<IDryRunInterceptor, DryRunInterceptor>()
+            .AddScoped<CertificateValidationService>()
+            .AddScoped<SonarrClient>()
+            .AddScoped<RadarrClient>()
+            .AddScoped<LidarrClient>()
+            .AddScoped<ReadarrClient>()
+            .AddScoped<WhisparrClient>()
+            .AddScoped<ArrClientFactory>()
+            .AddScoped<QueueCleaner>()
+            .AddScoped<ContentBlocker>()
+            .AddScoped<DownloadCleaner>()
+            .AddScoped<IQueueItemRemover, QueueItemRemover>()
+            .AddScoped<IDownloadHunter, DownloadHunter>()
+            .AddScoped<IFilenameEvaluator, FilenameEvaluator>()
+            .AddScoped<IHardLinkFileService, HardLinkFileService>()
+            .AddScoped<UnixHardLinkFileService>()
+            .AddScoped<WindowsHardLinkFileService>()
+            .AddScoped<ArrQueueIterator>()
+            .AddScoped<DownloadServiceFactory>()
+            .AddScoped<IStriker, Striker>()
             .AddSingleton<IJobManagementService, JobManagementService>()
-            // Core services
-            .AddTransient<IDryRunInterceptor, DryRunInterceptor>()
-            .AddTransient<CertificateValidationService>()
-            .AddTransient<SonarrClient>()
-            .AddTransient<RadarrClient>()
-            .AddTransient<LidarrClient>()
-            .AddTransient<ArrClientFactory>()
-            .AddTransient<QueueCleaner>()
-            .AddTransient<ContentBlocker>()
-            .AddTransient<DownloadCleaner>()
-            .AddTransient<IQueueItemRemover, QueueItemRemover>()
-            .AddTransient<IFilenameEvaluator, FilenameEvaluator>()
-            .AddTransient<IHardLinkFileService, HardLinkFileService>()
-            .AddTransient<UnixHardLinkFileService>()
-            .AddTransient<WindowsHardLinkFileService>()
-            .AddTransient<ArrQueueIterator>()
-            .AddTransient<DownloadServiceFactory>()
-            .AddTransient<IStriker, Striker>()
             .AddSingleton<BlocklistProvider>();
 }

code/backend/Cleanuparr.Api/HealthCheckResponseWriter.cs

@@ -0,0 +1,28 @@
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using System.Text;
+
+namespace Cleanuparr.Api;
+
+/// <summary>
+/// Custom health check response writers for different formats
+/// </summary>
+public static class HealthCheckResponseWriter
+{
+    /// <summary>
+    /// Writes a minimal plain text response suitable for Docker health checks
+    /// </summary>
+    public static async Task WriteMinimalPlaintext(HttpContext context, HealthReport report)
+    {
+        context.Response.ContentType = "text/plain";
+        
+        var status = report.Status switch
+        {
+            HealthStatus.Healthy => "healthy",
+            HealthStatus.Degraded => "degraded", 
+            HealthStatus.Unhealthy => "unhealthy",
+            _ => "unknown"
+        };
+
+        await context.Response.WriteAsync(status, Encoding.UTF8);
+    }
+} 

code/backend/Cleanuparr.Api/HostExtensions.cs

@@ -21,13 +21,16 @@ public static class HostExtensions
         logger.LogInformation("timezone: {tz}", TimeZoneInfo.Local.DisplayName);
         
         // Apply db migrations
-        var eventsContext = app.Services.GetRequiredService<EventsContext>();
+        var scopeFactory = app.Services.GetRequiredService<IServiceScopeFactory>();
+        await using var scope = scopeFactory.CreateAsyncScope();
+        
+        await using var eventsContext = scope.ServiceProvider.GetRequiredService<EventsContext>();
         if ((await eventsContext.Database.GetPendingMigrationsAsync()).Any())
         {
             await eventsContext.Database.MigrateAsync();
         }
 
-        var configContext = app.Services.GetRequiredService<DataContext>();
+        await using var configContext = scope.ServiceProvider.GetRequiredService<DataContext>();
         if ((await configContext.Database.GetPendingMigrationsAsync()).Any())
         {
             await configContext.Database.MigrateAsync();

code/backend/Cleanuparr.Api/Jobs/BackgroundJobManager.cs

@@ -22,18 +22,18 @@ namespace Cleanuparr.Api.Jobs;
 public class BackgroundJobManager : IHostedService
 {
     private readonly ISchedulerFactory _schedulerFactory;
-    private readonly DataContext _dataContext;
+    private readonly IServiceScopeFactory _scopeFactory;
     private readonly ILogger<BackgroundJobManager> _logger;
     private IScheduler? _scheduler;
 
     public BackgroundJobManager(
         ISchedulerFactory schedulerFactory,
-        DataContext dataContext,
+        IServiceScopeFactory scopeFactory,
         ILogger<BackgroundJobManager> logger
     )
     {
         _schedulerFactory = schedulerFactory;
-        _dataContext = dataContext;
+        _scopeFactory = scopeFactory;
         _logger = logger;
     }
 
@@ -86,14 +86,18 @@ public class BackgroundJobManager : IHostedService
             throw new InvalidOperationException("Scheduler not initialized");
         }
         
+        // Use scoped DataContext to prevent memory leaks
+        await using var scope = _scopeFactory.CreateAsyncScope();
+        await using var dataContext = scope.ServiceProvider.GetRequiredService<DataContext>();
+        
         // Get configurations from db
-        QueueCleanerConfig queueCleanerConfig = await _dataContext.QueueCleanerConfigs
+        QueueCleanerConfig queueCleanerConfig = await dataContext.QueueCleanerConfigs
             .AsNoTracking()
             .FirstAsync(cancellationToken);
-        ContentBlockerConfig contentBlockerConfig = await _dataContext.ContentBlockerConfigs
+        ContentBlockerConfig contentBlockerConfig = await dataContext.ContentBlockerConfigs
             .AsNoTracking()
             .FirstAsync(cancellationToken);
-        DownloadCleanerConfig downloadCleanerConfig = await _dataContext.DownloadCleanerConfigs
+        DownloadCleanerConfig downloadCleanerConfig = await dataContext.DownloadCleanerConfigs
             .AsNoTracking()
             .FirstAsync(cancellationToken);
         
@@ -175,7 +179,7 @@ public class BackgroundJobManager : IHostedService
             IOperableTrigger triggerObj = (IOperableTrigger)TriggerBuilder.Create()
                 .WithIdentity("ValidationTrigger")
                 .StartNow()
-                .WithCronSchedule(cronExpression)
+                .WithCronSchedule(cronExpression, x => x.WithMisfireHandlingInstructionDoNothing())
                 .Build();
 
             IReadOnlyList<DateTimeOffset> nextFireTimes = TriggerUtils.ComputeFireTimes(triggerObj, null, 2);
@@ -197,26 +201,26 @@ public class BackgroundJobManager : IHostedService
             }
         }
         
-        // Create cron trigger
+        // Create main cron trigger with consistent naming (matches JobManagementService)
         var trigger = TriggerBuilder.Create()
             .WithIdentity($"{typeName}-trigger")
             .ForJob(jobKey)
             .WithCronSchedule(cronExpression, x => x.WithMisfireHandlingInstructionDoNothing())
-            .StartNow()
             .Build();
         
-        // Create startup trigger to run immediately
+        // Schedule the main trigger
+        await _scheduler.ScheduleJob(trigger, cancellationToken);
+        
+        // Trigger immediate execution for startup using a one-time trigger
         var startupTrigger = TriggerBuilder.Create()
-            .WithIdentity($"{typeName}-startup-trigger")
+            .WithIdentity($"{typeName}-startup-{DateTimeOffset.UtcNow.Ticks}")
             .ForJob(jobKey)
             .StartNow()
             .Build();
         
-        // Schedule job with both triggers
-        await _scheduler.ScheduleJob(trigger, cancellationToken);
         await _scheduler.ScheduleJob(startupTrigger, cancellationToken);
         
-        _logger.LogInformation("Added triggers for job {name} with cron expression {CronExpression}", 
+        _logger.LogInformation("Added trigger for job {name} with cron expression {CronExpression} and immediate startup execution", 
             typeName, cronExpression);
     }
     

code/backend/Cleanuparr.Api/Jobs/GenericJob.cs

@@ -9,12 +9,12 @@ public sealed class GenericJob<T> : IJob
     where T : IHandler
 {
     private readonly ILogger<GenericJob<T>> _logger;
-    private readonly T _handler;
-
-    public GenericJob(ILogger<GenericJob<T>> logger, T handler)
+    private readonly IServiceScopeFactory _scopeFactory;
+    
+    public GenericJob(ILogger<GenericJob<T>> logger, IServiceScopeFactory scopeFactory)
     {
         _logger = logger;
-        _handler = handler;
+        _scopeFactory = scopeFactory;
     }
     
     public async Task Execute(IJobExecutionContext context)
@@ -23,7 +23,9 @@ public sealed class GenericJob<T> : IJob
         
         try
         {
-            await _handler.ExecuteAsync();
+            await using var scope = _scopeFactory.CreateAsyncScope();
+            var handler = scope.ServiceProvider.GetRequiredService<T>();
+            await handler.ExecuteAsync();
         }
         catch (Exception ex)
         {

code/backend/Cleanuparr.Api/Program.cs

@@ -4,6 +4,8 @@ using Cleanuparr.Api;
 using Cleanuparr.Api.DependencyInjection;
 using Cleanuparr.Infrastructure.Logging;
 using Cleanuparr.Shared.Helpers;
+using Microsoft.AspNetCore.Diagnostics.HealthChecks;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
 using Serilog;
 
 var builder = WebApplication.CreateBuilder(args);
@@ -68,7 +70,7 @@ builder.Services.AddCors(options =>
 
 // Register services needed for logging first
 builder.Services
-    .AddTransient<LoggingConfigManager>()
+    .AddScoped<LoggingConfigManager>()
     .AddSingleton<SignalRLogSink>();
 
 // Add logging with proper service provider
@@ -131,21 +133,38 @@ logger.LogInformation("Server configuration: PORT={port}, BASE_PATH={basePath}",
 await app.Init();
 
 // Get LoggingConfigManager (will be created if not already registered)
-var configManager = app.Services.GetRequiredService<LoggingConfigManager>();
-        
-// Get the dynamic level switch for controlling log levels
-var levelSwitch = configManager.GetLevelSwitch();
+var scopeFactory = app.Services.GetRequiredService<IServiceScopeFactory>();
+using (var scope = scopeFactory.CreateScope())
+{
+    var configManager = scope.ServiceProvider.GetRequiredService<LoggingConfigManager>();
+    
+    // Get the dynamic level switch for controlling log levels
+    var levelSwitch = configManager.GetLevelSwitch();
             
-// Get the SignalRLogSink instance
-var signalRSink = app.Services.GetRequiredService<SignalRLogSink>();
+    // Get the SignalRLogSink instance
+    var signalRSink = app.Services.GetRequiredService<SignalRLogSink>();
 
-var logConfig = LoggingDI.GetDefaultLoggerConfiguration();
-logConfig.MinimumLevel.ControlledBy(levelSwitch);
+    var logConfig = LoggingDI.GetDefaultLoggerConfiguration();
+    logConfig.MinimumLevel.ControlledBy(levelSwitch);
         
-// Add to Serilog pipeline
-logConfig.WriteTo.Sink(signalRSink);
+    // Add to Serilog pipeline
+    logConfig.WriteTo.Sink(signalRSink);
 
-Log.Logger = logConfig.CreateLogger();
+    Log.Logger = logConfig.CreateLogger();
+}
+
+// Configure health check endpoints before the API configuration
+app.MapHealthChecks("/health", new HealthCheckOptions
+{
+    Predicate = registration => registration.Tags.Contains("liveness"),
+    ResponseWriter = HealthCheckResponseWriter.WriteMinimalPlaintext
+});
+
+app.MapHealthChecks("/health/ready", new HealthCheckOptions
+{
+    Predicate = registration => registration.Tags.Contains("readiness"),
+    ResponseWriter = HealthCheckResponseWriter.WriteMinimalPlaintext
+});
 
 app.ConfigureApi();
 

code/backend/Cleanuparr.Application/Features/Arr/Dtos/UpdateReadarrConfigDto.cs

@@ -0,0 +1,9 @@
+namespace Cleanuparr.Application.Features.Arr.Dtos;
+
+/// <summary>
+/// DTO for updating Readarr configuration basic settings (instances managed separately)
+/// </summary>
+public record UpdateReadarrConfigDto
+{
+    public short FailedImportMaxStrikes { get; init; } = -1;
+} 

code/backend/Cleanuparr.Application/Features/Arr/Dtos/UpdateWhisparrConfigDto.cs

@@ -0,0 +1,9 @@
+namespace Cleanuparr.Application.Features.Arr.Dtos;
+
+/// <summary>
+/// DTO for updating Whisparr configuration basic settings (instances managed separately)
+/// </summary>
+public record UpdateWhisparrConfigDto
+{
+    public short FailedImportMaxStrikes { get; init; } = -1;
+} 

code/backend/Cleanuparr.Application/Features/ContentBlocker/ContentBlocker.cs

@@ -1,4 +1,5 @@
-using Cleanuparr.Domain.Enums;
+using Cleanuparr.Domain.Entities.Arr.Queue;
+using Cleanuparr.Domain.Enums;
 using Cleanuparr.Infrastructure.Events;
 using Cleanuparr.Infrastructure.Features.Arr;
 using Cleanuparr.Infrastructure.Features.Arr.Interfaces;
@@ -12,7 +13,6 @@ using Cleanuparr.Persistence.Models.Configuration;
 using Cleanuparr.Persistence.Models.Configuration.Arr;
 using Cleanuparr.Persistence.Models.Configuration.ContentBlocker;
 using Cleanuparr.Persistence.Models.Configuration.General;
-using Data.Models.Arr.Queue;
 using MassTransit;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
@@ -52,7 +52,7 @@ public sealed class ContentBlocker : GenericHandler
         
         var config = ContextProvider.Get<ContentBlockerConfig>();
         
-        if (!config.Sonarr.Enabled && !config.Radarr.Enabled && !config.Lidarr.Enabled)
+        if (!config.Sonarr.Enabled && !config.Radarr.Enabled && !config.Lidarr.Enabled && !config.Readarr.Enabled && !config.Whisparr.Enabled)
         {
             _logger.LogWarning("No blocklists are enabled");
             return;
@@ -63,21 +63,33 @@ public sealed class ContentBlocker : GenericHandler
         var sonarrConfig = ContextProvider.Get<ArrConfig>(nameof(InstanceType.Sonarr));
         var radarrConfig = ContextProvider.Get<ArrConfig>(nameof(InstanceType.Radarr));
         var lidarrConfig = ContextProvider.Get<ArrConfig>(nameof(InstanceType.Lidarr));
+        var readarrConfig = ContextProvider.Get<ArrConfig>(nameof(InstanceType.Readarr));
+        var whisparrConfig = ContextProvider.Get<ArrConfig>(nameof(InstanceType.Whisparr));
 
-        if (config.Sonarr.Enabled)
+        if (config.Sonarr.Enabled || config.DeleteKnownMalware)
         {
             await ProcessArrConfigAsync(sonarrConfig, InstanceType.Sonarr);
         }
         
-        if (config.Radarr.Enabled)
+        if (config.Radarr.Enabled || config.DeleteKnownMalware)
         {
             await ProcessArrConfigAsync(radarrConfig, InstanceType.Radarr);
         }
         
-        if (config.Lidarr.Enabled)
+        if (config.Lidarr.Enabled || config.DeleteKnownMalware)
         {
             await ProcessArrConfigAsync(lidarrConfig, InstanceType.Lidarr);
         }
+        
+        if (config.Readarr.Enabled || config.DeleteKnownMalware)
+        {
+            await ProcessArrConfigAsync(readarrConfig, InstanceType.Readarr);
+        }
+        
+        if (config.Whisparr.Enabled || config.DeleteKnownMalware)
+        {
+            await ProcessArrConfigAsync(whisparrConfig, InstanceType.Whisparr);
+        }
     }
 
     protected override async Task ProcessInstanceAsync(ArrInstance instance, InstanceType instanceType)
@@ -171,6 +183,10 @@ public sealed class ContentBlocker : GenericHandler
                             _logger.LogWarning("Download not found in any torrent client | {title}", record.Title);
                         }
                     }
+                    else
+                    {
+                        _logger.LogDebug("No torrent clients enabled");
+                    }
                 }
 
                 if (!result.ShouldRemove)
@@ -194,7 +210,7 @@ public sealed class ContentBlocker : GenericHandler
                     record,
                     group.Count() > 1,
                     removeFromClient,
-                    DeleteReason.AllFilesBlocked
+                    result.DeleteReason
                 );
             }
         });

code/backend/Cleanuparr.Application/Features/DownloadCleaner/DownloadCleaner.cs

@@ -1,3 +1,4 @@
+using Cleanuparr.Domain.Entities.Arr.Queue;
 using Cleanuparr.Domain.Enums;
 using Cleanuparr.Infrastructure.Events;
 using Cleanuparr.Infrastructure.Features.Arr;
@@ -10,7 +11,6 @@ using Cleanuparr.Persistence;
 using Cleanuparr.Persistence.Models.Configuration.Arr;
 using Cleanuparr.Persistence.Models.Configuration.DownloadCleaner;
 using Cleanuparr.Persistence.Models.Configuration.General;
-using Data.Models.Arr.Queue;
 using MassTransit;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
@@ -61,8 +61,8 @@ public sealed class DownloadCleaner : GenericHandler
         
         IReadOnlyList<string> ignoredDownloads = ContextProvider.Get<GeneralConfig>(nameof(GeneralConfig)).IgnoredDownloads;
         
-        // Process each client separately
-        var allDownloads = new List<object>();
+        var downloadServiceToDownloadsMap = new Dictionary<IDownloadService, List<object>>();
+        
         foreach (var downloadService in downloadServices)
         {
             try
@@ -71,24 +71,24 @@ public sealed class DownloadCleaner : GenericHandler
                 var clientDownloads = await downloadService.GetSeedingDownloads();
                 if (clientDownloads?.Count > 0)
                 {
-                    allDownloads.AddRange(clientDownloads);
+                    downloadServiceToDownloadsMap[downloadService] = clientDownloads;
                 }
             }
             catch (Exception ex)
             {
-                _logger.LogError(ex, "Failed to get seeding downloads from download client");
+                _logger.LogError(ex, "Failed to get seeding downloads from download client {clientName}", downloadService.ClientConfig.Name);
             }
         }
 
-        if (allDownloads.Count == 0)
+        if (downloadServiceToDownloadsMap.Count == 0)
         {
             _logger.LogDebug("no seeding downloads found");
             return;
         }
         
-        _logger.LogTrace("found {count} seeding downloads", allDownloads.Count);
+        var totalDownloads = downloadServiceToDownloadsMap.Values.Sum(x => x.Count);
+        _logger.LogTrace("found {count} seeding downloads across {clientCount} clients", totalDownloads, downloadServiceToDownloadsMap.Count);
         
-        // List<object>? downloadsToChangeCategory = null;
         List<Tuple<IDownloadService, List<object>>> downloadServiceWithDownloads = [];
 
         if (isUnlinkedEnabled)
@@ -102,24 +102,23 @@ public sealed class DownloadCleaner : GenericHandler
                 }
                 catch (Exception ex)
                 {
-                    _logger.LogError(ex, "Failed to create category for download client");
+                    _logger.LogError(ex, "Failed to create category for download client {clientName}", downloadService.ClientConfig.Name);
                 }
             }
             
-            // Get downloads to change category
-            foreach (var downloadService in downloadServices)
+            foreach (var (downloadService, clientDownloads) in downloadServiceToDownloadsMap)
             {
                 try
                 {
-                    var clientDownloads = downloadService.FilterDownloadsToChangeCategoryAsync(allDownloads, config.UnlinkedCategories);
-                    if (clientDownloads?.Count > 0)
+                    var downloadsToChangeCategory = downloadService.FilterDownloadsToChangeCategoryAsync(clientDownloads, config.UnlinkedCategories);
+                    if (downloadsToChangeCategory?.Count > 0)
                     {
-                        downloadServiceWithDownloads.Add(Tuple.Create(downloadService, clientDownloads));
+                        downloadServiceWithDownloads.Add(Tuple.Create(downloadService, downloadsToChangeCategory));
                     }
                 }
                 catch (Exception ex)
                 {
-                    _logger.LogError(ex, "Failed to filter downloads for category change");
+                    _logger.LogError(ex, "Failed to filter downloads for category change for download client {clientName}", downloadService.ClientConfig.Name);
                 }
             }
         }
@@ -130,7 +129,9 @@ public sealed class DownloadCleaner : GenericHandler
         await ProcessArrConfigAsync(ContextProvider.Get<ArrConfig>(nameof(InstanceType.Sonarr)), InstanceType.Sonarr, true);
         await ProcessArrConfigAsync(ContextProvider.Get<ArrConfig>(nameof(InstanceType.Radarr)), InstanceType.Radarr, true);
         await ProcessArrConfigAsync(ContextProvider.Get<ArrConfig>(nameof(InstanceType.Lidarr)), InstanceType.Lidarr, true);
-
+        await ProcessArrConfigAsync(ContextProvider.Get<ArrConfig>(nameof(InstanceType.Readarr)), InstanceType.Readarr, true);
+        await ProcessArrConfigAsync(ContextProvider.Get<ArrConfig>(nameof(InstanceType.Whisparr)), InstanceType.Whisparr, true);
+        
         if (isUnlinkedEnabled && downloadServiceWithDownloads.Count > 0)
         {
             _logger.LogInformation("Found {count} potential downloads to change category", downloadServiceWithDownloads.Sum(x => x.Item2.Count));
@@ -156,16 +157,15 @@ public sealed class DownloadCleaner : GenericHandler
             return;
         }
         
-        // Get downloads to clean
         downloadServiceWithDownloads = [];
-        foreach (var downloadService in downloadServices)
+        foreach (var (downloadService, clientDownloads) in downloadServiceToDownloadsMap)
         {
             try
             {
-                var clientDownloads = downloadService.FilterDownloadsToBeCleanedAsync(allDownloads, config.Categories);
-                if (clientDownloads?.Count > 0)
+                var downloadsToClean = downloadService.FilterDownloadsToBeCleanedAsync(clientDownloads, config.Categories);
+                if (downloadsToClean?.Count > 0)
                 {
-                    downloadServiceWithDownloads.Add(Tuple.Create(downloadService, clientDownloads));
+                    downloadServiceWithDownloads.Add(Tuple.Create(downloadService, downloadsToClean));
                 }
             }
             catch (Exception ex)
@@ -174,9 +174,6 @@ public sealed class DownloadCleaner : GenericHandler
             }
         }
         
-        // release unused objects
-        allDownloads = null;
-
         _logger.LogInformation("found {count} potential downloads to clean", downloadServiceWithDownloads.Sum(x => x.Item2.Count));
         
         // Process cleaning for each client

code/backend/Cleanuparr.Application/Features/QueueCleaner/QueueCleaner.cs

@@ -1,3 +1,4 @@
+using Cleanuparr.Domain.Entities.Arr.Queue;
 using Cleanuparr.Domain.Enums;
 using Cleanuparr.Infrastructure.Events;
 using Cleanuparr.Infrastructure.Features.Arr;
@@ -11,7 +12,6 @@ using Cleanuparr.Persistence.Models.Configuration;
 using Cleanuparr.Persistence.Models.Configuration.Arr;
 using Cleanuparr.Persistence.Models.Configuration.General;
 using Cleanuparr.Persistence.Models.Configuration.QueueCleaner;
-using Data.Models.Arr.Queue;
 using MassTransit;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
@@ -42,10 +42,14 @@ public sealed class QueueCleaner : GenericHandler
         var sonarrConfig = ContextProvider.Get<ArrConfig>(nameof(InstanceType.Sonarr));
         var radarrConfig = ContextProvider.Get<ArrConfig>(nameof(InstanceType.Radarr));
         var lidarrConfig = ContextProvider.Get<ArrConfig>(nameof(InstanceType.Lidarr));
+        var readarrConfig = ContextProvider.Get<ArrConfig>(nameof(InstanceType.Readarr));
+        var whisparrConfig = ContextProvider.Get<ArrConfig>(nameof(InstanceType.Whisparr));
         
         await ProcessArrConfigAsync(sonarrConfig, InstanceType.Sonarr);
         await ProcessArrConfigAsync(radarrConfig, InstanceType.Radarr);
         await ProcessArrConfigAsync(lidarrConfig, InstanceType.Lidarr);
+        await ProcessArrConfigAsync(readarrConfig, InstanceType.Readarr);
+        await ProcessArrConfigAsync(whisparrConfig, InstanceType.Whisparr);
     }
 
     protected override async Task ProcessInstanceAsync(ArrInstance instance, InstanceType instanceType)
@@ -103,7 +107,7 @@ public sealed class QueueCleaner : GenericHandler
 
                 DownloadCheckResult downloadCheckResult = new();
 
-                if (record.Protocol is "torrent")
+                if (record.Protocol.Contains("torrent", StringComparison.InvariantCultureIgnoreCase))
                 {
                     var torrentClients = downloadServices
                         .Where(x => x.ClientConfig.Type is DownloadClientType.Torrent)
@@ -137,12 +141,16 @@ public sealed class QueueCleaner : GenericHandler
                             _logger.LogWarning("Download not found in any torrent client | {title}", record.Title);
                         }
                     }
+                    else
+                    {
+                        _logger.LogDebug("No torrent clients enabled");
+                    }
                 }
                 
                 var config = ContextProvider.Get<QueueCleanerConfig>();
                 
                 // failed import check
-                bool shouldRemoveFromArr = await arrClient.ShouldRemoveFromQueue(instanceType, record, downloadCheckResult.IsPrivate, config.FailedImport.MaxStrikes);
+                bool shouldRemoveFromArr = await arrClient.ShouldRemoveFromQueue(instanceType, record, downloadCheckResult.IsPrivate, instance.ArrConfig.FailedImportMaxStrikes);
                 DeleteReason deleteReason = downloadCheckResult.ShouldRemove ? downloadCheckResult.DeleteReason : DeleteReason.FailedImport;
                 
                 if (!shouldRemoveFromArr && !downloadCheckResult.ShouldRemove)

code/backend/Cleanuparr.Domain/Entities/Arr/Queue/Image.cs

@@ -1,4 +1,4 @@
-namespace Data.Models.Arr.Queue;
+namespace Cleanuparr.Domain.Entities.Arr.Queue;
 
 public record Image
 {

code/backend/Cleanuparr.Domain/Entities/Arr/Queue/LidarrImage.cs

@@ -1,4 +1,4 @@
-namespace Data.Models.Arr.Queue;
+namespace Cleanuparr.Domain.Entities.Arr.Queue;
 
 public record LidarrImage
 {

code/backend/Cleanuparr.Domain/Entities/Arr/Queue/QueueAlbum.cs

@@ -1,4 +1,4 @@
-namespace Data.Models.Arr.Queue;
+namespace Cleanuparr.Domain.Entities.Arr.Queue;
 
 public sealed record QueueAlbum
 {

code/backend/Cleanuparr.Domain/Entities/Arr/Queue/QueueBook.cs

@@ -0,0 +1,6 @@
+namespace Cleanuparr.Domain.Entities.Arr.Queue;
+
+public sealed record QueueBook
+{
+    public List<ReadarrImage> Images { get; init; } = [];
+} 

code/backend/Cleanuparr.Domain/Entities/Arr/Queue/QueueListResponse.cs

@@ -1,4 +1,4 @@
-namespace Data.Models.Arr.Queue;
+namespace Cleanuparr.Domain.Entities.Arr.Queue;
 
 public record QueueListResponse
 {

code/backend/Cleanuparr.Domain/Entities/Arr/Queue/QueueMovie.cs

@@ -1,4 +1,4 @@
-namespace Data.Models.Arr.Queue;
+namespace Cleanuparr.Domain.Entities.Arr.Queue;
 
 public sealed record QueueMovie
 {

code/backend/Cleanuparr.Domain/Entities/Arr/Queue/QueueRecord.cs

@@ -1,8 +1,8 @@
-namespace Data.Models.Arr.Queue;
+namespace Cleanuparr.Domain.Entities.Arr.Queue;
 
 public sealed record QueueRecord
 {
-    // Sonarr
+    // Sonarr and Whisparr
     public long SeriesId { get; init; }
     public long EpisodeId { get; init; }
     public long SeasonNumber { get; init; }
@@ -21,6 +21,13 @@ public sealed record QueueRecord
     
     public QueueAlbum? Album { get; init; }
     
+    // Readarr
+    public long AuthorId { get; init; }
+    
+    public long BookId { get; init; }
+    
+    public QueueBook? Book { get; init; }
+    
     // common
     public required string Title { get; init; }
     public string Status { get; init; }

code/backend/Cleanuparr.Domain/Entities/Arr/Queue/QueueSeries.cs

@@ -1,4 +1,4 @@
-namespace Data.Models.Arr.Queue;
+namespace Cleanuparr.Domain.Entities.Arr.Queue;
 
 public sealed record QueueSeries
 {

code/backend/Cleanuparr.Domain/Entities/Arr/Queue/ReadarrImage.cs

@@ -0,0 +1,8 @@
+namespace Cleanuparr.Domain.Entities.Arr.Queue;
+
+public sealed record ReadarrImage
+{
+    public required string CoverType { get; init; }
+    
+    public required Uri Url { get; init; }
+}

code/backend/Cleanuparr.Domain/Entities/Arr/Queue/TrackedDownloadStatusMessage.cs

@@ -1,4 +1,4 @@
-namespace Data.Models.Arr.Queue;
+namespace Cleanuparr.Domain.Entities.Arr.Queue;
 
 public sealed record TrackedDownloadStatusMessage
 {

code/backend/Cleanuparr.Domain/Entities/Arr/SeriesSearchItem.cs

@@ -1,16 +1,17 @@
 using Cleanuparr.Domain.Enums;
+using Data.Models.Arr;
 
-namespace Data.Models.Arr;
+namespace Cleanuparr.Domain.Entities.Arr;
 
-public sealed class SonarrSearchItem : SearchItem
+public sealed class SeriesSearchItem : SearchItem
 {
     public long SeriesId { get; set; }
     
-    public SonarrSearchType SearchType { get; set; }
+    public SeriesSearchType SearchType { get; set; }
     
     public override bool Equals(object? obj)
     {
-        if (obj is not SonarrSearchItem other)
+        if (obj is not SeriesSearchItem other)
         {
             return false;
         }

code/backend/Cleanuparr.Domain/Entities/Readarr/Author.cs

@@ -0,0 +1,8 @@
+namespace Cleanuparr.Domain.Entities.Readarr;
+
+public sealed record Author
+{
+    public long Id { get; set; }
+    
+    public string AuthorName { get; set; } = string.Empty;
+} 

code/backend/Cleanuparr.Domain/Entities/Readarr/Book.cs

@@ -0,0 +1,12 @@
+namespace Cleanuparr.Domain.Entities.Readarr;
+
+public sealed record Book
+{
+    public required long Id { get; init; }
+    
+    public required string Title { get; init; }
+    
+    public long AuthorId { get; set; }
+    
+    public Author Author { get; set; } = new();
+} 

code/backend/Cleanuparr.Domain/Entities/Readarr/ReadarrCommand.cs

@@ -0,0 +1,8 @@
+namespace Cleanuparr.Domain.Entities.Readarr;
+
+public sealed record ReadarrCommand
+{
+    public string Name { get; set; } = string.Empty;
+    
+    public List<long> BookIds { get; set; } = [];
+} 

code/backend/Cleanuparr.Domain/Entities/Sonarr/SonarrCommand.cs

@@ -12,5 +12,5 @@ public sealed record SonarrCommand
     
     public List<long>? EpisodeIds { get; set; }
     
-    public SonarrSearchType SearchType { get; set; }
+    public SeriesSearchType SearchType { get; set; }
 }

code/backend/Cleanuparr.Domain/Entities/UTorrent/Request/UTorrentRequest.cs

@@ -0,0 +1,69 @@
+namespace Cleanuparr.Domain.Entities.UTorrent.Request;
+
+/// <summary>
+/// Represents a request to the µTorrent Web UI API
+/// </summary>
+public sealed class UTorrentRequest
+{
+    /// <summary>
+    /// The API action to perform
+    /// </summary>
+    public string Action { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Authentication token (required for CSRF protection)
+    /// </summary>
+    public string Token { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Additional parameters for the request
+    /// </summary>
+    public List<(string Name, string Value)> Parameters { get; set; } = new();
+
+    /// <summary>
+    /// Constructs the query string for the API call
+    /// </summary>
+    /// <returns>The complete query string including token and action</returns>
+    public string ToQueryString()
+    {
+        var queryParams = new List<string>
+        {
+            $"token={Token}",
+            Action
+        };
+
+        foreach (var param in Parameters)
+        {
+            queryParams.Add($"{Uri.EscapeDataString(param.Name)}={Uri.EscapeDataString(param.Value)}");
+        }
+
+        return string.Join("&", queryParams);
+    }
+
+    /// <summary>
+    /// Creates a new request with the specified action
+    /// </summary>
+    /// <param name="action">The API action</param>
+    /// <param name="token">Authentication token</param>
+    /// <returns>A new UTorrentRequest instance</returns>
+    public static UTorrentRequest Create(string action, string token)
+    {
+        return new UTorrentRequest
+        {
+            Action = action,
+            Token = token
+        };
+    }
+
+    /// <summary>
+    /// Adds a parameter to the request
+    /// </summary>
+    /// <param name="key">Parameter name</param>
+    /// <param name="value">Parameter value</param>
+    /// <returns>This instance for method chaining</returns>
+    public UTorrentRequest WithParameter(string key, string value)
+    {
+        Parameters.Add((key, value));
+        return this;
+    }
+} 

code/backend/Cleanuparr.Domain/Entities/UTorrent/Response/FileListResponse.cs

@@ -0,0 +1,28 @@
+using Newtonsoft.Json;
+
+namespace Cleanuparr.Domain.Entities.UTorrent.Response;
+
+/// <summary>
+/// Specific response type for file list API calls
+/// Replaces the generic UTorrentResponse<T> for file listings
+/// </summary>
+public sealed class FileListResponse
+{
+    /// <summary>
+    /// Raw file data from the API
+    /// </summary>
+    [JsonProperty(PropertyName = "files")]
+    public object[]? FilesRaw { get; set; }
+
+    /// <summary>
+    /// Torrent hash for which files are listed
+    /// </summary>
+    [JsonIgnore]
+    public string Hash { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Parsed files as strongly-typed objects
+    /// </summary>
+    [JsonIgnore]
+    public List<UTorrentFile> Files { get; set; } = new();
+}

code/backend/Cleanuparr.Domain/Entities/UTorrent/Response/LabelListResponse.cs

@@ -0,0 +1,22 @@
+using Newtonsoft.Json;
+
+namespace Cleanuparr.Domain.Entities.UTorrent.Response;
+
+/// <summary>
+/// Specific response type for label list API calls
+/// Replaces the generic UTorrentResponse<T> for label listings
+/// </summary>
+public sealed class LabelListResponse
+{
+    /// <summary>
+    /// Raw label data from the API
+    /// </summary>
+    [JsonProperty(PropertyName = "label")]
+    public object[][]? LabelsRaw { get; set; }
+
+    /// <summary>
+    /// Parsed labels as string list
+    /// </summary>
+    [JsonIgnore]
+    public List<string> Labels { get; set; } = new();
+}

code/backend/Cleanuparr.Domain/Entities/UTorrent/Response/PropertiesResponse.cs

@@ -0,0 +1,22 @@
+using Newtonsoft.Json;
+
+namespace Cleanuparr.Domain.Entities.UTorrent.Response;
+
+/// <summary>
+/// Specific response type for torrent properties API calls
+/// Replaces the generic UTorrentResponse<T> for properties retrieval
+/// </summary>
+public sealed class PropertiesResponse
+{
+    /// <summary>
+    /// Raw properties data from the API
+    /// </summary>
+    [JsonProperty(PropertyName = "props")]
+    public object[]? PropertiesRaw { get; set; }
+
+    /// <summary>
+    /// Parsed properties as strongly-typed object
+    /// </summary>
+    [JsonIgnore]
+    public UTorrentProperties Properties { get; set; } = new();
+}

code/backend/Cleanuparr.Domain/Entities/UTorrent/Response/TorrentListResponse.cs

@@ -0,0 +1,40 @@
+using Newtonsoft.Json;
+
+namespace Cleanuparr.Domain.Entities.UTorrent.Response;
+
+/// <summary>
+/// Specific response type for torrent list API calls
+/// Replaces the generic UTorrentResponse<T> for torrent listings
+/// </summary>
+public sealed class TorrentListResponse
+{
+    /// <summary>
+    /// µTorrent build number
+    /// </summary>
+    [JsonProperty(PropertyName = "build")]
+    public int Build { get; set; }
+
+    /// <summary>
+    /// List of torrent data from the API
+    /// </summary>
+    [JsonProperty(PropertyName = "torrents")]
+    public object[][]? TorrentsRaw { get; set; }
+
+    /// <summary>
+    /// Label data from the API
+    /// </summary>
+    [JsonProperty(PropertyName = "label")]
+    public object[][]? LabelsRaw { get; set; }
+
+    /// <summary>
+    /// Parsed torrents as strongly-typed objects
+    /// </summary>
+    [JsonIgnore]
+    public List<UTorrentItem> Torrents { get; set; } = new();
+
+    /// <summary>
+    /// Parsed labels as string list
+    /// </summary>
+    [JsonIgnore]
+    public List<string> Labels { get; set; } = new();
+}

code/backend/Cleanuparr.Domain/Entities/UTorrent/Response/UTorrentFile.cs

@@ -0,0 +1,18 @@
+namespace Cleanuparr.Domain.Entities.UTorrent.Response;
+
+/// <summary>
+/// Represents a file within a torrent from µTorrent Web UI API
+/// Based on the files array structure from the API documentation
+/// </summary>
+public sealed class UTorrentFile
+{
+    public string Name { get; set; } = string.Empty;
+
+    public long Size { get; set; }
+
+    public long Downloaded { get; set; }
+
+    public int Priority { get; set; }
+
+    public int Index { get; set; }
+} 

code/backend/Cleanuparr.Domain/Entities/UTorrent/Response/UTorrentItem.cs

@@ -0,0 +1,181 @@
+using Newtonsoft.Json;
+
+namespace Cleanuparr.Domain.Entities.UTorrent.Response;
+
+/// <summary>
+/// Represents a torrent from µTorrent Web UI API
+/// Based on the torrent array structure from the API documentation
+/// </summary>
+public sealed class UTorrentItem
+{
+    /// <summary>
+    /// Torrent hash (index 0)
+    /// </summary>
+    public string Hash { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Status bitfield (index 1)
+    /// </summary>
+    public int Status { get; set; }
+
+    /// <summary>
+    /// Torrent name (index 2)
+    /// </summary>
+    public string Name { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Total size in bytes (index 3)
+    /// </summary>
+    public long Size { get; set; }
+
+    /// <summary>
+    /// Progress in permille (1000 = 100%) (index 4)
+    /// </summary>
+    public int Progress { get; set; }
+
+    /// <summary>
+    /// Downloaded bytes (index 5)
+    /// </summary>
+    public long Downloaded { get; set; }
+
+    /// <summary>
+    /// Uploaded bytes (index 6)
+    /// </summary>
+    public long Uploaded { get; set; }
+
+    /// <summary>
+    /// Ratio * 1000 (index 7)
+    /// </summary>
+    public int RatioRaw { get; set; }
+
+    /// <summary>
+    /// Upload speed in bytes/sec (index 8)
+    /// </summary>
+    public int UploadSpeed { get; set; }
+
+    /// <summary>
+    /// Download speed in bytes/sec (index 9)
+    /// </summary>
+    public int DownloadSpeed { get; set; }
+
+    /// <summary>
+    /// ETA in seconds (index 10)
+    /// </summary>
+    public int ETA { get; set; }
+
+    /// <summary>
+    /// Label (index 11)
+    /// </summary>
+    public string Label { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Connected peers (index 12)
+    /// </summary>
+    public int PeersConnected { get; set; }
+
+    /// <summary>
+    /// Peers in swarm (index 13)
+    /// </summary>
+    public int PeersInSwarm { get; set; }
+
+    /// <summary>
+    /// Connected seeds (index 14)
+    /// </summary>
+    public int SeedsConnected { get; set; }
+
+    /// <summary>
+    /// Seeds in swarm (index 15)
+    /// </summary>
+    public int SeedsInSwarm { get; set; }
+
+    /// <summary>
+    /// Availability (index 16)
+    /// </summary>
+    public int Availability { get; set; }
+
+    /// <summary>
+    /// Queue order (index 17)
+    /// </summary>
+    public int QueueOrder { get; set; }
+
+    /// <summary>
+    /// Remaining bytes (index 18)
+    /// </summary>
+    public long Remaining { get; set; }
+
+    /// <summary>
+    /// Download URL (index 19)
+    /// </summary>
+    public string DownloadUrl { get; set; } = string.Empty;
+
+    /// <summary>
+    /// RSS feed URL (index 20)
+    /// </summary>
+    public string RssFeedUrl { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Status message (index 21)
+    /// </summary>
+    public string StatusMessage { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Stream ID (index 22)
+    /// </summary>
+    public string StreamId { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Date added as Unix timestamp (index 23)
+    /// </summary>
+    public long DateAdded { get; set; }
+
+    /// <summary>
+    /// Date completed as Unix timestamp (index 24)
+    /// </summary>
+    public long DateCompleted { get; set; }
+
+    /// <summary>
+    /// App update URL (index 25)
+    /// </summary>
+    public string AppUpdateUrl { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Save path (index 26)
+    /// </summary>
+    public string SavePath { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Calculated ratio value (RatioRaw / 1000.0)
+    /// </summary>
+    [JsonIgnore]
+    public double Ratio => RatioRaw / 1000.0;
+
+    /// <summary>
+    /// Progress as percentage (0.0 to 1.0)
+    /// </summary>
+    [JsonIgnore]
+    public double ProgressPercent => Progress / 1000.0;
+
+    /// <summary>
+    /// Date completed as DateTime (or null if not completed)
+    /// </summary>
+    [JsonIgnore]
+    public DateTime? DateCompletedDateTime => 
+        DateCompleted > 0 ? DateTimeOffset.FromUnixTimeSeconds(DateCompleted).DateTime : null;
+
+    /// <summary>
+    /// Seeding time in seconds (calculated from DateCompleted to now)
+    /// </summary>
+    [JsonIgnore]
+    public TimeSpan? SeedingTime
+    {
+        get
+        {
+            if (DateCompletedDateTime.HasValue)
+            {
+                return DateTime.UtcNow - DateCompletedDateTime.Value;
+            }
+            
+            return null;
+        }
+    }
+} 

code/backend/Cleanuparr.Domain/Entities/UTorrent/Response/UTorrentProperties.cs

@@ -0,0 +1,85 @@
+namespace Cleanuparr.Domain.Entities.UTorrent.Response;
+
+/// <summary>
+/// Represents torrent properties from µTorrent Web UI API getprops action
+/// Based on the properties structure from the API documentation
+/// </summary>
+public sealed class UTorrentProperties
+{
+    /// <summary>
+    /// Torrent hash
+    /// </summary>
+    public string Hash { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Trackers list (newlines are represented by \r\n)
+    /// </summary>
+    public string Trackers { get; set; } = string.Empty;
+    
+    public List<string> TrackerList => Trackers
+        .Split(new[] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries)
+        .Select(x => x.Trim())
+        .Where(x => !string.IsNullOrWhiteSpace(x))
+        .ToList();
+
+    /// <summary>
+    /// Upload limit in bytes per second
+    /// </summary>
+    public int UploadLimit { get; set; }
+
+    /// <summary>
+    /// Download limit in bytes per second
+    /// </summary>
+    public int DownloadLimit { get; set; }
+
+    /// <summary>
+    /// Initial seeding / Super seeding
+    /// -1 = Not allowed, 0 = Disabled, 1 = Enabled
+    /// </summary>
+    public int SuperSeed { get; set; }
+
+    /// <summary>
+    /// Use DHT
+    /// -1 = Not allowed, 0 = Disabled, 1 = Enabled
+    /// </summary>
+    public int Dht { get; set; }
+
+    /// <summary>
+    /// Use PEX (Peer Exchange)
+    /// -1 = Not allowed (indicates private torrent), 0 = Disabled, 1 = Enabled
+    /// </summary>
+    public int Pex { get; set; }
+
+    /// <summary>
+    /// Override queueing
+    /// -1 = Not allowed, 0 = Disabled, 1 = Enabled
+    /// </summary>
+    public int SeedOverride { get; set; }
+
+    /// <summary>
+    /// Seed ratio in per mils (1000 = 1.0 ratio)
+    /// </summary>
+    public int SeedRatio { get; set; }
+
+    /// <summary>
+    /// Seeding time in seconds
+    /// 0 = No minimum seeding time
+    /// </summary>
+    public int SeedTime { get; set; }
+
+    /// <summary>
+    /// Upload slots
+    /// </summary>
+    public int UploadSlots { get; set; }
+
+    /// <summary>
+    /// Whether this torrent is private (based on PEX value)
+    /// Private torrents have PEX = -1 (not allowed)
+    /// </summary>
+    public bool IsPrivate => Pex == -1;
+
+    /// <summary>
+    /// Calculated seed ratio value (SeedRatio / 1000.0)
+    /// </summary>
+    public double SeedRatioValue => SeedRatio / 1000.0;
+} 

code/backend/Cleanuparr.Domain/Entities/UTorrent/Response/UTorrentResponse.cs

@@ -0,0 +1,61 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Cleanuparr.Domain.Entities.UTorrent.Response;
+
+/// <summary>
+/// Base response wrapper for µTorrent Web UI API calls
+/// </summary>
+public sealed record UTorrentResponse<T>
+{
+    [JsonProperty(PropertyName = "build")]
+    public int Build { get; set; }
+
+    [JsonProperty(PropertyName = "label")]
+    public object[][]? Labels { get; set; }
+
+    [JsonProperty(PropertyName = "torrents")]
+    public T? Torrents { get; set; }
+
+    [JsonProperty(PropertyName = "torrentp")]
+    public object[]? TorrentProperties { get; set; }
+
+    [JsonProperty(PropertyName = "files")]
+    public object[]? FilesDto { get; set; }
+    
+    [JsonIgnore]
+    public List<UTorrentFile>? Files
+    {
+        get
+        {
+            if (FilesDto is null || FilesDto.Length < 2)
+            {
+                return null;
+            }
+
+            var files = new List<UTorrentFile>();
+            
+            if (FilesDto[1] is JArray jArray)
+            {
+                foreach (var jToken in jArray)
+                {
+                    var fileTokenArray = (JArray)jToken;
+                    var fileArray = fileTokenArray.ToObject<object[]>() ?? [];
+                    files.Add(new UTorrentFile
+                    {
+                        Name = fileArray[0].ToString() ?? string.Empty,
+                        Size = Convert.ToInt64(fileArray[1]),
+                        Downloaded = Convert.ToInt64(fileArray[2]),
+                        Priority = Convert.ToInt32(fileArray[3]),
+                    });
+                }
+                
+            }
+
+            return files;
+        }
+    }
+
+    [JsonProperty(PropertyName = "props")]
+    public UTorrentProperties[]? Properties { get; set; }
+} 

code/backend/Cleanuparr.Domain/Entities/Whisparr/WhisparrCommand.cs

@@ -0,0 +1,16 @@
+using Cleanuparr.Domain.Enums;
+
+namespace Cleanuparr.Domain.Entities.Whisparr;
+
+public sealed record WhisparrCommand
+{
+    public string Name { get; set; }
+
+    public long? SeriesId { get; set; }
+    
+    public long? SeasonNumber { get; set; }
+    
+    public List<long>? EpisodeIds { get; set; }
+    
+    public SeriesSearchType SearchType { get; set; }
+} 

code/backend/Cleanuparr.Domain/Enums/DeleteReason.cs

@@ -11,4 +11,5 @@ public enum DeleteReason
     AllFilesSkipped,
     AllFilesSkippedByQBit,
     AllFilesBlocked,
+    MalwareFileFound,
 }

code/backend/Cleanuparr.Domain/Enums/DownloadClientTypeName.cs

@@ -2,7 +2,8 @@
 
 public enum DownloadClientTypeName
 {
-    QBittorrent,
+    qBittorrent,
     Deluge,
     Transmission,
-}
+    uTorrent,
+}

code/backend/Cleanuparr.Domain/Enums/SeriesSearchType.cs

@@ -1,6 +1,6 @@
 namespace Cleanuparr.Domain.Enums;
 
-public enum SonarrSearchType
+public enum SeriesSearchType
 {
     Episode,
     Season,

code/backend/Cleanuparr.Domain/Exceptions/DelugeClientException.cs

@@ -1,4 +1,4 @@
-namespace Data.Models.Deluge.Exceptions;
+namespace Cleanuparr.Domain.Exceptions;
 
 public class DelugeClientException : Exception
 {

code/backend/Cleanuparr.Domain/Exceptions/DelugeLoginException.cs

@@ -1,4 +1,4 @@
-namespace Data.Models.Deluge.Exceptions;
+namespace Cleanuparr.Domain.Exceptions;
 
 public sealed class DelugeLoginException : DelugeClientException
 {

code/backend/Cleanuparr.Domain/Exceptions/DelugeLogoutException.cs

@@ -1,4 +1,4 @@
-namespace Data.Models.Deluge.Exceptions;
+namespace Cleanuparr.Domain.Exceptions;
 
 public sealed class DelugeLogoutException : DelugeClientException
 {

code/backend/Cleanuparr.Domain/Exceptions/UTorrentAuthenticationException.cs

@@ -0,0 +1,15 @@
+namespace Cleanuparr.Domain.Exceptions;
+
+/// <summary>
+/// Exception thrown when µTorrent authentication fails
+/// </summary>
+public class UTorrentAuthenticationException : UTorrentException
+{
+    public UTorrentAuthenticationException(string message) : base(message)
+    {
+    }
+    
+    public UTorrentAuthenticationException(string message, Exception innerException) : base(message, innerException)
+    {
+    }
+}

code/backend/Cleanuparr.Domain/Exceptions/UTorrentException.cs

@@ -0,0 +1,12 @@
+namespace Cleanuparr.Domain.Exceptions;
+
+public class UTorrentException : Exception
+{
+    public UTorrentException(string message) : base(message)
+    {
+    }
+    
+    public UTorrentException(string message, Exception innerException) : base(message, innerException)
+    {
+    }
+}

code/backend/Cleanuparr.Domain/Exceptions/UTorrentParsingException.cs

@@ -0,0 +1,22 @@
+namespace Cleanuparr.Domain.Exceptions;
+
+/// <summary>
+/// Exception thrown when µTorrent response parsing fails
+/// </summary>
+public class UTorrentParsingException : UTorrentException
+{
+    /// <summary>
+    /// The raw response that failed to parse
+    /// </summary>
+    public string RawResponse { get; }
+
+    public UTorrentParsingException(string message, string rawResponse) : base(message)
+    {
+        RawResponse = rawResponse;
+    }
+    
+    public UTorrentParsingException(string message, string rawResponse, Exception innerException) : base(message, innerException)
+    {
+        RawResponse = rawResponse;
+    }
+}

code/backend/Cleanuparr.Infrastructure.Tests/Cleanuparr.Infrastructure.Tests.csproj

@@ -16,6 +16,7 @@
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
+        <PackageReference Include="Moq" Version="4.20.72" />
         <PackageReference Include="NSubstitute" Version="5.3.0" />
         <PackageReference Include="Serilog" Version="4.3.0" />
         <PackageReference Include="Serilog.Expressions" Version="5.0.0" />

code/backend/Cleanuparr.Infrastructure.Tests/Verticals/DownloadClient/UTorrentClientTests.cs

@@ -0,0 +1,266 @@
+using System.Net;
+using Cleanuparr.Domain.Entities.UTorrent.Response;
+using Cleanuparr.Domain.Enums;
+using Cleanuparr.Infrastructure.Features.DownloadClient.UTorrent;
+using Cleanuparr.Persistence.Models.Configuration;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Moq.Protected;
+using Newtonsoft.Json;
+using Xunit;
+
+namespace Cleanuparr.Infrastructure.Tests.Verticals.DownloadClient;
+
+public class UTorrentClientTests
+{
+    private readonly UTorrentClient _client;
+    private readonly Mock<HttpMessageHandler> _mockHttpHandler;
+    private readonly DownloadClientConfig _config;
+    private readonly Mock<IUTorrentAuthenticator> _mockAuthenticator;
+    private readonly Mock<IUTorrentHttpService> _mockHttpService;
+    private readonly Mock<IUTorrentResponseParser> _mockResponseParser;
+    private readonly Mock<ILogger<UTorrentClient>> _mockLogger;
+
+    public UTorrentClientTests()
+    {
+        _mockHttpHandler = new Mock<HttpMessageHandler>();
+        _mockAuthenticator = new Mock<IUTorrentAuthenticator>();
+        _mockHttpService = new Mock<IUTorrentHttpService>();
+        _mockResponseParser = new Mock<IUTorrentResponseParser>();
+        _mockLogger = new Mock<ILogger<UTorrentClient>>();
+        
+        _config = new DownloadClientConfig
+        {
+            Name = "test",
+            Type = DownloadClientType.Torrent,
+            TypeName = DownloadClientTypeName.uTorrent,
+            Host = new Uri("http://localhost:8080"),
+            Username = "admin",
+            Password = "password"
+        };
+
+        _client = new UTorrentClient(
+            _config,
+            _mockAuthenticator.Object,
+            _mockHttpService.Object,
+            _mockResponseParser.Object,
+            _mockLogger.Object
+        );
+    }
+
+    [Fact]
+    public async Task GetTorrentFilesAsync_ShouldDeserializeMixedArrayCorrectly()
+    {
+        // Arrange
+        var mockResponse = new UTorrentResponse<object>
+        {
+            Build = 30470,
+            FilesDto = new object[]
+            {
+                "F0616FB199B78254474AF6D72705177E71D713ED", // Hash (string)
+                new object[] // File 1
+                {
+                    "test name",
+                    2604L,
+                    0L,
+                    2,
+                    0,
+                    1,
+                    false,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    0
+                },
+                new object[] // File 2
+                {
+                    "Dir1/Dir11/test11.zipx",
+                    2604L,
+                    0L,
+                    2,
+                    0,
+                    1,
+                    false,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    0
+                },
+                new object[] // File 3
+                {
+                    "Dir1/sample.txt",
+                    2604L,
+                    0L,
+                    2,
+                    0,
+                    1,
+                    false,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    0
+                }
+            }
+        };
+
+        // Mock the token request
+        var tokenResponse = new HttpResponseMessage
+        {
+            StatusCode = HttpStatusCode.OK,
+            Content = new StringContent("<div id='token'>test-token</div>")
+        };
+        tokenResponse.Headers.Add("Set-Cookie", "GUID=test-guid; path=/");
+
+        // Mock the files request
+        var filesResponse = new HttpResponseMessage
+        {
+            StatusCode = HttpStatusCode.OK,
+            Content = new StringContent(JsonConvert.SerializeObject(mockResponse))
+        };
+
+        // Setup mock to return different responses based on URL
+        _mockHttpHandler
+            .Protected()
+            .Setup<Task<HttpResponseMessage>>("SendAsync", 
+                ItExpr.Is<HttpRequestMessage>(req => req.RequestUri!.AbsolutePath.Contains("token.html")), 
+                ItExpr.IsAny<CancellationToken>())
+            .ReturnsAsync(tokenResponse);
+
+        _mockHttpHandler
+            .Protected()
+            .Setup<Task<HttpResponseMessage>>("SendAsync", 
+                ItExpr.Is<HttpRequestMessage>(req => req.RequestUri!.AbsolutePath.Contains("gui") && req.RequestUri.Query.Contains("action=getfiles")), 
+                ItExpr.IsAny<CancellationToken>())
+            .ReturnsAsync(filesResponse);
+
+        // Act
+        var files = await _client.GetTorrentFilesAsync("test-hash");
+
+        // Assert
+        Assert.NotNull(files);
+        Assert.Equal(3, files.Count);
+        
+        Assert.Equal("test name", files[0].Name);
+        Assert.Equal(2604L, files[0].Size);
+        Assert.Equal(0L, files[0].Downloaded);
+        Assert.Equal(2, files[0].Priority);
+        Assert.Equal(0, files[0].Index);
+        
+        Assert.Equal("Dir1/Dir11/test11.zipx", files[1].Name);
+        Assert.Equal(2604L, files[1].Size);
+        Assert.Equal(0L, files[1].Downloaded);
+        Assert.Equal(2, files[1].Priority);
+        Assert.Equal(1, files[1].Index);
+        
+        Assert.Equal("Dir1/sample.txt", files[2].Name);
+        Assert.Equal(2604L, files[2].Size);
+        Assert.Equal(0L, files[2].Downloaded);
+        Assert.Equal(2, files[2].Priority);
+        Assert.Equal(2, files[2].Index);
+    }
+
+    [Fact]
+    public async Task GetTorrentFilesAsync_ShouldHandleEmptyResponse()
+    {
+        // Arrange
+        var mockResponse = new UTorrentResponse<object>
+        {
+            Build = 30470,
+            FilesDto = new object[]
+            {
+                "F0616FB199B78254474AF6D72705177E71D713ED" // Only hash, no files
+            }
+        };
+
+        // Mock the token request
+        var tokenResponse = new HttpResponseMessage
+        {
+            StatusCode = HttpStatusCode.OK,
+            Content = new StringContent("<div id='token'>test-token</div>")
+        };
+        tokenResponse.Headers.Add("Set-Cookie", "GUID=test-guid; path=/");
+
+        // Mock the files request
+        var filesResponse = new HttpResponseMessage
+        {
+            StatusCode = HttpStatusCode.OK,
+            Content = new StringContent(JsonConvert.SerializeObject(mockResponse))
+        };
+
+        // Setup mock to return different responses based on URL
+        _mockHttpHandler
+            .Protected()
+            .Setup<Task<HttpResponseMessage>>("SendAsync", 
+                ItExpr.Is<HttpRequestMessage>(req => req.RequestUri!.AbsolutePath.Contains("token.html")), 
+                ItExpr.IsAny<CancellationToken>())
+            .ReturnsAsync(tokenResponse);
+
+        _mockHttpHandler
+            .Protected()
+            .Setup<Task<HttpResponseMessage>>("SendAsync", 
+                ItExpr.Is<HttpRequestMessage>(req => req.RequestUri!.AbsolutePath.Contains("gui") && req.RequestUri.Query.Contains("action=getfiles")), 
+                ItExpr.IsAny<CancellationToken>())
+            .ReturnsAsync(filesResponse);
+
+        // Act
+        var files = await _client.GetTorrentFilesAsync("test-hash");
+
+        // Assert
+        Assert.NotNull(files);
+        Assert.Empty(files);
+    }
+
+    [Fact]
+    public async Task GetTorrentFilesAsync_ShouldHandleNullResponse()
+    {
+        // Arrange
+        var mockResponse = new UTorrentResponse<object>
+        {
+            Build = 30470,
+            FilesDto = null
+        };
+
+        // Mock the token request
+        var tokenResponse = new HttpResponseMessage
+        {
+            StatusCode = HttpStatusCode.OK,
+            Content = new StringContent("<div id='token'>test-token</div>")
+        };
+        tokenResponse.Headers.Add("Set-Cookie", "GUID=test-guid; path=/");
+
+        // Mock the files request
+        var filesResponse = new HttpResponseMessage
+        {
+            StatusCode = HttpStatusCode.OK,
+            Content = new StringContent(JsonConvert.SerializeObject(mockResponse))
+        };
+
+        // Setup mock to return different responses based on URL
+        _mockHttpHandler
+            .Protected()
+            .Setup<Task<HttpResponseMessage>>("SendAsync", 
+                ItExpr.Is<HttpRequestMessage>(req => req.RequestUri!.AbsolutePath.Contains("token.html")), 
+                ItExpr.IsAny<CancellationToken>())
+            .ReturnsAsync(tokenResponse);
+
+        _mockHttpHandler
+            .Protected()
+            .Setup<Task<HttpResponseMessage>>("SendAsync", 
+                ItExpr.Is<HttpRequestMessage>(req => req.RequestUri!.AbsolutePath.Contains("gui") && req.RequestUri.Query.Contains("action=getfiles")), 
+                ItExpr.IsAny<CancellationToken>())
+            .ReturnsAsync(filesResponse);
+
+        // Act
+        var files = await _client.GetTorrentFilesAsync("test-hash");
+
+        // Assert
+        Assert.NotNull(files);
+        Assert.Empty(files);
+    }
+} 

code/backend/Cleanuparr.Infrastructure/Cleanuparr.Infrastructure.csproj

@@ -6,16 +6,13 @@
         <Nullable>enable</Nullable>
     </PropertyGroup>
 
-    <ItemGroup>
-      <Folder Include="Features\" />
-    </ItemGroup>
-
     <ItemGroup>
       <PackageReference Include="FLM.QBittorrent" Version="1.0.1" />
       <PackageReference Include="FLM.Transmission" Version="1.0.3" />
       <PackageReference Include="Mapster" Version="7.4.0" />
       <PackageReference Include="MassTransit.Abstractions" Version="8.4.1" />
       <PackageReference Include="Microsoft.AspNetCore.SignalR" Version="1.2.0" />
+      <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions" Version="9.0.0" />
       <PackageReference Include="Microsoft.Extensions.Http" Version="9.0.6" />
       <PackageReference Include="Microsoft.Extensions.Http.Polly" Version="9.0.6" />
       <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.6" />

code/backend/Cleanuparr.Infrastructure/Events/EventCleanupService.cs

@@ -11,15 +11,15 @@ namespace Cleanuparr.Infrastructure.Events;
 /// </summary>
 public class EventCleanupService : BackgroundService
 {
-    private readonly IServiceProvider _serviceProvider;
     private readonly ILogger<EventCleanupService> _logger;
+    private readonly IServiceScopeFactory _scopeFactory;
     private readonly TimeSpan _cleanupInterval = TimeSpan.FromHours(4); // Run every 4 hours
     private readonly int _retentionDays = 30; // Keep events for 30 days
 
-    public EventCleanupService(IServiceProvider serviceProvider, ILogger<EventCleanupService> logger)
+    public EventCleanupService(ILogger<EventCleanupService> logger, IServiceScopeFactory scopeFactory)
     {
-        _serviceProvider = serviceProvider;
         _logger = logger;
+        _scopeFactory = scopeFactory;
     }
 
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
@@ -58,7 +58,7 @@ public class EventCleanupService : BackgroundService
     {
         try
         {
-            using var scope = _serviceProvider.CreateScope();
+            await using var scope = _scopeFactory.CreateAsyncScope();
             var context = scope.ServiceProvider.GetRequiredService<EventsContext>();
 
             var cutoffDate = DateTime.UtcNow.AddDays(-_retentionDays);

code/backend/Cleanuparr.Infrastructure/Events/EventPublisher.cs

@@ -1,4 +1,7 @@
+using System.Dynamic;
 using System.Text.Json;
+using System.Text.Json.Serialization;
+using Cleanuparr.Domain.Entities.Arr.Queue;
 using Cleanuparr.Domain.Enums;
 using Cleanuparr.Infrastructure.Features.Context;
 using Cleanuparr.Infrastructure.Features.Notifications;
@@ -47,7 +50,10 @@ public class EventPublisher
             EventType = eventType,
             Message = message,
             Severity = severity,
-            Data = data != null ? JsonSerializer.Serialize(data) : null,
+            Data = data != null ? JsonSerializer.Serialize(data, new JsonSerializerOptions
+            {
+                Converters = { new JsonStringEnumConverter() }
+            }) : null,
             TrackingId = trackingId
         };
 
@@ -75,12 +81,37 @@ public class EventPublisher
             StrikeType.SlowTime => EventType.SlowTimeStrike,
         };
 
+        dynamic data;
+
+        if (strikeType is StrikeType.FailedImport)
+        {
+            QueueRecord record = ContextProvider.Get<QueueRecord>(nameof(QueueRecord));
+            data = new
+            {
+                hash,
+                itemName,
+                strikeCount,
+                strikeType,
+                failedImportReasons = record.StatusMessages ?? [],
+            };
+        }
+        else
+        {
+            data = new
+            {
+                hash,
+                itemName,
+                strikeCount,
+                strikeType,
+            };
+        }
+
         // Publish the event
         await PublishAsync(
             eventType,
             $"Item '{itemName}' has been struck {strikeCount} times for reason '{strikeType}'",
             EventSeverity.Important,
-            data: new { hash, itemName, strikeCount, strikeType });
+            data: data);
 
         // Send notification (uses ContextProvider internally)
         await _notificationPublisher.NotifyStrike(strikeType, strikeCount);

code/backend/Cleanuparr.Infrastructure/Extensions/DelugeExtensions.cs

@@ -1,6 +1,5 @@
 using Cleanuparr.Domain.Entities.Deluge.Response;
 using Cleanuparr.Infrastructure.Services;
-using Infrastructure.Services;
 
 namespace Cleanuparr.Infrastructure.Extensions;
 

code/backend/Cleanuparr.Infrastructure/Extensions/QBitExtensions.cs

@@ -1,5 +1,4 @@
 using Cleanuparr.Infrastructure.Services;
-using Infrastructure.Services;
 using QBittorrent.Client;
 
 namespace Cleanuparr.Infrastructure.Extensions;

code/backend/Cleanuparr.Infrastructure/Extensions/TransmissionExtensions.cs

@@ -1,5 +1,4 @@
 using Cleanuparr.Infrastructure.Services;
-using Infrastructure.Services;
 using Transmission.API.RPC.Entity;
 
 namespace Cleanuparr.Infrastructure.Extensions;

code/backend/Cleanuparr.Infrastructure/Features/Arr/ArrClient.cs

@@ -1,3 +1,4 @@
+using Cleanuparr.Domain.Entities.Arr.Queue;
 using Cleanuparr.Domain.Enums;
 using Cleanuparr.Infrastructure.Features.Arr.Interfaces;
 using Cleanuparr.Infrastructure.Features.Context;
@@ -6,7 +7,6 @@ using Cleanuparr.Persistence.Models.Configuration.Arr;
 using Cleanuparr.Persistence.Models.Configuration.QueueCleaner;
 using Cleanuparr.Shared.Helpers;
 using Data.Models.Arr;
-using Data.Models.Arr.Queue;
 using Infrastructure.Interceptors;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
@@ -65,7 +65,7 @@ public abstract class ArrClient : IArrClient
         return queueResponse;
     }
 
-    public virtual async Task<bool> ShouldRemoveFromQueue(InstanceType instanceType, QueueRecord record, bool isPrivateDownload, ushort arrMaxStrikes)
+    public virtual async Task<bool> ShouldRemoveFromQueue(InstanceType instanceType, QueueRecord record, bool isPrivateDownload, short arrMaxStrikes)
     {
         var queueCleanerConfig = ContextProvider.Get<QueueCleanerConfig>();
         
@@ -105,6 +105,12 @@ public abstract class ArrClient : IArrClient
             
             ushort maxStrikes = arrMaxStrikes > 0 ? (ushort)arrMaxStrikes : queueCleanerConfig.FailedImport.MaxStrikes;
             
+            _logger.LogInformation(
+                "Item {title} has failed import status with the following reason(s):\n{messages}",
+                record.Title,
+                string.Join("\n",  record.StatusMessages?.Select(JsonConvert.SerializeObject) ?? [])
+            );
+            
             return await _striker.StrikeAndCheckLimit(
                 record.DownloadId,
                 record.Title,
@@ -206,7 +212,7 @@ public abstract class ArrClient : IArrClient
         return response;
     }
     
-    private bool HasIgnoredPatterns(QueueRecord record)
+    private static bool HasIgnoredPatterns(QueueRecord record)
     {
         var queueCleanerConfig = ContextProvider.Get<QueueCleanerConfig>();
         

code/backend/Cleanuparr.Infrastructure/Features/Arr/ArrClientFactory.cs

@@ -8,16 +8,22 @@ public sealed class ArrClientFactory
     private readonly ISonarrClient _sonarrClient;
     private readonly IRadarrClient _radarrClient;
     private readonly ILidarrClient _lidarrClient;
+    private readonly IReadarrClient _readarrClient;
+    private readonly IWhisparrClient _whisparrClient;
 
     public ArrClientFactory(
         SonarrClient sonarrClient,
         RadarrClient radarrClient,
-        LidarrClient lidarrClient
+        LidarrClient lidarrClient,
+        ReadarrClient readarrClient,
+        WhisparrClient whisparrClient
     )
     {
         _sonarrClient = sonarrClient;
         _radarrClient = radarrClient;
         _lidarrClient = lidarrClient;
+        _readarrClient = readarrClient;
+        _whisparrClient = whisparrClient;
     }
     
     public IArrClient GetClient(InstanceType type) =>
@@ -26,6 +32,8 @@ public sealed class ArrClientFactory
             InstanceType.Sonarr => _sonarrClient,
             InstanceType.Radarr => _radarrClient,
             InstanceType.Lidarr => _lidarrClient,
+            InstanceType.Readarr => _readarrClient,
+            InstanceType.Whisparr => _whisparrClient,
             _ => throw new NotImplementedException($"instance type {type} is not yet supported")
         };
 }

code/backend/Cleanuparr.Infrastructure/Features/Arr/ArrQueueIterator.cs

@@ -1,6 +1,6 @@
-using Cleanuparr.Infrastructure.Features.Arr.Interfaces;
+using Cleanuparr.Domain.Entities.Arr.Queue;
+using Cleanuparr.Infrastructure.Features.Arr.Interfaces;
 using Cleanuparr.Persistence.Models.Configuration.Arr;
-using Data.Models.Arr.Queue;
 using Microsoft.Extensions.Logging;
 
 namespace Cleanuparr.Infrastructure.Features.Arr;

code/backend/Cleanuparr.Infrastructure/Features/Arr/Interfaces/IArrClient.cs

@@ -1,7 +1,7 @@
-using Cleanuparr.Domain.Enums;
+using Cleanuparr.Domain.Entities.Arr.Queue;
+using Cleanuparr.Domain.Enums;
 using Cleanuparr.Persistence.Models.Configuration.Arr;
 using Data.Models.Arr;
-using Data.Models.Arr.Queue;
 
 namespace Cleanuparr.Infrastructure.Features.Arr.Interfaces;
 
@@ -9,7 +9,7 @@ public interface IArrClient
 {
     Task<QueueListResponse> GetQueueItemsAsync(ArrInstance arrInstance, int page);
 
-    Task<bool> ShouldRemoveFromQueue(InstanceType instanceType, QueueRecord record, bool isPrivateDownload, ushort arrMaxStrikes);
+    Task<bool> ShouldRemoveFromQueue(InstanceType instanceType, QueueRecord record, bool isPrivateDownload, short arrMaxStrikes);
 
     Task DeleteQueueItemAsync(ArrInstance arrInstance, QueueRecord record, bool removeFromClient, DeleteReason deleteReason);
     

code/backend/Cleanuparr.Infrastructure/Features/Arr/Interfaces/IReadarrClient.cs

@@ -0,0 +1,5 @@
+namespace Cleanuparr.Infrastructure.Features.Arr.Interfaces;
+
+public interface IReadarrClient : IArrClient
+{
+} 

code/backend/Cleanuparr.Infrastructure/Features/Arr/Interfaces/IWhisparrClient.cs

@@ -0,0 +1,5 @@
+namespace Cleanuparr.Infrastructure.Features.Arr.Interfaces;
+
+public interface IWhisparrClient : IArrClient
+{
+} 

code/backend/Cleanuparr.Infrastructure/Features/Arr/LidarrClient.cs

@@ -1,10 +1,10 @@
 using System.Text;
+using Cleanuparr.Domain.Entities.Arr.Queue;
 using Cleanuparr.Domain.Entities.Lidarr;
 using Cleanuparr.Infrastructure.Features.Arr.Interfaces;
 using Cleanuparr.Infrastructure.Features.ItemStriker;
 using Cleanuparr.Persistence.Models.Configuration.Arr;
 using Data.Models.Arr;
-using Data.Models.Arr.Queue;
 using Infrastructure.Interceptors;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;

code/backend/Cleanuparr.Infrastructure/Features/Arr/RadarrClient.cs

@@ -1,10 +1,10 @@
 using System.Text;
+using Cleanuparr.Domain.Entities.Arr.Queue;
 using Cleanuparr.Domain.Entities.Radarr;
 using Cleanuparr.Infrastructure.Features.Arr.Interfaces;
 using Cleanuparr.Infrastructure.Features.ItemStriker;
 using Cleanuparr.Persistence.Models.Configuration.Arr;
 using Data.Models.Arr;
-using Data.Models.Arr.Queue;
 using Infrastructure.Interceptors;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;

code/backend/Cleanuparr.Infrastructure/Features/Arr/ReadarrClient.cs

@@ -0,0 +1,151 @@
+using System.Text;
+using Cleanuparr.Domain.Entities.Arr.Queue;
+using Cleanuparr.Domain.Entities.Readarr;
+using Cleanuparr.Infrastructure.Features.Arr.Interfaces;
+using Cleanuparr.Infrastructure.Features.ItemStriker;
+using Cleanuparr.Persistence.Models.Configuration.Arr;
+using Data.Models.Arr;
+using Infrastructure.Interceptors;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+
+namespace Cleanuparr.Infrastructure.Features.Arr;
+
+public class ReadarrClient : ArrClient, IReadarrClient
+{
+    public ReadarrClient(
+        ILogger<ReadarrClient> logger,
+        IHttpClientFactory httpClientFactory,
+        IStriker striker,
+        IDryRunInterceptor dryRunInterceptor
+    ) : base(logger, httpClientFactory, striker, dryRunInterceptor)
+    {
+    }
+
+    protected override string GetQueueUrlPath()
+    {
+        return "/api/v1/queue";
+    }
+
+    protected override string GetQueueUrlQuery(int page)
+    {
+        return $"page={page}&pageSize=200&includeUnknownAuthorItems=true&includeAuthor=true&includeBook=true";
+    }
+
+    protected override string GetQueueDeleteUrlPath(long recordId)
+    {
+        return $"/api/v1/queue/{recordId}";
+    }
+
+    protected override string GetQueueDeleteUrlQuery(bool removeFromClient)
+    {
+        string query = "blocklist=true&skipRedownload=true&changeCategory=false";
+        query += removeFromClient ? "&removeFromClient=true" : "&removeFromClient=false";
+
+        return query;
+    }
+
+    public override async Task SearchItemsAsync(ArrInstance arrInstance, HashSet<SearchItem>? items)
+    {
+        if (items?.Count is null or 0)
+        {
+            return;
+        }
+
+        List<long> ids = items.Select(item => item.Id).ToList();
+        
+        UriBuilder uriBuilder = new(arrInstance.Url);
+        uriBuilder.Path = $"{uriBuilder.Path.TrimEnd('/')}/api/v1/command";
+        
+        ReadarrCommand command = new()
+        {
+            Name = "BookSearch",
+            BookIds = ids,
+        };
+        
+        using HttpRequestMessage request = new(HttpMethod.Post, uriBuilder.Uri);
+        request.Content = new StringContent(
+            JsonConvert.SerializeObject(command),
+            Encoding.UTF8,
+            "application/json"
+        );
+        SetApiKey(request, arrInstance.ApiKey);
+
+        string? logContext = await ComputeCommandLogContextAsync(arrInstance, command);
+
+        try
+        {
+            HttpResponseMessage? response = await _dryRunInterceptor.InterceptAsync<HttpResponseMessage>(SendRequestAsync, request);
+            response?.Dispose();
+            
+            _logger.LogInformation("{log}", GetSearchLog(arrInstance.Url, command, true, logContext));
+        }
+        catch
+        {
+            _logger.LogError("{log}", GetSearchLog(arrInstance.Url, command, false, logContext));
+            throw;
+        }
+    }
+
+    public override bool IsRecordValid(QueueRecord record)
+    {
+        if (record.AuthorId is 0 || record.BookId is 0)
+        {
+            _logger.LogDebug("skip | author id and/or book id missing | {title}", record.Title);
+            return false;
+        }
+        
+        return base.IsRecordValid(record);
+    }
+
+    private static string GetSearchLog(Uri instanceUrl, ReadarrCommand command, bool success, string? logContext)
+    {
+        string status = success ? "triggered" : "failed";
+        string message = logContext ?? $"book ids: {string.Join(',', command.BookIds)}";
+
+        return $"book search {status} | {instanceUrl} | {message}";
+    }
+
+    private async Task<string?> ComputeCommandLogContextAsync(ArrInstance arrInstance, ReadarrCommand command)
+    {
+        try
+        {
+            StringBuilder log = new();
+
+            foreach (long bookId in command.BookIds)
+            {
+                Book? book = await GetBookAsync(arrInstance, bookId);
+
+                if (book is null)
+                {
+                    return null;
+                }
+
+                log.Append($"[{book.Title}]");
+            }
+
+            return log.ToString();
+        }
+        catch (Exception exception)
+        {
+            _logger.LogDebug(exception, "failed to compute log context");
+        }
+
+        return null;
+    }
+
+    private async Task<Book?> GetBookAsync(ArrInstance arrInstance, long bookId)
+    {
+        UriBuilder uriBuilder = new(arrInstance.Url);
+        uriBuilder.Path = $"{uriBuilder.Path.TrimEnd('/')}/api/v1/book/{bookId}";
+        
+        using HttpRequestMessage request = new(HttpMethod.Get, uriBuilder.Uri);
+        SetApiKey(request, arrInstance.ApiKey);
+
+        using HttpResponseMessage response = await _httpClient.SendAsync(request);
+        response.EnsureSuccessStatusCode();
+                
+        string responseBody = await response.Content.ReadAsStringAsync();
+        return JsonConvert.DeserializeObject<Book>(responseBody);
+    }
+} 

code/backend/Cleanuparr.Infrastructure/Features/Arr/SonarrClient.cs

@@ -1,11 +1,12 @@
 using System.Text;
+using Cleanuparr.Domain.Entities.Arr;
+using Cleanuparr.Domain.Entities.Arr.Queue;
 using Cleanuparr.Domain.Entities.Sonarr;
 using Cleanuparr.Domain.Enums;
 using Cleanuparr.Infrastructure.Features.Arr.Interfaces;
 using Cleanuparr.Infrastructure.Features.ItemStriker;
 using Cleanuparr.Persistence.Models.Configuration.Arr;
 using Data.Models.Arr;
-using Data.Models.Arr.Queue;
 using Infrastructure.Interceptors;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
@@ -57,7 +58,7 @@ public class SonarrClient : ArrClient, ISonarrClient
         UriBuilder uriBuilder = new(arrInstance.Url);
         uriBuilder.Path = $"{uriBuilder.Path.TrimEnd('/')}/api/v3/command";
         
-        foreach (SonarrCommand command in GetSearchCommands(items.Cast<SonarrSearchItem>().ToHashSet()))
+        foreach (SonarrCommand command in GetSearchCommands(items.Cast<SeriesSearchItem>().ToHashSet()))
         {
             using HttpRequestMessage request = new(HttpMethod.Post, uriBuilder.Uri);
             request.Content = new StringContent(
@@ -96,7 +97,7 @@ public class SonarrClient : ArrClient, ISonarrClient
     }
 
     private static string GetSearchLog(
-        SonarrSearchType searchType,
+        SeriesSearchType searchType,
         Uri instanceUrl,
         SonarrCommand command,
         bool success,
@@ -107,22 +108,22 @@ public class SonarrClient : ArrClient, ISonarrClient
         
         return searchType switch
         {
-            SonarrSearchType.Episode =>
+            SeriesSearchType.Episode =>
                 $"episodes search {status} | {instanceUrl} | {logContext ?? $"episode ids: {string.Join(',', command.EpisodeIds)}"}",
-            SonarrSearchType.Season =>
+            SeriesSearchType.Season =>
                 $"season search {status} | {instanceUrl} | {logContext ?? $"season: {command.SeasonNumber} series id: {command.SeriesId}"}",
-            SonarrSearchType.Series => $"series search {status} | {instanceUrl} | {logContext ?? $"series id: {command.SeriesId}"}",
+            SeriesSearchType.Series => $"series search {status} | {instanceUrl} | {logContext ?? $"series id: {command.SeriesId}"}",
             _ => throw new ArgumentOutOfRangeException(nameof(searchType), searchType, null)
         };
     }
 
-    private async Task<string?> ComputeCommandLogContextAsync(ArrInstance arrInstance, SonarrCommand command, SonarrSearchType searchType)
+    private async Task<string?> ComputeCommandLogContextAsync(ArrInstance arrInstance, SonarrCommand command, SeriesSearchType searchType)
     {
         try
         {
             StringBuilder log = new();
 
-            if (searchType is SonarrSearchType.Episode)
+            if (searchType is SeriesSearchType.Episode)
             {
                 var episodes = await GetEpisodesAsync(arrInstance, command.EpisodeIds);
 
@@ -164,7 +165,7 @@ public class SonarrClient : ArrClient, ISonarrClient
                 }
             }
 
-            if (searchType is SonarrSearchType.Season)
+            if (searchType is SeriesSearchType.Season)
             {
                 Series? show = await GetSeriesAsync(arrInstance, command.SeriesId.Value);
 
@@ -176,7 +177,7 @@ public class SonarrClient : ArrClient, ISonarrClient
                 log.Append($"[{show.Title} season {command.SeasonNumber}]");
             }
 
-            if (searchType is SonarrSearchType.Series)
+            if (searchType is SeriesSearchType.Series)
             {
                 Series? show = await GetSeriesAsync(arrInstance, command.SeriesId.Value);
 
@@ -229,7 +230,7 @@ public class SonarrClient : ArrClient, ISonarrClient
         return JsonConvert.DeserializeObject<Series>(responseBody);
     }
 
-    private List<SonarrCommand> GetSearchCommands(HashSet<SonarrSearchItem> items)
+    private List<SonarrCommand> GetSearchCommands(HashSet<SeriesSearchItem> items)
     {
         const string episodeSearch = "EpisodeSearch";
         const string seasonSearch = "SeasonSearch";
@@ -237,29 +238,29 @@ public class SonarrClient : ArrClient, ISonarrClient
         
         List<SonarrCommand> commands = new();
 
-        foreach (SonarrSearchItem item in items)
+        foreach (SeriesSearchItem item in items)
         {
-            SonarrCommand command = item.SearchType is SonarrSearchType.Episode
+            SonarrCommand command = item.SearchType is SeriesSearchType.Episode
                 ? commands.FirstOrDefault() ?? new() { Name = episodeSearch, EpisodeIds = new() }
                 : new();
             
             switch (item.SearchType)
             {
-                case SonarrSearchType.Episode when command.EpisodeIds is null:
+                case SeriesSearchType.Episode when command.EpisodeIds is null:
                     command.EpisodeIds = [item.Id];
                     break;
                 
-                case SonarrSearchType.Episode when command.EpisodeIds is not null:
+                case SeriesSearchType.Episode when command.EpisodeIds is not null:
                     command.EpisodeIds.Add(item.Id);
                     break;
                 
-                case SonarrSearchType.Season:
+                case SeriesSearchType.Season:
                     command.Name = seasonSearch;
                     command.SeasonNumber = item.Id;
-                    command.SeriesId = ((SonarrSearchItem)item).SeriesId;
+                    command.SeriesId = ((SeriesSearchItem)item).SeriesId;
                     break;
                 
-                case SonarrSearchType.Series:
+                case SeriesSearchType.Series:
                     command.Name = seriesSearch;
                     command.SeriesId = item.Id;
                     break;
@@ -268,7 +269,7 @@ public class SonarrClient : ArrClient, ISonarrClient
                     throw new ArgumentOutOfRangeException(nameof(item.SearchType), item.SearchType, null);
             }
 
-            if (item.SearchType is SonarrSearchType.Episode && commands.Count > 0)
+            if (item.SearchType is SeriesSearchType.Episode && commands.Count > 0)
             {
                 // only one command will be generated for episodes search
                 continue;

code/backend/Cleanuparr.Infrastructure/Features/Arr/WhisparrClient.cs

@@ -0,0 +1,282 @@
+using System.Text;
+using Cleanuparr.Domain.Entities.Arr;
+using Cleanuparr.Domain.Entities.Arr.Queue;
+using Cleanuparr.Domain.Entities.Sonarr;
+using Cleanuparr.Domain.Entities.Whisparr;
+using Cleanuparr.Domain.Enums;
+using Cleanuparr.Infrastructure.Features.Arr.Interfaces;
+using Cleanuparr.Infrastructure.Features.ItemStriker;
+using Cleanuparr.Persistence.Models.Configuration.Arr;
+using Data.Models.Arr;
+using Infrastructure.Interceptors;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+
+namespace Cleanuparr.Infrastructure.Features.Arr;
+
+public class WhisparrClient : ArrClient, IWhisparrClient
+{
+    public WhisparrClient(
+        ILogger<WhisparrClient> logger,
+        IHttpClientFactory httpClientFactory,
+        IStriker striker,
+        IDryRunInterceptor dryRunInterceptor
+    ) : base(logger, httpClientFactory, striker, dryRunInterceptor)
+    {
+    }
+    
+    protected override string GetQueueUrlPath()
+    {
+        return "/api/v3/queue";
+    }
+
+    protected override string GetQueueUrlQuery(int page)
+    {
+        return $"page={page}&pageSize=200&includeUnknownSeriesItems=true&includeSeries=true&includeEpisode=true";
+    }
+
+    protected override string GetQueueDeleteUrlPath(long recordId)
+    {
+        return $"/api/v3/queue/{recordId}";
+    }
+
+    protected override string GetQueueDeleteUrlQuery(bool removeFromClient)
+    {
+        string query = "blocklist=true&skipRedownload=true&changeCategory=false";
+        query += removeFromClient ? "&removeFromClient=true" : "&removeFromClient=false";
+        
+        return query;
+    }
+
+    public override async Task SearchItemsAsync(ArrInstance arrInstance, HashSet<SearchItem>? items)
+    {
+        if (items?.Count is null or 0)
+        {
+            return;
+        }
+
+        UriBuilder uriBuilder = new(arrInstance.Url);
+        uriBuilder.Path = $"{uriBuilder.Path.TrimEnd('/')}/api/v3/command";
+        
+        foreach (WhisparrCommand command in GetSearchCommands(items.Cast<SeriesSearchItem>().ToHashSet()))
+        {
+            using HttpRequestMessage request = new(HttpMethod.Post, uriBuilder.Uri);
+            request.Content = new StringContent(
+                JsonConvert.SerializeObject(command, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }),
+                Encoding.UTF8,
+                "application/json"
+            );
+            SetApiKey(request, arrInstance.ApiKey);
+
+            string? logContext = await ComputeCommandLogContextAsync(arrInstance, command, command.SearchType);
+
+            try
+            {
+                HttpResponseMessage? response = await _dryRunInterceptor.InterceptAsync<HttpResponseMessage>(SendRequestAsync, request);
+                response?.Dispose();
+                
+                _logger.LogInformation("{log}", GetSearchLog(command.SearchType, arrInstance.Url, command, true, logContext));
+            }
+            catch
+            {
+                _logger.LogError("{log}", GetSearchLog(command.SearchType, arrInstance.Url, command, false, logContext));
+                throw;
+            }
+        }
+    }
+
+    public override bool IsRecordValid(QueueRecord record)
+    {
+        if (record.EpisodeId is 0 || record.SeriesId is 0)
+        {
+            _logger.LogDebug("skip | episode id and/or series id missing | {title}", record.Title);
+            return false;
+        }
+
+        return base.IsRecordValid(record);
+    }
+
+    private static string GetSearchLog(
+        SeriesSearchType searchType,
+        Uri instanceUrl,
+        WhisparrCommand command,
+        bool success,
+        string? logContext
+    )
+    {
+        string status = success ? "triggered" : "failed";
+        
+        return searchType switch
+        {
+            SeriesSearchType.Episode =>
+                $"episodes search {status} | {instanceUrl} | {logContext ?? $"episode ids: {string.Join(',', command.EpisodeIds)}"}",
+            SeriesSearchType.Season =>
+                $"season search {status} | {instanceUrl} | {logContext ?? $"season: {command.SeasonNumber} series id: {command.SeriesId}"}",
+            SeriesSearchType.Series => $"series search {status} | {instanceUrl} | {logContext ?? $"series id: {command.SeriesId}"}",
+            _ => throw new ArgumentOutOfRangeException(nameof(searchType), searchType, null)
+        };
+    }
+
+    private async Task<string?> ComputeCommandLogContextAsync(ArrInstance arrInstance, WhisparrCommand command, SeriesSearchType searchType)
+    {
+        try
+        {
+            StringBuilder log = new();
+
+            if (searchType is SeriesSearchType.Episode)
+            {
+                var episodes = await GetEpisodesAsync(arrInstance, command.EpisodeIds);
+
+                if (episodes?.Count is null or 0)
+                {
+                    return null;
+                }
+
+                var seriesIds = episodes
+                    .Select(x => x.SeriesId)
+                    .Distinct()
+                    .ToList();
+
+                List<Series> series = [];
+
+                foreach (long id in seriesIds)
+                {
+                    Series? show = await GetSeriesAsync(arrInstance, id);
+
+                    if (show is null)
+                    {
+                        return null;
+                    }
+
+                    series.Add(show);
+                }
+
+                foreach (var group in command.EpisodeIds.GroupBy(id => episodes.First(x => x.Id == id).SeriesId))
+                {
+                    var show = series.First(x => x.Id == group.Key);
+                    var episode = episodes
+                        .Where(ep => group.Any(x => x == ep.Id))
+                        .OrderBy(x => x.SeasonNumber)
+                        .ThenBy(x => x.EpisodeNumber)
+                        .Select(x => $"S{x.SeasonNumber.ToString().PadLeft(2, '0')}E{x.EpisodeNumber.ToString().PadLeft(2, '0')}")
+                        .ToList();
+
+                    log.Append($"[{show.Title} {string.Join(',', episode)}]");
+                }
+            }
+
+            if (searchType is SeriesSearchType.Season)
+            {
+                Series? show = await GetSeriesAsync(arrInstance, command.SeriesId.Value);
+
+                if (show is null)
+                {
+                    return null;
+                }
+
+                log.Append($"[{show.Title} season {command.SeasonNumber}]");
+            }
+
+            if (searchType is SeriesSearchType.Series)
+            {
+                Series? show = await GetSeriesAsync(arrInstance, command.SeriesId.Value);
+
+                if (show is null)
+                {
+                    return null;
+                }
+
+                log.Append($"[{show.Title}]");
+            }
+
+            return log.ToString();
+        }
+        catch (Exception exception)
+        {
+            _logger.LogDebug(exception, "failed to compute log context");
+        }
+
+        return null;
+    }
+
+    private async Task<List<Episode>?> GetEpisodesAsync(ArrInstance arrInstance, List<long> episodeIds)
+    {
+        UriBuilder uriBuilder = new(arrInstance.Url);
+        uriBuilder.Path = $"{uriBuilder.Path.TrimEnd('/')}/api/v3/episode";
+        uriBuilder.Query = $"episodeIds={string.Join(',', episodeIds)}";
+
+        using HttpRequestMessage request = new(HttpMethod.Get, uriBuilder.Uri);
+        SetApiKey(request, arrInstance.ApiKey);
+
+        HttpResponseMessage response = await SendRequestAsync(request);
+        string responseContent = await response.Content.ReadAsStringAsync();
+
+        return JsonConvert.DeserializeObject<List<Episode>>(responseContent);
+    }
+
+    private async Task<Series?> GetSeriesAsync(ArrInstance arrInstance, long seriesId)
+    {
+        UriBuilder uriBuilder = new(arrInstance.Url);
+        uriBuilder.Path = $"{uriBuilder.Path.TrimEnd('/')}/api/v3/series/{seriesId}";
+
+        using HttpRequestMessage request = new(HttpMethod.Get, uriBuilder.Uri);
+        SetApiKey(request, arrInstance.ApiKey);
+
+        HttpResponseMessage response = await SendRequestAsync(request);
+        string responseContent = await response.Content.ReadAsStringAsync();
+
+        return JsonConvert.DeserializeObject<Series>(responseContent);
+    }
+
+    private List<WhisparrCommand> GetSearchCommands(HashSet<SeriesSearchItem> items)
+    {
+        const string episodeSearch = "EpisodeSearch";
+        const string seasonSearch = "SeasonSearch";
+        const string seriesSearch = "SeriesSearch";
+        
+        List<WhisparrCommand> commands = new();
+
+        foreach (SeriesSearchItem item in items)
+        {
+            WhisparrCommand command = item.SearchType is SeriesSearchType.Episode
+                ? commands.FirstOrDefault() ?? new() { Name = episodeSearch, EpisodeIds = new() }
+                : new();
+            
+            switch (item.SearchType)
+            {
+                case SeriesSearchType.Episode when command.EpisodeIds is null:
+                    command.EpisodeIds = [item.Id];
+                    break;
+                
+                case SeriesSearchType.Episode when command.EpisodeIds is not null:
+                    command.EpisodeIds.Add(item.Id);
+                    break;
+                
+                case SeriesSearchType.Season:
+                    command.Name = seasonSearch;
+                    command.SeasonNumber = item.Id;
+                    command.SeriesId = ((SeriesSearchItem)item).SeriesId;
+                    break;
+                
+                case SeriesSearchType.Series:
+                    command.Name = seriesSearch;
+                    command.SeriesId = item.Id;
+                    break;
+                
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(item.SearchType), item.SearchType, null);
+            }
+
+            if (item.SearchType is SeriesSearchType.Episode && commands.Count > 0)
+            {
+                // only one command will be generated for episodes search
+                continue;
+            }
+            
+            command.SearchType = item.SearchType;
+            commands.Add(command);
+        }
+
+        return commands;
+    }
+} 

code/backend/Cleanuparr.Infrastructure/Features/ContentBlocker/BlocklistProvider.cs

@@ -19,22 +19,25 @@ namespace Cleanuparr.Infrastructure.Features.ContentBlocker;
 public sealed class BlocklistProvider
 {
     private readonly ILogger<BlocklistProvider> _logger;
-    private readonly IServiceProvider _serviceProvider;
+    private readonly IServiceScopeFactory _scopeFactory;
     private readonly HttpClient _httpClient;
     private readonly IMemoryCache _cache;
     private readonly Dictionary<InstanceType, string> _configHashes = new();
-    private static DateTime _lastLoadTime = DateTime.MinValue;
-    private const int LoadIntervalHours = 4;
+    private readonly Dictionary<string, DateTime> _lastLoadTimes = new();
+    private const int DefaultLoadIntervalHours = 4;
+    private const int FastLoadIntervalMinutes = 5;
+    private const string MalwareListUrl = "https://cleanuparr.pages.dev/static/known_malware_file_name_patterns";
+    private const string MalwareListKey = "MALWARE_PATTERNS";
 
     public BlocklistProvider(
         ILogger<BlocklistProvider> logger,
-        IServiceProvider serviceProvider,
+        IServiceScopeFactory scopeFactory,
         IMemoryCache cache,
         IHttpClientFactory httpClientFactory
     )
     {
         _logger = logger;
-        _serviceProvider = serviceProvider;
+        _scopeFactory = scopeFactory;
         _cache = cache;
         _httpClient = httpClientFactory.CreateClient(Constants.HttpClientWithRetryName);
     }
@@ -43,18 +46,12 @@ public sealed class BlocklistProvider
     {
         try
         {
-            var dataContext = _serviceProvider.GetRequiredService<DataContext>();
+            await using var scope = _scopeFactory.CreateAsyncScope();
+            await using var dataContext = scope.ServiceProvider.GetRequiredService<DataContext>();
             int changedCount = 0;
             var contentBlockerConfig = await dataContext.ContentBlockerConfigs
                 .AsNoTracking()
                 .FirstAsync();
-            bool shouldReload = false;
-
-            if (_lastLoadTime.AddHours(LoadIntervalHours) < DateTime.UtcNow)
-            {
-                shouldReload = true;
-                _lastLoadTime = DateTime.UtcNow;
-            }
             
             if (!contentBlockerConfig.Enabled)
             {
@@ -64,37 +61,77 @@ public sealed class BlocklistProvider
             
             // Check and update Sonarr blocklist if needed
             string sonarrHash = GenerateSettingsHash(contentBlockerConfig.Sonarr);
-            if (shouldReload || !_configHashes.TryGetValue(InstanceType.Sonarr, out string? oldSonarrHash) || sonarrHash != oldSonarrHash)
+            var sonarrInterval = GetLoadInterval(contentBlockerConfig.Sonarr.BlocklistPath);
+            var sonarrIdentifier = $"Sonarr_{contentBlockerConfig.Sonarr.BlocklistPath}";
+            if (ShouldReloadBlocklist(sonarrIdentifier, sonarrInterval) || !_configHashes.TryGetValue(InstanceType.Sonarr, out string? oldSonarrHash) || sonarrHash != oldSonarrHash)
             {
                 _logger.LogDebug("Loading Sonarr blocklist");
                 
                 await LoadPatternsAndRegexesAsync(contentBlockerConfig.Sonarr, InstanceType.Sonarr);
                 _configHashes[InstanceType.Sonarr] = sonarrHash;
+                _lastLoadTimes[sonarrIdentifier] = DateTime.UtcNow;
                 changedCount++;
             }
             
             // Check and update Radarr blocklist if needed
             string radarrHash = GenerateSettingsHash(contentBlockerConfig.Radarr);
-            if (shouldReload || !_configHashes.TryGetValue(InstanceType.Radarr, out string? oldRadarrHash) || radarrHash != oldRadarrHash)
+            var radarrInterval = GetLoadInterval(contentBlockerConfig.Radarr.BlocklistPath);
+            var radarrIdentifier = $"Radarr_{contentBlockerConfig.Radarr.BlocklistPath}";
+            if (ShouldReloadBlocklist(radarrIdentifier, radarrInterval) || !_configHashes.TryGetValue(InstanceType.Radarr, out string? oldRadarrHash) || radarrHash != oldRadarrHash)
             {
                 _logger.LogDebug("Loading Radarr blocklist");
                 
                 await LoadPatternsAndRegexesAsync(contentBlockerConfig.Radarr, InstanceType.Radarr);
                 _configHashes[InstanceType.Radarr] = radarrHash;
+                _lastLoadTimes[radarrIdentifier] = DateTime.UtcNow;
                 changedCount++;
             }
             
             // Check and update Lidarr blocklist if needed
             string lidarrHash = GenerateSettingsHash(contentBlockerConfig.Lidarr);
-            if (shouldReload || !_configHashes.TryGetValue(InstanceType.Lidarr, out string? oldLidarrHash) || lidarrHash != oldLidarrHash)
+            var lidarrInterval = GetLoadInterval(contentBlockerConfig.Lidarr.BlocklistPath);
+            var lidarrIdentifier = $"Lidarr_{contentBlockerConfig.Lidarr.BlocklistPath}";
+            if (ShouldReloadBlocklist(lidarrIdentifier, lidarrInterval) || !_configHashes.TryGetValue(InstanceType.Lidarr, out string? oldLidarrHash) || lidarrHash != oldLidarrHash)
             {
                 _logger.LogDebug("Loading Lidarr blocklist");
                 
                 await LoadPatternsAndRegexesAsync(contentBlockerConfig.Lidarr, InstanceType.Lidarr);
                 _configHashes[InstanceType.Lidarr] = lidarrHash;
+                _lastLoadTimes[lidarrIdentifier] = DateTime.UtcNow;
                 changedCount++;
             }
             
+            // Check and update Readarr blocklist if needed
+            string readarrHash = GenerateSettingsHash(contentBlockerConfig.Readarr);
+            var readarrInterval = GetLoadInterval(contentBlockerConfig.Readarr.BlocklistPath);
+            var readarrIdentifier = $"Readarr_{contentBlockerConfig.Readarr.BlocklistPath}";
+            if (ShouldReloadBlocklist(readarrIdentifier, readarrInterval) || !_configHashes.TryGetValue(InstanceType.Readarr, out string? oldReadarrHash) || readarrHash != oldReadarrHash)
+            {
+                _logger.LogDebug("Loading Readarr blocklist");
+                
+                await LoadPatternsAndRegexesAsync(contentBlockerConfig.Readarr, InstanceType.Readarr);
+                _configHashes[InstanceType.Readarr] = readarrHash;
+                _lastLoadTimes[readarrIdentifier] = DateTime.UtcNow;
+                changedCount++;
+            }
+            
+            // Check and update Whisparr blocklist if needed
+            string whisparrHash = GenerateSettingsHash(contentBlockerConfig.Whisparr);
+            var whisparrInterval = GetLoadInterval(contentBlockerConfig.Whisparr.BlocklistPath);
+            var whisparrIdentifier = $"Whisparr_{contentBlockerConfig.Whisparr.BlocklistPath}";
+            if (ShouldReloadBlocklist(whisparrIdentifier, whisparrInterval) || !_configHashes.TryGetValue(InstanceType.Whisparr, out string? oldWhisparrHash) || whisparrHash != oldWhisparrHash)
+            {
+                _logger.LogDebug("Loading Whisparr blocklist");
+                
+                await LoadPatternsAndRegexesAsync(contentBlockerConfig.Whisparr, InstanceType.Whisparr);
+                _configHashes[InstanceType.Whisparr] = whisparrHash;
+                _lastLoadTimes[whisparrIdentifier] = DateTime.UtcNow;
+                changedCount++;
+            }
+            
+            // Always check and update malware patterns
+            await LoadMalwarePatternsAsync();
+            
             if (changedCount > 0)
             {
                 _logger.LogInformation("Successfully loaded {count} blocklists", changedCount);
@@ -131,6 +168,77 @@ public sealed class BlocklistProvider
         
         return regexes ?? [];
     }
+    
+    public ConcurrentBag<string> GetMalwarePatterns()
+    {
+        _cache.TryGetValue(CacheKeys.KnownMalwarePatterns(), out ConcurrentBag<string>? patterns);
+        
+        return patterns ?? [];
+    }
+    
+    private TimeSpan GetLoadInterval(string? path)
+    {
+        if (!string.IsNullOrEmpty(path) && Uri.TryCreate(path, UriKind.Absolute, out var uri))
+        {
+            if (uri.Host.Equals("cleanuparr.pages.dev", StringComparison.OrdinalIgnoreCase))
+            {
+                return TimeSpan.FromMinutes(FastLoadIntervalMinutes);
+            }
+
+            return TimeSpan.FromHours(DefaultLoadIntervalHours);
+        }
+        
+        // If fast load interval for local files
+        return TimeSpan.FromMinutes(FastLoadIntervalMinutes);
+    }
+    
+    private bool ShouldReloadBlocklist(string identifier, TimeSpan interval)
+    {
+        if (!_lastLoadTimes.TryGetValue(identifier, out DateTime lastLoad))
+        {
+            return true;
+        }
+        
+        return DateTime.UtcNow - lastLoad >= interval;
+    }
+    
+    private async Task LoadMalwarePatternsAsync()
+    {
+        var malwareInterval = TimeSpan.FromMinutes(FastLoadIntervalMinutes);
+        
+        if (!ShouldReloadBlocklist(MalwareListKey, malwareInterval))
+        {
+            return;
+        }
+        
+        try
+        {
+            _logger.LogDebug("Loading malware patterns");
+            
+            string[] filePatterns = await ReadContentAsync(MalwareListUrl);
+            
+            long startTime = Stopwatch.GetTimestamp();
+            ParallelOptions options = new() { MaxDegreeOfParallelism = 5 };
+            ConcurrentBag<string> patterns = [];
+            
+            Parallel.ForEach(filePatterns, options, pattern =>
+            {
+                patterns.Add(pattern);
+            });
+
+            TimeSpan elapsed = Stopwatch.GetElapsedTime(startTime);
+
+            _cache.Set(CacheKeys.KnownMalwarePatterns(), patterns);
+            _lastLoadTimes[MalwareListKey] = DateTime.UtcNow;
+            
+            _logger.LogDebug("loaded {count} known malware patterns", patterns.Count);
+            _logger.LogDebug("malware patterns loaded in {elapsed} ms", elapsed.TotalMilliseconds);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to load malware patterns from {url}", MalwareListUrl);
+        }
+    }
 
     private async Task LoadPatternsAndRegexesAsync(BlocklistSettings blocklistSettings, InstanceType instanceType)
     {

code/backend/Cleanuparr.Infrastructure/Features/ContentBlocker/FilenameEvaluator.cs

@@ -20,6 +20,16 @@ public class FilenameEvaluator : IFilenameEvaluator
         return IsValidAgainstPatterns(filename, type, patterns) && IsValidAgainstRegexes(filename, type, regexes);
     }
 
+    public bool IsKnownMalware(string filename, ConcurrentBag<string> malwarePatterns)
+    {
+        if (malwarePatterns.Count is 0)
+        {
+            return false;
+        }
+        
+        return malwarePatterns.Any(pattern => filename.Contains(pattern, StringComparison.InvariantCultureIgnoreCase));
+    }
+
     private static bool IsValidAgainstPatterns(string filename, BlocklistType type, ConcurrentBag<string> patterns)
     {
         if (patterns.Count is 0)

code/backend/Cleanuparr.Infrastructure/Features/ContentBlocker/IFilenameEvaluator.cs

@@ -7,4 +7,6 @@ namespace Cleanuparr.Infrastructure.Features.ContentBlocker;
 public interface IFilenameEvaluator
 {
     bool IsValid(string filename, BlocklistType type, ConcurrentBag<string> patterns, ConcurrentBag<Regex> regexes);
+
+    bool IsKnownMalware(string filename, ConcurrentBag<string> malwarePatterns);
 }

code/backend/Cleanuparr.Infrastructure/Features/DownloadClient/BlockFilesResult.cs

@@ -1,4 +1,6 @@
-namespace Cleanuparr.Infrastructure.Features.DownloadClient;
+using Cleanuparr.Domain.Enums;
+
+namespace Cleanuparr.Infrastructure.Features.DownloadClient;
 
 public sealed record BlockFilesResult
 {
@@ -13,4 +15,6 @@ public sealed record BlockFilesResult
     public bool IsPrivate { get; set; }
     
     public bool Found { get; set; }
+    
+    public DeleteReason DeleteReason { get; set; } = DeleteReason.None;
 }

code/backend/Cleanuparr.Infrastructure/Features/DownloadClient/Deluge/DelugeClient.cs

@@ -4,7 +4,6 @@ using Cleanuparr.Domain.Entities.Deluge.Response;
 using Cleanuparr.Domain.Exceptions;
 using Cleanuparr.Infrastructure.Features.DownloadClient.Deluge.Extensions;
 using Cleanuparr.Persistence.Models.Configuration;
-using Data.Models.Deluge.Exceptions;
 using Newtonsoft.Json;
 
 namespace Cleanuparr.Infrastructure.Features.DownloadClient.Deluge;

code/backend/Cleanuparr.Infrastructure/Features/DownloadClient/Deluge/DelugeServiceCB.cs

@@ -21,7 +21,7 @@ public partial class DelugeService
         
         if (download?.Hash is null)
         {
-            _logger.LogDebug("failed to find torrent {hash} in the download client", hash);
+            _logger.LogDebug("failed to find torrent {hash} in the {name} download client", hash, _downloadClientConfig.Name);
             return result;
         }
         
@@ -52,7 +52,7 @@ public partial class DelugeService
         }
         catch (Exception exception)
         {
-            _logger.LogDebug(exception, "failed to find torrent {hash} in the download client", hash);
+            _logger.LogDebug(exception, "failed to find files in the download client | {name}", download.Name);
         }
 
         if (contents is null)
@@ -69,14 +69,28 @@ public partial class DelugeService
         BlocklistType blocklistType = _blocklistProvider.GetBlocklistType(instanceType);
         ConcurrentBag<string> patterns = _blocklistProvider.GetPatterns(instanceType);
         ConcurrentBag<Regex> regexes = _blocklistProvider.GetRegexes(instanceType);
+        ConcurrentBag<string> malwarePatterns = _blocklistProvider.GetMalwarePatterns();
 
         ProcessFiles(contents.Contents, (name, file) =>
         {
             totalFiles++;
             int priority = file.Priority;
 
+            if (result.ShouldRemove)
+            {
+                return;
+            }
+            
+            if (contentBlockerConfig.DeleteKnownMalware && _filenameEvaluator.IsKnownMalware(name, malwarePatterns))
+            {
+                _logger.LogInformation("malware file found | {file} | {title}", file.Path, download.Name);
+                result.ShouldRemove = true;
+                result.DeleteReason = DeleteReason.MalwareFileFound;
+            }
+
             if (file.Priority is 0)
             {
+                _logger.LogTrace("File is already skipped | {file}", file.Path);
                 totalUnwantedFiles++;
             }
 
@@ -88,9 +102,15 @@ public partial class DelugeService
                 _logger.LogInformation("unwanted file found | {file}", file.Path);
             }
             
+            _logger.LogTrace("File is valid | {file}", file.Path);
             priorities.Add(file.Index, priority);
         });
 
+        if (result.ShouldRemove)
+        {
+            return result;
+        }
+
         if (!hasPriorityUpdates)
         {
             return result;
@@ -105,8 +125,12 @@ public partial class DelugeService
 
         if (totalUnwantedFiles == totalFiles)
         {
+            _logger.LogDebug("All files are blocked for {name}", download.Name);
             result.ShouldRemove = true;
+            result.DeleteReason = DeleteReason.AllFilesBlocked;
         }
+        
+        _logger.LogDebug("Marking {count} unwanted files as skipped for {name}", totalUnwantedFiles, download.Name);
 
         await _dryRunInterceptor.InterceptAsync(ChangeFilesPriority, hash, sortedPriorities);
 

code/backend/Cleanuparr.Infrastructure/Features/DownloadClient/Deluge/DelugeServiceQC.cs

@@ -1,6 +1,4 @@
-using System.Collections.Concurrent;
-using System.Text.RegularExpressions;
-using Cleanuparr.Domain.Entities;
+using Cleanuparr.Domain.Entities;
 using Cleanuparr.Domain.Entities.Deluge.Response;
 using Cleanuparr.Domain.Enums;
 using Cleanuparr.Infrastructure.Extensions;
@@ -25,7 +23,7 @@ public partial class DelugeService
         
         if (download?.Hash is null)
         {
-            _logger.LogDebug("failed to find torrent {hash} in the download client", hash);
+            _logger.LogDebug("failed to find torrent {hash} in the {name} download client", hash, _downloadClientConfig.Name);
             return result;
         }
         
@@ -44,7 +42,7 @@ public partial class DelugeService
         }
         catch (Exception exception)
         {
-            _logger.LogDebug(exception, "failed to find torrent {hash} in the download client", hash);
+            _logger.LogDebug(exception, "failed to find files in the download client | {name}", download.Name);
         }
         
 
@@ -61,6 +59,7 @@ public partial class DelugeService
         if (shouldRemove)
         {
             // remove if all files are unwanted
+            _logger.LogTrace("all files are unwanted | removing download | {name}", download.Name);
             result.ShouldRemove = true;
             result.DeleteReason = DeleteReason.AllFilesSkipped;
             return result;
@@ -95,11 +94,13 @@ public partial class DelugeService
         
         if (download.State is null || !download.State.Equals("Downloading", StringComparison.InvariantCultureIgnoreCase))
         {
+            _logger.LogTrace("skip slow check | item is in {state} state | {name}", download.State, download.Name);
             return (false, DeleteReason.None);
         }
         
         if (download.DownloadSpeed <= 0)
         {
+            _logger.LogTrace("skip slow check | download speed is 0 | {name}", download.Name);
             return (false, DeleteReason.None);
         }
         
@@ -137,6 +138,7 @@ public partial class DelugeService
         
         if (queueCleanerConfig.Stalled.MaxStrikes is 0)
         {
+            _logger.LogTrace("skip stalled check | max strikes is 0 | {name}", status.Name);
             return (false, DeleteReason.None);
         }
         
@@ -149,11 +151,13 @@ public partial class DelugeService
         
         if (status.State is null || !status.State.Equals("Downloading", StringComparison.InvariantCultureIgnoreCase))
         {
+            _logger.LogTrace("skip stalled check | download is in {state} state | {name}", status.State, status.Name);
             return (false, DeleteReason.None);
         }
 
         if (status.Eta > 0)
         {
+            _logger.LogTrace("skip stalled check | download is not stalled | {name}", status.Name);
             return (false, DeleteReason.None);
         }
         

code/backend/Cleanuparr.Infrastructure/Features/DownloadClient/DownloadServiceFactory.cs

@@ -12,6 +12,7 @@ using Microsoft.Extensions.Logging;
 using DelugeService = Cleanuparr.Infrastructure.Features.DownloadClient.Deluge.DelugeService;
 using QBitService = Cleanuparr.Infrastructure.Features.DownloadClient.QBittorrent.QBitService;
 using TransmissionService = Cleanuparr.Infrastructure.Features.DownloadClient.Transmission.TransmissionService;
+using UTorrentService = Cleanuparr.Infrastructure.Features.DownloadClient.UTorrent.UTorrentService;
 
 namespace Cleanuparr.Infrastructure.Features.DownloadClient;
 
@@ -20,12 +21,13 @@ namespace Cleanuparr.Infrastructure.Features.DownloadClient;
 /// </summary>
 public sealed class DownloadServiceFactory
 {
-    private readonly IServiceProvider _serviceProvider;
     private readonly ILogger<DownloadServiceFactory> _logger;
+    private readonly IServiceProvider _serviceProvider;
     
     public DownloadServiceFactory(
-        IServiceProvider serviceProvider, 
-        ILogger<DownloadServiceFactory> logger)
+        ILogger<DownloadServiceFactory> logger,
+        IServiceProvider serviceProvider
+    )
     {
         _serviceProvider = serviceProvider;
         _logger = logger;
@@ -45,9 +47,10 @@ public sealed class DownloadServiceFactory
         
         return downloadClientConfig.TypeName switch
         {
-            DownloadClientTypeName.QBittorrent => CreateQBitService(downloadClientConfig),
+            DownloadClientTypeName.qBittorrent => CreateQBitService(downloadClientConfig),
             DownloadClientTypeName.Deluge => CreateDelugeService(downloadClientConfig),
             DownloadClientTypeName.Transmission => CreateTransmissionService(downloadClientConfig),
+            DownloadClientTypeName.uTorrent => CreateUTorrentService(downloadClientConfig),
             _ => throw new NotSupportedException($"Download client type {downloadClientConfig.TypeName} is not supported")
         };
     }
@@ -114,4 +117,26 @@ public sealed class DownloadServiceFactory
         
         return service;
     }
+
+    private UTorrentService CreateUTorrentService(DownloadClientConfig downloadClientConfig)
+    {
+        var logger = _serviceProvider.GetRequiredService<ILogger<UTorrentService>>();
+        var cache = _serviceProvider.GetRequiredService<IMemoryCache>();
+        var filenameEvaluator = _serviceProvider.GetRequiredService<IFilenameEvaluator>();
+        var striker = _serviceProvider.GetRequiredService<IStriker>();
+        var dryRunInterceptor = _serviceProvider.GetRequiredService<IDryRunInterceptor>();
+        var hardLinkFileService = _serviceProvider.GetRequiredService<IHardLinkFileService>();
+        var httpClientProvider = _serviceProvider.GetRequiredService<IDynamicHttpClientProvider>();
+        var eventPublisher = _serviceProvider.GetRequiredService<EventPublisher>();
+        var blocklistProvider = _serviceProvider.GetRequiredService<BlocklistProvider>();
+        var loggerFactory = _serviceProvider.GetRequiredService<ILoggerFactory>();
+        
+        // Create the UTorrentService instance
+        UTorrentService service = new(
+            logger, cache, filenameEvaluator, striker, dryRunInterceptor,
+            hardLinkFileService, httpClientProvider, eventPublisher, blocklistProvider, downloadClientConfig, loggerFactory
+        );
+        
+        return service;
+    }
 }

code/backend/Cleanuparr.Infrastructure/Features/DownloadClient/QBittorrent/QBitServiceCB.cs

@@ -20,7 +20,7 @@ public partial class QBitService
 
         if (download is null)
         {
-            _logger.LogDebug("failed to find torrent {hash} in the download client", hash);
+            _logger.LogDebug("failed to find torrent {hash} in the {name} download client", hash, _downloadClientConfig.Name);
             return result;
         }
 
@@ -39,7 +39,7 @@ public partial class QBitService
 
         if (torrentProperties is null)
         {
-            _logger.LogDebug("failed to find torrent properties {hash} in the download client", hash);
+            _logger.LogError("Failed to find torrent properties {name}", download.Name);
             return result;
         }
 
@@ -60,8 +60,9 @@ public partial class QBitService
         
         IReadOnlyList<TorrentContent>? files = await _client.GetTorrentContentsAsync(hash);
 
-        if (files is null)
+        if (files?.Count is null or 0)
         {
+            _logger.LogDebug("skip files check | no files found | {name}", download.Name);
             return result;
         }
 
@@ -73,24 +74,36 @@ public partial class QBitService
         BlocklistType blocklistType = _blocklistProvider.GetBlocklistType(instanceType);
         ConcurrentBag<string> patterns = _blocklistProvider.GetPatterns(instanceType);
         ConcurrentBag<Regex> regexes = _blocklistProvider.GetRegexes(instanceType);
+        ConcurrentBag<string> malwarePatterns = _blocklistProvider.GetMalwarePatterns();
         
         foreach (TorrentContent file in files)
         {
             if (!file.Index.HasValue)
             {
+                _logger.LogTrace("Skipping file with no index | {file}", file.Name);
                 continue;
             }
 
             totalFiles++;
+            
+            if (contentBlockerConfig.DeleteKnownMalware && _filenameEvaluator.IsKnownMalware(file.Name, malwarePatterns))
+            {
+                _logger.LogInformation("malware file found | {file} | {title}", file.Name, download.Name);
+                result.ShouldRemove = true;
+                result.DeleteReason = DeleteReason.MalwareFileFound;
+                return result;
+            }
 
             if (file.Priority is TorrentContentPriority.Skip)
             {
+                _logger.LogTrace("File is already skipped | {file}", file.Name);
                 totalUnwantedFiles++;
                 continue;
             }
 
             if (_filenameEvaluator.IsValid(file.Name, blocklistType, patterns, regexes))
             {
+                _logger.LogTrace("File is valid | {file}", file.Name);
                 continue;
             }
             
@@ -101,13 +114,18 @@ public partial class QBitService
 
         if (unwantedFiles.Count is 0)
         {
+            _logger.LogDebug("No unwanted files found for {name}", download.Name);
             return result;
         }
         
         if (totalUnwantedFiles == totalFiles)
         {
+            _logger.LogDebug("All files are blocked for {name}", download.Name);
             result.ShouldRemove = true;
+            result.DeleteReason = DeleteReason.AllFilesBlocked;
         }
+        
+        _logger.LogDebug("Marking {count} unwanted files as skipped for {name}", totalUnwantedFiles, download.Name);
 
         foreach (int fileIndex in unwantedFiles)
         {

code/backend/Cleanuparr.Infrastructure/Features/DownloadClient/QBittorrent/QBitServiceDC.cs

@@ -12,7 +12,7 @@ public partial class QBitService
     /// <inheritdoc/>
     public override async Task<List<object>?> GetSeedingDownloads()
     {
-        var torrentList = await _client.GetTorrentListAsync(new TorrentListQuery { Filter = TorrentListFilter.Seeding });
+        var torrentList = await _client.GetTorrentListAsync(new TorrentListQuery { Filter = TorrentListFilter.Completed });
         return torrentList?.Where(x => !string.IsNullOrEmpty(x.Hash))
             .Cast<object>()
             .ToList();
@@ -97,7 +97,7 @@ public partial class QBitService
 
                 if (torrentProperties is null)
                 {
-                    _logger.LogDebug("failed to find torrent properties in the download client | {name}", download.Name);
+                    _logger.LogError("Failed to find torrent properties | {name}", download.Name);
                     return;
                 }
 

code/backend/Cleanuparr.Infrastructure/Features/DownloadClient/QBittorrent/QBitServiceQC.cs

@@ -19,7 +19,7 @@ public partial class QBitService
 
         if (download is null)
         {
-            _logger.LogDebug("failed to find torrent {hash} in the download client", hash);
+            _logger.LogDebug("failed to find torrent {hash} in the {name} download client", hash, _downloadClientConfig.Name);
             return result;
         }
 
@@ -38,7 +38,7 @@ public partial class QBitService
 
         if (torrentProperties is null)
         {
-            _logger.LogDebug("failed to find torrent properties {hash} in the download client", hash);
+            _logger.LogError("Failed to find torrent properties for {name}", download.Name);
             return result;
         }
 
@@ -55,11 +55,13 @@ public partial class QBitService
             // if all files were blocked by qBittorrent
             if (download is { CompletionOn: not null, Downloaded: null or 0 })
             {
+                _logger.LogDebug("all files are unwanted by qBit | removing download | {name}", download.Name);
                 result.DeleteReason = DeleteReason.AllFilesSkippedByQBit;
                 return result;
             }
 
             // remove if all files are unwanted
+            _logger.LogDebug("all files are unwanted | removing download | {name}", download.Name);
             result.DeleteReason = DeleteReason.AllFilesSkipped;
             return result;
         }
@@ -87,29 +89,32 @@ public partial class QBitService
         
         if (queueCleanerConfig.Slow.MaxStrikes is 0)
         {
+            _logger.LogTrace("skip slow check | max strikes is 0 | {name}", download.Name);
             return (false, DeleteReason.None);
         }
 
         if (download.State is not (TorrentState.Downloading or TorrentState.ForcedDownload))
         {
+            _logger.LogTrace("skip slow check | download is in {state} state | {name}", download.State, download.Name);
             return (false, DeleteReason.None);
         }
 
         if (download.DownloadSpeed <= 0)
         {
+            _logger.LogTrace("skip slow check | download speed is 0 | {name}", download.Name);
             return (false, DeleteReason.None);
         }
 
         if (queueCleanerConfig.Slow.IgnorePrivate && isPrivate)
         {
             // ignore private trackers
-            _logger.LogDebug("skip slow check | download is private | {name}", download.Name);
+            _logger.LogTrace("skip slow check | download is private | {name}", download.Name);
             return (false, DeleteReason.None);
         }
 
         if (download.Size > (queueCleanerConfig.Slow.IgnoreAboveSizeByteSize?.Bytes ?? long.MaxValue))
         {
-            _logger.LogDebug("skip slow check | download is too large | {name}", download.Name);
+            _logger.LogTrace("skip slow check | download is too large | {name}", download.Name);
             return (false, DeleteReason.None);
         }
 
@@ -134,6 +139,7 @@ public partial class QBitService
         
         if (queueCleanerConfig.Stalled.MaxStrikes is 0 && queueCleanerConfig.Stalled.DownloadingMetadataMaxStrikes is 0)
         {
+            _logger.LogTrace("skip stalled check | max strikes is 0 | {name}", torrent.Name);
             return (false, DeleteReason.None);
         }
 
@@ -141,6 +147,7 @@ public partial class QBitService
             and not TorrentState.ForcedFetchingMetadata)
         {
             // ignore other states
+            _logger.LogTrace("skip stalled check | download is in {state} state | {name}", torrent.State, torrent.Name);
             return (false, DeleteReason.None);
         }
 
@@ -149,7 +156,7 @@ public partial class QBitService
             if (queueCleanerConfig.Stalled.IgnorePrivate && isPrivate)
             {
                 // ignore private trackers
-                _logger.LogDebug("skip stalled check | download is private | {name}", torrent.Name);
+                _logger.LogTrace("skip stalled check | download is private | {name}", torrent.Name);
             }
             else
             {
@@ -168,6 +175,7 @@ public partial class QBitService
                     StrikeType.DownloadingMetadata), DeleteReason.DownloadingMetadata);
         }
 
+        _logger.LogTrace("skip stalled check | download is not stalled | {name}", torrent.Name);
         return (false, DeleteReason.None);
     }
 }

code/backend/Cleanuparr.Infrastructure/Features/DownloadClient/Transmission/TransmissionServiceCB.cs

@@ -19,7 +19,7 @@ public partial class TransmissionService
 
         if (download?.FileStats is null || download.FileStats.Length == 0)
         {
-            _logger.LogDebug("failed to find torrent {hash} in the download client", hash);
+            _logger.LogDebug("failed to find torrent {hash} in the {name} download client", hash, _downloadClientConfig.Name);
             return result;
         }
         
@@ -57,24 +57,36 @@ public partial class TransmissionService
         BlocklistType blocklistType = _blocklistProvider.GetBlocklistType(instanceType);
         ConcurrentBag<string> patterns = _blocklistProvider.GetPatterns(instanceType);
         ConcurrentBag<Regex> regexes = _blocklistProvider.GetRegexes(instanceType);
+        ConcurrentBag<string> malwarePatterns = _blocklistProvider.GetMalwarePatterns();
         
         for (int i = 0; i < download.Files.Length; i++)
         {
             if (download.FileStats?[i].Wanted == null)
             {
+                _logger.LogTrace("Skipping file with no stats | {file}", download.Files[i].Name);
                 continue;
             }
 
             totalFiles++;
             
+            if (contentBlockerConfig.DeleteKnownMalware && _filenameEvaluator.IsKnownMalware(download.Files[i].Name, malwarePatterns))
+            {
+                _logger.LogInformation("malware file found | {file} | {title}", download.Files[i].Name, download.Name);
+                result.ShouldRemove = true;
+                result.DeleteReason = DeleteReason.MalwareFileFound;
+                return result;
+            }
+            
             if (!download.FileStats[i].Wanted.Value)
             {
+                _logger.LogTrace("File is already skipped | {file}", download.Files[i].Name);
                 totalUnwantedFiles++;
                 continue;
             }
 
             if (_filenameEvaluator.IsValid(download.Files[i].Name, blocklistType, patterns, regexes))
             {
+                _logger.LogTrace("File is valid | {file}", download.Files[i].Name);
                 continue;
             }
             
@@ -85,15 +97,18 @@ public partial class TransmissionService
 
         if (unwantedFiles.Count is 0)
         {
+            _logger.LogDebug("No unwanted files found for {name}", download.Name);
             return result;
         }
 
         if (totalUnwantedFiles == totalFiles)
         {
+            _logger.LogDebug("All files are blocked for {name}", download.Name);
             result.ShouldRemove = true;
+            result.DeleteReason = DeleteReason.AllFilesBlocked;
         }
         
-        _logger.LogDebug("marking {count} unwanted files as skipped for {name}", totalUnwantedFiles, download.Name);
+        _logger.LogDebug("Marking {count} unwanted files as skipped for {name}", totalUnwantedFiles, download.Name);
 
         await _dryRunInterceptor.InterceptAsync(SetUnwantedFiles, download.Id, unwantedFiles.ToArray());
 

code/backend/Cleanuparr.Infrastructure/Features/DownloadClient/Transmission/TransmissionServiceQC.cs

@@ -1,6 +1,4 @@
-using System.Collections.Concurrent;
-using System.Text.RegularExpressions;
-using Cleanuparr.Domain.Entities;
+using Cleanuparr.Domain.Entities;
 using Cleanuparr.Domain.Enums;
 using Cleanuparr.Infrastructure.Extensions;
 using Cleanuparr.Infrastructure.Features.Context;
@@ -22,7 +20,7 @@ public partial class TransmissionService
 
         if (download is null)
         {
-            _logger.LogDebug("failed to find torrent {hash} in the download client", hash);
+            _logger.LogDebug("failed to find torrent {hash} in the {name} download client", hash, _downloadClientConfig.Name);
             return result;
         }
         
@@ -56,6 +54,7 @@ public partial class TransmissionService
         if (shouldRemove)
         {
             // remove if all files are unwanted
+            _logger.LogDebug("all files are unwanted | removing download | {name}", download.Name);
             result.ShouldRemove = true;
             result.DeleteReason = DeleteReason.AllFilesSkipped;
             return result;
@@ -100,11 +99,13 @@ public partial class TransmissionService
         if (download.Status is not 4)
         {
             // not in downloading state
+            _logger.LogTrace("skip slow check | download is in {state} state | {name}", download.Status, download.Name);
             return (false, DeleteReason.None);
         }
         
         if (download.RateDownload <= 0)
         {
+            _logger.LogTrace("skip slow check | download speed is 0 | {name}", download.Name);
             return (false, DeleteReason.None);
         }
         
@@ -142,17 +143,20 @@ public partial class TransmissionService
         
         if (queueCleanerConfig.Stalled.MaxStrikes is 0)
         {
+            _logger.LogTrace("skip stalled check | max strikes is 0 | {name}", download.Name);
             return (false, DeleteReason.None);
         }
         
         if (download.Status is not 4)
         {
             // not in downloading state
+            _logger.LogTrace("skip stalled check | download is in {state} state | {name}", download.Status, download.Name);
             return (false, DeleteReason.None);
         }
         
         if (download.RateDownload > 0 || download.Eta > 0)
         {
+            _logger.LogTrace("skip stalled check | download is not stalled | {name}", download.Name);
             return (false, DeleteReason.None);
         }
         

code/backend/Cleanuparr.Infrastructure/Features/DownloadClient/UTorrent/Extensions/UTorrentExtensions.cs

@@ -0,0 +1,77 @@
+using Cleanuparr.Domain.Entities.UTorrent.Response;
+using Cleanuparr.Infrastructure.Services;
+
+namespace Cleanuparr.Infrastructure.Features.DownloadClient.UTorrent.Extensions;
+
+/// <summary>
+/// Extension methods for µTorrent entities and status checking
+/// </summary>
+public static class UTorrentExtensions
+{
+    /// <summary>
+    /// Checks if the torrent is currently seeding
+    /// </summary>
+    public static bool IsSeeding(this UTorrentItem item)
+    {
+        return IsDownloading(item.Status) && item.DateCompleted > 0;
+    }
+
+    /// <summary>
+    /// Checks if the torrent is currently downloading
+    /// </summary>
+    public static bool IsDownloading(this UTorrentItem item)
+    {
+        return IsDownloading(item.Status);
+    }
+
+    /// <summary>
+    /// Checks if the status indicates downloading
+    /// </summary>
+    public static bool IsDownloading(int status)
+    {
+        return (status & UTorrentStatus.Started) != 0 && 
+               (status & UTorrentStatus.Checked) != 0 &&
+               (status & UTorrentStatus.Error) == 0;
+    }
+    
+    /// <summary>
+    /// Checks if a torrent should be ignored based on the ignored patterns
+    /// </summary>
+    public static bool ShouldIgnore(this UTorrentItem download, IReadOnlyList<string> ignoredDownloads)
+    {
+        foreach (string value in ignoredDownloads)
+        {
+            if (download.Hash.Equals(value, StringComparison.InvariantCultureIgnoreCase))
+            {
+                return true;
+            }
+            
+            if (download.Label.Equals(value, StringComparison.InvariantCultureIgnoreCase))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+    
+    public static bool ShouldIgnore(this string tracker, IReadOnlyList<string> ignoredDownloads)
+    {
+        string? trackerUrl = UriService.GetDomain(tracker);
+
+        if (trackerUrl is null)
+        {
+            return false;
+        }
+        
+        foreach (string value in ignoredDownloads)
+        {
+            if (trackerUrl.EndsWith(value, StringComparison.InvariantCultureIgnoreCase))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+} 

code/backend/Cleanuparr.Infrastructure/Features/DownloadClient/UTorrent/IUTorrentAuthenticator.cs

@@ -0,0 +1,46 @@
+namespace Cleanuparr.Infrastructure.Features.DownloadClient.UTorrent;
+
+/// <summary>
+/// Interface for µTorrent authentication management with caching support
+/// Handles token management and session state with multi-client support
+/// </summary>
+public interface IUTorrentAuthenticator
+{
+    /// <summary>
+    /// Ensures that the client is authenticated and the token is valid
+    /// </summary>
+    /// <returns>True if authentication is successful</returns>
+    Task<bool> EnsureAuthenticatedAsync();
+
+    /// <summary>
+    /// Gets a valid authentication token, refreshing if necessary
+    /// </summary>
+    /// <returns>Valid authentication token</returns>
+    Task<string> GetValidTokenAsync();
+
+    /// <summary>
+    /// Gets a valid GUID cookie, refreshing if necessary
+    /// </summary>
+    /// <returns>Valid GUID cookie</returns>
+    Task<string> GetValidGuidCookieAsync();
+
+    /// <summary>
+    /// Forces a refresh of the authentication session
+    /// </summary>
+    Task RefreshSessionAsync();
+
+    /// <summary>
+    /// Invalidates the cached authentication session
+    /// </summary>
+    Task InvalidateSessionAsync();
+
+    /// <summary>
+    /// Gets whether the client is currently authenticated
+    /// </summary>
+    bool IsAuthenticated { get; }
+
+    /// <summary>
+    /// Gets the GUID cookie for the current session
+    /// </summary>
+    string GuidCookie { get; }
+}

code/backend/Cleanuparr.Infrastructure/Features/DownloadClient/UTorrent/IUTorrentHttpService.cs

@@ -0,0 +1,24 @@
+using Cleanuparr.Domain.Entities.UTorrent.Request;
+
+namespace Cleanuparr.Infrastructure.Features.DownloadClient.UTorrent;
+
+/// <summary>
+/// Interface for raw HTTP communication with µTorrent Web UI API
+/// Handles low-level HTTP requests and authentication token retrieval
+/// </summary>
+public interface IUTorrentHttpService
+{
+    /// <summary>
+    /// Sends a raw HTTP request to the µTorrent API
+    /// </summary>
+    /// <param name="request">The request to send</param>
+    /// <param name="guidCookie">The GUID cookie for authentication</param>
+    /// <returns>Raw JSON response from the API</returns>
+    Task<string> SendRawRequestAsync(UTorrentRequest request, string guidCookie);
+
+    /// <summary>
+    /// Retrieves authentication token and GUID cookie from µTorrent
+    /// </summary>
+    /// <returns>Tuple containing the authentication token and GUID cookie</returns>
+    Task<(string token, string guidCookie)> GetTokenAndCookieAsync();
+}

code/backend/Cleanuparr.Infrastructure/Features/DownloadClient/UTorrent/IUTorrentResponseParser.cs

@@ -0,0 +1,38 @@
+using Cleanuparr.Domain.Entities.UTorrent.Response;
+
+namespace Cleanuparr.Infrastructure.Features.DownloadClient.UTorrent;
+
+/// <summary>
+/// Interface for parsing µTorrent API responses
+/// Provides endpoint-specific parsing methods for different response types
+/// </summary>
+public interface IUTorrentResponseParser
+{
+    /// <summary>
+    /// Parses a torrent list response from JSON
+    /// </summary>
+    /// <param name="json">Raw JSON response from the API</param>
+    /// <returns>Parsed torrent list response</returns>
+    TorrentListResponse ParseTorrentList(string json);
+
+    /// <summary>
+    /// Parses a file list response from JSON
+    /// </summary>
+    /// <param name="json">Raw JSON response from the API</param>
+    /// <returns>Parsed file list response</returns>
+    FileListResponse ParseFileList(string json);
+
+    /// <summary>
+    /// Parses a properties response from JSON
+    /// </summary>
+    /// <param name="json">Raw JSON response from the API</param>
+    /// <returns>Parsed properties response</returns>
+    PropertiesResponse ParseProperties(string json);
+
+    /// <summary>
+    /// Parses a label list response from JSON
+    /// </summary>
+    /// <param name="json">Raw JSON response from the API</param>
+    /// <returns>Parsed label list response</returns>
+    LabelListResponse ParseLabelList(string json);
+}

code/backend/Cleanuparr.Infrastructure/Features/DownloadClient/UTorrent/IUTorrentService.cs

@@ -0,0 +1,8 @@
+namespace Cleanuparr.Infrastructure.Features.DownloadClient.UTorrent;
+
+/// <summary>
+/// Interface for µTorrent download service
+/// </summary>
+public interface IUTorrentService : IDownloadService
+{
+}