plexsonic 0.1.4 → 0.1.5

package/package.json

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

package/src/server.js

@@ -1694,6 +1694,64 @@ 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)');
 }
@@ -2120,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',
   };
 }
@@ -2287,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;
@@ -2891,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;
@@ -3889,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);
   });
@@ -3931,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) => {
@@ -5049,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) => {
@@ -5068,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);
   });
 
@@ -6536,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']),