clean up CI job

.gitea/workflows/build.yaml

@@ -33,11 +33,6 @@ jobs:
       - name: Run tests
         run: dotnet test Jellyfin.Plugin.Jellypod.sln --no-build --configuration Release --verbosity normal
 
-      - name: Install JPRM
-        run: |
-          python3 -m venv /tmp/jprm-venv
-          /tmp/jprm-venv/bin/pip install jprm
-
       - name: Build Jellyfin Plugin
         id: jprm
         run: |
@@ -45,7 +40,7 @@ jobs:
           mkdir -p artifacts
 
           # Build plugin using JPRM
-          /tmp/jprm-venv/bin/jprm --verbosity=debug plugin build .
+          jprm --verbosity=debug plugin build .
 
           # Find the generated zip file
           ARTIFACT=$(find . -name "*.zip" -type f -print -quit)

.gitea/workflows/release.yaml

@@ -49,11 +49,6 @@ jobs:
       - name: Run tests
         run: dotnet test Jellyfin.Plugin.Jellypod.sln --no-build --configuration Release --verbosity normal
 
-      - name: Install JPRM
-        run: |
-          python3 -m venv /tmp/jprm-venv
-          /tmp/jprm-venv/bin/pip install jprm
-
       - name: Build Jellyfin Plugin
         id: jprm
         run: |
@@ -61,7 +56,7 @@ jobs:
           mkdir -p artifacts
 
           # Build plugin using JPRM
-          /tmp/jprm-venv/bin/jprm --verbosity=debug plugin build ./
+          jprm --verbosity=debug plugin build ./
 
           # Find the generated zip file
           ARTIFACT=$(find . -name "*.zip" -type f -print -quit)
@@ -70,7 +65,15 @@ jobs:
           echo "artifact_name=${ARTIFACT_NAME}" >> $GITHUB_OUTPUT
           echo "Found artifact: ${ARTIFACT}"
 
+      - name: Calculate checksum
+        id: checksum
+        run: |
+          CHECKSUM=$(md5sum "${{ steps.jprm.outputs.artifact }}" | awk '{print $1}')
+          echo "checksum=${CHECKSUM}" >> $GITHUB_OUTPUT
+          echo "MD5 Checksum: ${CHECKSUM}"
+
       - name: Create Release
+        id: create_release
         env:
           GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
@@ -80,7 +83,7 @@ jobs:
           GITEA_URL="${{ github.server_url }}"
 
           # Prepare release body
-          RELEASE_BODY="Jellypod Jellyfin Plugin ${{ steps.get_version.outputs.version }}\n\nSee attached files for plugin installation."
+          RELEASE_BODY="Jellypod Jellyfin Plugin ${{ steps.get_version.outputs.version }}\n\nSee attached files for plugin installation.\n\nTo install, add this repository URL to Jellyfin:\n\`${GITEA_URL}/${REPO_OWNER}/${REPO_NAME}/raw/branch/master/manifest.json\`"
           RELEASE_BODY_JSON=$(echo -n "${RELEASE_BODY}" | jq -Rs .)
 
           # Create release using Gitea API
@@ -101,6 +104,7 @@ jobs:
 
           if [ "$HTTP_CODE" -ge 200 ] && [ "$HTTP_CODE" -lt 300 ]; then
             RELEASE_ID=$(echo "$BODY" | jq -r '.id')
+            echo "release_id=${RELEASE_ID}" >> $GITHUB_OUTPUT
             echo "Created release with ID: ${RELEASE_ID}"
           else
             echo "Failed to create release. HTTP ${HTTP_CODE}"
@@ -126,3 +130,47 @@ jobs:
 
           echo "Release created successfully!"
           echo "View at: ${GITEA_URL}/${REPO_OWNER}/${REPO_NAME}/releases/tag/${{ steps.get_version.outputs.version }}"
+
+      - name: Update manifest.json
+        env:
+          GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          REPO_OWNER="${{ github.repository_owner }}"
+          REPO_NAME="${{ github.event.repository.name }}"
+          GITEA_URL="${{ github.server_url }}"
+          VERSION="${{ steps.get_version.outputs.version_number }}"
+          CHECKSUM="${{ steps.checksum.outputs.checksum }}"
+          ARTIFACT_NAME="${{ steps.jprm.outputs.artifact_name }}"
+          TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+          DOWNLOAD_URL="${GITEA_URL}/${REPO_OWNER}/${REPO_NAME}/releases/download/${{ steps.get_version.outputs.version }}/${ARTIFACT_NAME}"
+
+          # Configure git
+          git config user.name "Gitea Actions"
+          git config user.email "actions@gitea.tourolle.paris"
+
+          # Fetch and checkout master branch
+          git fetch origin master
+          git checkout master
+
+          # Create new version entry
+          NEW_VERSION=$(cat <<EOF
+          {
+            "version": "${VERSION}",
+            "changelog": "Release ${VERSION}",
+            "targetAbi": "10.9.0.0",
+            "sourceUrl": "${DOWNLOAD_URL}",
+            "checksum": "${CHECKSUM}",
+            "timestamp": "${TIMESTAMP}"
+          }
+          EOF
+          )
+
+          # Update manifest.json - prepend new version to versions array
+          jq --argjson newver "${NEW_VERSION}" '.[0].versions = [$newver] + .[0].versions' manifest.json > manifest.tmp && mv manifest.tmp manifest.json
+
+          # Commit and push
+          git add manifest.json
+          git commit -m "Update manifest.json for version ${VERSION}"
+          git push origin master
+
+          echo "Manifest updated successfully!"

Jellyfin.Plugin.Jellypod/Api/ImageController.cs

