Update version

fix condition for onWatchedStatusChanged

.github/ISSUE_TEMPLATE/BUG-REPORT.yml

@@ -15,8 +15,12 @@ body:
       options:
         - label: I'm running the latest version of tubearchivist-jf-plugin.
           required: true
+        - label: I'm running the latest version of TubeArchivist.
+          required: true
         - label: I have read the [how to open an issue](https://github.com/tubearchivist/tubearchivist/blob/master/CONTRIBUTING.md#how-to-open-an-issue) guide, particularly the [bug report](https://github.com/tubearchivist/tubearchivist/blob/master/CONTRIBUTING.md#bug-report) section.
           required: true
+        - label: I have searched for both closed and open already existing issues about the problem I am reporting.
+          required: true
 
   - type: input
     id: os

.github/workflows/build.yaml

@@ -27,7 +27,7 @@ jobs:
       - name: Setup .Net
         uses: actions/setup-dotnet@v1
         with:
-          dotnet-version: 8.0.x
+          dotnet-version: 9.0.x
 
       - name: Add Jellyfin GitHub Nuget registry to sources
         run: |
@@ -63,7 +63,7 @@ jobs:
         uses: DarkFighterLuke/jellyfin-plugin-repository-manager@7a96768accc155ac7b597351b5033532f3c48173
         id: jprm
         with:
-          dotnet-target: net8.0
+          dotnet-target: net9.0
           version: ${VERSION}
           update-manifest: "true"
 

.vscode/settings.json

@@ -1,15 +1,16 @@
 {
     // jellyfinDir : The directory of the cloned jellyfin server project
     // This needs to be built once before it can be used
-    "jellyfinDir"     : "${workspaceFolder}/../jellyfin/Jellyfin.Server",
+    "jellyfinDir": "${workspaceFolder}/../jellyfin/Jellyfin.Server",
     // jellyfinWebDir : The directory of the cloned jellyfin-web project
     // This needs to be built once before it can be used
-    "jellyfinWebDir"  : "${workspaceFolder}/../jellyfin-web",
+    "jellyfinWebDir": "${workspaceFolder}/../jellyfin-web",
     // jellyfinDataDir : the root data directory for a running jellyfin instance
     // This is where jellyfin stores its configs, plugins, metadata etc
     // This is platform specific by default, but on Windows defaults to
     // ${env:LOCALAPPDATA}/jellyfin
-    "jellyfinDataDir" : "${env:LOCALAPPDATA}/jellyfin",
+    "jellyfinDataDir": "${env:LOCALAPPDATA}/jellyfin",
     // The name of the plugin
-    "pluginName" : "Jellyfin.Plugin.Template",
-}
+    "pluginName": "Jellyfin.Plugin.Template",
+    "git.ignoreLimitWarning": true,
+}

Directory.Build.props

@@ -1,7 +1,7 @@
 <Project>
     <PropertyGroup>
-        <Version>1.3.4.0</Version>
-        <AssemblyVersion>1.3.4.0</AssemblyVersion>
-        <FileVersion>1.3.4.0</FileVersion>
+        <Version>1.4.3.0</Version>
+        <AssemblyVersion>1.4.3.0</AssemblyVersion>
+        <FileVersion>1.4.3.0</FileVersion>
     </PropertyGroup>
 </Project>

Jellyfin.Plugin.TubeArchivistMetadata/Configuration/NumberingScheme.cs

@@ -0,0 +1,17 @@
+namespace Jellyfin.Plugin.TubeArchivistMetadata.Configuration;
+
+/// <summary>
+/// The NumberingScheme.
+/// </summary>
+public enum NumberingScheme
+{
+    /// <summary>
+    /// Default (no numbering).
+    /// </summary>
+    Default,
+
+    /// <summary>
+    /// YYYYMMDD (e.g. 20250804 for August 4th, 2025).
+    /// </summary>
+    YYYYMMDD,
+}

Jellyfin.Plugin.TubeArchivistMetadata/Configuration/PluginConfiguration.cs

@@ -36,11 +36,17 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Configuration
             _tubeArchivistUrl = string.Empty;
             _tubeArchivistApiKey = string.Empty;
             MaxDescriptionLength = 500;
-            JFTASync = false;
+            JFTAProgressSync = false;
             JFUsernameFrom = string.Empty;
-            TAJFSync = false;
+            TAJFProgressSync = false;
+            JFTAPlaylistsSync = false;
+            JFTAPlaylistsDelete = false;
+            TAJFPlaylistsSync = false;
+            TAJFPlaylistsDelete = false;
             _jfUsernamesTo = new HashSet<string>();
-            TAJFTaskInterval = 1;
+            TAJFProgressTaskInterval = 60;
+            JFTAPlaylistsSyncTaskInterval = 60;
+            TAJFPlaylistsSyncTaskInterval = 60;
         }
 
         /// <summary>
@@ -88,6 +94,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Configuration
             {
                 _tubeArchivistApiKey = value;
                 Plugin.Instance?.LogTAApiConnectionStatus();
+                Plugin.Instance?.UpdateAuthorizationHeader(value);
             }
         }
 
@@ -99,12 +106,32 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Configuration
         /// <summary>
         /// Gets or sets a value indicating whether to enable TA->JF playback progress synchronization.
         /// </summary>
-        public bool TAJFSync { get; set; }
+        public bool TAJFProgressSync { get; set; }
 
         /// <summary>
         /// Gets or sets a value indicating whether to enable JF->TA playback progress synchronization.
         /// </summary>
-        public bool JFTASync { get; set; }
+        public bool JFTAProgressSync { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to enable JF->TA playlists synchronization.
+        /// </summary>
+        public bool JFTAPlaylistsSync { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to delete playlists from TA when not found on JF.
+        /// </summary>
+        public bool JFTAPlaylistsDelete { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to enable TA->JF playlists synchronization.
+        /// </summary>
+        public bool TAJFPlaylistsSync { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to delete playlists from JF when not found on TA.
+        /// </summary>
+        public bool TAJFPlaylistsDelete { get; set; }
 
         /// <summary>
         /// Gets or sets the playback progress owner Jellyfin username to synchronize data to TubeArchivist.
@@ -118,14 +145,26 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Configuration
         {
             get
             {
-                _logger.LogDebug("JFUsernamesTo configured: {Message}", string.Join(", ", _jfUsernamesTo));
+                _logger.LogInformation("JFUsernamesTo configured: {Message}", string.Join(", ", _jfUsernamesTo));
                 return string.Join(", ", _jfUsernamesTo);
             }
 
             set
             {
-                value.Replace(" ", string.Empty, StringComparison.CurrentCulture).Split(',').ToList().ForEach(u => _jfUsernamesTo.Add(u));
-                _logger.LogDebug("Set JFUsernamesTo to: {Message}", value);
+                // Clear existing usernames
+                _jfUsernamesTo.Clear();
+
+                // Split by comma, then trim each part to remove leading/trailing spaces
+                foreach (var username in value.Split(','))
+                {
+                    var trimmedUsername = username.Trim();
+                    if (!string.IsNullOrEmpty(trimmedUsername))
+                    {
+                        _jfUsernamesTo.Add(trimmedUsername);
+                    }
+                }
+
+                _logger.LogInformation("Set JFUsernamesTo to: {Message}", string.Join(", ", _jfUsernamesTo));
             }
         }
 
@@ -133,7 +172,24 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Configuration
         /// Gets or sets the interval in seconds at which the TubeArchivist to Jellyfin playback progress synchronization task should run.
         /// It requires Jellyfin server restart to take effect.
         /// </summary>
-        public int TAJFTaskInterval { get; set; }
+        public int TAJFProgressTaskInterval { get; set; }
+
+        /// <summary>
+        /// Gets or sets the interval in seconds at which the Jellyfin to TubeArchivist playlists synchronization task should run.
+        /// It requires Jellyfin server restart to take effect.
+        /// </summary>
+        public int JFTAPlaylistsSyncTaskInterval { get; set; }
+
+        /// <summary>
+        /// Gets or sets the interval in seconds at which the TubeArchivist to Jellyfin playlists synchronization task should run.
+        /// It requires Jellyfin server restart to take effect.
+        /// </summary>
+        public int TAJFPlaylistsSyncTaskInterval { get; set; }
+
+        /// <summary>
+        /// Gets or sets the preferred numbering scheme for episodes (index number) in Jellyfin.
+        /// </summary>
+        public NumberingScheme EpisodeNumberingScheme { get; set; } = NumberingScheme.Default;
 
         /// <summary>
         /// Gets the playback progress owners Jellyfin usernames to synchronize data from TubeArchivist.

Jellyfin.Plugin.TubeArchivistMetadata/Configuration/configPage.html

@@ -41,29 +41,56 @@
                         <div class="fieldDescription">This is the maximum length of the descriptions showed in series
                             and episodes</div>
                     </div>
-                    <div>
-                        <h2>Playback synchronization</h2>
+                    <div class="selectContainer">
+                        <label class="selectLabel" for="EpisodeNumberingScheme">Episode numbering scheme</label>
+                        <select is="emby-select" id="EpisodeNumberingScheme" name="EpisodeNumberingScheme" label="Description markup" class="emby-select-withcolor emby-select">
+                            <option value="Default">Default (no specified numbering)</option>
+                            <option value="YYYYMMDD">YYYYMMDD (e.g. 20250804 for August 4th, 2025)</option>
+                        </select>
+                        <div class="selectArrowContainer">
+                            <span class="selectArrow material-icons keyboard_arrow_down" aria-hidden="true"></span>
+                        </div>
+                        <div class="fieldDescription">This is the numbering scheme for episodes in Jellyfin (IndexNumber).
+                            Default is the same as no numbering which allows Jellyfin to use the fallback numbering scheme.
                     </div>
-                    <div class="checkboxContainer checkboxContainer-withDescription">
-                        <label class="emby-checkbox-label" for="JFTASync">
-                            <input id="JFTASync" name="JFTASync" type="checkbox" is="emby-checkbox" />
-                            <span>Synchronize Jellyfin playback progress to TubeArchivist</span>
-                        </label>
+                    <div>
+                        <h2>Synchronization</h2>
+                    </div>
+                    <div>
+                        <h3>Jellyfin to TubeArchivist</h3>
                     </div>
                     <div class="inputContainer">
                         <label class="inputLabel inputLabelUnfocused" for="JFUsernameFrom">Jellyfin username to sync
-                            playback status from</label>
+                            from</label>
                         <input id="JFUsernameFrom" name="JFUsernameFrom" type="text" is="emby-input"
-                            placeholder="Username1, username2, ..." />
-                        <div class="fieldDescription">This is the Jellyfin username to synchronize data from on
+                            placeholder="Username" />
+                        <div class="fieldDescription">This is the Jellyfin username to synchronize data to
                             TubeArchivist</div>
                     </div>
                     <div class="checkboxContainer checkboxContainer-withDescription">
-                        <label class="emby-checkbox-label" for="TAJFSync">
-                            <input id="TAJFSync" name="TAJFSync" type="checkbox" is="emby-checkbox" />
-                            <span>Synchronize TubeArchivist playback progress to Jellyfin</span>
+                        <label class="emby-checkbox-label" for="JFTAProgressSync">
+                            <input id="JFTAProgressSync" name="JFTAProgressSync" type="checkbox" is="emby-checkbox" />
+                            <span>Synchronize Jellyfin playback progress to TubeArchivist</span>
                         </label>
                     </div>
+                    <div style="display: flex; gap: 2em;">
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label class="emby-checkbox-label" for="JFTAPlaylistsSync">
+                                <input id="JFTAPlaylistsSync" name="JFTAPlaylistsSync" type="checkbox" is="emby-checkbox" />
+                                <span>Synchronize Jellyfin playlists to TubeArchivist</span>
+                            </label>
+                        </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label class="emby-checkbox-label" for="JFTAPlaylistsDelete">
+                                <input id="JFTAPlaylistsDelete" name="JFTAPlaylistsDelete" type="checkbox" is="emby-checkbox" />
+                                <span>Delete TubeArchivist playlists when no more present on Jellyfin</span>
+                            </label>
+                        </div>
+                    </div>
+                    <div>
+                        <h3>TubeArchivist to Jellyfin</h3>
+                    </div>
                     <div class="inputContainer">
                         <label class="inputLabel inputLabelUnfocused" for="JFUsernamesTo">Jellyfin usernames to sync
                             playback status to</label>
@@ -72,13 +99,52 @@
                         <div class="fieldDescription">These are the (comma separated) Jellyfin usernames to synchronize
                             data from TubeArchivist</div>
                     </div>
+                    <div class="checkboxContainer checkboxContainer-withDescription">
+                        <label class="emby-checkbox-label" for="TAJFProgressSync">
+                            <input id="TAJFProgressSync" name="TAJFProgressSync" type="checkbox" is="emby-checkbox" />
+                            <span>Synchronize TubeArchivist playback progress to Jellyfin</span>
+                        </label>
+                    </div>
+                    <div style="display: flex; gap: 2em;">
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label class="emby-checkbox-label" for="TAJFPlaylistsSync">
+                                <input id="TAJFPlaylistsSync" name="TAJFPlaylistsSync" type="checkbox" is="emby-checkbox" />
+                                <span>Synchronize TubeArchivist playlists to Jellyfin</span>
+                            </label>
+                        </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label class="emby-checkbox-label" for="TAJFPlaylistsDelete">
+                                <input id="TAJFPlaylistsDelete" name="TAJFPlaylistsDelete" type="checkbox" is="emby-checkbox" />
+                                <span>Delete Jellyfin playlists when no more present on TubeArchivist</span>
+                            </label>
+                        </div>
+                    </div>
+                    <div>
+                        <h2>Tasks intervals</h2>
+                    </div>
                     <div class="inputContainer">
-                        <label class="inputLabel inputLabelUnfocused" for="TAJFTaskInterval">TubeArchivist to Jellyfin
+                        <label class="inputLabel inputLabelUnfocused" for="TAJFProgressTaskInterval">TubeArchivist to Jellyfin
                             playback progress synchronization interval</label>
-                        <input id="TAJFTaskInterval" name="TAJFTaskInterval" type="number" is="emby-input" min="1" />
+                        <input id="TAJFProgressTaskInterval" name="TAJFProgressTaskInterval" type="number" is="emby-input" min="60" />
                         <div class="fieldDescription">This is the TubeArchivist to Jellyfin playback progress
                             synchronization interval in seconds (Jellyfin restart required).</div>
                     </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="JFTAPlaylistsSyncTaskInterval">Jellyfin to TubeArchivist
+                            playlists synchronization interval</label>
+                        <input id="JFTAPlaylistsSyncTaskInterval" name="JFTAPlaylistsSyncTaskInterval" type="number" is="emby-input" min="60" />
+                        <div class="fieldDescription">This is the Jellyfin to TubeArchivist playlists
+                            synchronization interval in seconds (Jellyfin restart required).</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="TAJFPlaylistsSyncTaskInterval">TubeArchivist to Jellyfin
+                            playlists synchronization interval</label>
+                        <input id="TAJFPlaylistsSyncTaskInterval" name="TAJFPlaylistsSyncTaskInterval" type="number" is="emby-input"
+                            min="60" />
+                        <div class="fieldDescription">This is the TubeArchivist to Jellyfin playlists
+                            synchronization interval in seconds (Jellyfin restart required).</div>
+                    </div>
                     <div>
                         <button is="emby-button" type="submit" class="raised button-submit block emby-button">
                             <span>Save</span>
@@ -100,11 +166,16 @@
                         document.querySelector('#TubeArchivistUrl').value = config.TubeArchivistUrl;
                         document.querySelector('#TubeArchivistApiKey').value = config.TubeArchivistApiKey;
                         document.querySelector('#MaxDescriptionLength').value = config.MaxDescriptionLength;
-                        document.querySelector('#JFTASync').checked = config.JFTASync;
+                        document.querySelector('#JFTAProgressSync').checked = config.JFTAProgressSync;
                         document.querySelector('#JFUsernamesTo').value = config.JFUsernamesTo;
-                        document.querySelector('#TAJFSync').checked = config.TAJFSync;
+                        document.querySelector('#TAJFProgressSync').checked = config.TAJFProgressSync;
+                        document.querySelector('#JFTAPlaylistsSync').checked = config.JFTAPlaylistsSync;
+                        document.querySelector('#TAJFPlaylistsSync').checked = config.TAJFPlaylistsSync;
                         document.querySelector('#JFUsernameFrom').value = config.JFUsernameFrom;
-                        document.querySelector('#TAJFTaskInterval').value = config.TAJFTaskInterval;
+                        document.querySelector('#EpisodeNumberingScheme').value = config.EpisodeNumberingScheme;
+                        document.querySelector('#TAJFProgressTaskInterval').value = config.TAJFProgressTaskInterval;
+                        document.querySelector('#JFTAPlaylistsSyncTaskInterval').value = config.JFTAPlaylistsSyncTaskInterval;
+                        document.querySelector('#TAJFPlaylistsSyncTaskInterval').value = config.TAJFPlaylistsSyncTaskInterval;
                         Dashboard.hideLoadingMsg();
                     });
                 });
