chore(deps): update typescript-eslint monorepo to v5.62.0

.github/ISSUE_TEMPLATE/bug.yml

@@ -91,14 +91,6 @@ body:
     attributes:
       label: Additional Context
       description: Please provide any additional information that may be relevant or helpful.
-  - type: checkboxes
-    id: search-existing
-    attributes:
-      label: Search Existing Issues
-      description: Have you searched existing issues to see if this bug has already been reported?
-      options:
-        - label: Yes, I have searched existing issues.
-          required: true
   - type: checkboxes
     id: terms
     attributes:

.github/ISSUE_TEMPLATE/enhancement.yml

@@ -27,14 +27,6 @@ body:
     attributes:
       label: Additional Context
       description: Provide any additional information or screenshots that may be relevant or helpful.
-  - type: checkboxes
-    id: search-existing
-    attributes:
-      label: Search Existing Issues
-      description: Have you searched existing issues to see if this feature has already been requested?
-      options:
-        - label: Yes, I have searched existing issues.
-          required: true
   - type: checkboxes
     id: terms
     attributes:

README.md

@@ -8,7 +8,7 @@
 <p align="center">
 <a href="https://discord.gg/seerr"><img src="https://img.shields.io/discord/783137440809746482" alt="Discord"></a>
 <a href="https://hub.docker.com/r/seerr/seerr"><img src="https://img.shields.io/docker/pulls/seerr/seerr" alt="Docker pulls"></a>