@@ -0,0 +1,189 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.Jellypod.Services;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.Jellypod.Api;
+
+/// <summary>
+/// Controller for serving podcast and episode images.
+/// </summary>
+[ApiController]
+[Route("Jellypod/Image")]
+public class ImageController : ControllerBase
+{
+    private readonly ILogger<ImageController> _logger;
+    private readonly IPodcastStorageService _storageService;
+    private readonly IHttpClientFactory _httpClientFactory;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ImageController"/> class.
+    /// </summary>
+    /// <param name="logger">Logger instance.</param>
+    /// <param name="storageService">Storage service instance.</param>
+    /// <param name="httpClientFactory">HTTP client factory.</param>
+    public ImageController(
+        ILogger<ImageController> logger,
+        IPodcastStorageService storageService,
+        IHttpClientFactory httpClientFactory)
+    {
+        _logger = logger;
+        _storageService = storageService;
+        _httpClientFactory = httpClientFactory;
+    }
+
+    /// <summary>
+    /// Gets the image for a podcast.
+    /// </summary>
+    /// <param name="podcastId">The podcast ID.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The image file.</returns>
+    [HttpGet("podcast/{podcastId}")]
+    [AllowAnonymous]
+    [SuppressMessage("Microsoft.Security", "CA3003:ReviewCodeForFilePathInjectionVulnerabilities", Justification = "Path is constructed from validated GUID and sanitized podcast title")]
+    public async Task<IActionResult> GetPodcastImage(
+        [FromRoute] Guid podcastId,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            var podcast = await _storageService.GetPodcastAsync(podcastId).ConfigureAwait(false);
+            if (podcast == null)
+            {
+                return NotFound("Podcast not found");
+            }
+
+            // Try to serve local cached image first
+            var config = Plugin.Instance?.Configuration;
+            if (config?.CreatePodcastFolders == true)
+            {
+                var basePath = _storageService.GetStoragePath();
+                var podcastFolder = Path.Combine(basePath, SanitizeFileName(podcast.Title));
+                var artworkPath = Path.Combine(podcastFolder, "folder.jpg");
+
+                if (System.IO.File.Exists(artworkPath))
+                {
+                    var fileStream = System.IO.File.OpenRead(artworkPath);
+                    return File(fileStream, "image/jpeg");
+                }
+            }
+
+            // Fall back to proxying the external URL
+            if (!string.IsNullOrEmpty(podcast.ImageUrl))
+            {
+                return await ProxyImageAsync(podcast.ImageUrl, cancellationToken).ConfigureAwait(false);
+            }
+
+            return NotFound("No image available");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error serving podcast image for {PodcastId}", podcastId);
+            return StatusCode(500, "Failed to serve podcast image");
+        }
+    }
+
+    /// <summary>
+    /// Gets the image for an episode.
+    /// </summary>
+    /// <param name="podcastId">The podcast ID.</param>
+    /// <param name="episodeId">The episode ID.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The image file.</returns>
+    [HttpGet("episode/{podcastId}/{episodeId}")]
+    [AllowAnonymous]
+    [SuppressMessage("Microsoft.Security", "CA3003:ReviewCodeForFilePathInjectionVulnerabilities", Justification = "Path is constructed from validated GUIDs and sanitized podcast title")]
+    public async Task<IActionResult> GetEpisodeImage(
+        [FromRoute] Guid podcastId,
+        [FromRoute] Guid episodeId,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            var podcast = await _storageService.GetPodcastAsync(podcastId).ConfigureAwait(false);
+            if (podcast == null)
+            {
+                return NotFound("Podcast not found");
+            }
+
+            var episode = podcast.Episodes.FirstOrDefault(e => e.Id == episodeId);
+            if (episode == null)
+            {
+                return NotFound("Episode not found");
+            }
+
+            // Try to serve local cached episode image first
+            var config = Plugin.Instance?.Configuration;
+            if (config?.CreatePodcastFolders == true)
+            {
+                var basePath = _storageService.GetStoragePath();
+                var podcastFolder = Path.Combine(basePath, SanitizeFileName(podcast.Title));
+                var episodeFileName = $"{SanitizeFileName(episode.Id.ToString())}.jpg";
+                var artworkPath = Path.Combine(podcastFolder, episodeFileName);
+
+                if (System.IO.File.Exists(artworkPath))
+                {
+                    var fileStream = System.IO.File.OpenRead(artworkPath);
+                    return File(fileStream, "image/jpeg");
+                }
+            }
+
+            // Fall back to episode ImageUrl if available
+            if (!string.IsNullOrEmpty(episode.ImageUrl))
+            {
+                return await ProxyImageAsync(episode.ImageUrl, cancellationToken).ConfigureAwait(false);
+            }
+
+            // Final fallback to podcast image
+            if (!string.IsNullOrEmpty(podcast.ImageUrl))
+            {
+                return await ProxyImageAsync(podcast.ImageUrl, cancellationToken).ConfigureAwait(false);
+            }
+
+            return NotFound("No image available");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error serving episode image for {EpisodeId}", episodeId);
+            return StatusCode(500, "Failed to serve episode image");
+        }
+    }
+
+    private async Task<IActionResult> ProxyImageAsync(string imageUrl, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var client = _httpClientFactory.CreateClient("Jellypod");
+            var response = await client.GetAsync(imageUrl, cancellationToken).ConfigureAwait(false);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                _logger.LogWarning("Failed to fetch image: {StatusCode} from {Url}", response.StatusCode, imageUrl);
+                return StatusCode((int)response.StatusCode);
+            }
+
+            var contentType = response.Content.Headers.ContentType?.MediaType ?? "image/jpeg";
+            var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
+
+            return File(stream, contentType);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error proxying image from {Url}", imageUrl);
+            return StatusCode(500, "Failed to proxy image");
+        }
+    }
+
+    private static string SanitizeFileName(string name)
+    {
+        var invalidChars = Path.GetInvalidFileNameChars();
+        return string.Join("_", name.Split(invalidChars, StringSplitOptions.RemoveEmptyEntries)).TrimEnd('.');
+    }
+}