@@ -117,11 +188,16 @@
                         config.TubeArchivistUrl = document.querySelector('#TubeArchivistUrl').value;
                         config.TubeArchivistApiKey = document.querySelector('#TubeArchivistApiKey').value;
                         config.MaxDescriptionLength = document.querySelector('#MaxDescriptionLength').value;
-                        config.JFTASync = document.querySelector('#JFTASync').checked;
+                        config.JFTAProgressSync = document.querySelector('#JFTAProgressSync').checked;
                         config.JFUsernamesTo = document.querySelector('#JFUsernamesTo').value;
-                        config.TAJFSync = document.querySelector('#TAJFSync').checked;
+                        config.TAJFProgressSync = document.querySelector('#TAJFProgressSync').checked;
+                        config.JFTAPlaylistsSync = document.querySelector('#JFTAPlaylistsSync').checked;
+                        config.TAJFPlaylistsSync = document.querySelector('#TAJFPlaylistsSync').checked;
                         config.JFUsernameFrom = document.querySelector('#JFUsernameFrom').value;
-                        config.TAJFTaskInterval = document.querySelector('#TAJFTaskInterval').value;
+                        config.EpisodeNumberingScheme = document.querySelector('#EpisodeNumberingScheme').value;
+                        config.TAJFProgressTaskInterval = document.querySelector('#TAJFProgressTaskInterval').value;
+                        config.JFTAPlaylistsSyncTaskInterval = document.querySelector('#JFTAPlaylistsSyncTaskInterval').value;
+                        config.TAJFPlaylistsSyncTaskInterval = document.querySelector('#TAJFPlaylistsSyncTaskInterval').value;
                         ApiClient.updatePluginConfiguration(TAMetadataConfig.pluginUniqueId, config).then(function (result) {
                             Dashboard.processPluginConfigurationUpdateResult(result);
                         });

Jellyfin.Plugin.TubeArchivistMetadata/Jellyfin.Plugin.TubeArchivistMetadata.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <RootNamespace>Jellyfin.Plugin.TubeArchivistMetadata</RootNamespace>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
@@ -11,8 +11,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Jellyfin.Controller" Version="10.10.0" />
-    <PackageReference Include="Jellyfin.Model" Version="10.10.0" />
+    <PackageReference Include="Jellyfin.Controller" Version="10.11.0" />
+    <PackageReference Include="Jellyfin.Model" Version="10.11.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
   </ItemGroup>
 

Jellyfin.Plugin.TubeArchivistMetadata/Plugin.cs

@@ -14,6 +14,7 @@ using MediaBrowser.Common.Plugins;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Playlists;
 using MediaBrowser.Controller.Session;
 using MediaBrowser.Model.Plugins;
 using MediaBrowser.Model.Serialization;
@@ -28,6 +29,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata
     public class Plugin : BasePlugin<PluginConfiguration>, IHasWebPages
     {
         private readonly IUserManager _userManager;
+        private readonly IUserDataManager _userDataManager;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Plugin"/> class.
@@ -37,18 +39,18 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata
         /// <param name="logger">Instance of the <see cref="ILogger"/> interface.</param>
         /// <param name="sessionManager">Instance of the <see cref="ISessionManager"/> interface.</param>
         /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
-        /// <param name="taskManager">Instance of the <see cref="ITaskManager"/> interface.</param>
         /// <param name="userManager">Instance of the <see cref="IUserManager"/> interface.</param>
         /// <param name="userDataManager">Instance of the <see cref="IUserDataManager"/> interface.</param>
+        /// <param name="playlistManager">Instance of the <see cref="IPlaylistManager"/> interface.</param>
         public Plugin(
             IApplicationPaths applicationPaths,
             IXmlSerializer xmlSerializer,
             ILogger<Plugin> logger,
             ISessionManager sessionManager,
             ILibraryManager libraryManager,
-            ITaskManager taskManager,
             IUserManager userManager,
-            IUserDataManager userDataManager)
+            IUserDataManager userDataManager,
+            IPlaylistManager playlistManager)
             : base(applicationPaths, xmlSerializer)
         {
             Instance = this;
@@ -57,31 +59,15 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata
             handler.AllowAutoRedirect = false;
             handler.CheckCertificateRevocationList = true;
             HttpClient = new HttpClient(handler);
-            HttpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Token", Instance?.Configuration.TubeArchivistApiKey);
+            UpdateAuthorizationHeader(Configuration.TubeArchivistApiKey);
+
             SessionManager = sessionManager;
             sessionManager.PlaybackProgress += OnPlaybackProgress;
             LibraryManager = libraryManager;
             _userManager = userManager;
+            _userDataManager = userDataManager;
             userDataManager.UserDataSaved += OnWatchedStatusChange;
 
-            var taToJellyfinProgressSyncTask = new TAToJellyfinProgressSyncTask(logger, libraryManager, userManager, userDataManager);
-            var jfToTubearchivistProgressSyncTask = new JFToTubearchivistProgressSyncTask(logger, libraryManager, userManager, userDataManager);
-            var isTAJFTaskPresent = taskManager.ScheduledTasks.Any(t => t.Name.Equals(taToJellyfinProgressSyncTask.Name, StringComparison.Ordinal));
-            if (Instance!.Configuration.TAJFSync && !isTAJFTaskPresent)
-            {
-                logger.LogInformation("Queueing task {TaskName}.", taToJellyfinProgressSyncTask.Name);
-                taskManager.AddTasks([taToJellyfinProgressSyncTask]);
-                taskManager.Execute<TAToJellyfinProgressSyncTask>();
-            }
-
-            var isJFTATaskPresent = taskManager.ScheduledTasks.Any(t => t.Name.Equals(jfToTubearchivistProgressSyncTask.Name, StringComparison.Ordinal));
-            if (Instance!.Configuration.JFTASync && !isJFTATaskPresent)
-            {
-                logger.LogInformation("Queueing task {TaskName}.", jfToTubearchivistProgressSyncTask.Name);
-                taskManager.AddTasks([jfToTubearchivistProgressSyncTask]);
-                taskManager.Execute<JFToTubearchivistProgressSyncTask>();
-            }
-
             logger.LogInformation("{Message}", "Collection display name: " + Instance?.Configuration.CollectionTitle);
             logger.LogInformation("{Message}", "TubeArchivist API URL: " + Instance?.Configuration.TubeArchivistUrl);
             logger.LogInformation("{Message}", "Pinging TubeArchivist API...");
@@ -128,6 +114,23 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata
             }
         };
 
+        /// <summary>
+        /// Updates the HTTP client's Authorization header with the current API key.
+        /// </summary>
+        /// <param name="apiKey">TubeArchivist API key.</param>
+        public void UpdateAuthorizationHeader(string apiKey)
+        {
+            if (!string.IsNullOrEmpty(apiKey))
+            {
+                HttpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Token", apiKey);
+                Logger.LogInformation("{Message}", "Updated Authorization header with API key");
+            }
+            else
+            {
+                Logger.LogWarning("{Message}", "No TubeArchivist API key configured");
+            }
+        }
+
         /// <summary>
         /// Logs the TubeArchivist API connection status.
         /// </summary>
@@ -153,29 +156,59 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata
 
         private async void OnPlaybackProgress(object? sender, PlaybackProgressEventArgs eventArgs)
         {
-            if (Instance!.Configuration.JFTASync && eventArgs.Users.Any(u => Instance!.Configuration.JFUsernameFrom.Equals(u.Username, StringComparison.Ordinal)))
+            if (eventArgs == null || eventArgs.Item.Id == Guid.Empty)
             {
-                BaseItem? channel = LibraryManager.GetItemById(eventArgs.Item.ParentId);
-                BaseItem? collection = LibraryManager.GetItemById(channel!.ParentId);
-                if (collection?.Name.ToLower(CultureInfo.CurrentCulture) == Instance?.Configuration.CollectionTitle.ToLower(CultureInfo.CurrentCulture) && eventArgs.PlaybackPositionTicks != null)
+                Logger.LogDebug("Skipping progress synchronization: PlaybackProgress event triggered with null or empty Guid.");
+                return;
+            }
+
+            var topParent = eventArgs.Item.GetTopParent();
+            if (
+                Instance!.Configuration.JFTAProgressSync &&
+                eventArgs.Users.Any(u => Instance!.Configuration.JFUsernameFrom.Equals(u.Username, StringComparison.Ordinal)) &&
+                eventArgs.PlaybackPositionTicks.HasValue &&
+                string.Equals(topParent?.Name, Instance?.Configuration.CollectionTitle, StringComparison.OrdinalIgnoreCase)
+            )
+            {
+                long progress = (long)eventArgs.PlaybackPositionTicks / TimeSpan.TicksPerSecond;
+                var videoId = Utils.GetVideoNameFromPath(eventArgs.Item.Path);
+                var statusCode = await TubeArchivistApi.GetInstance().SetProgress(videoId, progress).ConfigureAwait(true);
+                if (statusCode != System.Net.HttpStatusCode.OK)
                 {
-                    long progress = (long)eventArgs.PlaybackPositionTicks / TimeSpan.TicksPerSecond;
-                    var videoId = Utils.GetVideoNameFromPath(eventArgs.Item.Path);
-                    var statusCode = await TubeArchivistApi.GetInstance().SetProgress(videoId, progress).ConfigureAwait(true);
-                    if (statusCode != System.Net.HttpStatusCode.OK)
-                    {
-                        Logger.LogCritical("{Message}", $"POST /video/{videoId}/progress returned {statusCode} for video {eventArgs.Item.Name} with progress {progress} seconds");
-                    }
+                    Logger.LogCritical("{Message}", $"POST /video/{videoId}/progress returned {statusCode} for video {eventArgs.Item.Name} with progress {progress} seconds");
                 }
             }
         }
 
         private async void OnWatchedStatusChange(object? sender, UserDataSaveEventArgs eventArgs)
         {
-            var user = _userManager.GetUserById(eventArgs.UserId);
-            if (user != null && Configuration.GetJFUsernamesToArray().Contains(user!.Username))
+            if (eventArgs == null || eventArgs.Item.Id == Guid.Empty)
             {
-                var isPlayed = eventArgs.Item.IsPlayed(user);
+                Logger.LogDebug("Skipping watched status synchronization: WatchedStatusChange event triggered with null or empty Guid.");
+                return;
+            }
+
+            var topParent = eventArgs.Item.GetTopParent();
+            var user = _userManager.GetUserById(eventArgs.UserId);
+            if (
+                Configuration.JFTAProgressSync
+                && user == null
+                && string.Equals(topParent?.Name, Instance?.Configuration.CollectionTitle, StringComparison.OrdinalIgnoreCase)
+            )
+            {
+                Logger.LogError("OnWatchedStatusChange callback called without user id for item {ItemName}", eventArgs.Item.Name);
+                return;
+            }
+
+            if (
+                Configuration.JFTAProgressSync
+                && user != null
+                && string.Equals(Configuration.JFUsernameFrom, user!.Username, StringComparison.Ordinal)
+                && string.Equals(topParent?.Name, Instance?.Configuration.CollectionTitle, StringComparison.OrdinalIgnoreCase)
+            )
+            {
+                var userItemData = _userDataManager.GetUserData(user, eventArgs.Item);
+                var isPlayed = eventArgs.Item.IsPlayed(user, userItemData);
                 Logger.LogDebug("User {UserId} changed watched status to {Status} for the item {ItemName}", eventArgs.UserId, isPlayed, eventArgs.Item.Name);
                 string itemYTId;
                 try
@@ -199,10 +232,31 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata
                     return;
                 }
 
-                var statusCode = await TubeArchivistApi.GetInstance().SetWatchedStatus(itemYTId, isPlayed).ConfigureAwait(true);
-                if (statusCode != System.Net.HttpStatusCode.OK)
+                try
                 {
-                    Logger.LogCritical("POST /watched returned {StatusCode} for item {ItemName} ({VideoYTId}) with watched status {IsPlayed}", statusCode, eventArgs.Item.Name, itemYTId, isPlayed);
+                    var statusCode = await TubeArchivistApi.GetInstance().SetWatchedStatus(itemYTId, isPlayed).ConfigureAwait(true);
+                    if (statusCode != System.Net.HttpStatusCode.OK)
+                    {
+                        Logger.LogCritical("POST /watched returned {StatusCode} for item {ItemName} ({VideoYTId}) with watched status {IsPlayed}", statusCode, eventArgs.Item.Name, itemYTId, isPlayed);
+                    }
+
+                    if (eventArgs.Item is Episode)
+                    {
+                        var progress = _userDataManager.GetUserData(user, eventArgs.Item)?.PlaybackPositionTicks / TimeSpan.TicksPerSecond;
+                        if (progress != null)
+                        {
+                            var videoId = Utils.GetVideoNameFromPath(eventArgs.Item.Path);
+                            statusCode = await TubeArchivistApi.GetInstance().SetProgress(videoId, progress.Value).ConfigureAwait(true);
+                            if (statusCode != System.Net.HttpStatusCode.OK)
+                            {
+                                Logger.LogCritical("{Message}", $"POST /video/{videoId}/progress returned {statusCode} for video {eventArgs.Item.Name} with progress {progress} seconds");
+                            }
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Logger.LogCritical("An exception occurred while calling POST /watched for item {ItemName} ({VideoYTId}) with watched status {IsPlayed}: {ExceptionMessage}", eventArgs.Item.Name, itemYTId, isPlayed, ex.Message);
                 }
             }
         }

Jellyfin.Plugin.TubeArchivistMetadata/Providers/EpisodeImageProvider.cs

@@ -62,8 +62,8 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Providers
             var taApi = TubeArchivistApi.GetInstance();
             var videoTAId = Utils.GetVideoNameFromPath(item.Path);
             var video = await taApi.GetVideo(videoTAId).ConfigureAwait(true);
-            _logger.LogInformation("{Message}", string.Format(CultureInfo.CurrentCulture, "Getting images for video: {0} ({1})", video?.Title, videoTAId));
-            _logger.LogInformation("{Message}", "Thumb URI: " + video?.VidThumbUrl);
+            _logger.LogDebug("{Message}", string.Format(CultureInfo.CurrentCulture, "Getting images for video: {0} ({1})", video?.Title, videoTAId));
+            _logger.LogDebug("{Message}", "Thumb URI: " + video?.VidThumbUrl);
 
             if (video != null)
             {

Jellyfin.Plugin.TubeArchivistMetadata/Providers/EpisodeMetadataProvider.cs

@@ -53,8 +53,8 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Providers
             var taApi = TubeArchivistApi.GetInstance();
             var videoTAId = Utils.GetVideoNameFromPath(info.Path);
             var video = await taApi.GetVideo(videoTAId).ConfigureAwait(true);
-            _logger.LogInformation("{Message}", string.Format(CultureInfo.CurrentCulture, "Getting metadata for video: {0} ({1})", video?.Title, videoTAId));
-            _logger.LogInformation("{Message}", "Received metadata: \n" + JsonConvert.SerializeObject(video));
+            _logger.LogDebug("{Message}", string.Format(CultureInfo.CurrentCulture, "Getting metadata for video: {0} ({1})", video?.Title, videoTAId));
+            _logger.LogDebug("{Message}", "Received metadata: \n" + JsonConvert.SerializeObject(video));
 
             if (video != null)
             {
@@ -67,6 +67,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Providers
                 });
                 result.HasMetadata = true;
                 result.Item = video.ToEpisode();
+                result.Item.Path = info.Path;
                 result.Provider = Name;
                 result.People = peopleInfo;
             }

