plexsonic 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plexsonic",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "PlexMusic to OpenSubsonic bridge",
   "main": "./src/index.js",
   "bin": {

package/src/plex.js

@@ -208,6 +208,7 @@ function normalizeLibrarySection(section) {
     id: String(section.key ?? section.id ?? ''),
     title: section.title || section.name || 'Untitled',
     type: section.type || '',
+    scanning: toBool(section.refreshing) || toBool(section.scanning),
     updatedAt: parseTimestamp(section.updatedAt),
     scannedAt: parseTimestamp(section.scannedAt),
     refreshedAt: parseTimestamp(section.refreshedAt),
@@ -629,6 +630,20 @@ export async function listMusicSections({ baseUrl, plexToken }) {
     .filter((section) => section.type === 'artist' || section.type === 'music');
 }
 
+export async function startPlexSectionScan({ baseUrl, plexToken, sectionId, force = true }) {
+  await fetchPms(
+    baseUrl,
+    plexToken,
+    `/library/sections/${encodeURIComponent(sectionId)}/refresh`,
+    {
+      method: 'GET',
+      searchParams: {
+        force: force ? 1 : 0,
+      },
+    },
+  );
+}
+
 export async function listPlexSectionFolder({ baseUrl, plexToken, sectionId, folderPath = null }) {
   const path = folderPath
     ? normalizeSectionFolderPath(folderPath, sectionId)

package/src/server.js

@@ -69,6 +69,7 @@ import {
   searchSectionHubs,
   searchSectionMetadata,
   scrobblePlexItem,
+  startPlexSectionScan,
   updatePlexPlaybackStatus,
 } from './plex.js';
 import { createTokenCipher } from './token-crypto.js';
@@ -933,6 +934,7 @@ function albumAttrs(album, fallbackArtistId = null, fallbackArtistName = null) {
     [album?.parentTitle, fallbackArtistName],
     'Unknown Artist',
   );
+  const genre = firstGenreTag(album) || undefined;
 
   return {
     id: albumId,
@@ -948,6 +950,7 @@ function albumAttrs(album, fallbackArtistId = null, fallbackArtistName = null) {
     duration: durationSeconds(album.duration),
     created: toIsoFromEpochSeconds(album.addedAt),
     year: album.year,
+    genre,
     ...subsonicRatingAttrs(album),
   };
 }
@@ -1051,7 +1054,9 @@ function songAttrs(track, albumTitle = null, albumCoverArt = null, albumMetadata
     [albumCoverArt, track?.parentRatingKey, track?.ratingKey],
     undefined,
   );
-  const genreTags = allGenreTags(track);
+  const albumGenreTags = albumMetadata ? allGenreTags(albumMetadata) : [];
+  const genreTagsRaw = allGenreTags(track);
+  const genreTags = genreTagsRaw.length > 0 ? genreTagsRaw : albumGenreTags;
   const genre = genreTags[0] || undefined;
   const genres = genreTags.length > 0 ? genreTags.join('; ') : undefined;
   const discNumber = parsePositiveInt(track?.parentIndex ?? track?.discNumber, 0) || undefined;
@@ -1689,6 +1694,10 @@ function isAbortError(error) {
   return error?.name === 'AbortError' || error?.code === 'ABORT_ERR';
 }
 
+function isPlexNotFoundError(error) {
+  return String(error?.message || '').includes('(404)');
+}
+
 function safeLower(value) {
   return String(value || '').toLowerCase();
 }
@@ -1983,6 +1992,24 @@ function resolvedGenreTagsForTrack(track, albumGenreTagMap) {
   return Array.isArray(albumTags) ? albumTags : [];
 }
 
+function withResolvedTrackGenres(track, albumGenreTagMap) {
+  const resolvedTags = resolvedGenreTagsForTrack(track, albumGenreTagMap);
+  if (resolvedTags.length === 0) {
+    return track;
+  }
+
+  const currentTags = allGenreTags(track);
+  if (currentTags.length > 0) {
+    return track;
+  }
+
+  return {
+    ...track,
+    Genre: resolvedTags.map((tag) => ({ tag })),
+    genre: resolvedTags.join('; '),
+  };
+}
+
 function firstGenreTag(item) {
   const tags = allGenreTags(item);
   return tags[0] || null;
@@ -2395,12 +2422,21 @@ export async function buildServer(config = loadConfig()) {
   }
 
   async function loadLibraryTracksRaw({ plexState }) {
-    const loaded = await listTracks({
-      baseUrl: plexState.baseUrl,
-      plexToken: plexState.plexToken,
-      sectionId: plexState.musicSectionId,
-    });
-    return sortTracksForLibraryBrowse(loaded);
+    const [tracks, albums] = await Promise.all([
+      listTracks({
+        baseUrl: plexState.baseUrl,
+        plexToken: plexState.plexToken,
+        sectionId: plexState.musicSectionId,
+      }),
+      listAlbums({
+        baseUrl: plexState.baseUrl,
+        plexToken: plexState.plexToken,
+        sectionId: plexState.musicSectionId,
+      }),
+    ]);
+    const albumGenreTagMap = buildAlbumGenreTagMap(albums);
+    const enrichedTracks = tracks.map((track) => withResolvedTrackGenres(track, albumGenreTagMap));
+    return sortTracksForLibraryBrowse(enrichedTracks);
   }
 
   function getLibraryCollectionLoader(collection, plexState) {
@@ -2867,6 +2903,62 @@ export async function buildServer(config = loadConfig()) {
     return applyRatingOverridesToItems(entry, items, Date.now());
   }
 
+  async function resolveArtistFromCachedLibrary({ accountId, plexState, request, artistId }) {
+    const normalizedArtistId = String(artistId || '').trim();
+    if (!normalizedArtistId) {
+      return null;
+    }
+
+    const [artists, albums, tracks] = await Promise.all([
+      getCachedLibraryArtists({ accountId, plexState, request }),
+      getCachedLibraryAlbums({ accountId, plexState, request }),
+      getCachedLibraryTracks({ accountId, plexState, request }),
+    ]);
+
+    const cachedArtist = artists.find((item) => String(item?.ratingKey || '').trim() === normalizedArtistId) || null;
+    const cachedAlbums = albums.filter((item) => String(item?.parentRatingKey || '').trim() === normalizedArtistId);
+    const artistTracks = tracks.filter((item) => String(item?.grandparentRatingKey || '').trim() === normalizedArtistId);
+
+    if (!cachedArtist && cachedAlbums.length === 0 && artistTracks.length === 0) {
+      return null;
+    }
+
+    const artistName = cachedArtist?.title ||
+      firstNonEmptyText(artistTracks.map((item) => item?.grandparentTitle), `Artist ${normalizedArtistId}`);
+
+    const artist = cachedArtist || {
+      ratingKey: normalizedArtistId,
+      title: artistName,
+      addedAt: artistTracks[0]?.addedAt,
+      updatedAt: artistTracks[0]?.updatedAt,
+    };
+
+    const resolvedAlbums = cachedAlbums.length > 0
+      ? cachedAlbums
+      : deriveAlbumsFromTracks(artistTracks, normalizedArtistId, artistName);
+
+    return {
+      artist,
+      albums: resolvedAlbums,
+    };
+  }
+
+  function scanStatusAttrsFromSection(section, { fallbackScanning = false } = {}) {
+    return {
+      scanning: Boolean(section?.scanning ?? fallbackScanning),
+      count: parseNonNegativeInt(section?.leafCount, 0),
+    };
+  }
+
+  async function getMusicSectionScanStatus(plexState) {
+    const sections = await listMusicSections({
+      baseUrl: plexState.baseUrl,
+      plexToken: plexState.plexToken,
+    });
+    const section = sections.find((item) => String(item?.id || '') === String(plexState.musicSectionId || ''));
+    return section || null;
+  }
+
   function beginSearchRequest(request, accountId) {
     const clientName =
       getRequestParam(request, 'c') ||
@@ -3848,13 +3940,22 @@ export async function buildServer(config = loadConfig()) {
       return;
     }
 
-    return sendSubsonicOk(
-      reply,
-      emptyNode('scanStatus', {
-        scanning: false,
-        count: 0,
-      }),
-    );
+    const context = repo.getAccountPlexContext(account.id);
+    const plexState = requiredPlexStateForSubsonic(reply, context, tokenCipher);
+    if (!plexState) {
+      return;
+    }
+
+    try {
+      const section = await getMusicSectionScanStatus(plexState);
+      return sendSubsonicOk(
+        reply,
+        emptyNode('scanStatus', scanStatusAttrsFromSection(section)),
+      );
+    } catch (error) {
+      request.log.error(error, 'Failed to load scan status from Plex');
+      return sendSubsonicError(reply, 10, 'Failed to load scan status');
+    }
   });
 
   app.get('/rest/startScan.view', async (request, reply) => {
@@ -3863,13 +3964,31 @@ export async function buildServer(config = loadConfig()) {
       return;
     }
 
-    return sendSubsonicOk(
-      reply,
-      emptyNode('scanStatus', {
-        scanning: false,
-        count: 0,
-      }),
-    );
+    const context = repo.getAccountPlexContext(account.id);
+    const plexState = requiredPlexStateForSubsonic(reply, context, tokenCipher);
+    if (!plexState) {
+      return;
+    }
+
+    try {
+      await startPlexSectionScan({
+        baseUrl: plexState.baseUrl,
+        plexToken: plexState.plexToken,
+        sectionId: plexState.musicSectionId,
+        force: true,
+      });
+
+      markSearchBrowseCacheDirty(searchBrowseCacheKey(account.id, plexState));
+
+      const section = await getMusicSectionScanStatus(plexState);
+      return sendSubsonicOk(
+        reply,
+        emptyNode('scanStatus', scanStatusAttrsFromSection(section, { fallbackScanning: true })),
+      );
+    } catch (error) {
+      request.log.error(error, 'Failed to trigger Plex scan');
+      return sendSubsonicError(reply, 10, 'Failed to trigger scan');
+    }
   });
 
   app.get('/rest/getStarred.view', async (request, reply) => {
@@ -4073,7 +4192,8 @@ export async function buildServer(config = loadConfig()) {
         );
 
         const sortedSongs = sortTracksForLibraryBrowse(matchedSongs);
-        const page = takePage(sortedSongs, offset, count);
+        const page = takePage(sortedSongs, offset, count)
+          .map((track) => withResolvedTrackGenres(track, albumGenreTagMap));
         const songXml = page.map((track) => emptyNode('song', songAttrs(track))).join('');
         return sendSubsonicOk(reply, node('songsByGenre', {}, songXml));
       } catch (error) {
@@ -4337,7 +4457,7 @@ export async function buildServer(config = loadConfig()) {
     }
 
     try {
-      const track = await getTrack({
+      let track = await getTrack({
         baseUrl: plexState.baseUrl,
         plexToken: plexState.plexToken,
         trackId: id,
@@ -4345,6 +4465,25 @@ export async function buildServer(config = loadConfig()) {
       if (!track) {
         return sendSubsonicError(reply, 70, 'Song not found');
       }
+
+      if (!firstGenreTag(track)) {
+        const albumId = String(track?.parentRatingKey || '').trim();
+        if (albumId) {
+          try {
+            const album = await getAlbum({
+              baseUrl: plexState.baseUrl,
+              plexToken: plexState.plexToken,
+              albumId,
+            });
+            if (album) {
+              const albumGenreTagMap = buildAlbumGenreTagMap([album]);
+              track = withResolvedTrackGenres(track, albumGenreTagMap);
+            }
+          } catch (error) {
+            request.log.debug(error, 'Failed to enrich song genre from album metadata');
+          }
+        }
+      }
       applyCachedRatingOverridesForAccount({ accountId: account.id, plexState, items: [track] });
 
       return sendSubsonicOk(reply, node('song', songAttrs(track)));
@@ -5651,32 +5790,51 @@ export async function buildServer(config = loadConfig()) {
     }
 
     try {
-      const artist = await getArtist({
-        baseUrl: plexState.baseUrl,
-        plexToken: plexState.plexToken,
-        artistId,
-      });
+      let artist = null;
+      let finalAlbums = [];
 
-      if (!artist) {
-        return sendSubsonicError(reply, 70, 'Artist not found');
+      try {
+        artist = await getArtist({
+          baseUrl: plexState.baseUrl,
+          plexToken: plexState.plexToken,
+          artistId,
+        });
+      } catch (error) {
+        if (!isPlexNotFoundError(error)) {
+          throw error;
+        }
       }
-      applyCachedRatingOverridesForAccount({ accountId: account.id, plexState, items: [artist] });
 
-      const albums = await listArtistAlbums({
-        baseUrl: plexState.baseUrl,
-        plexToken: plexState.plexToken,
-        artistId,
-      });
-      applyCachedRatingOverridesForAccount({ accountId: account.id, plexState, items: albums });
-
-      let finalAlbums = albums;
-      if (finalAlbums.length === 0) {
-        const tracks = await listArtistTracks({
+      if (artist) {
+        applyCachedRatingOverridesForAccount({ accountId: account.id, plexState, items: [artist] });
+        const albums = await listArtistAlbums({
           baseUrl: plexState.baseUrl,
           plexToken: plexState.plexToken,
           artistId,
         });
-        finalAlbums = deriveAlbumsFromTracks(tracks, artist.ratingKey, artist.title);
+        applyCachedRatingOverridesForAccount({ accountId: account.id, plexState, items: albums });
+        finalAlbums = albums;
+        if (finalAlbums.length === 0) {
+          const tracks = await listArtistTracks({
+            baseUrl: plexState.baseUrl,
+            plexToken: plexState.plexToken,
+            artistId,
+          });
+          applyCachedRatingOverridesForAccount({ accountId: account.id, plexState, items: tracks });
+          finalAlbums = deriveAlbumsFromTracks(tracks, artist.ratingKey, artist.title);
+        }
+      } else {
+        const fallback = await resolveArtistFromCachedLibrary({
+          accountId: account.id,
+          plexState,
+          request,
+          artistId,
+        });
+        if (!fallback?.artist) {
+          return sendSubsonicError(reply, 70, 'Artist not found');
+        }
+        artist = fallback.artist;
+        finalAlbums = fallback.albums || [];
       }
 
       const albumXml = finalAlbums
@@ -5882,11 +6040,18 @@ export async function buildServer(config = loadConfig()) {
         );
       }
 
-      const artist = await getArtist({
-        baseUrl: plexState.baseUrl,
-        plexToken: plexState.plexToken,
-        artistId: id,
-      });
+      let artist = null;
+      try {
+        artist = await getArtist({
+          baseUrl: plexState.baseUrl,
+          plexToken: plexState.plexToken,
+          artistId: id,
+        });
+      } catch (error) {
+        if (!isPlexNotFoundError(error)) {
+          throw error;
+        }
+      }
 
       if (artist) {
         applyCachedRatingOverridesForAccount({ accountId: account.id, plexState, items: [artist] });
@@ -5925,6 +6090,34 @@ export async function buildServer(config = loadConfig()) {
         );
       }
 
+      if (!artist) {
+        const fallback = await resolveArtistFromCachedLibrary({
+          accountId: account.id,
+          plexState,
+          request,
+          artistId: id,
+        });
+        if (fallback?.artist) {
+          const fallbackAlbums = fallback.albums || [];
+          const children = fallbackAlbums
+            .map((album) => emptyNode('child', albumAttrs(album, fallback.artist.ratingKey, fallback.artist.title)))
+            .join('');
+
+          return sendSubsonicOk(
+            reply,
+            node(
+              'directory',
+              {
+                id: fallback.artist.ratingKey,
+                parent: rootDirectoryId,
+                name: fallback.artist.title,
+              },
+              children,
+            ),
+          );
+        }
+      }
+
       const album = await getAlbum({
         baseUrl: plexState.baseUrl,
         plexToken: plexState.plexToken,