Jellyfin.Plugin.Jellypod/Api/JellypodController.cs

@@ -119,6 +119,12 @@ public class JellypodController : ControllerBase
         // Download podcast artwork
         await _downloadService.DownloadPodcastArtworkAsync(podcast).ConfigureAwait(false);
 
+        // Download episode artwork for all initial episodes
+        foreach (var episode in podcast.Episodes)
+        {
+            await _downloadService.DownloadEpisodeArtworkAsync(podcast, episode).ConfigureAwait(false);
+        }
+
         _logger.LogInformation("Added podcast: {Title} ({Url})", podcast.Title, podcast.FeedUrl);
 
         return CreatedAtAction(nameof(GetPodcast), new { id = podcast.Id }, podcast);
@@ -180,6 +186,11 @@ public class JellypodController : ControllerBase
             podcast.MaxEpisodesToKeep = request.MaxEpisodesToKeep.Value;
         }
 
+        if (request.MaxEpisodeAgeDays.HasValue)
+        {
+            podcast.MaxEpisodeAgeDays = request.MaxEpisodeAgeDays.Value;
+        }
+
         await _storageService.UpdatePodcastAsync(podcast).ConfigureAwait(false);
         return Ok(podcast);
     }
@@ -225,6 +236,12 @@ public class JellypodController : ControllerBase
         podcast.LastUpdated = DateTime.UtcNow;
         await _storageService.UpdatePodcastAsync(podcast).ConfigureAwait(false);
 
+        // Download artwork for new episodes
+        foreach (var episode in newEpisodes)
+        {
+            await _downloadService.DownloadEpisodeArtworkAsync(podcast, episode).ConfigureAwait(false);
+        }
+
         return Ok(podcast);
     }
 

Jellyfin.Plugin.Jellypod/Api/Models/UpdatePodcastRequest.cs

@@ -14,4 +14,9 @@ public class UpdatePodcastRequest
     /// Gets or sets the maximum episodes to keep.
     /// </summary>
     public int? MaxEpisodesToKeep { get; set; }
+
+    /// <summary>
+    /// Gets or sets the maximum age in days for episodes (0 = use global, -1 = unlimited).
+    /// </summary>
+    public int? MaxEpisodeAgeDays { get; set; }
 }

Jellyfin.Plugin.Jellypod/Channels/JellypodChannel.cs

@@ -189,7 +189,7 @@ public class JellypodChannel : IChannel, IHasCacheKey, IRequiresMediaInfoCallbac
                 Id = podcast.Id.ToString("N"),
                 Name = podcast.Title,
                 Overview = podcast.Description,
-                ImageUrl = podcast.ImageUrl,
+                ImageUrl = GetPodcastImageUrl(podcast.Id),
                 Type = ChannelItemType.Folder,
                 FolderType = ChannelFolderType.Container,
                 DateCreated = podcast.DateAdded,
@@ -257,7 +257,7 @@ public class JellypodChannel : IChannel, IHasCacheKey, IRequiresMediaInfoCallbac
                 Id = episode.Id.ToString("N"),
                 Name = episodeName,
                 Overview = overview,
-                ImageUrl = episode.ImageUrl ?? podcast.ImageUrl,
+                ImageUrl = GetEpisodeImageUrl(podcast.Id, episode.Id),
                 Type = ChannelItemType.Media,
                 ContentType = ChannelMediaContentType.Podcast,
                 MediaType = ChannelMediaType.Audio,
@@ -387,10 +387,9 @@ public class JellypodChannel : IChannel, IHasCacheKey, IRequiresMediaInfoCallbac
     /// <inheritdoc />
     public string? GetCacheKey(string? userId)
     {
-        // Use 5-minute time buckets for cache key
-        var now = DateTime.Now;
-        var timeBucket = new DateTime(now.Year, now.Month, now.Day, now.Hour, (now.Minute / 5) * 5, 0);
-        return timeBucket.ToString("yyyy-MM-dd-HH-mm", CultureInfo.InvariantCulture);
+        // Include database modification time so cache invalidates when podcasts/episodes change
+        var lastModified = _storageService.LastModified;
+        return lastModified.ToString("O", CultureInfo.InvariantCulture);
     }
 
     /// <inheritdoc />
@@ -498,4 +497,16 @@ public class JellypodChannel : IChannel, IHasCacheKey, IRequiresMediaInfoCallbac
             ReadAtNativeFramerate = false
         };
     }
+
+    private string GetPodcastImageUrl(Guid podcastId)
+    {
+        var localAddress = _appHost.GetApiUrlForLocalAccess();
+        return $"{localAddress}/Jellypod/Image/podcast/{podcastId:N}";
+    }
+
+    private string GetEpisodeImageUrl(Guid podcastId, Guid episodeId)
+    {
+        var localAddress = _appHost.GetApiUrlForLocalAccess();
+        return $"{localAddress}/Jellypod/Image/episode/{podcastId:N}/{episodeId:N}";
+    }
 }

Jellyfin.Plugin.Jellypod/Configuration/PluginConfiguration.cs

@@ -17,8 +17,11 @@ public class PluginConfiguration : BasePluginConfiguration
         GlobalAutoDownloadEnabled = true;
         MaxConcurrentDownloads = 2;
         MaxEpisodesPerPodcast = 50;
+        MaxEpisodeAgeDays = 0;
         CreatePodcastFolders = true;
         DownloadNewEpisodesOnly = true;
+        PostDownloadScriptPath = string.Empty;
+        PostDownloadScriptTimeout = 60;
     }
 
     /// <summary>