Jellyfin.Plugin.TubeArchivistMetadata/Providers/SeriesImageProvider.cs

@@ -60,10 +60,10 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Providers
             var taApi = TubeArchivistApi.GetInstance();
             var channelTAId = Utils.GetChannelNameFromPath(item.Path);
             var channel = await taApi.GetChannel(channelTAId).ConfigureAwait(true);
-            _logger.LogInformation("{Message}", string.Format(CultureInfo.CurrentCulture, "Getting images for channel: {0} ({1})", channel?.Name, channelTAId));
-            _logger.LogInformation("{Message}", "Thumb URI: " + channel?.ThumbUrl);
-            _logger.LogInformation("{Message}", "TVArt URI: " + channel?.TvartUrl);
-            _logger.LogInformation("{Message}", "Banner URI: " + channel?.BannerUrl);
+            _logger.LogDebug("{Message}", string.Format(CultureInfo.CurrentCulture, "Getting images for channel: {0} ({1})", channel?.Name, channelTAId));
+            _logger.LogDebug("{Message}", "Thumb URI: " + channel?.ThumbUrl);
+            _logger.LogDebug("{Message}", "TVArt URI: " + channel?.TvartUrl);
+            _logger.LogDebug("{Message}", "Banner URI: " + channel?.BannerUrl);
 
             if (channel != null)
             {

Jellyfin.Plugin.TubeArchivistMetadata/Providers/SeriesMetadataProvider.cs

@@ -52,8 +52,8 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Providers
             var taApi = TubeArchivistApi.GetInstance();
             var channelTAId = Utils.GetChannelNameFromPath(info.Path);
             var channel = await taApi.GetChannel(channelTAId).ConfigureAwait(true);
-            _logger.LogInformation("{Message}", string.Format(CultureInfo.CurrentCulture, "Getting metadata for channel: {0} ({1})", channel?.Name, channelTAId));
-            _logger.LogInformation("{Message}", "Received metadata: \n" + JsonConvert.SerializeObject(channel));
+            _logger.LogDebug("{Message}", string.Format(CultureInfo.CurrentCulture, "Getting metadata for channel: {0} ({1})", channel?.Name, channelTAId));
+            _logger.LogDebug("{Message}", "Received metadata: \n" + JsonConvert.SerializeObject(channel));
 
             if (channel != null)
             {

Jellyfin.Plugin.TubeArchivistMetadata/Tasks/JFToTubeArchivistPlaylistsSyncTask.cs

@@ -0,0 +1,437 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Net;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+using J2N.Collections.Generic.Extensions;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Extensions;
+using Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist;
+using Jellyfin.Plugin.TubeArchivistMetadata.Utilities;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Playlists;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Playlists;
+using MediaBrowser.Model.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
+{
+    /// <summary>
+    /// Task to sync TubeArchivist playlists to Jellyfin.
+    /// </summary>
+    public class JFToTubeArchivistPlaylistsSyncTask : IScheduledTask
+    {
+        private readonly ILogger<Plugin> _logger;
+        private readonly ILibraryManager _libraryManager;
+        private readonly IUserManager _userManager;
+        private readonly IPlaylistManager _playlistManager;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JFToTubeArchivistPlaylistsSyncTask"/> class.
+        /// </summary>
+        /// <param name="logger">Logger.</param>
+        /// <param name="libraryManager">Library manager.</param>
+        /// <param name="userManager">User manager.</param>
+        /// <param name="playlistManager">Playlists manager.</param>
+        public JFToTubeArchivistPlaylistsSyncTask(ILogger<Plugin> logger, ILibraryManager libraryManager, IUserManager userManager, IPlaylistManager playlistManager)
+        {
+            _logger = logger;
+            _libraryManager = libraryManager;
+            _userManager = userManager;
+            _playlistManager = playlistManager;
+        }
+
+        /// <inheritdoc/>
+        public string Name => "JFToTubeArchivistPlaylistsSyncTask";
+
+        /// <inheritdoc/>
+        public string Description => "This tasks syncs Jellyfin playlists to TubeArchivist";
+
+        /// <inheritdoc/>
+        public string Category => "TubeArchivistMetadata";
+
+        /// <inheritdoc/>
+        public string Key => "JFToTubeArchivistPlaylistsSyncTask";
+
+        private Dictionary<Guid, List<BaseItem>> GetAllVideos(IEnumerable<MediaBrowser.Controller.Playlists.Playlist> playlists, User user)
+        {
+            var items = new Dictionary<Guid, List<BaseItem>>();
+            foreach (var playlist in playlists)
+            {
+                items[playlist.Id] = new List<BaseItem>(playlist.GetChildren(user, true, new InternalItemsQuery()));
+            }
+
+            return items;
+        }
+
+        private int CountTotalVideos(Dictionary<Guid, List<BaseItem>> playlistsItems)
+        {
+            var totalVideosCount = 0;
+            foreach (var playlistId in playlistsItems.Keys)
+            {
+                totalVideosCount += playlistsItems[playlistId].Count;
+            }
+
+            return totalVideosCount;
+        }
+
+        private string GetPlaylistUpdatedName(string playlistName, string newId)
+        {
+            var index = playlistName.LastIndexOf(" (", StringComparison.CurrentCulture);
+            if (index < 0)
+            {
+                return $"{playlistName} ({newId})";
+            }
+            else
+            {
+                var authorAndName = playlistName.Substring(0, index);
+                return $"{authorAndName} ({newId})";
+            }
+        }
+
+        private void MoveElementToPosition(Collection<PlaylistEntry> playlistEntries, int oldPosition, int newPosition)
+        {
+            var oldItem = playlistEntries[oldPosition];
+            playlistEntries.RemoveAt(oldPosition);
+            playlistEntries.Insert(newPosition, oldItem);
+        }
+
+        /// <inheritdoc/>
+        public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            progress.Report(0);
+            if (Plugin.Instance!.Configuration.JFTAPlaylistsSync)
+            {
+                var start = DateTime.Now;
+                _logger.LogInformation("Starting Jellyfin->TubeArchivist playlists synchronization.");
+                var taApi = TubeArchivistApi.GetInstance();
+                var taPlaylists = await taApi.GetPlaylists().ConfigureAwait(true);
+
+                var jfUsername = Plugin.Instance!.Configuration.JFUsernameFrom;
+
+                var user = _userManager.GetUserByName(jfUsername);
+                if (user == null)
+                {
+                    _logger.LogInformation("{Message}", $"Jellyfin user with username {jfUsername} not found");
+                    return;
+                }
+
+                var userPlaylists = _playlistManager.GetPlaylists(user.Id).ToList();
+                var jfItemsToAnalyze = GetAllVideos(userPlaylists, user);
+                var totalVideosCount = CountTotalVideos(jfItemsToAnalyze);
+                var processedVideosCount = 0;
+
+                _logger.LogInformation("Found a total of {PlaylistsCount} playlists to analyze with a total of {VideosCount} videos", userPlaylists.Count, totalVideosCount);
+                if (taPlaylists != null && Plugin.Instance!.Configuration.JFTAPlaylistsDelete)
+                {
+                    var taPlaylistsToDelete = taPlaylists.Where(tp => !userPlaylists.Select(up => Utils.GetTAPlaylistIdFromName(up.Name)).Contains(tp.Id));
+                    foreach (var taPlaylistToDelete in taPlaylistsToDelete)
+                    {
+                        _logger.LogInformation("Deleting TubeArchivist playlist {PlaylistName} ({PlaylistId})", taPlaylistToDelete.Name, taPlaylistToDelete.Id);
+                        await taApi.DeletePlaylist(taPlaylistToDelete.Id).ConfigureAwait(true);
+                    }
+                }
+
+                foreach (var jfPlaylist in userPlaylists)
+                {
+                    _logger.LogInformation("Analyzing playlist {PlaylistName}...", jfPlaylist.Name);
+                    var taPlaylistId = Utils.GetTAPlaylistIdFromName(jfPlaylist.Name);
+                    if (taPlaylistId == null)
+                    {
+                        _logger.LogDebug("The playlist {PlaylistName} was not a TA playlist: could not find TA playlist id at the end", jfPlaylist.Name);
+                        continue;
+                    }
+
+                    // Try to find a TA playlist with matching id
+                    // N.B.: only videos with TubeArchivist provider can be synced to TA, if there is a non matching video log a warn
+                    var taPlaylist = taPlaylists?.Where(tp => tp.Id == taPlaylistId).FirstOrDefault();
+
+                    if (taPlaylist != null)
+                    {
+                        // If it exists and is custom add new videos and update videos order
+                        if (taPlaylist.Type == PlaylistType.Custom)
+                        {
+                            var jfItems = jfItemsToAnalyze[jfPlaylist.Id];
+                            _logger.LogInformation("Found {PlaylistVideosCount} videos in playlist {PlaylistName}", jfItems.Count, jfPlaylist.Name);
+
+                            var itemsToProcess = new List<PlaylistItemAction>();
+
+                            // Add videos to move/add to the TA playlist
+                            for (var i = 0; i < jfItems.Count; i++)
+                            {
+                                if (!jfItems[i].ProviderIds.ContainsKey(Constants.ProviderName))
+                                {
+                                    _logger.LogError("Could not sync {JFItem} video from playlist {JFPlaylist} because it doesn't belong to TubeArchivist", jfItems[i].Name, jfPlaylist.Name);
+                                    continue;
+                                }
+
+                                var position = taPlaylist.Entries.FindIndex(e => e.YoutubeId == jfItems[i].ProviderIds[Constants.ProviderName]);
+                                PlaylistItemAction action;
+                                if (position < 0)
+                                {
+                                    _logger.LogDebug("Video {VideoName} from playlist {PlaylistName} not found in TA playlist", jfItems[i].Name, jfPlaylist.Name);
+                                    var positionsToMove = i - position;
+                                    action = new PlaylistItemAction(i, jfItems[i].ProviderIds[Constants.ProviderName], CustomPlaylistAction.Create, positionsToMove, jfItems[i].Name);
+                                    taPlaylist.Entries.Insert(i, new PlaylistEntry(jfItems[i].ProviderIds[Constants.ProviderName], jfItems[i].Name, jfItems[i].Studios[0], i, true));
+                                }
+                                else
+                                {
+                                    _logger.LogDebug("Found video {VideoName} at position {JFPosition} in playlist {PlaylistName} at position {TAPosition} in TA playlist", jfItems[i].Name, i, jfPlaylist.Name, position);
+                                    if (i == 0)
+                                    {
+                                        action = new PlaylistItemAction(i, jfItems[i].ProviderIds[Constants.ProviderName], CustomPlaylistAction.Top, jfItems[i].Name);
+                                    }
+                                    else if (i == jfItems.Count)
+                                    {
+                                        action = new PlaylistItemAction(i, jfItems[i].ProviderIds[Constants.ProviderName], CustomPlaylistAction.Bottom, jfItems[i].Name);
+                                    }
+                                    else
+                                    {
+                                        var positionsToMove = i - position;
+                                        action = new PlaylistItemAction(i, jfItems[i].ProviderIds[Constants.ProviderName], positionsToMove > 0 ? CustomPlaylistAction.Up : CustomPlaylistAction.Down, Math.Abs(positionsToMove), jfItems[i].Name);
+                                    }
+
+                                    var temp = taPlaylist.Entries[position];
+                                    taPlaylist.Entries.RemoveAt(position);
+                                    taPlaylist.Entries.Insert(i, temp);
+                                }
+
+                                itemsToProcess.Add(action);
+                            }
+
+                            // Add videos to delete from the TA playlist
+                            var itemsToDelete = taPlaylist.Entries
+                            .Where(e => !itemsToProcess
+                                .Select(i => i.YoutubeId)
+                                .Contains(e.YoutubeId))
+                                .ToList();
+                            foreach (var item in itemsToDelete)
+                            {
+                                _logger.LogDebug("Video {VideoName} not found in JF playlist, marking for deletion", item.Title);
+                                var ret = taPlaylist.Entries.Remove(item);
+                            }
+
+                            itemsToProcess.AddRange(itemsToDelete.Select(e => new PlaylistItemAction(e.YoutubeId, e.Title)));
+
+                            foreach (var item in itemsToProcess)
+                            {
+                                _logger.LogDebug("Analyzing video {VideoName} from playlist {PlaylistName} at position {Position}", item.Name, jfPlaylist.Name, item.Index);
+                                switch (item.Action)
+                                {
+                                    case CustomPlaylistAction.Create:
+                                        var success = await AddVideoToTAPlaylist(taApi, jfPlaylist, taPlaylistId, item).ConfigureAwait(true);
+                                        if (!success)
+                                        {
+                                            continue;
+                                        }
+
+                                        break;
+
+                                    case CustomPlaylistAction.Top:
+                                    case CustomPlaylistAction.Bottom:
+                                        _logger.LogDebug("Moving the video {VideoName} to the {Side} of the playlist {PlaylistName}", item.Name, item.Action, jfPlaylist.Name);
+                                        await MoveOrDeleteVideo(taApi, jfPlaylist, taPlaylistId, item).ConfigureAwait(true);
+                                        break;
+
+                                    case CustomPlaylistAction.Remove:
+                                        _logger.LogDebug("Removing the video {VideoName} in playlist {PlaylistName}", item.Name, jfPlaylist.Name);
+                                        await MoveOrDeleteVideo(taApi, jfPlaylist, taPlaylistId, item).ConfigureAwait(true);
+                                        break;
+
+                                    default:
+                                        _logger.LogDebug("Moving the video {VideoName} {Direction} in playlist {PlaylistName}", item.Name, item.Action, jfPlaylist.Name);
+                                        await MoveOrDeleteVideo(taApi, jfPlaylist, taPlaylistId, item).ConfigureAwait(true);
+                                        break;
+                                }
+
+                                processedVideosCount++;
+                                progress.Report(processedVideosCount * 100 / totalVideosCount);
+                            }
+                        }
+                        else
+                        {
+                            _logger.LogWarning("Could not sync modifications on a YouTube downloaded TA playlist: {TAPlaylist}", $"{taPlaylist.Name} - {taPlaylist.Channel} ({taPlaylist.Id})");
+                            continue;
+                        }
+                    }
+                    else
+                    {
+                        // If it doesn't, create a new custom playlist and add videos
+                        _logger.LogInformation("Playlist {PlaylistName} was not found on TubeArchivist. Creating a new playlist...", jfPlaylist.Name);
+
+                        var playlistName = Utils.GetTAPlaylistNameFromName(jfPlaylist.Name);
+                        if (string.IsNullOrEmpty(playlistName))
+                        {
+                            playlistName = jfPlaylist.Name;
+                        }
+
+                        _logger.LogDebug("Creating a new TubeArchivist playlist with name: {PlaylistName}", playlistName);
+
+                        var creationRequest = new CustomPlaylistCreation(playlistName);
+                        var createdTAPlaylist = await taApi.CreateCustomPlaylist(creationRequest).ConfigureAwait(true);
+                        if (createdTAPlaylist == null)
+                        {
+                            _logger.LogError("Failed to create the playlist {JFPlaylist}", playlistName);
+                            continue;
+                        }
+
+                        // Update the JF playlist name with the new TA playlist id
+                        var newPlaylistName = GetPlaylistUpdatedName(jfPlaylist.Name, createdTAPlaylist.Id);
+                        var updateRequest = new PlaylistUpdateRequest
+                        {
+                            Id = jfPlaylist.Id,
+                            Name = newPlaylistName,
+                            UserId = user.Id
+                        };
+                        await _playlistManager.UpdatePlaylist(updateRequest).ConfigureAwait(true);
+                        _logger.LogDebug("Updated the playlist name from {NewPlaylistName} to {NewPlaylistName}", playlistName, newPlaylistName);
+
+                        foreach (var jfItem in jfPlaylist.GetItemList(new InternalItemsQuery()))
+                        {
+                            _logger.LogDebug("Adding the video {VideoName} to the playlist {PlaylistName}", jfItem.Name, jfPlaylist.Name);
+                            var action = new CustomPlaylistEntryAction(CustomPlaylistAction.Create, jfItem.ProviderIds[Constants.ProviderName]);
+                            var response = await taApi.CustomPlaylistEntryAction(taPlaylistId, action).ConfigureAwait(true);
+                            if (response != System.Net.HttpStatusCode.OK)
+                            {
+                                _logger.LogError("Failed to add the video {JFItem} to playlist {JFPlaylist}", $"{jfItem.Name} ({jfItem.ProviderIds[Constants.ProviderName]})", jfPlaylist.Name);
+                                continue;
+                            }
+
+                            processedVideosCount++;
+                            progress.Report(processedVideosCount * 100 / totalVideosCount);
+                        }
+                    }
+                }
+
+                _logger.LogInformation("Time elapsed: {Time}", DateTime.Now - start);
+            }
+            else
+            {
+                _logger.LogInformation("Jellyfin->TubeArchivist playlists synchronization is currently disabled.");
+            }
+
+            progress.Report(100);
+        }
+
+        private async Task MoveOrDeleteVideo(TubeArchivistApi taApi, MediaBrowser.Controller.Playlists.Playlist jfPlaylist, string taPlaylistId, PlaylistItemAction item)
+        {
+            var response = HttpStatusCode.OK;
+            for (var i = 0; i < item.PositionsToMove; i++)
+            {
+                var action = new CustomPlaylistEntryAction(item.Action, item.YoutubeId);
+                response = await taApi.CustomPlaylistEntryAction(taPlaylistId, action).ConfigureAwait(true);
+                if (response != System.Net.HttpStatusCode.OK)
+                {
+                    _logger.LogError("Failed to execute the operation {Operation} for the video {JFItem} in playlist {PlaylistName}", item.Action, $"{item.Name} ({item.YoutubeId})", jfPlaylist.Name);
+                }
+            }
+        }
+
+        private async Task<bool> AddVideoToTAPlaylist(TubeArchivistApi taApi, MediaBrowser.Controller.Playlists.Playlist jfPlaylist, string taPlaylistId, PlaylistItemAction item)
+        {
+            // TA playlist doesn't contain the JF video
+            _logger.LogDebug("Adding the video {VideoName} to the playlist {PlaylistName}", item.Name, jfPlaylist.Name);
+            var action = new CustomPlaylistEntryAction(CustomPlaylistAction.Create, item.YoutubeId);
+            var response = await taApi.CustomPlaylistEntryAction(taPlaylistId, action).ConfigureAwait(true);
+            if (response != System.Net.HttpStatusCode.OK)
+            {
+                _logger.LogError("Failed to add the video {JFItem} to playlist {JFPlaylist}", $"{item.Name} ({item.YoutubeId})", jfPlaylist.Name);
+                return false;
+            }
+
+            // Since now we have the video added at the bottom of the TA playlist (previouse entries count + 1),
+            // we need to move the video to the correct position
+            var positionsToMove = item.PositionsToMove;
+            action = new CustomPlaylistEntryAction(CustomPlaylistAction.Up, item.YoutubeId);
+            if (item.PositionsToMove < 0)
+            {
+                positionsToMove = (int)Math.Abs((decimal)positionsToMove!);
+                action = new CustomPlaylistEntryAction(CustomPlaylistAction.Up, item.YoutubeId);
+            }
+
+            _logger.LogDebug("Moving the video {VideoName} of the playlist {PlaylistName} {Positions} up", item.Name, jfPlaylist.Name, positionsToMove);
+            for (var i = 0; i < positionsToMove; i++)
+            {
+                response = await taApi.CustomPlaylistEntryAction(taPlaylistId, action).ConfigureAwait(true);
+                if (response != System.Net.HttpStatusCode.OK)
+                {
+                    _logger.LogError("Failed to move {Direction} the video {JFItem} in playlist {JFPlaylist}", item.Action, $"{item.Name} ({item.YoutubeId})", jfPlaylist.Name);
+                    continue;
+                }
+            }
+
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
+        {
+            return
+            [
+                new TaskTriggerInfo
+                {
+                    Type = TaskTriggerInfoType.IntervalTrigger,
+                    IntervalTicks = TimeSpan.FromSeconds(Plugin.Instance!.Configuration.TAJFProgressTaskInterval).Ticks
+                },
+            ];
+        }
+
+        private sealed class PlaylistItemAction
+        {
+            public PlaylistItemAction(
+                int index,
+                string youtubeId,
+                CustomPlaylistAction action,
+                int positionsToMove,
+                string name)
+            {
+                Index = index;
+                YoutubeId = youtubeId;
+                Action = action;
+                PositionsToMove = positionsToMove;
+                Name = name;
+            }
+
+            public PlaylistItemAction(
+                int index,
+                string youtubeId,
+                CustomPlaylistAction action,
+                string name)
+            {
+                Index = index;
+                YoutubeId = youtubeId;
+                Action = action;
+                Name = name;
+                PositionsToMove = 1;
+            }
+
+            public PlaylistItemAction(
+                string youtubeId,
+                string name)
+            {
+                YoutubeId = youtubeId;
+                Action = CustomPlaylistAction.Remove;
+                Name = name;
+                PositionsToMove = 1;
+            }
+
+            public int? Index { get; set; }
+
+            public string YoutubeId { get; set; }
+
+            public string Name { get; set; }
+
+            public CustomPlaylistAction Action { get; set; }
+
+            public int? PositionsToMove { get; set; }
+        }
+    }
+}

Jellyfin.Plugin.TubeArchivistMetadata/Tasks/JFToTubeArchivistProgressSyncTask.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Data.Enums;
@@ -19,7 +20,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
     /// <summary>
     /// Task to sync Jellyfin playback progresses to TubeArchivist.
     /// </summary>
-    public class JFToTubearchivistProgressSyncTask : IScheduledTask
+    public class JFToTubeArchivistProgressSyncTask : IScheduledTask
     {
         private readonly ILogger<Plugin> _logger;
         private readonly ILibraryManager _libraryManager;
@@ -27,13 +28,13 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
         private readonly IUserDataManager _userDataManager;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="JFToTubearchivistProgressSyncTask"/> class.
+        /// Initializes a new instance of the <see cref="JFToTubeArchivistProgressSyncTask"/> class.
         /// </summary>
         /// <param name="logger">Logger.</param>
         /// <param name="libraryManager">Library manager.</param>
         /// <param name="userManager">User manager.</param>
         /// <param name="userDataManager">User data manager.</param>
-        public JFToTubearchivistProgressSyncTask(ILogger<Plugin> logger, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataManager)
+        public JFToTubeArchivistProgressSyncTask(ILogger<Plugin> logger, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataManager)
         {
             _logger = logger;
             _libraryManager = libraryManager;
@@ -45,7 +46,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
         public string Name => "JFToTubeArchivistProgressSyncTask";
 
         /// <inheritdoc/>
-        public string Description => "This tasks syncs TubeArchivist playback progresses to Jellyfin";
+        public string Description => "This tasks syncs Jellyfin playback progresses to TubeArchivist";
 
         /// <inheritdoc/>
         public string Category => "TubeArchivistMetadata";
@@ -57,152 +58,160 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
         public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
         {
             progress.Report(0);
-            if (Plugin.Instance!.Configuration.JFTASync)
+            if (Plugin.Instance!.Configuration.JFTAProgressSync)
             {
                 var start = DateTime.Now;
                 _logger.LogInformation("Starting Jellyfin->TubeArchivist playback progresses synchronization.");
                 var taApi = TubeArchivistApi.GetInstance();
                 var videosCount = 0;
-                foreach (var jfUsername in Plugin.Instance!.Configuration.GetJFUsernamesToArray())
+                var jfUsername = Plugin.Instance!.Configuration.JFUsernameFrom;
+                var user = _userManager.GetUserByName(jfUsername);
+                if (user == null)
                 {
-                    var user = _userManager.GetUserByName(jfUsername);
-                    if (user == null)
-                    {
-                        _logger.LogInformation("{Message}", $"Jellyfin user with username {jfUsername} not found");
-                        continue;
-                    }
+                    _logger.LogInformation("{Message}", $"Jellyfin user with username {jfUsername} not found");
+                    return;
+                }
 
-                    var collectionItem = _libraryManager.GetItemList(new InternalItemsQuery
-                    {
-                        Name = Plugin.Instance?.Configuration.CollectionTitle,
-                        IncludeItemTypes = new[] { BaseItemKind.CollectionFolder }
-                    }).FirstOrDefault();
+                var items = _libraryManager.GetItemList(new InternalItemsQuery
+                {
+                    Name = Plugin.Instance?.Configuration.CollectionTitle,
+                    IncludeItemTypes = new[] { BaseItemKind.CollectionFolder }
+                });
 
-                    if (collectionItem == null)
+                var collectionItem = items.Count > 0 ? items[0] : null;
+
+                if (collectionItem == null)
+                {
+                    var message = $"Collection '{Plugin.Instance?.Configuration.CollectionTitle}' not found.";
+                    _logger.LogCritical("{Message}", message);
+                }
+                else
+                {
+                    var collection = (CollectionFolder)collectionItem;
+                    var channels = collection.GetChildren(user, false, new InternalItemsQuery
                     {
-                        var message = $"Collection '{Plugin.Instance?.Configuration.CollectionTitle}' not found.";
-                        _logger.LogCritical("{Message}", message);
-                    }
-                    else
+                        IncludeItemTypes = new[] { BaseItemKind.Series }
+                    });
+                    _logger.LogDebug("Analyzing collection {Id} with name {Name}", collectionItem.Id, collectionItem.Name);
+                    _logger.LogDebug("Found {Message} channels", channels.Count);
+
+                    foreach (Series channel in channels)
                     {
-                        var collection = (CollectionFolder)collectionItem;
-                        var channels = collection.GetChildren(user, false, new InternalItemsQuery
+                        var channelYTId = Utils.GetChannelNameFromPath(channel.Path);
+                        var years = channel.GetChildren(user, false, new InternalItemsQuery
                         {
-                            IncludeItemTypes = new[] { BaseItemKind.Series }
+                            IncludeItemTypes = new[] { BaseItemKind.Season }
                         });
-                        _logger.LogInformation("Analyzing collection {Id} with name {Name}", collectionItem.Id, collectionItem.Name);
-                        _logger.LogDebug("Found {Message} channels", channels.Count);
+                        _logger.LogDebug("Found {Years} years in channel {ChannelName}", years.Count, channel.Name);
 
-                        foreach (Series channel in channels)
+                        foreach (Season year in years)
                         {
-                            var channelYTId = Utils.GetChannelNameFromPath(channel.Path);
-                            var years = channel.GetChildren(user, false, new InternalItemsQuery
+                            var videos = year.GetChildren(user, false, new InternalItemsQuery
                             {
-                                IncludeItemTypes = new[] { BaseItemKind.Season }
+                                IncludeItemTypes = new[] { BaseItemKind.Episode }
                             });
-                            _logger.LogDebug("Found {Years} years in channel {ChannelName}", years.Count, channel.Name);
-
-                            foreach (Season year in years)
-                            {
-                                var videos = year.GetChildren(user, false, new InternalItemsQuery
-                                {
-                                    IncludeItemTypes = new[] { BaseItemKind.Episode }
-                                });
-                                _logger.LogDebug("Found {Videos} videos in year {YearName} of the channel {ChannelName}", videos.Count, year.Name, channel.Name);
-                                videosCount += videos.Count;
-                            }
+                            _logger.LogDebug("Found {Videos} videos in year {YearName} of the channel {ChannelName}", videos.Count, year.Name, channel.Name);
+                            videosCount += videos.Count;
                         }
                     }
                 }
 
-                _logger.LogInformation("Found a total of {VideosCount} videos", videosCount);
+                _logger.LogDebug("Found a total of {VideosCount} videos", videosCount);
 
                 var processedVideosCount = 0;
-                foreach (var jfUsername in Plugin.Instance!.Configuration.GetJFUsernamesToArray())
+                if (collectionItem == null)
                 {
-                    var user = _userManager.GetUserByName(jfUsername);
-                    if (user == null)
+                    var message = $"Collection '{Plugin.Instance?.Configuration.CollectionTitle}' not found.";
+                    _logger.LogCritical("{Message}", message);
+                }
+                else
+                {
+                    var collection = (CollectionFolder)collectionItem;
+                    var channels = collection.GetChildren(user, false, new InternalItemsQuery
                     {
-                        _logger.LogInformation("{Message}", $"Jellyfin user with username {jfUsername} not found");
-                        continue;
-                    }
+                        IncludeItemTypes = new[] { BaseItemKind.Series }
+                    });
 
-                    var collectionItem = _libraryManager.GetItemList(new InternalItemsQuery
+                    foreach (Series channel in channels)
                     {
-                        Name = Plugin.Instance?.Configuration.CollectionTitle,
-                        IncludeItemTypes = new[] { BaseItemKind.CollectionFolder }
-                    }).FirstOrDefault();
-
-                    if (collectionItem == null)
-                    {
-                        var message = $"Collection '{Plugin.Instance?.Configuration.CollectionTitle}' not found.";
-                        _logger.LogCritical("{Message}", message);
-                    }
-                    else
-                    {
-                        var collection = (CollectionFolder)collectionItem;
-                        var channels = collection.GetChildren(user, false, new InternalItemsQuery
+                        var channelYTId = Utils.GetChannelNameFromPath(channel.Path);
+                        var isChannelWatched = false;
+                        var isChannelCheckedForWatched = false;
+                        var years = channel.GetChildren(user, false, new InternalItemsQuery
                         {
-                            IncludeItemTypes = new[] { BaseItemKind.Series }
+                            IncludeItemTypes = new[] { BaseItemKind.Season }
                         });
 
-                        foreach (Series channel in channels)
+                        foreach (Season year in years)
                         {
-                            var channelYTId = Utils.GetChannelNameFromPath(channel.Path);
-                            var isChannelWatched = false;
-                            var isChannelCheckedForWatched = false;
-                            var years = channel.GetChildren(user, false, new InternalItemsQuery
+                            var videos = year.GetChildren(user, false, new InternalItemsQuery
                             {
-                                IncludeItemTypes = new[] { BaseItemKind.Season }
+                                IncludeItemTypes = new[] { BaseItemKind.Episode }
                             });
+                            videosCount += videos.Count;
 
-                            foreach (Season year in years)
+                            foreach (Episode video in videos)
                             {
-                                var videos = year.GetChildren(user, false, new InternalItemsQuery
-                                {
-                                    IncludeItemTypes = new[] { BaseItemKind.Episode }
-                                });
-                                videosCount += videos.Count;
+                                var videoYTId = Utils.GetVideoNameFromPath(video.Path);
+                                _logger.LogDebug("Current video extracted YouTube id: {VideoYtId}", videoYTId);
+                                HttpStatusCode statusCode;
+                                var channelItemData = _userDataManager.GetUserData(user, channel);
 
-                                foreach (Episode video in videos)
+                                if (!isChannelCheckedForWatched && channel.IsPlayed(user, channelItemData))
                                 {
-                                    var videoYTId = Utils.GetVideoNameFromPath(video.Path);
-                                    var playbackProgress = _userDataManager.GetUserData(user, video).PlaybackPositionTicks / TimeSpan.TicksPerSecond;
-                                    var statusCode = await taApi.SetProgress(videoYTId, playbackProgress).ConfigureAwait(true);
+                                    var isChannelPlayed = channel.IsPlayed(user, channelItemData);
+                                    statusCode = await taApi.SetWatchedStatus(channelYTId, isChannelPlayed).ConfigureAwait(true);
                                     if (statusCode != System.Net.HttpStatusCode.OK)
                                     {
-                                        _logger.LogCritical("{Message}", $"POST /video/{videoYTId}/progress returned {statusCode} for video {video.Name} with progress {progress} seconds");
+                                        _logger.LogCritical("{Message}", $"POST /watched returned {statusCode} for channel {channel.Name} ({channelYTId}) with wacthed status {isChannelPlayed}");
                                     }
-
-                                    if (!isChannelCheckedForWatched && channel.IsPlayed(user))
+                                    else
                                     {
-                                        var isChannelPlayed = channel.IsPlayed(user);
-                                        statusCode = await taApi.SetWatchedStatus(channelYTId, isChannelPlayed).ConfigureAwait(true);
-                                        if (statusCode != System.Net.HttpStatusCode.OK)
-                                        {
-                                            _logger.LogCritical("{Message}", $"POST /watched returned {statusCode} for channel {channel.Name} ({channelYTId}) with wacthed status {isChannelPlayed}");
-                                        }
-                                        else
-                                        {
-                                            isChannelWatched = true;
-                                        }
-
-                                        isChannelCheckedForWatched = true;
+                                        isChannelWatched = true;
                                     }
 
-                                    if (!isChannelWatched)
-                                    {
-                                        var isVideoPlayed = video.IsPlayed(user);
-                                        statusCode = await taApi.SetWatchedStatus(videoYTId, isVideoPlayed).ConfigureAwait(true);
-                                        if (statusCode != System.Net.HttpStatusCode.OK)
-                                        {
-                                            _logger.LogCritical("{Message}", $"POST /watched returned {statusCode} for video {video.Name} ({videoYTId}) with wacthed status {isVideoPlayed}");
-                                        }
-                                    }
-
-                                    processedVideosCount++;
-                                    progress.Report(processedVideosCount * 100 / videosCount);
+                                    isChannelCheckedForWatched = true;
                                 }
+
+                                var videoItemData = _userDataManager.GetUserData(user, video);
+                                if (!isChannelWatched)
+                                {
+                                    var isVideoPlayed = video.IsPlayed(user, videoItemData);
+                                    var taVideo = await taApi.GetVideo(videoYTId).ConfigureAwait(true);
+                                    if (taVideo != null)
+                                    {
+                                        var isTAVideoPlayed = taVideo?.Player.IsWatched ?? false;
+                                        if (isTAVideoPlayed != isVideoPlayed)
+                                        {
+                                            statusCode = await taApi.SetWatchedStatus(videoYTId, isVideoPlayed).ConfigureAwait(true);
+                                            if (statusCode != System.Net.HttpStatusCode.OK)
+                                            {
+                                                _logger.LogCritical("{Message}", $"POST /watched returned {statusCode} for video {video.Name} ({videoYTId}) with wacthed status {isVideoPlayed}");
+                                            }
+                                            else
+                                            {
+                                                _logger.LogInformation("Video {VideoId} watch status marked as {Status} in TubeArchivist", videoYTId, isVideoPlayed);
+                                            }
+                                        }
+                                    }
+
+                                    _logger.LogDebug("{Message}", isVideoPlayed);
+                                    if (!isVideoPlayed)
+                                    {
+                                        var playbackProgress = _userDataManager.GetUserData(user, video)?.PlaybackPositionTicks / TimeSpan.TicksPerSecond;
+                                        if (playbackProgress != null)
+                                        {
+                                            statusCode = await taApi.SetProgress(videoYTId, playbackProgress.Value).ConfigureAwait(true);
+                                            if (statusCode != System.Net.HttpStatusCode.OK)
+                                            {
+                                                _logger.LogCritical("{Message}", $"POST /video/{videoYTId}/progress returned {statusCode} for video {video.Name} with progress {progress} seconds");
+                                            }
+                                        }
+                                    }
+                                }
+
+                                processedVideosCount++;
+                                progress.Report(processedVideosCount * 100 / videosCount);
                             }
                         }
                     }
@@ -225,7 +234,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
             [
                 new TaskTriggerInfo
                 {
-                    Type = TaskTriggerInfo.TriggerStartup,
+                    Type = TaskTriggerInfoType.StartupTrigger,
                 },
             ];
         }

Jellyfin.Plugin.TubeArchivistMetadata/Tasks/TAToJellyfinPlaylistsSyncTask.cs

@@ -0,0 +1,201 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist;
+using Jellyfin.Plugin.TubeArchivistMetadata.Utilities;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Playlists;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Playlists;
+using MediaBrowser.Model.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
+{
+    /// <summary>
+    /// Task to sync TubeArchivist playlists to Jellyfin.
+    /// </summary>
+    public class TAToJellyfinPlaylistsSyncTask : IScheduledTask
+    {
+        private readonly ILogger<Plugin> _logger;
+        private readonly ILibraryManager _libraryManager;
+        private readonly IUserManager _userManager;
+        private readonly IPlaylistManager _playlistManager;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TAToJellyfinPlaylistsSyncTask"/> class.
+        /// </summary>
+        /// <param name="logger">Logger.</param>
+        /// <param name="libraryManager">Library manager.</param>
+        /// <param name="userManager">User manager.</param>
+        /// <param name="playlistManager">Playlists manager.</param>
+        public TAToJellyfinPlaylistsSyncTask(ILogger<Plugin> logger, ILibraryManager libraryManager, IUserManager userManager, IPlaylistManager playlistManager)
+        {
+            _logger = logger;
+            _libraryManager = libraryManager;
+            _userManager = userManager;
+            _playlistManager = playlistManager;
+        }
+
+        /// <inheritdoc/>
+        public string Name => "TAToJellyfinPlaylistsSyncTask";
+
+        /// <inheritdoc/>
+        public string Description => "This tasks syncs TubeArchivist playlists to Jellyfin";
+
+        /// <inheritdoc/>
+        public string Category => "TubeArchivistMetadata";
+
+        /// <inheritdoc/>
+        public string Key => "TAToJellyfinPlaylistsSyncTask";
+
+        private int CountTotalVideos(ISet<TubeArchivist.Playlist> taPlaylists)
+        {
+            var totalEntries = 0;
+            foreach (var taPlaylist in taPlaylists)
+            {
+                totalEntries += taPlaylist.Entries.Count;
+            }
+
+            return totalEntries;
+        }
+
+        /// <inheritdoc/>
+        public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            progress.Report(0);
+            if (Plugin.Instance!.Configuration.TAJFPlaylistsSync)
+            {
+                var start = DateTime.Now;
+                _logger.LogInformation("Starting TubeArchivist->Jellyfin playlists synchronization.");
+                var taApi = TubeArchivistApi.GetInstance();
+                _logger.LogInformation("Getting TubeArchivist playlists");
+                var taPlaylists = await taApi.GetPlaylists().ConfigureAwait(true);
+                _logger.LogInformation("Received playlists:\n{Playlists}", taPlaylists);
+                if (taPlaylists != null)
+                {
+                    var totalVideosCount = CountTotalVideos(taPlaylists);
+                    var processedVideosCount = 0;
+                    foreach (var jfUsername in Plugin.Instance!.Configuration.GetJFUsernamesToArray())
+                    {
+                        var user = _userManager.GetUserByName(jfUsername);
+                        if (user == null)
+                        {
+                            _logger.LogInformation("{Message}", $"Jellyfin user with username {jfUsername} not found");
+                            continue;
+                        }
+
+                        var userPlaylists = _playlistManager.GetPlaylists(user.Id).ToList();
+
+                        if (Plugin.Instance!.Configuration.TAJFPlaylistsDelete)
+                        {
+                            var jfPlaylistsToDelete = userPlaylists.Where(up => !taPlaylists.Select(tp => tp.Id).Contains(Utils.GetTAPlaylistIdFromName(up.Name)));
+                            foreach (var jfPlaylistToDelete in jfPlaylistsToDelete)
+                            {
+                                _logger.LogInformation("Deleting Jellyfin playlist {PlaylistName}", jfPlaylistToDelete.Name);
+                                _libraryManager.DeleteItem(jfPlaylistToDelete, new DeleteOptions());
+                            }
+                        }
+
+                        foreach (var taPlaylist in taPlaylists)
+                        {
+                            var playlistName = taPlaylist.Type == PlaylistType.Regular ? $"{taPlaylist.Name} - {taPlaylist.Channel} ({taPlaylist.Id})" : $"{taPlaylist.Name} ({taPlaylist.Id})";
+                            var userPlaylist = userPlaylists.Where(up => up.Name == playlistName).FirstOrDefault();
+
+                            var jfEntryIds = new List<Guid>();
+                            var currentPlaylistVideos = 0;
+                            foreach (var taEntry in taPlaylist.Entries)
+                            {
+                                currentPlaylistVideos++;
+                                var taEntryStr = $"{taEntry.Uploader} - {taEntry.Title} ({taEntry.YoutubeId}) in playlist {playlistName}";
+                                if (!taEntry.IsDownloaded)
+                                {
+                                    _logger.LogInformation("The entry {TAEntry} was skipped because has not been downloaded by TubeArchivist", taEntryStr);
+                                    continue;
+                                }
+
+                                var entries = _libraryManager.GetItemList(new InternalItemsQuery
+                                {
+                                    HasAnyProviderId = new Dictionary<string, string>()
+                                        {
+                                            {
+                                                Constants.ProviderName, taEntry.YoutubeId
+                                            }
+                                        }
+                                });
+
+                                var jfEntry = entries.Count > 0 ? entries[0] : null;
+
+                                if (jfEntry != null)
+                                {
+                                    jfEntryIds.Add(jfEntry.Id);
+                                }
+                                else
+                                {
+                                    _logger.LogWarning("The relative video for {TAEntry} was not found on Jellyfin", taEntryStr);
+                                }
+                            }
+
+                            if (userPlaylist != null)
+                            {
+                                var updateRequest = new PlaylistUpdateRequest
+                                {
+                                    Id = userPlaylist.Id,
+                                    UserId = user.Id,
+                                    Name = playlistName,
+                                    Ids = jfEntryIds
+                                };
+
+                                var result = _playlistManager.UpdatePlaylist(updateRequest);
+                                _logger.LogInformation("Updated playlist {PlaylistName} with id {Id}", playlistName, result.Id);
+                            }
+                            else
+                            {
+                                var creationRequest = new PlaylistCreationRequest
+                                {
+                                    Name = playlistName,
+                                    ItemIdList = jfEntryIds,
+                                    MediaType = MediaType.Video,
+                                    UserId = user.Id
+                                };
+
+                                var result = await _playlistManager.CreatePlaylist(creationRequest).ConfigureAwait(true);
+                                _logger.LogInformation("Created playlist {PlaylistName} with id {Id}", playlistName, result.Id);
+                            }
+
+                            processedVideosCount += currentPlaylistVideos;
+                            progress.Report(processedVideosCount * 100 / totalVideosCount);
+                        }
+                    }
+                }
+
+                _logger.LogInformation("Time elapsed: {Time}", DateTime.Now - start);
+            }
+            else
+            {
+                _logger.LogInformation("TubeArchivist->Jellyfin playlists synchronization is currently disabled.");
+            }
+
+            progress.Report(100);
+        }
+
+        /// <inheritdoc/>
+        public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
+        {
+            return
+            [
+                new TaskTriggerInfo
+                {
+                    Type = TaskTriggerInfoType.IntervalTrigger,
+                    IntervalTicks = TimeSpan.FromSeconds(Plugin.Instance!.Configuration.TAJFProgressTaskInterval).Ticks
+                },
+            ];
+        }
+    }
+}

Jellyfin.Plugin.TubeArchivistMetadata/Tasks/TAToJellyfinProgressSyncTask.cs

@@ -57,7 +57,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
         public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
         {
             progress.Report(0);
-            if (Plugin.Instance!.Configuration.TAJFSync)
+            if (Plugin.Instance!.Configuration.TAJFProgressSync)
             {
                 var start = DateTime.Now;
                 _logger.LogInformation("Starting TubeArchivist->Jellyfin playback progresses synchronization.");
@@ -72,11 +72,13 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
                         continue;
                     }
 
-                    var collectionItem = _libraryManager.GetItemList(new InternalItemsQuery
+                    var items = _libraryManager.GetItemList(new InternalItemsQuery
                     {
                         Name = Plugin.Instance?.Configuration.CollectionTitle,
                         IncludeItemTypes = new[] { BaseItemKind.CollectionFolder }
-                    }).FirstOrDefault();
+                    });
+
+                    var collectionItem = items.Count > 0 ? items[0] : null;
 
                     if (collectionItem == null)
                     {
@@ -90,7 +92,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
                         {
                             IncludeItemTypes = new[] { BaseItemKind.Series }
                         });
-                        _logger.LogInformation("Analyzing collection {Id} with name {Name}", collectionItem.Id, collectionItem.Name);
+                        _logger.LogDebug("Analyzing collection {Id} with name {Name}", collectionItem.Id, collectionItem.Name);
                         _logger.LogDebug("Found {Message} channels", channels.Count);
 
                         foreach (Series channel in channels)
@@ -115,7 +117,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
                     }
                 }
 
-                _logger.LogInformation("Found a total of {VideosCount} videos", videosCount);
+                _logger.LogDebug("Found a total of {VideosCount} videos", videosCount);
 
                 var processedVideosCount = 0;
                 foreach (var jfUsername in Plugin.Instance!.Configuration.GetJFUsernamesToArray())
@@ -123,15 +125,17 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
                     var user = _userManager.GetUserByName(jfUsername);
                     if (user == null)
                     {
-                        _logger.LogInformation("{Message}", $"Jellyfin user with username {jfUsername} not found");
+                        _logger.LogDebug("{Message}", $"Jellyfin user with username {jfUsername} not found");
                         continue;
                     }
 
-                    var collectionItem = _libraryManager.GetItemList(new InternalItemsQuery
+                    var items = _libraryManager.GetItemList(new InternalItemsQuery
                     {
                         Name = Plugin.Instance?.Configuration.CollectionTitle,
                         IncludeItemTypes = new[] { BaseItemKind.CollectionFolder }
-                    }).FirstOrDefault();
+                    });
+
+                    var collectionItem = items.Count > 0 ? items[0] : null;
 
                     if (collectionItem == null)
                     {
@@ -185,8 +189,8 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
                                         }
 
                                         _userDataManager.SaveUserData(user, video, userUpdateData, UserDataSaveReason.UpdateUserData);
-                                        _logger.LogInformation("{Message}", $"Playback progress for video {video.Name} set to {userItemData.PlaybackPositionTicks / TimeSpan.TicksPerSecond} seconds for user {jfUsername}.");
-                                        _logger.LogInformation("{Message}", $"Watched status for video {video.Name} set to {userItemData.Played} seconds for user {jfUsername}.");
+                                        _logger.LogInformation("{Message}", $"Playback progress for video {video.Name} set to {userItemData?.PlaybackPositionTicks / TimeSpan.TicksPerSecond} seconds for user {jfUsername}.");
+                                        _logger.LogInformation("{Message}", $"Watched status for video {video.Name} set to {userItemData?.Played} seconds for user {jfUsername}.");
 
                                         processedVideosCount++;
                                         progress.Report(processedVideosCount * 100 / videosCount);
@@ -214,8 +218,8 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
             [
                 new TaskTriggerInfo
                 {
-                    Type = TaskTriggerInfo.TriggerInterval,
-                    IntervalTicks = TimeSpan.FromSeconds(Plugin.Instance!.Configuration.TAJFTaskInterval).Ticks
+                    Type = TaskTriggerInfoType.IntervalTrigger,
+                    IntervalTicks = TimeSpan.FromSeconds(Plugin.Instance!.Configuration.TAJFProgressTaskInterval).Ticks
                 },
             ];
         }

Jellyfin.Plugin.TubeArchivistMetadata/TubeArchivist/Channel/Channel.cs

@@ -126,7 +126,9 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
                         Type = ImageType.Primary
                     }
                 },
-                Tags = this.Tags.ToArray<string>()
+                Tags = this.Tags != null ?
+                    this.Tags.ToArray<string>() :
+                    []
             };
         }
     }

