plexsonic 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plexsonic",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "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,68 @@ function isAbortError(error) {
   return error?.name === 'AbortError' || error?.code === 'ABORT_ERR';
 }
 
+const RETRYABLE_UPSTREAM_STATUSES = new Set([408, 429, 500, 502, 503, 504]);
+
+function waitMs(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+async function fetchWithRetry({
+  url,
+  options = {},
+  request = null,
+  context = 'upstream request',
+  maxAttempts = 3,
+  baseDelayMs = 200,
+}) {
+  let lastError = null;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      const response = await fetch(url, options);
+      if (!RETRYABLE_UPSTREAM_STATUSES.has(response.status) || attempt >= maxAttempts) {
+        return response;
+      }
+
+      request?.log?.warn(
+        { context, status: response.status, attempt, maxAttempts },
+        'Transient upstream failure, retrying',
+      );
+
+      try {
+        await response.body?.cancel?.();
+      } catch {}
+    } catch (error) {
+      if (isAbortError(error)) {
+        throw error;
+      }
+      lastError = error;
+      if (attempt >= maxAttempts) {
+        throw error;
+      }
+
+      request?.log?.warn(
+        { context, attempt, maxAttempts, message: error?.message || String(error) },
+        'Transient upstream error, retrying',
+      );
+    }
+
+    await waitMs(baseDelayMs * attempt);
+  }
+
+  if (lastError) {
+    throw lastError;
+  }
+
+  throw new Error(`${context} failed after retries`);
+}
+
+function isPlexNotFoundError(error) {
+  return String(error?.message || '').includes('(404)');
+}
+
 function safeLower(value) {
   return String(value || '').toLowerCase();
 }
@@ -1983,6 +2050,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;
@@ -2093,6 +2178,7 @@ function requiredPlexStateForSubsonic(reply, plexContext, tokenCipher) {
     baseUrl: plexContext.server_base_url,
     machineId: plexContext.machine_id,
     musicSectionId: plexContext.music_section_id,
+    musicSectionName: plexContext.music_section_name || null,
     serverName: plexContext.server_name || 'Plex Music',
   };
 }
@@ -2260,11 +2346,13 @@ export async function buildServer(config = loadConfig()) {
   });
 
   const playbackSessions = new Map();
+  const savedPlayQueues = new Map();
   const PLAYBACK_RECONCILE_INTERVAL_MS = 15000;
   const PLAYBACK_IDLE_TIMEOUT_MS = 120000;
   const STREAM_DISCONNECT_STOP_DELAY_MS = 4000;
   const PLAYBACK_MAX_DISCONNECT_WAIT_MS = 30 * 60 * 1000;
   const STREAM_PROGRESS_HEARTBEAT_MS = 10000;
+  const PLAY_QUEUE_IDLE_TTL_MS = 6 * 60 * 60 * 1000;
   const activeSearchRequests = new Map();
   const searchBrowseCache = new Map();
   const SEARCH_BROWSE_REVALIDATE_DEBOUNCE_MS = 15000;
@@ -2395,12 +2483,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) {
@@ -2855,6 +2952,90 @@ export async function buildServer(config = loadConfig()) {
     });
   }
 