@@ -47,6 +50,12 @@ public class PluginConfiguration : BasePluginConfiguration
     /// </summary>
     public int MaxEpisodesPerPodcast { get; set; }
 
+    /// <summary>
+    /// Gets or sets the maximum age in days for downloaded episodes (0 = unlimited).
+    /// Episodes older than this will be automatically deleted.
+    /// </summary>
+    public int MaxEpisodeAgeDays { get; set; }
+
     /// <summary>
     /// Gets or sets a value indicating whether to create subfolders for each podcast.
     /// </summary>
@@ -56,4 +65,15 @@ public class PluginConfiguration : BasePluginConfiguration
     /// Gets or sets a value indicating whether to only download new episodes after subscription.
     /// </summary>
     public bool DownloadNewEpisodesOnly { get; set; }
+
+    /// <summary>
+    /// Gets or sets the path to post-download processing script.
+    /// Script is called with: script input_file output_file.
+    /// </summary>
+    public string PostDownloadScriptPath { get; set; }
+
+    /// <summary>
+    /// Gets or sets the timeout in seconds for post-download script execution.
+    /// </summary>
+    public int PostDownloadScriptTimeout { get; set; }
 }

Jellyfin.Plugin.Jellypod/Configuration/configPage.html

@@ -164,6 +164,38 @@
                                 Maximum episodes to keep downloaded per podcast (0 = unlimited)
                             </div>
                         </div>
+                        <div class="inputContainer">
+                            <label class="inputLabel inputLabelUnfocused" for="MaxEpisodeAgeDays">
+                                Max Episode Age (days)
+                            </label>
+                            <input id="MaxEpisodeAgeDays" name="MaxEpisodeAgeDays" type="number" is="emby-input" min="0" />
+                            <div class="fieldDescription">
+                                Automatically delete episodes downloaded more than this many days ago (0 = unlimited)
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- Post-Download Processing -->
+                    <div class="verticalSection">
+                        <h3 class="sectionTitle">Post-Download Processing</h3>
+                        <div class="inputContainer">
+                            <label class="inputLabel inputLabelUnfocused" for="PostDownloadScriptPath">
+                                Post-Download Script Path
+                            </label>
+                            <input id="PostDownloadScriptPath" name="PostDownloadScriptPath" type="text" is="emby-input" />
+                            <div class="fieldDescription">
+                                Optional script to process episodes after download. Called as: script input_file output_file
+                            </div>
+                        </div>
+                        <div class="inputContainer">
+                            <label class="inputLabel inputLabelUnfocused" for="PostDownloadScriptTimeout">
+                                Script Timeout (seconds)
+                            </label>
+                            <input id="PostDownloadScriptTimeout" name="PostDownloadScriptTimeout" type="number" is="emby-input" min="1" max="3600" />
+                            <div class="fieldDescription">
+                                Maximum time to wait for script completion (default: 60 seconds)
+                            </div>
+                        </div>
                     </div>
 
                     <div>
@@ -228,7 +260,10 @@
                     document.querySelector('#GlobalAutoDownloadEnabled').checked = config.GlobalAutoDownloadEnabled;
                     document.querySelector('#MaxConcurrentDownloads').value = config.MaxConcurrentDownloads;
                     document.querySelector('#MaxEpisodesPerPodcast').value = config.MaxEpisodesPerPodcast;
+                    document.querySelector('#MaxEpisodeAgeDays').value = config.MaxEpisodeAgeDays;
                     document.querySelector('#CreatePodcastFolders').checked = config.CreatePodcastFolders;
+                    document.querySelector('#PostDownloadScriptPath').value = config.PostDownloadScriptPath || '';
+                    document.querySelector('#PostDownloadScriptTimeout').value = config.PostDownloadScriptTimeout || 60;
                     Dashboard.hideLoadingMsg();
                 });
             }
@@ -407,7 +442,10 @@
                     config.GlobalAutoDownloadEnabled = document.querySelector('#GlobalAutoDownloadEnabled').checked;
                     config.MaxConcurrentDownloads = parseInt(document.querySelector('#MaxConcurrentDownloads').value, 10);
                     config.MaxEpisodesPerPodcast = parseInt(document.querySelector('#MaxEpisodesPerPodcast').value, 10);
+                    config.MaxEpisodeAgeDays = parseInt(document.querySelector('#MaxEpisodeAgeDays').value, 10);
                     config.CreatePodcastFolders = document.querySelector('#CreatePodcastFolders').checked;
+                    config.PostDownloadScriptPath = document.querySelector('#PostDownloadScriptPath').value;
+                    config.PostDownloadScriptTimeout = parseInt(document.querySelector('#PostDownloadScriptTimeout').value, 10);
                     ApiClient.updatePluginConfiguration(JellypodConfig.pluginUniqueId, config).then(function (result) {
                         Dashboard.processPluginConfigurationUpdateResult(result);
                     });

Jellyfin.Plugin.Jellypod/Models/Podcast.cs

@@ -69,6 +69,12 @@ public class Podcast
     /// </summary>
     public int MaxEpisodesToKeep { get; set; }
 
+    /// <summary>
+    /// Gets or sets the maximum age in days for downloaded episodes.
+    /// 0 = use global setting, -1 = unlimited, greater than 0 = specific days.
+    /// </summary>
+    public int MaxEpisodeAgeDays { get; set; }
+
     /// <summary>
     /// Gets or sets the list of episodes.
     /// </summary>

Jellyfin.Plugin.Jellypod/ScheduledTasks/PodcastUpdateTask.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Jellyfin.Plugin.Jellypod.Models;
 using Jellyfin.Plugin.Jellypod.Services;
 using MediaBrowser.Model.Tasks;
 using Microsoft.Extensions.Logging;
@@ -117,7 +118,22 @@ public class PodcastUpdateTask : IScheduledTask
             }
 
             processedCount++;