Jellyfin.Plugin.TubeArchivistMetadata/TubeArchivist/Playlist/CustomPlaylistCreation.cs

@@ -0,0 +1,25 @@
+using Newtonsoft.Json;
+
+namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
+{
+    /// <summary>
+    /// A class representing TubeArchivist API custom playlist creation request.
+    /// </summary>
+    public class CustomPlaylistCreation
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CustomPlaylistCreation"/> class.
+        /// </summary>
+        /// <param name="playlistName">The name of the new custom playlist to create.</param>
+        public CustomPlaylistCreation(string playlistName)
+        {
+            this.PlaylistName = playlistName;
+        }
+
+        /// <summary>
+        /// Gets or sets the name of the new custom playlist to create.
+        /// </summary>
+        [JsonProperty(PropertyName = "playlist_name")]
+        public string PlaylistName { get; set; }
+    }
+}

Jellyfin.Plugin.TubeArchivistMetadata/TubeArchivist/Playlist/CustomPlaylistEntryAction.cs

@@ -0,0 +1,72 @@
+using System.Globalization;
+using Newtonsoft.Json;
+
+namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
+{
+    /// <summary>
+    /// Enum representing the possible actions to execute on a TubeArchivist custom playlist video.
+    /// </summary>
+    public enum CustomPlaylistAction
+    {
+        /// <summary>
+        /// Create a new custom playlist video.
+        /// </summary>
+        Create,
+
+        /// <summary>
+        /// Removea custom playlist video.
+        /// </summary>
+        Remove,
+
+        /// <summary>
+        /// Move a custom playlist video to the top of the list.
+        /// </summary>
+        Top,
+
+        /// <summary>
+        /// Move a custom playlist video to the bottom of the list.
+        /// </summary>
+        Bottom,
+
+        /// <summary>
+        /// Move a custom playlist video up in the list.
+        /// </summary>
+        Up,
+
+        /// <summary>
+        /// Move a custom playlist video down in the list.
+        /// </summary>
+        Down
+    }
+
+    /// <summary>
+    /// A class representing TubeArchivist API custom playlist entry operation request.
+    /// </summary>
+    public class CustomPlaylistEntryAction
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CustomPlaylistEntryAction"/> class.
+        /// </summary>
+        /// <param name="action">The standard action to create a new entry.</param>
+        /// <param name="videoId">The entry YoutubeId.</param>
+        public CustomPlaylistEntryAction(
+            CustomPlaylistAction action,
+            string videoId)
+        {
+            this.Action = action.ToString().ToLower(CultureInfo.CurrentCulture);
+            this.VideoId = videoId;
+        }
+
+        /// <summary>
+        /// Gets or sets the standard action to create a new entry.
+        /// </summary>
+        [JsonProperty(PropertyName = "action")]
+        public string Action { get; set; }
+
+        /// <summary>
+        /// Gets or sets the entry YoutubeId.
+        /// </summary>
+        [JsonProperty(PropertyName = "video_id")]
+        public string VideoId { get; set; }
+    }
+}

