Added a post-download hook for applying processing of downloaded audio before adding to library.

Jellyfin.Plugin.Jellypod/Configuration/PluginConfiguration.cs

@@ -19,6 +19,8 @@ public class PluginConfiguration : BasePluginConfiguration
         MaxEpisodesPerPodcast = 50;
         CreatePodcastFolders = true;
         DownloadNewEpisodesOnly = true;
+        PostDownloadScriptPath = string.Empty;
+        PostDownloadScriptTimeout = 60;
     }
 
     /// <summary>
@@ -56,4 +58,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

@@ -166,6 +166,29 @@
                         </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>
                         <button is="emby-button" type="submit" class="raised button-submit block emby-button">
                             <span>Save Settings</span>
@@ -229,6 +252,8 @@
                     document.querySelector('#MaxConcurrentDownloads').value = config.MaxConcurrentDownloads;
                     document.querySelector('#MaxEpisodesPerPodcast').value = config.MaxEpisodesPerPodcast;
                     document.querySelector('#CreatePodcastFolders').checked = config.CreatePodcastFolders;
+                    document.querySelector('#PostDownloadScriptPath').value = config.PostDownloadScriptPath || '';
+                    document.querySelector('#PostDownloadScriptTimeout').value = config.PostDownloadScriptTimeout || 60;
                     Dashboard.hideLoadingMsg();
                 });
             }
@@ -408,6 +433,8 @@
                     config.MaxConcurrentDownloads = parseInt(document.querySelector('#MaxConcurrentDownloads').value, 10);
                     config.MaxEpisodesPerPodcast = parseInt(document.querySelector('#MaxEpisodesPerPodcast').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/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 />
@@ -240,6 +317,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()
     {

README.md

@@ -15,6 +15,59 @@ https://gitea.tourolle.paris/dtourolle/jellypod/raw/branch/master/manifest.json
 - 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