-            progress.Report((double)processedCount / totalPodcasts * 100);
+            progress.Report((double)processedCount / totalPodcasts * 90 / 100);
+        }
+
+        // Run cleanup for expired episodes
+        _logger.LogInformation("Starting episode retention cleanup");
+        foreach (var podcast in podcasts)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            try
+            {
+                await CleanupExpiredEpisodesAsync(podcast, cancellationToken).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Failed to cleanup expired episodes for: {Title}", podcast.Title);
+            }
         }
 
         progress.Report(100);
@@ -139,4 +155,78 @@ public class PodcastUpdateTask : IScheduledTask
             }
         };
     }
+
+    /// <summary>
+    /// Cleans up episodes that exceed the retention policy.
+    /// </summary>
+    /// <param name="podcast">The podcast to clean up.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    private async Task CleanupExpiredEpisodesAsync(Podcast podcast, CancellationToken cancellationToken)
+    {
+        var config = Plugin.Instance?.Configuration;
+
+        // Determine effective max age for this podcast
+        int effectiveMaxAgeDays;
+        if (podcast.MaxEpisodeAgeDays == -1)
+        {
+            // Per-podcast override: unlimited
+            return;
+        }
+        else if (podcast.MaxEpisodeAgeDays > 0)
+        {
+            // Per-podcast specific value
+            effectiveMaxAgeDays = podcast.MaxEpisodeAgeDays;
+        }
+        else
+        {
+            // Use global setting (podcast.MaxEpisodeAgeDays == 0)
+            effectiveMaxAgeDays = config?.MaxEpisodeAgeDays ?? 0;
+        }
+
+        // 0 means unlimited
+        if (effectiveMaxAgeDays <= 0)
+        {
+            return;
+        }
+
+        var cutoffDate = DateTime.UtcNow.AddDays(-effectiveMaxAgeDays);
+        var expiredEpisodes = podcast.Episodes
+            .Where(e => e.Status == EpisodeStatus.Downloaded
+                        && e.DownloadedDate.HasValue
+                        && e.DownloadedDate.Value < cutoffDate)
+            .ToList();
+
+        if (expiredEpisodes.Count == 0)
+        {
+            return;
+        }
+
+        _logger.LogInformation(
+            "Found {Count} expired episodes for {Podcast} (older than {Days} days)",
+            expiredEpisodes.Count,
+            podcast.Title,
+            effectiveMaxAgeDays);
+
+        foreach (var episode in expiredEpisodes)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            try
+            {
+                await _downloadService.DeleteEpisodeFileAsync(episode).ConfigureAwait(false);
+                _logger.LogDebug(
+                    "Deleted expired episode: {Title} (downloaded {Date})",
+                    episode.Title,
+                    episode.DownloadedDate);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Failed to delete expired episode: {Title}", episode.Title);
+            }
+        }
+
+        // Save changes to storage
+        await _storageService.UpdatePodcastAsync(podcast).ConfigureAwait(false);
+    }
 }

Jellyfin.Plugin.Jellypod/Services/IPodcastDownloadService.cs

@@ -46,4 +46,13 @@ public interface IPodcastDownloadService
     /// <param name="cancellationToken">Cancellation token.</param>
     /// <returns>Task representing the download operation.</returns>
     Task DownloadPodcastArtworkAsync(Podcast podcast, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Downloads episode artwork.
+    /// </summary>
+    /// <param name="podcast">The podcast.</param>
+    /// <param name="episode">The episode.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>Task representing the download operation.</returns>
+    Task DownloadEpisodeArtworkAsync(Podcast podcast, Episode episode, CancellationToken cancellationToken = default);
 }

Jellyfin.Plugin.Jellypod/Services/IPodcastStorageService.cs

@@ -10,6 +10,12 @@ namespace Jellyfin.Plugin.Jellypod.Services;
 /// </summary>
 public interface IPodcastStorageService
 {
+    /// <summary>
+    /// Gets the cached last modification time (synchronous, for cache key generation).
+    /// Returns default if database hasn't been loaded yet.
+    /// </summary>
+    DateTime LastModified { get; }
+
     /// <summary>
     /// Gets all subscribed podcasts.
     /// </summary>
@@ -57,4 +63,10 @@ public interface IPodcastStorageService
     /// </summary>
     /// <returns>The base path for podcast storage.</returns>
     string GetStoragePath();
+
+    /// <summary>
+    /// Gets the last time the database was modified.
+    /// </summary>
+    /// <returns>The last modification time, or null if unknown.</returns>
+    Task<DateTime?> GetLastModifiedAsync();
 }

Jellyfin.Plugin.Jellypod/Services/PodcastDownloadService.cs