+  function pruneSavedPlayQueues(now = Date.now()) {
+    for (const [key, value] of savedPlayQueues.entries()) {
+      if (!value || (now - Number(value.updatedAt || 0)) > PLAY_QUEUE_IDLE_TTL_MS) {
+        savedPlayQueues.delete(key);
+      }
+    }
+  }
+
+  function playQueueClientKey(request) {
+    const rawClient =
+      getRequestParam(request, 'c') ||
+      String(request.headers?.['user-agent'] || '').trim() ||
+      'subsonic-client';
+    return safeLower(rawClient).slice(0, 128) || 'subsonic-client';
+  }
+
+  function playQueueStorageKey(accountId, request) {
+    return `${accountId}:${playQueueClientKey(request)}`;
+  }
+
+  function requestedPlayQueueItemIds(request) {
+    const ids = getRequestParamValues(request, 'id');
+    if (ids.length > 0) {
+      return ids;
+    }
+    return getRequestParamValues(request, 'songId');
+  }
+
+  async function resolveTracksByIdOrder({ accountId, plexState, request, ids }) {
+    const orderedIds = (Array.isArray(ids) ? ids : [])
+      .map((id) => String(id || '').trim())
+      .filter(Boolean);
+    if (orderedIds.length === 0) {
+      return [];
+    }
+
+    const tracks = await getCachedLibraryTracks({ accountId, plexState, request });
+    const cachedById = new Map();
+    for (const track of tracks) {
+      const ratingKey = String(track?.ratingKey || '').trim();
+      if (ratingKey && !cachedById.has(ratingKey)) {
+        cachedById.set(ratingKey, track);
+      }
+    }
+
+    const missingIds = [];
+    for (const id of orderedIds) {
+      if (!cachedById.has(id)) {
+        missingIds.push(id);
+      }
+    }
+
+    if (missingIds.length > 0) {
+      const fetched = await Promise.all(
+        missingIds.map(async (trackId) => {
+          try {
+            const track = await getTrack({
+              baseUrl: plexState.baseUrl,
+              plexToken: plexState.plexToken,
+              trackId,
+            });
+            return track || null;
+          } catch {
+            return null;
+          }
+        }),
+      );
+
+      const nonNullFetched = fetched.filter(Boolean);
+      applyCachedRatingOverridesForAccount({ accountId, plexState, items: nonNullFetched });
+
+      for (const track of nonNullFetched) {
+        const ratingKey = String(track?.ratingKey || '').trim();
+        if (ratingKey && !cachedById.has(ratingKey)) {
+          cachedById.set(ratingKey, track);
+        }
+      }
+    }
+
+    return orderedIds
+      .map((id) => cachedById.get(id))
+      .filter(Boolean);
+  }
+
   function applyCachedRatingOverridesForAccount({ accountId, plexState, items }) {
     if (!Array.isArray(items) || items.length === 0) {
       return 0;
@@ -2867,6 +3048,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') ||
@@ -3797,10 +4034,17 @@ export async function buildServer(config = loadConfig()) {
       return;
     }
 
+    const rawSectionId = String(plexState.musicSectionId || '').trim();
+    const musicFolderId = /^\d+$/.test(rawSectionId) ? Number(rawSectionId) : rawSectionId;
+    const musicFolderName =
+      String(plexState.musicSectionName || '').trim() ||
+      String(plexState.serverName || '').trim() ||
+      'Music';
+
     const inner = node(
       'musicFolders',
       {},
-      emptyNode('musicFolder', { id: plexState.musicSectionId, name: plexState.serverName }),
+      emptyNode('musicFolder', { id: musicFolderId, name: musicFolderName }),
     );
     return sendSubsonicOk(reply, inner);
   });
@@ -3839,7 +4083,67 @@ export async function buildServer(config = loadConfig()) {
       return;
     }
 
-    return sendSubsonicOk(reply, node('nowPlaying'));
+    const context = repo.getAccountPlexContext(account.id);
+    const plexState = requiredPlexStateForSubsonic(reply, context, tokenCipher);
+    if (!plexState) {
+      return;
+    }
+
+    try {
+      const sessions = [...playbackSessions.values()]
+        .filter((session) =>
+          session &&
+          session.accountId === account.id &&
+          session.itemId &&
+          session.state !== 'stopped',
+        )
+        .sort((a, b) => Number(b.updatedAt || 0) - Number(a.updatedAt || 0));
+
+      if (sessions.length === 0) {
+        return sendSubsonicOk(reply, node('nowPlaying'));
+      }
+
+      const dedupedByItemId = new Map();
+      for (const session of sessions) {
+        const itemId = String(session.itemId || '').trim();
+        if (itemId && !dedupedByItemId.has(itemId)) {
+          dedupedByItemId.set(itemId, session);
+        }
+      }
+
+      const itemIds = [...dedupedByItemId.keys()];
+      const tracks = await resolveTracksByIdOrder({
+        accountId: account.id,
+        plexState,
+        request,
+        ids: itemIds,
+      });
+
+      const sessionByTrackId = new Map(
+        [...dedupedByItemId.entries()].map(([id, session]) => [id, session]),
+      );
+      const entries = tracks
+        .map((track) => {
+          const trackId = String(track?.ratingKey || '').trim();
+          const session = sessionByTrackId.get(trackId);
+          const minutesAgo = Math.max(
+            0,
+            Math.floor((Date.now() - Number(session?.updatedAt || Date.now())) / 60000),
+          );
+          return emptyNode('entry', {
+            ...songAttrs(track),
+            username: account.username,
+            playerId: session?.clientIdentifier || undefined,
+            minutesAgo,
+          });
+        })
+        .join('');
+
+      return sendSubsonicOk(reply, node('nowPlaying', {}, entries));
+    } catch (error) {
+      request.log.error(error, 'Failed to load now playing entries');
+      return sendSubsonicError(reply, 10, 'Failed to load now playing');
+    }
   });
 
   app.get('/rest/getScanStatus.view', async (request, reply) => {
@@ -3848,13 +4152,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 +4176,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 +4404,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 +4669,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 +4677,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)));
@@ -4910,17 +5261,54 @@ export async function buildServer(config = loadConfig()) {
       return;
     }
 