Jellyfin.Plugin.TubeArchivistMetadata/TubeArchivist/Playlist/Playlist.cs

@@ -0,0 +1,116 @@
+using System.Collections.ObjectModel;
+using Newtonsoft.Json;
+
+namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
+{
+    /// <summary>
+    /// Enum representing whether the playlist on TubeArchivist belongs from YouTube or is created by the user.
+    /// </summary>
+    public enum PlaylistType
+    {
+        /// <summary>
+        /// Playlist belongs from YouTube.
+        /// </summary>
+        Regular,
+
+        /// <summary>
+        /// Playlist created by the user.
+        /// </summary>
+        Custom
+    }
+
+    /// <summary>
+    /// A class representing TubeArchivist API playlist data.
+    /// </summary>
+    public class Playlist
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Playlist"/> class.
+        /// </summary>
+        /// <param name="isActive">URL of the channel banner image.</param>
+        /// <param name="channel">Playlist channel name.</param>
+        /// <param name="channelId">Playlist channel YouTube id.</param>
+        /// <param name="description">Playlist description.</param>
+        /// <param name="entries">Playlist videos.</param>
+        /// <param name="id">Playlist YouTube id.</param>
+        /// <param name="name">Playlist name.</param>
+        /// <param name="thumbnailUrl">URL of the playlist thumbnail.</param>
+        /// <param name="type">Type of the playlist. See <see cref="PlaylistType"/>.</param>
+        public Playlist(
+            bool isActive,
+            string channel,
+            string channelId,
+            string description,
+            Collection<PlaylistEntry> entries,
+            string id,
+            string name,
+            string thumbnailUrl, // TODO: Check if settable on Jellyfin
+            PlaylistType type)
+        {
+            this.IsActive = isActive;
+            this.Channel = channel;
+            this.ChannelId = channelId;
+            this.Description = description;
+            this.Entries = entries;
+            this.Id = id;
+            this.Name = name;
+            this.ThumbnailUrl = thumbnailUrl;
+            this.Type = type;
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the playlist is active or not.
+        /// </summary>
+        [JsonProperty(PropertyName = "playlist_active")]
+        public bool IsActive { get; set; }
+
+        /// <summary>
+        /// Gets or sets the playlist channel name.
+        /// </summary>
+        [JsonProperty(PropertyName = "playlist_channel")]
+        public string Channel { get; set; }
+
+        /// <summary>
+        /// Gets or sets the playlist channel YouTube id.
+        /// </summary>
+        [JsonProperty(PropertyName = "playlist_channel_id")]
+        public string ChannelId { get; set; }
+
+        /// <summary>
+        /// Gets or sets the playlist description.
+        /// </summary>
+        [JsonProperty(PropertyName = "playlist_description")]
+        public string Description { get; set; }
+
+        /// <summary>
+        /// Gets the playlist videos.
+        /// </summary>
+        [JsonProperty(PropertyName = "playlist_entries")]
+        public Collection<PlaylistEntry> Entries { get; }
+
+        /// <summary>
+        /// Gets or sets the playlist YouTube id.
+        /// </summary>
+        [JsonProperty(PropertyName = "playlist_id")]
+        public string Id { get; set; }
+
+        /// <summary>
+        /// Gets or sets the playlist name.
+        /// </summary>
+        [JsonProperty(PropertyName = "playlist_name")]
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Gets or sets the playlist thumbnail URL.
+        /// </summary>
+        [JsonProperty(PropertyName = "playlist_thumbnail")]
+        public string ThumbnailUrl { get; set; }
+
+        /// <summary>
+        /// Gets or sets the playlist type.
+        /// </summary>
+        /// <value>One of the <see cref="PlaylistType"/> values indicating the playlist's type.</value>
+        [JsonProperty(PropertyName = "playlist_type")]
+        public PlaylistType Type { get; set; }
+    }
+}