-<a href="https://translate.seerr.dev/engage/seerr/"><img src="https://translate.seerr.dev/widget/seerr/svg-badge.svg" alt="Translation status" /></a>
+<a href="https://translate.seerr.dev/engage/seerr/"><img src="https://translate.seerr.dev/widget/seerr/seerr-frontend/svg-badge.svg" alt="Translation status" /></a>
 <a href="https://github.com/seerr-team/seerr/blob/develop/LICENSE"><img alt="GitHub" src="https://img.shields.io/github/license/seerr-team/seerr"></a>
 
 **Seerr** is a free and open source software application for managing requests for your media library. It integrates with the media server of your choice: [Jellyfin](https://jellyfin.org), [Plex](https://plex.tv), and [Emby](https://emby.media/). In addition, it integrates with your existing services, such as **[Sonarr](https://sonarr.tv/)**, **[Radarr](https://radarr.video/)**.

docs/troubleshooting.mdx

@@ -174,36 +174,4 @@ This can happen if you have a new installation of Jellyfin/Emby or if you have c
 
 This process should restore your admin privileges while preserving your settings.
 
-## Failed to enable web push notifications
-
-### Option 1: You are using Pi-hole
-
-When using Pi-hole, you need to whitelist the proper domains in order for the queries to not be intercepted and blocked by Pi-hole.
-If you are using a chromium based browser (eg: Chrome, Brave, Edge...), the domain you need to whitelist is `fcm.googleapis.com`
-If you are using Firefox, the domain you need to whitelist is `push.services.mozilla.com`
-
-1. Log into your Pi-hole through the admin interface, then click on Domains situated under GROUP MANAGEMENT.
-2. Add the domain corresponding to your browser in the `Domain to be added` field and then click on Add to allowed domains.
-3. Now in order for those changes to be used you need to flush your current dns cache.
-4. You can do so by using this command line in your Pi-hole terminal:
-    ```bash
-    pihole restartdns
-    ```
-If this command fails (which is unlikely), use this equivalent:
-    ```bash
-    pihole -f && pihole restartdns
-    ```
-5. Then restart your Seerr instance and try to enable the web push notifications again.
-
-
-### Option 2: You are using Brave browser
-
-Brave is a "De-Googled" browser. So by default or if you refused a prompt in the past, it cuts the access to the FCM (Firebase Cloud Messaging) service, which is mandatory for the web push notifications on Chromium based browsers.
-
-1. Open Brave and paste this address in the url bar: `brave://settings/privacy`
-2. Look for the option: "Use Google services for push messaging"
-3. Activate this option
-4. Relaunch Brave completely
-5. You should now see the notifications prompt appearing instead of an error message.
-
 If you still encounter issues, please reach out on our support channels.

package.json

@@ -145,8 +145,8 @@
     "@types/xml2js": "0.4.11",
     "@types/yamljs": "0.2.31",
     "@types/yup": "0.29.14",
-    "@typescript-eslint/eslint-plugin": "5.54.0",
-    "@typescript-eslint/parser": "5.54.0",
+    "@typescript-eslint/eslint-plugin": "5.62.0",
+    "@typescript-eslint/parser": "5.62.0",
     "autoprefixer": "10.4.22",
     "baseline-browser-mapping": "^2.8.32",
     "commitizen": "4.3.1",

server/api/jellyfin.ts

@@ -112,10 +112,6 @@ export interface JellyfinLibraryItemExtended extends JellyfinLibraryItem {
   DateCreated?: string;
 }
 
-type EpisodeReturn<T> = T extends { includeMediaInfo: true }
-  ? JellyfinLibraryItemExtended[]
-  : JellyfinLibraryItem[];
-
 export interface JellyfinItemsReponse {
   Items: JellyfinLibraryItemExtended[];
   TotalRecordCount: number;
@@ -419,22 +415,13 @@ class JellyfinAPI extends ExternalAPI {
     }
   }
 
-  public async getEpisodes<
-    T extends { includeMediaInfo?: boolean } | undefined = undefined
-  >(
+  public async getEpisodes(
     seriesID: string,
-    seasonID: string,
-    options?: T
-  ): Promise<EpisodeReturn<T>> {
+    seasonID: string
+  ): Promise<JellyfinLibraryItem[]> {
     try {
       const episodeResponse = await this.get<any>(
-        `/Shows/${seriesID}/Episodes`,
-        {
-          params: {
-            seasonId: seasonID,
-            ...(options?.includeMediaInfo && { fields: 'MediaSources' }),
-          },
-        }
+        `/Shows/${seriesID}/Episodes?seasonId=${seasonID}`
       );
 
       return episodeResponse.Items.filter(

server/lib/scanners/baseScanner.ts

@@ -34,8 +34,6 @@ interface ProcessOptions {
   is4k?: boolean;
   mediaAddedAt?: Date;
   ratingKey?: string;
-  jellyfinMediaId?: string;
-  imdbId?: string;
   serviceId?: number;
   externalServiceId?: number;
   externalServiceSlug?: string;
@@ -97,8 +95,6 @@ class BaseScanner<T> {
       is4k = false,
       mediaAddedAt,
       ratingKey,
-      jellyfinMediaId,
-      imdbId,
       serviceId,
       externalServiceId,
       externalServiceSlug,
@@ -137,21 +133,6 @@ class BaseScanner<T> {
           changedExisting = true;
         }
 
-        if (
-          jellyfinMediaId &&
-          existing[is4k ? 'jellyfinMediaId4k' : 'jellyfinMediaId'] !==
-            jellyfinMediaId
-        ) {
-          existing[is4k ? 'jellyfinMediaId4k' : 'jellyfinMediaId'] =
-            jellyfinMediaId;
-          changedExisting = true;
-        }
-
-        if (imdbId && !existing.imdbId) {
-          existing.imdbId = imdbId;
-          changedExisting = true;
-        }
-
         if (
           serviceId !== undefined &&
           existing[is4k ? 'serviceId4k' : 'serviceId'] !== serviceId
@@ -192,7 +173,6 @@ class BaseScanner<T> {
       } else {
         const newMedia = new Media();
         newMedia.tmdbId = tmdbId;
-        newMedia.imdbId = imdbId;
 
         newMedia.status =
           !is4k && !processing
@@ -223,13 +203,6 @@ class BaseScanner<T> {
           newMedia.ratingKey4k =
             is4k && this.enable4kMovie ? ratingKey : undefined;
         }
-
-        if (jellyfinMediaId) {
-          newMedia.jellyfinMediaId = !is4k ? jellyfinMediaId : undefined;
-          newMedia.jellyfinMediaId4k =
-            is4k && this.enable4kMovie ? jellyfinMediaId : undefined;
-        }
-
         await mediaRepository.save(newMedia);
         this.log(`Saved new media: ${title}`);
       }
@@ -248,12 +221,11 @@ class BaseScanner<T> {
    */
   protected async processShow(
     tmdbId: number,
-    tvdbId: number | undefined,
+    tvdbId: number,
     seasons: ProcessableSeason[],
     {
       mediaAddedAt,
       ratingKey,
-      jellyfinMediaId,
       serviceId,
       externalServiceId,
       externalServiceSlug,
@@ -285,7 +257,7 @@ class BaseScanner<T> {
           (es) => es.seasonNumber === season.seasonNumber
         );
 
-        // We update the rating keys and jellyfinMediaId in the seasons loop because we need episode counts
+        // We update the rating keys in the seasons loop because we need episode counts
         if (media && season.episodes > 0 && media.ratingKey !== ratingKey) {
           media.ratingKey = ratingKey;
         }
@@ -299,23 +271,6 @@ class BaseScanner<T> {
           media.ratingKey4k = ratingKey;
         }
 
-        if (
-          media &&
-          season.episodes > 0 &&
-          media.jellyfinMediaId !== jellyfinMediaId
-        ) {
-          media.jellyfinMediaId = jellyfinMediaId;
-        }
-
-        if (
-          media &&
-          season.episodes4k > 0 &&
-          this.enable4kShow &&
-          media.jellyfinMediaId4k !== jellyfinMediaId
-        ) {
-          media.jellyfinMediaId4k = jellyfinMediaId;
-        }
-
         if (existingSeason) {
           // Here we update seasons if they already exist.
           // If the season is already marked as available, we
@@ -536,22 +491,6 @@ class BaseScanner<T> {
             )
               ? ratingKey
               : undefined,
-          jellyfinMediaId: newSeasons.some(
-            (sn) =>
-              sn.status === MediaStatus.PARTIALLY_AVAILABLE ||
-              sn.status === MediaStatus.AVAILABLE
-          )
-            ? jellyfinMediaId
-            : undefined,
-          jellyfinMediaId4k:
-            this.enable4kShow &&
-            newSeasons.some(
-              (sn) =>
-                sn.status4k === MediaStatus.PARTIALLY_AVAILABLE ||
-                sn.status4k === MediaStatus.AVAILABLE
-            )
-              ? jellyfinMediaId
-              : undefined,
           status: isAllStandardSeasons
             ? MediaStatus.AVAILABLE
             : newSeasons.some(

server/lib/scanners/jellyfin/index.ts

@@ -1,8 +1,5 @@
 import animeList from '@server/api/animelist';
-import type {
-  JellyfinLibraryItem,
-  JellyfinLibraryItemExtended,
-} from '@server/api/jellyfin';
+import type { JellyfinLibraryItem } from '@server/api/jellyfin';
 import JellyfinAPI from '@server/api/jellyfin';
 import { getMetadataProvider } from '@server/api/metadata';
 import TheMovieDb from '@server/api/themoviedb';
@@ -11,119 +8,132 @@ import type {
   TmdbKeyword,
   TmdbTvDetails,
 } from '@server/api/themoviedb/interfaces';
+import { MediaStatus, MediaType } from '@server/constants/media';
 import { MediaServerType } from '@server/constants/server';
 import { getRepository } from '@server/datasource';
+import Media from '@server/entity/Media';
+import Season from '@server/entity/Season';
 import { User } from '@server/entity/User';
-import type {
-  ProcessableSeason,
-  RunnableScanner,
-  StatusBase,
-} from '@server/lib/scanners/baseScanner';
-import BaseScanner from '@server/lib/scanners/baseScanner';
 import type { Library } from '@server/lib/settings';
 import { getSettings } from '@server/lib/settings';
+import logger from '@server/logger';
+import AsyncLock from '@server/utils/asyncLock';
 import { getHostname } from '@server/utils/getHostname';
+import { randomUUID as uuid } from 'crypto';
 import { uniqWith } from 'lodash';
 
-interface JellyfinSyncStatus extends StatusBase {
+const BUNDLE_SIZE = 20;
+const UPDATE_RATE = 4 * 1000;
+
+interface SyncStatus {
+  running: boolean;
+  progress: number;
+  total: number;
   currentLibrary: Library;
   libraries: Library[];
 }
 
-class JellyfinScanner
-  extends BaseScanner<JellyfinLibraryItem>
-  implements RunnableScanner<JellyfinSyncStatus>
-{
+class JellyfinScanner {
+  private sessionId: string;
+  private tmdb: TheMovieDb;
   private jfClient: JellyfinAPI;
+  private items: JellyfinLibraryItem[] = [];
+  private progress = 0;
   private libraries: Library[];
   private currentLibrary: Library;
+  private running = false;
   private isRecentOnly = false;
+  private enable4kMovie = false;
+  private enable4kShow = false;
+  private asyncLock = new AsyncLock();
   private processedAnidbSeason: Map<number, Map<number, number>>;
 
   constructor({ isRecentOnly }: { isRecentOnly?: boolean } = {}) {
-    super('Jellyfin Sync');
+    this.tmdb = new TheMovieDb();
+
     this.isRecentOnly = isRecentOnly ?? false;
   }
 
-  private async extractMovieIds(jellyfinitem: JellyfinLibraryItem): Promise<{
-    tmdbId: number;
-    imdbId?: string;
-    metadata: JellyfinLibraryItemExtended;
-  } | null> {
-    let metadata = await this.jfClient.getItemData(jellyfinitem.Id);
+  private async getExisting(tmdbId: number, mediaType: MediaType) {
+    const mediaRepository = getRepository(Media);
 
-    if (!metadata?.Id) {
-      this.log('No Id metadata for this title. Skipping', 'debug', {
-        jellyfinItemId: jellyfinitem.Id,
-      });
-      return null;
-    }
+    const existing = await mediaRepository.findOne({
+      where: { tmdbId: tmdbId, mediaType },
+    });
 
-    const anidbId = Number(metadata.ProviderIds.AniDB ?? null);
-    let tmdbId = Number(metadata.ProviderIds.Tmdb ?? null);
-    let imdbId = metadata.ProviderIds.Imdb;
-
-    // We use anidb only if we have the anidbId and nothing else
-    if (anidbId && !imdbId && !tmdbId) {
-      const result = animeList.getFromAnidbId(anidbId);
-      tmdbId = Number(result?.tmdbId ?? null);
-      imdbId = result?.imdbId;
-    }
-
-    if (imdbId && !tmdbId) {
-      const tmdbMovie = await this.tmdb.getMediaByImdbId({
-        imdbId: imdbId,
-      });
-      tmdbId = tmdbMovie.id;
-    }
-
-    if (!tmdbId) {
-      throw new Error('Unable to find TMDb ID');
-    }
-
-    // With AniDB we can have mixed libraries with movies in a "show" library
-    // We take the first episode of the first season (the movie) and use it to
-    // get more information, like the MediaSource
-    if (anidbId && metadata.Type === 'Series') {
-      const season = (await this.jfClient.getSeasons(jellyfinitem.Id)).find(
-        (md) => {
-          return md.IndexNumber === 1;
-        }
-      );
-      if (!season) {
-        this.log('No season found for anidb movie', 'debug', {
-          jellyfinitem,
-        });
-        return null;
-      }
-      const episodes = await this.jfClient.getEpisodes(
-        jellyfinitem.Id,
-        season.Id
-      );
-      if (!episodes[0]) {
-        this.log('No episode found for anidb movie', 'debug', {
-          jellyfinitem,
-        });
-        return null;
-      }
-      metadata = await this.jfClient.getItemData(episodes[0].Id);
-      if (!metadata) {
-        this.log('No metadata found for anidb movie', 'debug', {
-          jellyfinitem,
-        });
-        return null;
-      }
-    }
-
-    return { tmdbId, imdbId, metadata };
+    return existing;
   }
 
-  private async processJellyfinMovie(jellyfinitem: JellyfinLibraryItem) {
-    try {
-      const extracted = await this.extractMovieIds(jellyfinitem);
-      if (!extracted) return;
+  private async processMovie(jellyfinitem: JellyfinLibraryItem) {
+    const mediaRepository = getRepository(Media);
 
-      const { tmdbId, imdbId, metadata } = extracted;
+    try {
+      let metadata = await this.jfClient.getItemData(jellyfinitem.Id);
+      const newMedia = new Media();
+
+      if (!metadata?.Id) {
+        logger.debug('No Id metadata for this title. Skipping', {
+          label: 'Jellyfin Sync',
+          jellyfinItemId: jellyfinitem.Id,
+        });
+        return;
+      }
+
+      const anidbId = Number(metadata.ProviderIds.AniDB ?? null);
+
+      newMedia.tmdbId = Number(metadata.ProviderIds.Tmdb ?? null);
+      newMedia.imdbId = metadata.ProviderIds.Imdb;
+
+      // We use anidb only if we have the anidbId and nothing else
+      if (anidbId && !newMedia.imdbId && !newMedia.tmdbId) {
+        const result = animeList.getFromAnidbId(anidbId);
+        newMedia.tmdbId = Number(result?.tmdbId ?? null);
+        newMedia.imdbId = result?.imdbId;
+      }
+
+      if (newMedia.imdbId && !isNaN(newMedia.tmdbId)) {
+        const tmdbMovie = await this.tmdb.getMediaByImdbId({
+          imdbId: newMedia.imdbId,
+        });
+        newMedia.tmdbId = tmdbMovie.id;
+      }
+      if (!newMedia.tmdbId) {
+        throw new Error('Unable to find TMDb ID');
+      }
+
+      // With AniDB we can have mixed libraries with movies in a "show" library
+      // We take the first episode of the first season (the movie) and use it to
+      // get more information, like the MediaSource
+      if (anidbId && metadata.Type === 'Series') {
+        const season = (await this.jfClient.getSeasons(jellyfinitem.Id)).find(
+          (md) => {
+            return md.IndexNumber === 1;
+          }
+        );
+        if (!season) {
+          this.log('No season found for anidb movie', 'debug', {
+            jellyfinitem,
+          });
+          return;
+        }
+        const episodes = await this.jfClient.getEpisodes(
+          jellyfinitem.Id,
+          season.Id
+        );
+        if (!episodes[0]) {
+          this.log('No episode found for anidb movie', 'debug', {
+            jellyfinitem,
+          });
+          return;
+        }
+        metadata = await this.jfClient.getItemData(episodes[0].Id);
+        if (!metadata) {
+          this.log('No metadata found for anidb movie', 'debug', {
+            jellyfinitem,
+          });
+          return;
+        }
+      }
 
       const has4k = metadata.MediaSources?.some((MediaSource) => {
         return MediaSource.MediaStreams.filter(
@@ -141,29 +151,93 @@ class JellyfinScanner
         });
       });
 
-      const mediaAddedAt = metadata.DateCreated
-        ? new Date(metadata.DateCreated)
-        : undefined;
+      await this.asyncLock.dispatch(newMedia.tmdbId, async () => {
+        if (!metadata) {
+          // this will never execute, but typescript thinks somebody could reset tvShow from
+          // outer scope back to null before this async gets called
+          return;
+        }
 
-      if (hasOtherResolution || (!this.enable4kMovie && has4k)) {
-        await this.processMovie(tmdbId, {
-          is4k: false,
-          mediaAddedAt,
-          jellyfinMediaId: metadata.Id,
-          imdbId,
-          title: metadata.Name,
-        });
-      }
+        const existing = await this.getExisting(
+          newMedia.tmdbId,
+          MediaType.MOVIE
+        );
 
-      if (has4k && this.enable4kMovie) {
-        await this.processMovie(tmdbId, {
-          is4k: true,
-          mediaAddedAt,
-          jellyfinMediaId: metadata.Id,
-          imdbId,
-          title: metadata.Name,
-        });
-      }
+        if (existing) {
+          let changedExisting = false;
+
+          if (
+            (hasOtherResolution || (!this.enable4kMovie && has4k)) &&
+            existing.status !== MediaStatus.AVAILABLE
+          ) {
+            existing.status = MediaStatus.AVAILABLE;
+            existing.mediaAddedAt = new Date(metadata.DateCreated ?? '');
+            changedExisting = true;
+          }
+
+          if (
+            has4k &&
+            this.enable4kMovie &&
+            existing.status4k !== MediaStatus.AVAILABLE
+          ) {
+            existing.status4k = MediaStatus.AVAILABLE;
+            changedExisting = true;
+          }
+
+          if (!existing.mediaAddedAt && !changedExisting) {
+            existing.mediaAddedAt = new Date(metadata.DateCreated ?? '');
+            changedExisting = true;
+          }
+
+          if (
+            (hasOtherResolution || (has4k && !this.enable4kMovie)) &&
+            existing.jellyfinMediaId !== metadata.Id
+          ) {
+            existing.jellyfinMediaId = metadata.Id;
+            changedExisting = true;
+          }
+
+          if (
+            has4k &&
+            this.enable4kMovie &&
+            existing.jellyfinMediaId4k !== metadata.Id
+          ) {
+            existing.jellyfinMediaId4k = metadata.Id;
+            changedExisting = true;
+          }
+
+          if (changedExisting) {
+            await mediaRepository.save(existing);
+            this.log(
+              `Request for ${metadata.Name} exists. New media types set to AVAILABLE`,
+              'info'
+            );
+          } else {
+            this.log(
+              `Title already exists and no new media types found ${metadata.Name}`
+            );
+          }
+        } else {
+          newMedia.status =
+            hasOtherResolution || (!this.enable4kMovie && has4k)
+              ? MediaStatus.AVAILABLE
+              : MediaStatus.UNKNOWN;
+          newMedia.status4k =
+            has4k && this.enable4kMovie
+              ? MediaStatus.AVAILABLE
+              : MediaStatus.UNKNOWN;
+          newMedia.mediaType = MediaType.MOVIE;
+          newMedia.mediaAddedAt = new Date(metadata.DateCreated ?? '');
+          newMedia.jellyfinMediaId =
+            hasOtherResolution || (!this.enable4kMovie && has4k)
+              ? metadata.Id
+              : null;
+          newMedia.jellyfinMediaId4k =
+            has4k && this.enable4kMovie ? metadata.Id : null;
+          await mediaRepository.save(newMedia);
+          this.log(`Saved ${metadata.Name}`);
+        }
+      });
     } catch (e) {
       this.log(
         `Failed to process Jellyfin item, id: ${jellyfinitem.Id}`,
@@ -212,7 +286,9 @@ class JellyfinScanner
     return tvShow;
   }
 
-  private async processJellyfinShow(jellyfinitem: JellyfinLibraryItem) {
+  private async processShow(jellyfinitem: JellyfinLibraryItem) {
+    const mediaRepository = getRepository(Media);
+
     let tvShow: TmdbTvDetails | null = null;
 
     try {
@@ -221,7 +297,8 @@ class JellyfinScanner
       const metadata = await this.jfClient.getItemData(Id);
 
       if (!metadata?.Id) {
-        this.log('No Id metadata for this title. Skipping', 'debug', {
+        logger.debug('No Id metadata for this title. Skipping', {
+          label: 'Jellyfin Sync',
           jellyfinItemId: jellyfinitem.Id,
         });
         return;
@@ -238,7 +315,6 @@ class JellyfinScanner
           });
         }
       }
-
       if (!tvShow && metadata.ProviderIds.Tvdb) {
         try {
           tvShow = await this.getTvShow({
@@ -250,7 +326,6 @@ class JellyfinScanner
           });
         }
       }
-
       let tvdbSeasonFromAnidb: number | undefined;
       if (!tvShow && metadata.ProviderIds.AniDB) {
         const anidbId = Number(metadata.ProviderIds.AniDB);
@@ -269,49 +344,71 @@ class JellyfinScanner
         }
         // With AniDB we can have mixed libraries with movies in a "show" library
         else if (result?.imdbId || result?.tmdbId) {
-          await this.processJellyfinMovie(jellyfinitem);
+          await this.processMovie(jellyfinitem);
           return;
         }
       }
 
       if (tvShow) {
-        const seasons = tvShow.seasons;
-        const jellyfinSeasons = await this.jfClient.getSeasons(Id);
+        await this.asyncLock.dispatch(tvShow.id, async () => {
+          if (!tvShow) {
+            // this will never execute, but typescript thinks somebody could reset tvShow from
+            // outer scope back to null before this async gets called
+            return;
+          }
 
-        const processableSeasons: ProcessableSeason[] = [];
+          // Lets get the available seasons from Jellyfin
+          const seasons = tvShow.seasons;
+          const media = await this.getExisting(tvShow.id, MediaType.TV);
 
-        const settings = getSettings();
-        const filteredSeasons = settings.main.enableSpecialEpisodes
-          ? seasons
-          : seasons.filter((sn) => sn.season_number !== 0);
+          const newSeasons: Season[] = [];
 
-        for (const season of filteredSeasons) {
-          const matchedJellyfinSeason = jellyfinSeasons.find((md) => {
-            if (tvdbSeasonFromAnidb) {
-              // In AniDB we don't have the concept of seasons,
-              // we have multiple shows with only Season 1 (and sometimes a season with index 0 for specials).
-              // We use tvdbSeasonFromAnidb to check if we are on the correct TMDB season and
-              // md.IndexNumber === 1 to be sure to find the correct season on jellyfin
-              return (
-                tvdbSeasonFromAnidb === season.season_number &&
-                md.IndexNumber === 1
-              );
-            } else {
-              return Number(md.IndexNumber) === season.season_number;
-            }
-          });
+          const currentStandardSeasonAvailable = (
+            media?.seasons.filter(
+              (season) => season.status === MediaStatus.AVAILABLE
+            ) ?? []
+          ).length;
+          const current4kSeasonAvailable = (
+            media?.seasons.filter(
+              (season) => season.status4k === MediaStatus.AVAILABLE
+            ) ?? []
+          ).length;
 
-          // Check if we found the matching season and it has all the available episodes
-          if (matchedJellyfinSeason) {
-            let totalStandard = 0;
-            let total4k = 0;
+          for (const season of seasons) {
+            const JellyfinSeasons = await this.jfClient.getSeasons(Id);
+            const matchedJellyfinSeason = JellyfinSeasons.find((md) => {
+              if (tvdbSeasonFromAnidb) {
+                // In AniDB we don't have the concept of seasons,
+                // we have multiple shows with only Season 1 (and sometimes a season with index 0 for specials).
+                // We use tvdbSeasonFromAnidb to check if we are on the correct TMDB season and
+                // md.IndexNumber === 1 to be sure to find the correct season on jellyfin
+                return (
+                  tvdbSeasonFromAnidb === season.season_number &&
+                  md.IndexNumber === 1
+                );
+              } else {
+                return Number(md.IndexNumber) === season.season_number;
+              }
+            });
 
-            if (!this.enable4kShow) {
+            const existingSeason = media?.seasons.find(
+              (es) => es.seasonNumber === season.season_number
+            );
+
+            // Check if we found the matching season and it has all the available episodes
+            if (matchedJellyfinSeason) {
+              // If we have a matched Jellyfin season, get its children metadata so we can check details
               const episodes = await this.jfClient.getEpisodes(
                 Id,
                 matchedJellyfinSeason.Id
               );
 
+              //Get count of episodes that are HD and 4K
+              let totalStandard = 0;
+              let total4k = 0;
+
+              //use for loop to make sure this loop _completes_ in full
+              //before the next section
               for (const episode of episodes) {
                 let episodeCount = 1;
 
@@ -324,94 +421,238 @@ class JellyfinScanner
                     episode.IndexNumberEnd - episode.IndexNumber + 1;
                 }
 
-                totalStandard += episodeCount;
-              }
-            } else {
-              // 4K detection enabled - request media info to check resolution
-              const episodes = await this.jfClient.getEpisodes(
-                Id,
-                matchedJellyfinSeason.Id,
-                { includeMediaInfo: true }
-              );
+                if (!this.enable4kShow) {
+                  totalStandard += episodeCount;
+                } else {
+                  const ExtendedEpisodeData = await this.jfClient.getItemData(
+                    episode.Id
+                  );
 
-              for (const episode of episodes) {
-                let episodeCount = 1;
-
-                // count number of combined episodes
-                if (
-                  episode.IndexNumber !== undefined &&
-                  episode.IndexNumberEnd !== undefined
-                ) {
-                  episodeCount =
-                    episode.IndexNumberEnd - episode.IndexNumber + 1;
+                  ExtendedEpisodeData?.MediaSources?.some((MediaSource) => {
+                    return MediaSource.MediaStreams.some((MediaStream) => {
+                      if (MediaStream.Type === 'Video') {
+                        if ((MediaStream.Width ?? 0) >= 2000) {
+                          total4k += episodeCount;
+                        } else {
+                          totalStandard += episodeCount;
+                        }
+                      }
+                    });
+                  });
                 }
-
-                const has4k = episode.MediaSources?.some((MediaSource) =>
-                  MediaSource.MediaStreams.some(
-                    (MediaStream) =>
-                      MediaStream.Type === 'Video' &&
-                      (MediaStream.Width ?? 0) > 2000
-                  )
-                );
-
-                const hasStandard = episode.MediaSources?.some((MediaSource) =>
-                  MediaSource.MediaStreams.some(
-                    (MediaStream) =>
-                      MediaStream.Type === 'Video' &&
-                      (MediaStream.Width ?? 0) <= 2000
-                  )
-                );
-
-                // Count in both if episode has both versions
-                // TODO: Make this more robust in the future
-                // Currently, this detection is based solely on file resolution, not which
-                // Radarr/Sonarr instance the file came from. If a 4K request results in
-                // 1080p files (no 4K release available yet), those files will be counted
-                // as "standard" even though they're in the 4K library. This can cause
-                // non-4K users to see content as "available" when they can't access it.
-                // See issue https://github.com/seerr-team/seerr/issues/1744 for details.
-                if (hasStandard) totalStandard += episodeCount;
-                if (has4k) total4k += episodeCount;
               }
-            }
 
-            // With AniDB we can have multiple shows for one season, so we need to save
-            // the episode from all the jellyfin entries to get the total
-            if (tvdbSeasonFromAnidb) {
-              let show = this.processedAnidbSeason.get(tvShow.id);
+              // With AniDB we can have multiple shows for one season, so we need to save
+              // the episode from all the jellyfin entries to get the total
+              if (tvdbSeasonFromAnidb) {
+                if (this.processedAnidbSeason.has(tvShow.id)) {
+                  const show = this.processedAnidbSeason.get(tvShow.id)!;
+                  if (show.has(season.season_number)) {
+                    show.set(
+                      season.season_number,
+                      show.get(season.season_number)! + totalStandard
+                    );
 
-              if (!show) {
-                show = new Map([[season.season_number, totalStandard]]);
-                this.processedAnidbSeason.set(tvShow.id, show);
+                    totalStandard = show.get(season.season_number)!;
+                  } else {
+                    show.set(season.season_number, totalStandard);
+                  }
+                } else {
+                  this.processedAnidbSeason.set(
+                    tvShow.id,
+                    new Map([[season.season_number, totalStandard]])
+                  );
+                }
+              }
+
+              if (
+                media &&
+                (totalStandard > 0 || (total4k > 0 && !this.enable4kShow)) &&
+                media.jellyfinMediaId !== Id
+              ) {
+                media.jellyfinMediaId = Id;
+              }
+
+              if (
+                media &&
+                total4k > 0 &&
+                this.enable4kShow &&
+                media.jellyfinMediaId4k !== Id
+              ) {
+                media.jellyfinMediaId4k = Id;
+              }
+
+              if (existingSeason) {
+                // These ternary statements look super confusing, but they are simply
+                // setting the status to AVAILABLE if all of a type is there, partially if some,
+                // and then not modifying the status if there are 0 items
+                existingSeason.status =
+                  totalStandard >= season.episode_count ||
+                  existingSeason.status === MediaStatus.AVAILABLE
+                    ? MediaStatus.AVAILABLE
+                    : totalStandard > 0
+                    ? MediaStatus.PARTIALLY_AVAILABLE
+                    : existingSeason.status;
+                existingSeason.status4k =
+                  (this.enable4kShow && total4k >= season.episode_count) ||
+                  existingSeason.status4k === MediaStatus.AVAILABLE
+                    ? MediaStatus.AVAILABLE
+                    : this.enable4kShow && total4k > 0
+                    ? MediaStatus.PARTIALLY_AVAILABLE
+                    : existingSeason.status4k;
               } else {
-                const currentCount = show.get(season.season_number) ?? 0;
-                const newCount = currentCount + totalStandard;
-                show.set(season.season_number, newCount);
-                totalStandard = newCount;
+                newSeasons.push(
+                  new Season({
+                    seasonNumber: season.season_number,
+                    // This ternary is the same as the ones above, but it just falls back to "UNKNOWN"
+                    // if we dont have any items for the season
+                    status:
+                      totalStandard >= season.episode_count
+                        ? MediaStatus.AVAILABLE
+                        : totalStandard > 0
+                        ? MediaStatus.PARTIALLY_AVAILABLE
+                        : MediaStatus.UNKNOWN,
+                    status4k:
+                      this.enable4kShow && total4k >= season.episode_count
+                        ? MediaStatus.AVAILABLE
+                        : this.enable4kShow && total4k > 0
+                        ? MediaStatus.PARTIALLY_AVAILABLE
+                        : MediaStatus.UNKNOWN,
+                  })
+                );
               }
             }
+          }
 
-            processableSeasons.push({
-              seasonNumber: season.season_number,
-              totalEpisodes: season.episode_count,
-              episodes: totalStandard,
-              episodes4k: total4k,
+          // Remove extras season. We dont count it for determining availability
+          const filteredSeasons = tvShow.seasons.filter(
+            (season) => season.season_number !== 0
+          );
+
+          const isAllStandardSeasons =
+            newSeasons.filter(
+              (season) => season.status === MediaStatus.AVAILABLE
+            ).length +
+              (media?.seasons.filter(
+                (season) => season.status === MediaStatus.AVAILABLE
+              ).length ?? 0) >=
+            filteredSeasons.length;
+
+          const isAll4kSeasons =
+            newSeasons.filter(
+              (season) => season.status4k === MediaStatus.AVAILABLE
+            ).length +
+              (media?.seasons.filter(
+                (season) => season.status4k === MediaStatus.AVAILABLE
+              ).length ?? 0) >=
+            filteredSeasons.length;
+
+          if (media) {
+            // Update existing
+            media.seasons = [...media.seasons, ...newSeasons];
+
+            const newStandardSeasonAvailable = (
+              media.seasons.filter(
+                (season) => season.status === MediaStatus.AVAILABLE
+              ) ?? []
+            ).length;
+
+            const new4kSeasonAvailable = (
+              media.seasons.filter(
+                (season) => season.status4k === MediaStatus.AVAILABLE
+              ) ?? []
+            ).length;
+
+            // If at least one new season has become available, update
+            // the lastSeasonChange field so we can trigger notifications
+            if (newStandardSeasonAvailable > currentStandardSeasonAvailable) {
+              this.log(
+                `Detected ${
+                  newStandardSeasonAvailable - currentStandardSeasonAvailable
+                } new standard season(s) for ${tvShow.name}`,
+                'debug'
+              );
+              media.lastSeasonChange = new Date();
+              media.mediaAddedAt = new Date(metadata.DateCreated ?? '');
+            }
+
+            if (new4kSeasonAvailable > current4kSeasonAvailable) {
+              this.log(
+                `Detected ${
+                  new4kSeasonAvailable - current4kSeasonAvailable
+                } new 4K season(s) for ${tvShow.name}`,
+                'debug'
+              );
+              media.lastSeasonChange = new Date();
+            }
+
+            if (!media.mediaAddedAt) {
+              media.mediaAddedAt = new Date(metadata.DateCreated ?? '');
+            }
+
+            // If the show is already available, and there are no new seasons, dont adjust
+            // the status
+            const shouldStayAvailable =
+              media.status === MediaStatus.AVAILABLE &&
+              newSeasons.filter(
+                (season) => season.status !== MediaStatus.UNKNOWN
+              ).length === 0;
+            const shouldStayAvailable4k =
+              media.status4k === MediaStatus.AVAILABLE &&
+              newSeasons.filter(
+                (season) => season.status4k !== MediaStatus.UNKNOWN
+              ).length === 0;
+
+            media.status =
+              isAllStandardSeasons || shouldStayAvailable
+                ? MediaStatus.AVAILABLE
+                : media.seasons.some(
+                    (season) => season.status !== MediaStatus.UNKNOWN
+                  )
+                ? MediaStatus.PARTIALLY_AVAILABLE
+                : MediaStatus.UNKNOWN;
+            media.status4k =
+              (isAll4kSeasons || shouldStayAvailable4k) && this.enable4kShow
+                ? MediaStatus.AVAILABLE
+                : this.enable4kShow &&
+                  media.seasons.some(
+                    (season) => season.status4k !== MediaStatus.UNKNOWN
+                  )
+                ? MediaStatus.PARTIALLY_AVAILABLE
+                : MediaStatus.UNKNOWN;
+            await mediaRepository.save(media);
+            this.log(`Updating existing title: ${tvShow.name}`);
+          } else {
+            const newMedia = new Media({
+              mediaType: MediaType.TV,
+              seasons: newSeasons,
+              tmdbId: tvShow.id,
+              tvdbId: tvShow.external_ids.tvdb_id,
+              mediaAddedAt: new Date(metadata.DateCreated ?? ''),
+              jellyfinMediaId: isAllStandardSeasons ? Id : null,
+              jellyfinMediaId4k:
+                isAll4kSeasons && this.enable4kShow ? Id : null,
+              status: isAllStandardSeasons
+                ? MediaStatus.AVAILABLE
+                : newSeasons.some(
+                    (season) => season.status !== MediaStatus.UNKNOWN
+                  )
+                ? MediaStatus.PARTIALLY_AVAILABLE
+                : MediaStatus.UNKNOWN,
+              status4k:
+                isAll4kSeasons && this.enable4kShow
+                  ? MediaStatus.AVAILABLE
+                  : this.enable4kShow &&
+                    newSeasons.some(
+                      (season) => season.status4k !== MediaStatus.UNKNOWN
+                    )
+                  ? MediaStatus.PARTIALLY_AVAILABLE
+                  : MediaStatus.UNKNOWN,
             });
+            await mediaRepository.save(newMedia);
+            this.log(`Saved ${tvShow.name}`);
           }
-        }
-
-        await this.processShow(
-          tvShow.id,
-          tvShow.external_ids?.tvdb_id,
-          processableSeasons,
-          {
-            mediaAddedAt: metadata.DateCreated
-              ? new Date(metadata.DateCreated)
-              : undefined,
-            jellyfinMediaId: Id,
-            title: tvShow.name,
-          }
-        );
+        });
       } else {
         this.log(
           `No information found for the show: ${metadata.Name}`,
@@ -427,17 +668,70 @@ class JellyfinScanner
           jellyfinitem.SeriesId ?? jellyfinitem.SeasonId ?? jellyfinitem.Id
         }`,
         'error',
-        { errorMessage: e.message, jellyfinitem }
+        {
+          errorMessage: e.message,
+          jellyfinitem,
+        }
       );
     }
   }
 
-  private async processItem(item: JellyfinLibraryItem): Promise<void> {
-    if (item.Type === 'Movie') {
-      await this.processJellyfinMovie(item);
-    } else if (item.Type === 'Series') {
-      await this.processJellyfinShow(item);
+  private async processItems(slicedItems: JellyfinLibraryItem[]) {
+    this.processedAnidbSeason = new Map();
+    await Promise.all(
+      slicedItems.map(async (item) => {
+        if (item.Type === 'Movie') {
+          await this.processMovie(item);
+        } else if (item.Type === 'Series') {
+          await this.processShow(item);
+        }
+      })
+    );
+  }
+
+  private async loop({
+    start = 0,
+    end = BUNDLE_SIZE,
+    sessionId,
+  }: {
+    start?: number;
+    end?: number;
+    sessionId?: string;
+  } = {}) {
+    const slicedItems = this.items.slice(start, end);
+
+    if (!this.running) {
+      throw new Error('Sync was aborted.');
     }
+
+    if (this.sessionId !== sessionId) {
+      throw new Error('New session was started. Old session aborted.');
+    }
+
+    if (start < this.items.length) {
+      this.progress = start;
+      await this.processItems(slicedItems);
+
+      await new Promise<void>((resolve, reject) =>
+        setTimeout(() => {
+          this.loop({
+            start: start + BUNDLE_SIZE,
+            end: end + BUNDLE_SIZE,
+            sessionId,
+          })
+            .then(() => resolve())
+            .catch((e) => reject(new Error(e.message)));
+        }, UPDATE_RATE)
+      );
+    }
+  }
+
+  private log(
+    message: string,
+    level: 'info' | 'error' | 'debug' | 'warn' = 'debug',
+    optional?: Record<string, unknown>
+  ): void {
+    logger[level](message, { label: 'Jellyfin Sync', ...optional });
   }
 
   public async run(): Promise<void> {
@@ -450,9 +744,14 @@ class JellyfinScanner
       return;
     }
 
-    const sessionId = this.startRun();
-
+    const sessionId = uuid();
+    this.sessionId = sessionId;
+    logger.info('Jellyfin Sync Starting', {
+      sessionId,
+      label: 'Jellyfin Sync',
+    });
     try {
+      this.running = true;
       const userRepository = getRepository(User);
       const admin = await userRepository.findOne({
         where: { id: 1 },
@@ -478,11 +777,25 @@ class JellyfinScanner
 
       await animeList.sync();
 
+      this.enable4kMovie = settings.radarr.some((radarr) => radarr.is4k);
+      if (this.enable4kMovie) {
+        this.log(
+          'At least one 4K Radarr server was detected. 4K movie detection is now enabled',
+          'info'
+        );
+      }
+
+      this.enable4kShow = settings.sonarr.some((sonarr) => sonarr.is4k);
+      if (this.enable4kShow) {
+        this.log(
+          'At least one 4K Sonarr server was detected. 4K series detection is now enabled',
+          'info'
+        );
+      }
+
       if (this.isRecentOnly) {
         for (const library of this.libraries) {
           this.currentLibrary = library;
-          // Reset AniDB season tracking per library
-          this.processedAnidbSeason = new Map();
           this.log(
             `Beginning to process recently added for library: ${library.name}`,
             'info'
@@ -502,19 +815,16 @@ class JellyfinScanner
             return mediaA.Id === mediaB.Id;
           });
 
-          await this.loop(this.processItem.bind(this), { sessionId });
+          await this.loop({ sessionId });
         }
       } else {
         for (const library of this.libraries) {
           this.currentLibrary = library;
-          // Reset AniDB season tracking per library
-          this.processedAnidbSeason = new Map();
           this.log(`Beginning to process library: ${library.name}`, 'info');
           this.items = await this.jfClient.getLibraryContents(library.id);
-          await this.loop(this.processItem.bind(this), { sessionId });
+          await this.loop({ sessionId });
         }
       }
-
       this.log(
         this.isRecentOnly
           ? 'Recently Added Scan Complete'
@@ -522,13 +832,19 @@ class JellyfinScanner
         'info'
       );
     } catch (e) {
-      this.log('Sync interrupted', 'error', { errorMessage: e.message });
+      logger.error('Sync interrupted', {
+        label: 'Jellyfin Sync',
+        errorMessage: e.message,
+      });
     } finally {
-      this.endRun(sessionId);
+      // If a new scanning session hasnt started, set running back to false
+      if (this.sessionId === sessionId) {
+        this.running = false;
+      }
     }
   }
 
-  public status(): JellyfinSyncStatus {
+  public status(): SyncStatus {
     return {
       running: this.running,
       progress: this.progress,
@@ -537,6 +853,10 @@ class JellyfinScanner
       libraries: this.libraries,
     };
   }
+
+  public cancel(): void {
+    this.running = false;
+  }
 }
 
 export const jellyfinFullScanner = new JellyfinScanner();

server/routes/auth.ts

@@ -626,6 +626,76 @@ authRoutes.post('/local', async (req, res, next) => {
       });
     }
 
+    const mainUser = await userRepository.findOneOrFail({
+      select: { id: true, plexToken: true, plexId: true },
+      where: { id: 1 },
+    });
+    const mainPlexTv = new PlexTvAPI(mainUser.plexToken ?? '');
+
+    if (!user.plexId) {
+      try {
+        const plexUsersResponse = await mainPlexTv.getUsers();
+        const account = plexUsersResponse.MediaContainer.User.find(
+          (account) =>
+            account.$.email &&
+            account.$.email.toLowerCase() === user.email.toLowerCase()
+        )?.$;
+
+        if (
+          account &&
+          (await mainPlexTv.checkUserAccess(parseInt(account.id)))
+        ) {
+          logger.info(
+            'Found matching Plex user; updating user with Plex data',
+            {
+              label: 'API',
+              ip: req.ip,
+              email: body.email,
+              userId: user.id,
+              plexId: account.id,
+              plexUsername: account.username,
+            }
+          );
+
+          user.plexId = parseInt(account.id);
+          user.avatar = account.thumb;
+          user.email = account.email;
+          user.plexUsername = account.username;
+          user.userType = UserType.PLEX;
+
+          await userRepository.save(user);
+        }
+      } catch (e) {
+        logger.error('Something went wrong fetching Plex users', {
+          label: 'API',
+          errorMessage: e.message,
+        });
+      }
+    }
+
+    if (
+      user.plexId &&
+      user.plexId !== mainUser.plexId &&
+      !(await mainPlexTv.checkUserAccess(user.plexId))
+    ) {
+      logger.warn(
+        'Failed sign-in attempt from Plex user without access to the media server',
+        {
+          label: 'API',
+          account: {
+            ip: req.ip,
+            email: body.email,
+            userId: user.id,
+            plexId: user.plexId,
+          },
+        }
+      );
+      return next({
+        status: 403,
+        message: 'Access denied.',
+      });
+    }
+
     // Set logged in session
     if (user && req.session) {
       req.session.userId = user.id;
@@ -705,7 +775,7 @@ authRoutes.post('/logout', async (req, res, next) => {
         });
         return next({ status: 500, message: 'Failed to destroy session.' });
       }
-      logger.debug('Successfully logged out user', {
+      logger.info('Successfully logged out user', {
         label: 'Auth',
         userId,
       });

src/components/Settings/SettingsMetadata.tsx

@@ -320,14 +320,12 @@ const SettingsMetadata = () => {
 
               addToast(intl.formatMessage(messages.metadataSettingsSaved), {
                 appearance: 'success',
-                autoDismiss: true,
               });
             } catch (e) {
               addToast(
                 intl.formatMessage(messages.failedToSaveMetadataSettings),
                 {
                   appearance: 'error',
-                  autoDismiss: true,
                 }
               );
             }
@@ -424,7 +422,6 @@ const SettingsMetadata = () => {
                                 ),
                                 {
                                   appearance: 'success',
-                                  autoDismiss: true,
                                 }
                               );
                             }

src/hooks/useUser.ts

@@ -2,7 +2,6 @@ import { UserType } from '@server/constants/user';
 import type { PermissionCheckOptions } from '@server/lib/permissions';
 import { hasPermission, Permission } from '@server/lib/permissions';
 import type { NotificationAgentKey } from '@server/lib/settings';
-import { useRouter } from 'next/router';
 import type { MutatorCallback } from 'swr';
 import useSWR from 'swr';
 
@@ -57,21 +56,13 @@ export const useUser = ({
   id,
   initialData,
 }: { id?: number; initialData?: User } = {}): UserHookResponse => {
-  const router = useRouter();
-  const isAuthPage = /^\/(login|setup|resetpassword(?:\/|$))/.test(
-    router.pathname
-  );
-
   const {
     data,
     error,
     mutate: revalidate,
   } = useSWR<User>(id ? `/api/v1/user/${id}` : `/api/v1/auth/me`, {
     fallbackData: initialData,
-    refreshInterval: !isAuthPage ? 30000 : 0,
-    revalidateOnFocus: !isAuthPage,
-    revalidateOnMount: !isAuthPage,
-    revalidateOnReconnect: !isAuthPage,
+    refreshInterval: 30000,
     errorRetryInterval: 30000,
     shouldRetryOnError: false,
   });