-    return sendSubsonicOk(
-      reply,
-      node(
-        'playQueue',
-        {
-          current: '',
-          position: 0,
-        },
-        '',
-      ),
-    );
+    const context = repo.getAccountPlexContext(account.id);
+    const plexState = requiredPlexStateForSubsonic(reply, context, tokenCipher);
+    if (!plexState) {
+      return;
+    }
+
+    pruneSavedPlayQueues();
+    const queueKey = playQueueStorageKey(account.id, request);
+    const queueState = savedPlayQueues.get(queueKey) || {
+      ids: [],
+      current: '',
+      position: 0,
+      updatedAt: Date.now(),
+    };
+
+    try {
+      const effectiveIds = queueState.current && !queueState.ids.includes(queueState.current)
+        ? [queueState.current, ...queueState.ids]
+        : queueState.ids;
+      const tracks = await resolveTracksByIdOrder({
+        accountId: account.id,
+        plexState,
+        request,
+        ids: effectiveIds,
+      });
+
+      const entries = tracks
+        .map((track) => emptyNode('entry', songAttrs(track)))
+        .join('');
+      const changedIso = new Date(Number(queueState.updatedAt || Date.now())).toISOString();
+
+      return sendSubsonicOk(
+        reply,
+        node(
+          'playQueue',
+          {
+            current: queueState.current || '',
+            position: parseNonNegativeInt(queueState.position, 0),
+            username: account.username,
+            changed: changedIso,
+          },
+          entries,
+        ),
+      );
+    } catch (error) {
+      request.log.error(error, 'Failed to load saved play queue');
+      return sendSubsonicError(reply, 10, 'Failed to load play queue');
+    }
   });
 
   app.get('/rest/savePlayQueue.view', async (request, reply) => {
@@ -4929,6 +5317,21 @@ export async function buildServer(config = loadConfig()) {
       return;
     }
 
+    const ids = requestedPlayQueueItemIds(request);
+    const explicitCurrent = String(getRequestParam(request, 'current') || '').trim();
+    const current = explicitCurrent || ids[0] || '';
+    const position = parseNonNegativeInt(getRequestParam(request, 'position'), 0);
+    const queueKey = playQueueStorageKey(account.id, request);
+    const now = Date.now();
+
+    savedPlayQueues.set(queueKey, {
+      ids,
+      current,
+      position,
+      updatedAt: now,
+    });
+    pruneSavedPlayQueues(now);
+
     return sendSubsonicOk(reply);
   });
 
@@ -5651,32 +6054,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 +6304,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 +6354,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,
@@ -6343,10 +6800,17 @@ export async function buildServer(config = loadConfig()) {
 
       const streamUrl = buildPmsAssetUrl(plexState.baseUrl, plexState.plexToken, partKey);
       const rangeHeader = request.headers.range;
-      const upstream = await fetch(streamUrl, {
-        headers: {
-          ...(rangeHeader ? { Range: rangeHeader } : {}),
+      const upstream = await fetchWithRetry({
+        url: streamUrl,
+        options: {
+          headers: {
+            ...(rangeHeader ? { Range: rangeHeader } : {}),
+          },
         },
+        request,
+        context: 'track stream proxy',
+        maxAttempts: 3,
+        baseDelayMs: 250,
       });
 
       if (!upstream.ok || !upstream.body) {

package/src/subsonic-xml.js

@@ -207,6 +207,8 @@ const ARRAY_CHILDREN_BY_PARENT = {
   playlists: new Set(['playlist']),
   directory: new Set(['child']),
   playlist: new Set(['entry']),
+  playQueue: new Set(['entry']),
+  nowPlaying: new Set(['entry']),
   lyricsList: new Set(['structuredLyrics']),
   structuredLyrics: new Set(['line']),
   starred: new Set(['artist', 'album', 'song']),