Jellyfin.Plugin.TubeArchivistMetadata/TubeArchivist/Playlist/PlaylistEntry.cs

@@ -0,0 +1,63 @@
+using ICU4N.Text;
+using Newtonsoft.Json;
+
+namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
+{
+    /// <summary>
+    /// A class representing TubeArchivist API playlist entries data.
+    /// </summary>
+    public class PlaylistEntry
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PlaylistEntry"/> class.
+        /// </summary>
+        /// <param name="youtubeId">Video YouTube id.</param>
+        /// <param name="title">Video title.</param>
+        /// <param name="uploader">Video uploader.</param>
+        /// <param name="index">Video index in the playlist.</param>
+        /// <param name="isDownloaded">A value indicating whether the video has been already downloaded or not.</param>
+        public PlaylistEntry(
+            string youtubeId,
+            string title,
+            string uploader,
+            int index,
+            bool isDownloaded)
+        {
+            this.YoutubeId = youtubeId;
+            this.Title = title;
+            this.Uploader = uploader;
+            this.Index = index;
+            this.IsDownloaded = isDownloaded;
+        }
+
+        /// <summary>
+        /// Gets or sets the video YouTube id.
+        /// </summary>
+        [JsonProperty(PropertyName = "youtube_id")]
+        public string YoutubeId { get; set; }
+
+        /// <summary>
+        /// Gets or sets the video title.
+        /// </summary>
+        [JsonProperty(PropertyName = "title")]
+        public string Title { get; set; }
+
+        /// <summary>
+        /// Gets or sets the video uploader.
+        /// </summary>
+        [JsonProperty(PropertyName = "uploader")]
+        public string Uploader { get; set; }
+
+        /// <summary>
+        /// Gets or sets the video index in the playlist.
+        /// </summary>
+        [JsonProperty(PropertyName = "idx")]
+        public int Index { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the video has been already downloaded or not.
+        /// </summary>
+        [JsonProperty(PropertyName = "downloaded")]
+        public bool IsDownloaded { get; set; }
+    }
+}