@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Concurrent;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Net.Http;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Plugin.Jellypod.Models;
@@ -63,15 +65,27 @@ public sealed class PodcastDownloadService : IPodcastDownloadService, IDisposabl
         IProgress<double>? progress = null,
         CancellationToken cancellationToken = default)
     {
-        var filePath = _storageService.GetEpisodeFilePath(podcast, episode);
-        var directory = Path.GetDirectoryName(filePath);
+        var finalPath = _storageService.GetEpisodeFilePath(podcast, episode);
+        var finalDirectory = Path.GetDirectoryName(finalPath);
 
-        if (!string.IsNullOrEmpty(directory))
+        if (!string.IsNullOrEmpty(finalDirectory))
         {
-            Directory.CreateDirectory(directory);
+            Directory.CreateDirectory(finalDirectory);
         }
 
-        _logger.LogInformation("Downloading episode: {Title} to {Path}", episode.Title, filePath);
+        // Determine if we should use temp directory for post-processing
+        var config = Plugin.Instance?.Configuration;
+        var usePostProcessing = !string.IsNullOrWhiteSpace(config?.PostDownloadScriptPath);
+
+        // Use temp directory if post-processing is enabled, otherwise download directly to final location
+        var downloadPath = usePostProcessing
+            ? Path.Combine(Path.GetTempPath(), "jellypod-" + Path.GetRandomFileName() + Path.GetExtension(finalPath))
+            : finalPath;
+
+        _logger.LogInformation("Downloading episode: {Title} to {Path}", episode.Title, downloadPath);
+
+        string? tempInputFile = null;
+        string? tempOutputFile = null;
 
         try
         {
@@ -91,7 +105,7 @@ public sealed class PodcastDownloadService : IPodcastDownloadService, IDisposabl
             long totalRead;
             try
             {
-                var fileStream = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.None, 81920, true);
+                var fileStream = new FileStream(downloadPath, FileMode.Create, FileAccess.Write, FileShare.None, 81920, true);
                 try
                 {
                     var buffer = new byte[81920];
@@ -119,17 +133,51 @@ public sealed class PodcastDownloadService : IPodcastDownloadService, IDisposabl
                 await contentStream.DisposeAsync().ConfigureAwait(false);
             }
 
-            episode.LocalFilePath = filePath;
+            _logger.LogInformation("Downloaded episode: {Title} ({Size} bytes)", episode.Title, totalRead);
+
+            // Post-processing if configured
+            string sourceFile = downloadPath;
+            if (usePostProcessing)
+            {
+                tempInputFile = downloadPath;
+                tempOutputFile = Path.Combine(
+                    Path.GetTempPath(),
+                    "jellypod-output-" + Path.GetRandomFileName() + Path.GetExtension(finalPath));
+
+                var scriptTimeout = config?.PostDownloadScriptTimeout ?? 60;
+                var processedFile = await ExecutePostDownloadScriptAsync(
+                    tempInputFile,
+                    tempOutputFile,
+                    scriptTimeout,
+                    cancellationToken).ConfigureAwait(false);
+
+                if (processedFile != null)
+                {
+                    _logger.LogInformation("Using processed file from post-download script");
+                    sourceFile = processedFile;
+                }
+                else
+                {
+                    _logger.LogInformation("Using original file (script failed, timed out, or not configured)");
+                    sourceFile = tempInputFile;
+                }
+
+                // Copy the selected file to final destination
+                File.Copy(sourceFile, finalPath, overwrite: true);
+                _logger.LogInformation("Copied episode to final location: {Path}", finalPath);
+            }
+
+            // Get final file size
+            var finalFileInfo = new FileInfo(finalPath);
+            episode.LocalFilePath = finalPath;
             episode.Status = EpisodeStatus.Downloaded;
             episode.DownloadedDate = DateTime.UtcNow;
-            episode.FileSizeBytes = totalRead;
-
-            _logger.LogInformation("Downloaded episode: {Title} ({Size} bytes)", episode.Title, totalRead);
+            episode.FileSizeBytes = finalFileInfo.Length;
 
             // Update the podcast in storage
             await _storageService.UpdatePodcastAsync(podcast).ConfigureAwait(false);
 
-            return filePath;
+            return finalPath;
         }
         catch (Exception ex)
         {
@@ -137,6 +185,35 @@ public sealed class PodcastDownloadService : IPodcastDownloadService, IDisposabl
             _logger.LogError(ex, "Failed to download episode: {Title}", episode.Title);
             throw;
         }
+        finally
+        {
+            // Clean up temp files
+            if (tempInputFile != null && File.Exists(tempInputFile))
+            {
+                try
+                {
+                    File.Delete(tempInputFile);
+                    _logger.LogDebug("Cleaned up temp input file: {Path}", tempInputFile);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogWarning(ex, "Failed to delete temp input file: {Path}", tempInputFile);
+                }
+            }
+
+            if (tempOutputFile != null && File.Exists(tempOutputFile))
+            {
+                try
+                {
+                    File.Delete(tempOutputFile);
+                    _logger.LogDebug("Cleaned up temp output file: {Path}", tempOutputFile);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogWarning(ex, "Failed to delete temp output file: {Path}", tempOutputFile);
+                }
+            }
+        }
     }
 
     /// <inheritdoc />
@@ -206,6 +283,46 @@ public sealed class PodcastDownloadService : IPodcastDownloadService, IDisposabl
         }
     }
 
+    /// <inheritdoc />
+    public async Task DownloadEpisodeArtworkAsync(Podcast podcast, Episode episode, CancellationToken cancellationToken = default)
+    {
+        if (string.IsNullOrEmpty(episode.ImageUrl))
+        {
+            return;
+        }
+
+        var config = Plugin.Instance?.Configuration;
+        if (config?.CreatePodcastFolders != true)
+        {
+            return;
+        }
+
+        var basePath = _storageService.GetStoragePath();
+        var podcastFolder = Path.Combine(basePath, SanitizeFileName(podcast.Title));
+        var episodeFileName = $"{SanitizeFileName(episode.Id.ToString())}.jpg";
+        var artworkPath = Path.Combine(podcastFolder, episodeFileName);
+
+        if (File.Exists(artworkPath))
+        {
+            return;
+        }
+
+        try
+        {
+            Directory.CreateDirectory(podcastFolder);
+
+            var httpClient = _httpClientFactory.CreateClient("Jellypod");
+            var imageBytes = await httpClient.GetByteArrayAsync(episode.ImageUrl, cancellationToken).ConfigureAwait(false);
+            await File.WriteAllBytesAsync(artworkPath, imageBytes, cancellationToken).ConfigureAwait(false);
+
+            _logger.LogDebug("Downloaded artwork for episode: {Title}", episode.Title);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "Failed to download artwork for episode: {Title}", episode.Title);
+        }
+    }
+
     private async Task ProcessQueueAsync()
     {
         try
@@ -240,6 +357,136 @@ public sealed class PodcastDownloadService : IPodcastDownloadService, IDisposabl
         return result.Length > 100 ? result.Substring(0, 100).Trim() : result.Trim();
     }
 