Jellyfin.Plugin.TubeArchivistMetadata/TubeArchivist/TubeArchivistApi.cs

@@ -1,10 +1,12 @@
 using System;
+using System.Collections.Generic;
 using System.Data;
 using System.Net;
 using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
 using Jellyfin.Plugin.TubeArchivistMetadata.Utilities;
+using MediaBrowser.Model.Playlists;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 
@@ -65,7 +67,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
         /// <returns>A task.</returns>
         public async Task<Channel?> GetChannel(string channelId)
         {
-            ResponseContainer<Channel>? channel = null;
+            Channel? channel = null;
 
             var channelsEndpoint = "/api/channel/";
             var url = new Uri(Utils.SanitizeUrl(Plugin.Instance?.Configuration.TubeArchivistUrl + channelsEndpoint + channelId));
@@ -73,19 +75,19 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
             while (response.StatusCode == HttpStatusCode.Moved)
             {
                 url = response.Headers.Location;
-                _logger.LogInformation("{Message}", "Received redirect to: " + url);
+                _logger.LogDebug("{Message}", "Received redirect to: " + url);
                 response = await client.GetAsync(url).ConfigureAwait(true);
             }
 
-            _logger.LogInformation("{Message}", url + ": " + response.StatusCode);
+            _logger.LogDebug("{Message}", url + ": " + response.StatusCode);
 
             if (response.IsSuccessStatusCode)
             {
                 string rawData = await response.Content.ReadAsStringAsync().ConfigureAwait(true);
-                channel = JsonConvert.DeserializeObject<ResponseContainer<Channel>>(rawData);
+                channel = JsonConvert.DeserializeObject<Channel>(rawData);
             }
 
-            return channel?.Data;
+            return channel;
         }
 
         /// <summary>
@@ -95,7 +97,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
         /// <returns>A task.</returns>
         public async Task<Video?> GetVideo(string videoId)
         {
-            ResponseContainer<Video>? video = null;
+            Video? video = null;
 
             var videosEndpoint = "/api/video/";
             var url = new Uri(Utils.SanitizeUrl(Plugin.Instance?.Configuration.TubeArchivistUrl + videosEndpoint + videoId));
@@ -103,19 +105,20 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
             while (response.StatusCode == HttpStatusCode.Moved)
             {
                 url = response.Headers.Location;
-                _logger.LogInformation("{Message}", "Received redirect to: " + url);
+                _logger.LogDebug("{Message}", "Received redirect to: " + url);
                 response = await client.GetAsync(url).ConfigureAwait(true);
             }
 
-            _logger.LogInformation("{Message}", url + ": " + response.StatusCode);
+            _logger.LogDebug("{Message}", url + ": " + response.StatusCode);
 
             if (response.IsSuccessStatusCode)
             {
                 string rawData = await response.Content.ReadAsStringAsync().ConfigureAwait(true);
-                video = JsonConvert.DeserializeObject<ResponseContainer<Video>>(rawData);
+                _logger.LogDebug("{Message}", rawData);
+                video = JsonConvert.DeserializeObject<Video>(rawData);
             }
 
-            return video?.Data;
+            return video;
         }
 
         /// <summary>
@@ -133,11 +136,11 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
             while (response.StatusCode == HttpStatusCode.Moved)
             {
                 url = response.Headers.Location;
-                _logger.LogInformation("{Message}", "Received redirect to: " + url);
+                _logger.LogDebug("{Message}", "Received redirect to: " + url);
                 response = await client.GetAsync(url).ConfigureAwait(true);
             }
 
-            _logger.LogInformation("{Message}", url + ": " + response.StatusCode);
+            _logger.LogDebug("{Message}", url + ": " + response.StatusCode);
 
             if (response.IsSuccessStatusCode)
             {
@@ -149,7 +152,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
         }
 
         /// <summary>
-        /// Send video playback progress to TubeArchivist.
+        /// Sends video playback progress to TubeArchivist.
         /// </summary>
         /// <param name="videoId">Video id.</param>
         /// <param name="progress">Progress in seconds.</param>
@@ -166,7 +169,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
         }
 
         /// <summary>
-        /// Send video playback progress to TubeArchivist.
+        /// Sends video playback progress to TubeArchivist.
         /// </summary>
         /// <param name="videoId">Video id.</param>
         /// <returns>Video playback progress data.</returns>
@@ -174,22 +177,18 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
         {
             Progress? progress = null;
 
-            var progressEndpoint = $"/api/video/{videoId}/progress/";
-            var url = new Uri(Utils.SanitizeUrl(Plugin.Instance!.Configuration.TubeArchivistUrl + progressEndpoint));
-
-            var response = await client.GetAsync(url).ConfigureAwait(true);
-
-            if (response.IsSuccessStatusCode)
+            var video = await GetVideo(videoId).ConfigureAwait(true);
+            if (video != null)
             {
-                string rawData = await response.Content.ReadAsStringAsync().ConfigureAwait(true);
-                progress = JsonConvert.DeserializeObject<Progress>(rawData);
+                progress = new Progress((long)video.Player.Position);
+                _logger.LogDebug("{Message}", $"Retrieved progress {video.Player.Position}");
             }
 
             return progress;
         }
 
         /// <summary>
-        /// Set video/channel/playlist as watched on TubeArchivist.
+        /// Sets video/channel/playlist as watched on TubeArchivist.
         /// </summary>
         /// <param name="itemId">Video/channel/playlist id.</param>
         /// <param name="isWatched">Whether the item has been watched or not.</param>
@@ -204,5 +203,93 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
 
             return response.StatusCode;
         }
+
+        /// <summary>
+        /// Retrieves the playlists from TubeArchivist.
+        /// </summary>
+        /// <returns>A task.</returns>
+        public async Task<ISet<Playlist>?> GetPlaylists()
+        {
+            ResponseContainer<ISet<Playlist>?>? playlists = null;
+
+            var playlistsEndpoint = "/api/playlist/";
+            var url = new Uri(Utils.SanitizeUrl(Plugin.Instance?.Configuration.TubeArchivistUrl + playlistsEndpoint));
+            var response = await client.GetAsync(url).ConfigureAwait(true);
+            while (response.StatusCode == HttpStatusCode.Moved)
+            {
+                url = response.Headers.Location;
+                _logger.LogInformation("{Message}", "Received redirect to: " + url);
+                response = await client.GetAsync(url).ConfigureAwait(true);
+            }
+
+            _logger.LogInformation("{Message}", url + ": " + response.StatusCode);
+
+            if (response.IsSuccessStatusCode)
+            {
+                string rawData = await response.Content.ReadAsStringAsync().ConfigureAwait(true);
+                playlists = JsonConvert.DeserializeObject<ResponseContainer<ISet<Playlist>?>>(rawData);
+            }
+
+            return playlists?.Data;
+        }
+
+        /// <summary>
+        /// Creates a new custom playlist.
+        /// </summary>
+        /// <param name="creationRequest">Playlist creation request.</param>
+        /// <returns>The created <see cref="Playlist"/>.</returns>
+        public async Task<Playlist?> CreateCustomPlaylist(CustomPlaylistCreation creationRequest)
+        {
+            Playlist? playlist = null;
+            var customPlaylistEndpoint = $"/api/playlist/custom/";
+            var url = new Uri(Utils.SanitizeUrl(Plugin.Instance!.Configuration.TubeArchivistUrl + customPlaylistEndpoint));
+            var body = JsonConvert.SerializeObject(creationRequest);
+            _logger.LogInformation("{Message}", body);
+
+            var response = await client.PostAsync(url, new StringContent(body, Encoding.UTF8, "application/json")).ConfigureAwait(true);
+            _logger.LogInformation("POST {Message}", url + ": " + response.StatusCode);
+
+            if (response.IsSuccessStatusCode)
+            {
+                string rawData = await response.Content.ReadAsStringAsync().ConfigureAwait(true);
+                playlist = JsonConvert.DeserializeObject<Playlist>(rawData);
+            }
+
+            return playlist;
+        }
+
+        /// <summary>
+        /// Creates a new custom playlist.
+        /// </summary>
+        /// <param name="playlistId">Playlist id.</param>
+        /// <param name="entryAction">Playlist creation request.</param>
+        /// <returns>The response <see cref="HttpStatusCode"/>.</returns>
+        public async Task<HttpStatusCode> CustomPlaylistEntryAction(string playlistId, CustomPlaylistEntryAction entryAction)
+        {
+            var customPlaylistEndpoint = $"/api/playlist/custom/";
+            var url = new Uri(Utils.SanitizeUrl(Plugin.Instance!.Configuration.TubeArchivistUrl + customPlaylistEndpoint + playlistId));
+            var body = JsonConvert.SerializeObject(entryAction);
+            _logger.LogDebug("CustomPlaylistEntryAction body: {Message}", body);
+
+            var response = await client.PostAsync(url, new StringContent(body, Encoding.UTF8, "application/json")).ConfigureAwait(true);
+            _logger.LogDebug("Response code: {Message}", response.StatusCode);
+
+            return response.StatusCode;
+        }
+
+        /// <summary>
+        /// Deletes a playlist.
+        /// </summary>
+        /// <param name="playlistId">Playlist id.</param>
+        /// <returns>Whether the playlist has been deleted successfully or not.</returns>
+        public async Task<bool> DeletePlaylist(string playlistId)
+        {
+            var deletePlaylistEndpoint = $"/api/playlist/";
+            var url = new Uri(Utils.SanitizeUrl(Plugin.Instance!.Configuration.TubeArchivistUrl + deletePlaylistEndpoint + playlistId));
+            var response = await client.DeleteAsync(url).ConfigureAwait(true);
+            _logger.LogDebug("Response code: {Message}", response.StatusCode);
+
+            return response.StatusCode == HttpStatusCode.NoContent;
+        }
     }
 }

Jellyfin.Plugin.TubeArchivistMetadata/TubeArchivist/Video/Player.cs

@@ -1,4 +1,3 @@
-using System;
 using Newtonsoft.Json;
 
 namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
@@ -13,12 +12,12 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
         /// </summary>
         /// <param name="duration">Duration of the video.</param>
         /// <param name="isWatched">Whether the video is marked as watched.</param>
-        /// <param name="watchedUnixTime">Unix time of when the video has been marked watched.</param>
-        public Player(long duration, bool isWatched, long watchedUnixTime)
+        /// <param name="position">Video watched seconds.</param>
+        public Player(long duration, bool isWatched, double position)
         {
             Duration = duration;
             IsWatched = isWatched;
-            WatchedUnixTime = watchedUnixTime;
+            Position = position;
         }
 
         /// <summary>
@@ -34,18 +33,9 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
         public bool IsWatched { get; }
 
         /// <summary>
-        /// Gets the Unix date and time when the video has been marked as watched.
+        /// Gets the video watched seconds.
         /// </summary>
-        [JsonProperty(PropertyName = "watched_date")]
-        public long WatchedUnixTime { get; }
-
-        /// <summary>
-        /// Gets the date and time when the video has been marked as watched.
-        /// </summary>
-        [JsonIgnore]
-        public DateTime WatchedTime
-        {
-            get => DateTimeOffset.FromUnixTimeSeconds(WatchedUnixTime).DateTime;
-        }
+        [JsonProperty(PropertyName = "position")]
+        public double Position { get; }
     }
 }

Jellyfin.Plugin.TubeArchivistMetadata/TubeArchivist/Video/Video.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
+using Jellyfin.Plugin.TubeArchivistMetadata.Configuration;
 using Jellyfin.Plugin.TubeArchivistMetadata.Utilities;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.TV;
@@ -126,6 +127,11 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
                 Overview = Utils.FormatDescription(Description),
                 SeasonName = Published.Year.ToString(CultureInfo.CurrentCulture),
                 ParentIndexNumber = Published.Year,
+                IndexNumber = Plugin.Instance?.Configuration?.EpisodeNumberingScheme switch
+                {
+                    NumberingScheme.YYYYMMDD => (Published.Year * 10000) + (Published.Month * 100) + Published.Day,
+                    _ => null
+                },
                 SeriesName = Channel.Name,
                 ProductionYear = Published.Year,
                 PremiereDate = Published,

Jellyfin.Plugin.TubeArchivistMetadata/Utils/Utils.cs

@@ -1,6 +1,8 @@
+using System;
 using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
+using Microsoft.Extensions.Logging;
 
 namespace Jellyfin.Plugin.TubeArchivistMetadata.Utilities
 {
@@ -9,8 +11,12 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Utilities
     /// </summary>
     public static class Utils
     {
+        private const string TAPlaylistIdRegex = @"^(.*)\((.*)\)$";
+        private const string YTTAPlaylistNameFormatRegex = @"^(.*)\s\-\s(.*)\s\((.*)\)$";
+        private const string TAPlaylistNameFormatRegex = @"^(.*)\s\((.*)\)$";
+
         /// <summary>
-        /// Sanitize the given URL.
+        /// Sanitizes the given URL.
         /// </summary>
         /// <param name="inputUrl">An URL string.</param>
         /// <returns>The URL string without spaces, doubled slashes and with a trailing slash.</returns>
@@ -35,12 +41,17 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Utilities
         }
 
         /// <summary>
-        /// Format episodes and series descriptions replacing newlines with br tags.
+        /// Formats episodes and series descriptions replacing newlines with br tags.
         /// </summary>
         /// <param name="description">String to format.</param>
         /// <returns>A string with \n replaced by br tags.</returns>
         public static string FormatDescription(string description)
         {
+            if (description == null)
+            {
+                return string.Empty;
+            }
+
             var maxLength = 500;
             if (Plugin.Instance != null)
             {
@@ -50,14 +61,15 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Utilities
             if (description.Length > maxLength)
             {
                 description = description.Substring(0, maxLength);
-                description = description.Replace("\n", "<br>", System.StringComparison.CurrentCulture);
             }
 
+            description = description.Replace("\n", "<br>", System.StringComparison.CurrentCulture);
+
             return description;
         }
 
         /// <summary>
-        /// Get video name from file path on the disk.
+        /// Gets video name from file path on the disk.
         /// </summary>
         /// <param name="path">File path on disk.</param>
         /// <returns>The video name.</returns>
@@ -67,7 +79,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Utilities
         }
 
         /// <summary>
-        /// Get channel name from directory path on the disk.
+        /// Gets channel name from directory path on the disk.
         /// </summary>
         /// <param name="path">Directory path on disk.</param>
         /// <returns>The channel name.</returns>
@@ -90,5 +102,35 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Utilities
                 return '/'; // Unix directory separator
             }
         }
+
+        /// <summary>
+        /// Gets the TubeArchivist playlist id from Jellyfin playlist name.
+        /// </summary>
+        /// <param name="playlistName">The Jellyfin playlist name.</param>
+        /// <returns>The TubeArchvist playlist id.</returns>
+        public static string? GetTAPlaylistIdFromName(string playlistName)
+        {
+            var regex = new Regex(TAPlaylistIdRegex);
+            return regex.Match(playlistName).Groups[2].ToString();
+        }
+
+        /// <summary>
+        /// Gets the TubeArchivist playlist name from Jellyfin playlist name.
+        /// </summary>
+        /// <param name="playlistName">The Jellyfin playlist name.</param>
+        /// <returns>The TubeArchivist playlist name.</returns>
+        public static string? GetTAPlaylistNameFromName(string playlistName)
+        {
+            var ytRegex = new Regex(YTTAPlaylistNameFormatRegex);
+            var regex = new Regex(TAPlaylistNameFormatRegex);
+
+            var name = ytRegex.Match(playlistName).Groups[1].ToString();
+            if (string.IsNullOrEmpty(name))
+            {
+                name = regex.Match(playlistName).Groups[1].ToString();
+            }
+
+            return name;
+        }
     }
 }

README.md

@@ -7,6 +7,11 @@
 
 > [!IMPORTANT]
 > Jellyfin release cycle has changed in the past few months and now it is shorter than before. The plugin supports only the latest Jellyfin release, in order to continue using this plugin with all the latest features you will need to upgrade your Jellyfin installation.
+> The same rule applies to TubeArchivist: the plugin is only guaranteed to work with the latest TubeArchivist version.
+
+> [!WARNING]
+> Jellyfin 10.10 introduced a bug that prevents the plugin to correctly create Season folders by year. The bug has been finally solved on the Jellyfin codebase, but, until the next minor release, a manual build of the Jellyfin branch `release-10.10.z` is required in order to get the fix running.<br>
+> This is not a plugin bug, any issue opened about this bug will be immediately closed!
 
 ## About
 
@@ -22,18 +27,23 @@ The plugin interacts with TubeArchivist APIs to fetch videos and channels metada
 - Add images for videos (episodes), ie. thumb images
 - Add images for channels (shows), ie. thumb, tvart and banner images
 - Organize videos (episodes) by year (seasons)
+- Bidirectional playback progress synchronization
+- Bidirectional playlists synchronization
+
+> [!WARNING]
+> Enabling synchronization in both directions you can run in race conditions and unexpected results.
 
 ## Installation
 ### From official repository (recommended)
-1. Go to `Dashboard -> Plugins` and select the `Repositories` tab
+1. Go to `Dashboard -> Plugins` and click on the `Manage Repositories` button
 2. Add a new repository with the following details:
 - Repository name: `TubeArchivistMetadata`
 - Repository URL: `https://github.com/tubearchivist/tubearchivist-jf-plugin/raw/master/manifest.json`
-  ![Add repository](https://github.com/tubearchivist/tubearchivist-jf-plugin/assets/31162436/b0216b21-79c4-445b-8cf1-fbf6b138dee0)
+  ![Add repository](https://github.com/user-attachments/assets/337ba921-bc97-47ea-815c-c664cf7661a2)
 
-3. Go to the `Catalog` tab
-4. Find `TubeArchivistMetadata` in the `Metadata` section and install it
-![Find plugin](https://github.com/tubearchivist/tubearchivist-jf-plugin/assets/31162436/a30a14c2-33cd-44c1-b96a-406662726e5e)
+3. Go back to the catalog
+4. Find `TubeArchivistMetadata` and install it
+![Find plugin](https://github.com/user-attachments/assets/41f7315b-27c6-47dd-958f-21a232c30013)
 5. Restart Jellyfin to apply the changes
 
 ### From ZIP in GitHub releases
@@ -67,28 +77,57 @@ _NOTE: If you are using Docker containers, it is important to mount the TubeArch
 5. Save and come back to Home, you will see the newly added library. Jellyfin will have executed the metadata fetching for you after the collection creation and then you will see the metadata and the images of channels and videos
 
 
-## Playback synchronization
-<p>Starting from v1.3.1 this plugin offers playback progress and watched status bidirectional synchronization, but you can choose to enable only a one way synchronization (Jellyfin->TubeArchivist or TubeArchivist->Jellyfin) too.</p>
+## Synchronization
+This plugin has different bidirectional sycnhronization features, that can be configured in the specific section in the plugin configuration page:
+![Synchronization settings](https://github.com/user-attachments/assets/b0bb556b-fce3-4a3e-bc6c-b0a2b482cedc)
 
-### Jellyfin->TubeArchivist synchronization
+### Playback synchronization
+<p>Starting from v1.3.1 this plugin offers playback progress and watched status bidirectional synchronization, but you can choose to enable only a one way synchronization (Jellyfin -> TubeArchivist or TubeArchivist -> Jellyfin) too.</p>
+
+#### Jellyfin -> TubeArchivist playback synchronization
 <p>This kind of synchronization is done listening for progress and watched status changes while playing the videos for the specified users.<br>Furthermore, there is a task that runs at Jellyfin startup to synchronize the whole library.</p>
-<p>In the plugin configuration you will find these settings:</p>
-
-![JF->TA playback synchronization settings](https://github.com/user-attachments/assets/dc6be82f-e685-4896-a502-317681c47fc7)
 <p>In the text field you can specify one Jellyfin username to synchronize data of to TubeArchivist.</p>
 
-### TubeArchivist->Jellyfin synchronization
+#### TubeArchivist -> Jellyfin playback synchronization
 <p>This kind of synchronization is done using a Jellyfin scheduled task that regularly synchronizes data from TubeArchivist API to Jellyfin.</p>
-<p>In the plugin configuration you will find these settings:</p>
+<p>In the text field you can specify one or more Jellyfin usernames to update data for.</p>
 
-![TA->JF playback synchronization settings](https://github.com/user-attachments/assets/1b4c33af-834f-45b3-9057-71830e7c8b4f)
-<p>In the first text field you can specify one or more Jellyfin usernames to update data for.<br>
-In the second field you can specify the interval in seconds the task should run at, so that you can choose according to your system requirements. The lower is the interval the higher will be the resources consuption on your system.</p>
+### Playlists synchronization
+<p>Starting from v.1.4.1 this plugin offers playlists bidirectional synchronization, but you can choose to enable only a one way synchronization (Jellyfin -> TubeArchivist or TubeArchivist -> Jellyfin) too.</p>
 
+#### Jellyfin -> TubeArchivist playlists synchronization
+<p>There is a task that retrieves playlists and recreates them on TubeArchivist with the videos in the same order. Please note that playlists can also have videos not beloging from TubeArchivist, they will be simply ignored, so you won't find them on TubeArchivist playlist.</p>
+<p>It is present also a setting to automatically delete playlists from TubeArchivist when they are no more available on Jellyfin.</p>
+
+#### TubeArchivist -> Jellyfin playlists synchronization
+<p>There is a task that retrieves playlists from TubeArchivist and recreates them on Jellyfin with videos in the same order.</p>
+<p>It is present, also in this case, a setting to automatically delete playlists from Jellyfin when they are no more present on TubeArchivist, but beware that the will be deleted also if they contain videos not beloning to TubeArchivist.</p>
+
+> [!CAUTION]
+> Pay attention when you enable the automatic deletion options, be sure that is your wanted behavior, especially when playlists contain also other videos not belonging from TubeArchivist, playlists removed won't be available again, there's no undo!
+
+
+## Tasks intervals
+<p>Since many of the feature are implemented as background tasks periodically executing, in the `Tasks intervals` section you will find the settings to adjust this period in seconds.<br>
+Keep in mind that Jellyfin lowest accepted period is of 1 minute (60 seconds) and the lower is the interval the higher will be the resources consuption on your system.</p>
+<p>Here are the configurable intervals:</p>
+
+![Tasks intervals settings](https://github.com/user-attachments/assets/19db6b83-6715-477d-8ce7-b78526e87ba9)
+
+## Episode numbering
+
+<p>There are different ways to number the episodes as they are configured in Jellyfin.<br>
+This changes the number after E in S--E-- (for example S2024E100 for episode number 100 of season 2024).</p>
+
+![Episode numbering scheme options](https://github.com/user-attachments/assets/6d36bc2c-ca9d-4a5c-8021-e15d399316fc)
+
+The options correlate with:
+- Default - leave the numbering to what Jellyfin does by default (this is what the plugin has always done)
+- YYYYMMDD - numbers the episode by the year, month, day (e.g. 20250804 for a video published on the 4th of August 2025)
 
 ## Build
 
-1. To build this plugin you will need [.Net 8.x](https://dotnet.microsoft.com/download/dotnet/8.0).
+1. To build this plugin you will need [.Net 9.x](https://dotnet.microsoft.com/download/dotnet/9.0).
 
 2. Build plugin with following command
   ```

build.yaml

@@ -2,9 +2,9 @@
 name: "TubeArchivistMetadata"
 guid: "dc97d0c6-28b0-4242-afb4-5833ae1b3715"
 imageUrl: https://raw.githubusercontent.com/tubearchivist/tubearchivist-jf-plugin/master/images/logo.png
-version: "1.3.4.0"
-targetAbi: "10.10.0.0"
-framework: "net8.0"
+version: "1.4.3.0"
+targetAbi: "10.11.0.0"
+framework: "net9.0"
 overview: "Metadata for your TubeArchivist library on Jellyfin"
 description: >
   TubeArchivistMetadata is a plugin that automatically manages
@@ -14,4 +14,4 @@ owner: "DarkFighterLuke"
 artifacts:
 - "Jellyfin.Plugin.TubeArchivistMetadata.dll"
 changelog: >
-  Merge workaround for JF crashing when scanning Series pull request by wolffshots
+  Fix JF->TA watched status sync

manifest.json

@@ -8,6 +8,62 @@
         "overview": "Metadata for your TubeArchivist library on Jellyfin",
         "imageUrl": "https://raw.githubusercontent.com/tubearchivist/tubearchivist-jf-plugin/master/images/logo.png",
         "versions": [
+            {
+                "version": "1.4.2.0",
+                "changelog": "Introduce episode numbering alternative schema\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://github.com/tubearchivist/tubearchivist-jf-plugin/releases/download/v1.4.2/tubearchivistmetadata_1.4.2.0.zip",
+                "checksum": "8df142d2f1f0c0dffa302a567b40ef84",
+                "timestamp": "2025-10-23T20:27:32Z"
+            },
+            {
+                "version": "1.4.1.0",
+                "changelog": "Introduce bidirectional playlists synchronization\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://github.com/tubearchivist/tubearchivist-jf-plugin/releases/download/v1.4.1/tubearchivistmetadata_1.4.1.0.zip",
+                "checksum": "2dc0b9140472a4f783f093a7ee425493",
+                "timestamp": "2025-10-22T07:00:27Z"
+            },
+            {
+                "version": "1.4.0.0",
+                "changelog": "Introduce bidirectional playlists synchronization\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://github.com/tubearchivist/tubearchivist-jf-plugin/releases/download/v1.4.0/tubearchivistmetadata_1.4.0.0.zip",
+                "checksum": "4b81ab60022b532a64bb5eeb7be67dcc",
+                "timestamp": "2025-10-22T06:57:53Z"
+            },
+            {
+                "version": "1.3.7.0",
+                "changelog": "Fix JF->TA Sync\n",
+                "targetAbi": "10.10.0.0",
+                "sourceUrl": "https://github.com/tubearchivist/tubearchivist-jf-plugin/releases/download/v1.3.7/tubearchivistmetadata_1.3.7.0.zip",
+                "checksum": "60d8e9f134912f907dccd30b531da4f6",
+                "timestamp": "2025-05-27T18:36:55Z"
+            },
+            {
+                "version": "1.3.6.0",
+                "changelog": "Fix TA auth header\n",
+                "targetAbi": "10.10.0.0",
+                "sourceUrl": "https://github.com/tubearchivist/tubearchivist-jf-plugin/releases/download/v1.3.6/tubearchivistmetadata_1.3.6.0.zip",
+                "checksum": "513cde64268867d0047009eb2d986054",
+                "timestamp": "2025-03-10T22:01:13Z"
+            },
+            {
+                "version": "1.3.5.0",
+                "changelog": "Adapt to the new TA API changes Fix JF crash when setting watched status with TA offline\n",
+                "targetAbi": "10.10.0.0",
+                "sourceUrl": "https://github.com/tubearchivist/tubearchivist-jf-plugin/releases/download/v1.3.5/tubearchivistmetadata_1.3.5.0.zip",
+                "checksum": "2536622c0ec73e6401860929f24849f7",
+                "timestamp": "2025-03-10T17:47:43Z"
+            },
+            {
+                "version": "1.3.4.0",
+                "changelog": "Merge workaround for JF crashing when scanning Series pull request by wolffshots\n",
+                "targetAbi": "10.10.0.0",
+                "sourceUrl": "https://github.com/tubearchivist/tubearchivist-jf-plugin/releases/download/v1.3.4/tubearchivistmetadata_1.3.4.0.zip",
+                "checksum": "1ee6041139a6fdc3cecc8b2a427c60a8",
+                "timestamp": "2024-11-04T21:30:24Z"
+            },
             {
                 "version": "1.3.3.0",
                 "changelog": "Add compatibility with Jellyfin 10.10\n",
@@ -114,4 +170,4 @@
             }
         ]
     }
-]
+]