+    /// <summary>
+    /// Executes the post-download script if configured.
+    /// </summary>
+    /// <param name="inputFilePath">Path to the downloaded file.</param>
+    /// <param name="outputFilePath">Path where the script should write the processed file.</param>
+    /// <param name="timeoutSeconds">Timeout in seconds.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The output file path if successful, null if failed/timeout.</returns>
+    private async Task<string?> ExecutePostDownloadScriptAsync(
+        string inputFilePath,
+        string outputFilePath,
+        int timeoutSeconds,
+        CancellationToken cancellationToken)
+    {
+        var config = Plugin.Instance?.Configuration;
+        var scriptPath = config?.PostDownloadScriptPath;
+
+        if (string.IsNullOrWhiteSpace(scriptPath))
+        {
+            return null;
+        }
+
+        if (!File.Exists(scriptPath))
+        {
+            _logger.LogError("Post-download script not found at path: {ScriptPath}", scriptPath);
+            return null;
+        }
+
+        try
+        {
+            _logger.LogDebug(
+                "Executing post-download script: {ScriptPath} {InputFile} {OutputFile}",
+                scriptPath,
+                inputFilePath,
+                outputFilePath);
+
+            var processStartInfo = new ProcessStartInfo
+            {
+                FileName = scriptPath,
+                Arguments = $"\"{inputFilePath}\" \"{outputFilePath}\"",
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                UseShellExecute = false,
+                CreateNoWindow = true
+            };
+
+            using var process = new Process { StartInfo = processStartInfo };
+            var stdoutBuilder = new StringBuilder();
+            var stderrBuilder = new StringBuilder();
+
+            process.OutputDataReceived += (sender, e) =>
+            {
+                if (e.Data != null)
+                {
+                    stdoutBuilder.AppendLine(e.Data);
+                }
+            };
+
+            process.ErrorDataReceived += (sender, e) =>
+            {
+                if (e.Data != null)
+                {
+                    stderrBuilder.AppendLine(e.Data);
+                }
+            };
+
+            process.Start();
+            process.BeginOutputReadLine();
+            process.BeginErrorReadLine();
+
+            // Create a timeout cancellation token
+            using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            timeoutCts.CancelAfter(TimeSpan.FromSeconds(timeoutSeconds));
+
+            try
+            {
+                await process.WaitForExitAsync(timeoutCts.Token).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException)
+            {
+                if (!process.HasExited)
+                {
+                    _logger.LogWarning(
+                        "Post-download script timed out after {Timeout} seconds, killing process",
+                        timeoutSeconds);
+                    process.Kill(entireProcessTree: true);
+                }
+
+                return null;
+            }
+
+            var stdout = stdoutBuilder.ToString();
+            var stderr = stderrBuilder.ToString();
+
+            if (!string.IsNullOrWhiteSpace(stdout))
+            {
+                _logger.LogDebug("Script stdout: {Stdout}", stdout.Trim());
+            }
+
+            if (!string.IsNullOrWhiteSpace(stderr))
+            {
+                _logger.LogDebug("Script stderr: {Stderr}", stderr.Trim());
+            }
+
+            if (process.ExitCode != 0)
+            {
+                _logger.LogError(
+                    "Post-download script failed with exit code {ExitCode}",
+                    process.ExitCode);
+                return null;
+            }
+
+            if (!File.Exists(outputFilePath))
+            {
+                _logger.LogWarning(
+                    "Post-download script succeeded but output file was not created: {OutputFile}",
+                    outputFilePath);
+                return null;
+            }
+
+            _logger.LogInformation("Post-download script executed successfully");
+            return outputFilePath;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to execute post-download script");
+            return null;
+        }
+    }
+
     /// <inheritdoc />
     public void Dispose()
     {

Jellyfin.Plugin.Jellypod/Services/PodcastStorageService.cs

@@ -28,6 +28,7 @@ public sealed class PodcastStorageService : IPodcastStorageService, IDisposable
     private readonly IApplicationPaths _applicationPaths;
     private readonly SemaphoreSlim _dbLock = new(1, 1);
     private PodcastDatabase? _cache;
+    private DateTime _lastModified;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PodcastStorageService"/> class.
@@ -47,6 +48,9 @@ public sealed class PodcastStorageService : IPodcastStorageService, IDisposable
         "Jellypod",
         "podcasts.json");
 
+    /// <inheritdoc />
+    public DateTime LastModified => _lastModified;
+
     /// <inheritdoc />
     public async Task<IReadOnlyList<Podcast>> GetAllPodcastsAsync()
     {
@@ -180,6 +184,7 @@ public sealed class PodcastStorageService : IPodcastStorageService, IDisposable
         {
             _logger.LogWarning("Database file does not exist at {Path}", DatabasePath);
             _cache = new PodcastDatabase();
+            _lastModified = DateTime.UtcNow;
             return _cache;
         }
 
@@ -189,6 +194,7 @@ public sealed class PodcastStorageService : IPodcastStorageService, IDisposable
             var json = await File.ReadAllTextAsync(DatabasePath).ConfigureAwait(false);
             _logger.LogInformation("Read {Length} characters from database file", json.Length);
             _cache = JsonSerializer.Deserialize<PodcastDatabase>(json, JsonOptions) ?? new PodcastDatabase();
+            _lastModified = _cache.LastSaved;
             _logger.LogInformation("Loaded {Count} podcasts from database", _cache.Podcasts.Count);
             return _cache;
         }
@@ -196,6 +202,7 @@ public sealed class PodcastStorageService : IPodcastStorageService, IDisposable
         {
             _logger.LogError(ex, "Failed to load podcast database, starting fresh");
             _cache = new PodcastDatabase();
+            _lastModified = DateTime.UtcNow;
             return _cache;
         }
     }
@@ -211,6 +218,7 @@ public sealed class PodcastStorageService : IPodcastStorageService, IDisposable
             }
 
             db.LastSaved = DateTime.UtcNow;
+            _lastModified = db.LastSaved;
             var json = JsonSerializer.Serialize(db, JsonOptions);
             await File.WriteAllTextAsync(DatabasePath, json).ConfigureAwait(false);
             _cache = db;
@@ -261,6 +269,13 @@ public sealed class PodcastStorageService : IPodcastStorageService, IDisposable
         return ".mp3";
     }
 
+    /// <inheritdoc />
+    public async Task<DateTime?> GetLastModifiedAsync()
+    {
+        var db = await LoadDatabaseAsync().ConfigureAwait(false);
+        return db.LastSaved;
+    }
+
     /// <inheritdoc />
     public void Dispose()
     {

README.md

@@ -2,11 +2,72 @@
 
 A Jellyfin plugin that adds podcast support to your media server.
 
+## Quick Install
+
+Add this repository URL in Jellyfin (Dashboard → Plugins → Repositories):
+
+```
+https://gitea.tourolle.paris/dtourolle/jellypod/raw/branch/master/manifest.json
+```
+
 ## Features
 
 - Browse and subscribe to podcasts
 - Automatic episode downloads
 - Integration with Jellyfin's library system
+- Post-download script hook for audio processing
+
+## Post-Download Script Hook
+
+Jellypod supports running a custom script on each downloaded episode before it's added to your library. This is useful for:
+
+- Audio normalization (e.g., using ffmpeg-normalize)
+- Format conversion
+- Metadata enhancement
+- Custom processing workflows
+
+### Configuration
+
+In the plugin settings (Dashboard → Plugins → Jellypod):
+
+1. **Post-Download Script Path**: Full path to your script or executable
+2. **Script Timeout**: Maximum execution time in seconds (default: 60)
+
+### Script API
+
+Your script will be called with two arguments:
+
+```bash
+script <input_file> <output_file>
+```
+
+- `input_file`: Path to the downloaded episode (read-only)
+- `output_file`: Path where your script should write the processed file
+
+### Example Scripts
+
+**Audio normalization (bash + ffmpeg):**
+```bash
+#!/bin/bash
+INPUT="$1"
+OUTPUT="$2"
+ffmpeg-normalize "$INPUT" -o "$OUTPUT" -c:a libmp3lame -b:a 128k
+```
+
+**Format conversion (bash + ffmpeg):**
+```bash
+#!/bin/bash
+INPUT="$1"
+OUTPUT="$2"
+ffmpeg -i "$INPUT" -c:a aac -b:a 128k "$OUTPUT"
+```
+
+### Behavior
+
+- If the script succeeds (exit code 0) and creates the output file, the processed file is added to your library
+- If the script fails, times out, or doesn't create an output file, the original downloaded file is used instead
+- All script output (stdout/stderr) is logged for debugging
+- Leave the script path empty to disable post-processing
 
 ## Screenshots
 
@@ -18,6 +79,17 @@ A Jellyfin plugin that adds podcast support to your media server.
 
 ## Installation
 
+### From Plugin Repository (Recommended)
+
+1. In Jellyfin, go to **Dashboard** → **Plugins** → **Repositories**
+2. Click the **+** button to add a new repository
+3. Enter:
+   - **Repository Name**: `Jellypod`
+   - **Repository URL**: `https://gitea.tourolle.paris/dtourolle/jellypod/raw/branch/master/manifest.json`
+4. Click **Save**
+5. Go to **Catalog** tab and find **Jellypod**
+6. Click **Install** and restart Jellyfin
+
 ### Manual Installation
 
 1. Download the latest release from [Releases](https://gitea.tourolle.paris/dtourolle/jellypod/releases)

manifest.json

@@ -0,0 +1,37 @@
+[
+  {
+    "guid": "c713faf4-4e50-4e87-941a-1200178ed605",
+    "name": "Jellypod",
+    "description": "Jellypod allows you to subscribe to podcast RSS feeds, automatically download episodes, and manage your podcast library within Jellyfin. Episodes are stored as standard audio files and integrate with Jellyfin's built-in audio player.",
+    "overview": "Podcast management plugin for Jellyfin",
+    "owner": "dtourolle",
+    "category": "General",
+    "imageUrl": "https://gitea.tourolle.paris/dtourolle/jellypod/raw/branch/master/Jellyfin.Plugin.Jellypod/Images/channel-icon.jpg",
+    "versions": [
+      {
+        "version": "1.0.2",
+        "changelog": "Release 1.0.2",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellypod/releases/download/v1.0.2/jellypod_1.0.2.0.zip",
+        "checksum": "874f6b76c8cf4bac6495fe946224096a",
+        "timestamp": "2025-12-30T15:25:33Z"
+      },
+      {
+        "version": "1.0.1",
+        "changelog": "Release 1.0.1",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellypod/releases/download/v1.0.1/jellypod_1.0.1.0.zip",
+        "checksum": "8b8cddefe4e6b5c7128e1626a424519b",
+        "timestamp": "2025-12-21T13:07:42Z"
+      },
+      {
+        "version": "1.0.0",
+        "changelog": "Release 1.0.0",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellypod/releases/download/v1.0.0/jellypod_1.0.0.0.zip",
+        "checksum": "3267fa2bee3661f9a85c959497fe20dd",
+        "timestamp": "2025-12-20T13:00:27Z"
+      }
+    ]
+  }
+]