plexsonic 0.1.4 → 0.1.6

package/package.json

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

package/src/server.js

@@ -868,6 +868,111 @@ function isPlexLiked(value) {
   return normalized != null && normalized >= 2 && normalized % 2 === 0;
 }
 
+function normalizePlainText(value) {
+  return String(value || '')
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/p>/gi, '\n')
+    .replace(/<[^>]*>/g, '')
+    .replace(/\r\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+function asArray(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (value == null) {
+    return [];
+  }
+  return [value];
+}
+
+function plexGuidIds(item) {
+  const candidates = [];
+
+  for (const guid of asArray(item?.Guid)) {
+    if (typeof guid === 'string') {
+      candidates.push(guid);
+      continue;
+    }
+    if (guid && typeof guid === 'object' && typeof guid.id === 'string') {
+      candidates.push(guid.id);
+    }
+  }
+
+  for (const raw of [item?.guid, item?.guids]) {
+    if (typeof raw === 'string') {
+      candidates.push(raw);
+    } else if (Array.isArray(raw)) {
+      for (const entry of raw) {
+        if (typeof entry === 'string') {
+          candidates.push(entry);
+        } else if (entry && typeof entry === 'object' && typeof entry.id === 'string') {
+          candidates.push(entry.id);
+        }
+      }
+    }
+  }
+
+  return uniqueNonEmptyValues(candidates);
+}
+
+function extractMusicBrainzArtistId(item) {
+  const guidIds = plexGuidIds(item);
+  const uuidPattern = /([0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})/i;
+
+  for (const guid of guidIds) {
+    const lower = safeLower(guid);
+
+    if (lower.startsWith('mbid://')) {
+      const id = guid.slice('mbid://'.length).split(/[/?#]/, 1)[0].trim();
+      if (id) {
+        return id;
+      }
+    }
+
+    if (lower.startsWith('musicbrainz://')) {
+      const id = guid
+        .slice('musicbrainz://'.length)
+        .replace(/^artist\//i, '')
+        .split(/[?#]/, 1)[0]
+        .replace(/^\/+/, '')
+        .trim();
+      if (id) {
+        return id;
+      }
+    }
+
+    if (lower.includes('musicbrainz.org/artist/')) {
+      const match = guid.match(/musicbrainz\.org\/artist\/([^/?#]+)/i);
+      if (match?.[1]) {
+        return match[1];
+      }
+    }
+
+    if (lower.includes('musicbrainz')) {
+      const uuid = guid.match(uuidPattern)?.[1];
+      if (uuid) {
+        return uuid;
+      }
+    }
+  }
+
+  return '';
+}
+
+function artistBioFromPlex(item) {
+  return firstNonEmptyText(
+    [
+      normalizePlainText(item?.summary),
+      normalizePlainText(item?.tagline),
+      normalizePlainText(item?.description),
+    ],
+    '',
+  );
+}
+
 function subsonicRatingToPlexRating(value, { liked = false } = {}) {
   const rating = Number.parseInt(String(value ?? ''), 10);
   if (!Number.isFinite(rating) || rating <= 0) {
@@ -1694,6 +1799,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 +2283,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 +2451,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 +3057,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 +4139,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 +4188,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 +5366,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 +5422,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);
   });
 
@@ -5867,7 +6236,61 @@ export async function buildServer(config = loadConfig()) {
       return;
     }
 
-    return sendSubsonicOk(reply, node('artistInfo'));
+    const artistId = String(getRequestParam(request, 'id') || '').trim();
+    if (!artistId) {
+      return sendSubsonicError(reply, 70, 'Missing artist id');
+    }
+
+    const context = repo.getAccountPlexContext(account.id);
+    const plexState = requiredPlexStateForSubsonic(reply, context, tokenCipher);
+    if (!plexState) {
+      return;
+    }
+
+    try {
+      let artist = null;
+      try {
+        artist = await getArtist({
+          baseUrl: plexState.baseUrl,
+          plexToken: plexState.plexToken,
+          artistId,
+        });
+      } catch (error) {
+        if (!isPlexNotFoundError(error)) {
+          throw error;
+        }
+      }
+
+      if (!artist) {
+        const fallback = await resolveArtistFromCachedLibrary({
+          accountId: account.id,
+          plexState,
+          request,
+          artistId,
+        });
+        if (fallback?.artist) {
+          artist = fallback.artist;
+        }
+      }
+
+      if (!artist) {
+        return sendSubsonicError(reply, 70, 'Artist not found');
+      }
+
+      const biography = artistBioFromPlex(artist);
+      const musicBrainzId = extractMusicBrainzArtistId(artist);
+      const children = [
+        biography ? node('biography', {}, biography) : '',
+        musicBrainzId ? node('musicBrainzId', {}, musicBrainzId) : '',
+      ]
+        .filter(Boolean)
+        .join('');
+
+      return sendSubsonicOk(reply, node('artistInfo', {}, children));
+    } catch (error) {
+      request.log.error(error, 'Failed to load artist info');
+      return sendSubsonicError(reply, 10, 'Failed to load artist info');
+    }
   });
 
   app.get('/rest/getArtistInfo2.view', async (request, reply) => {
@@ -5876,7 +6299,61 @@ export async function buildServer(config = loadConfig()) {
       return;
     }
 
-    return sendSubsonicOk(reply, node('artistInfo2'));
+    const artistId = String(getRequestParam(request, 'id') || '').trim();
+    if (!artistId) {
+      return sendSubsonicError(reply, 70, 'Missing artist id');
+    }
+
+    const context = repo.getAccountPlexContext(account.id);
+    const plexState = requiredPlexStateForSubsonic(reply, context, tokenCipher);
+    if (!plexState) {
+      return;
+    }
+
+    try {
+      let artist = null;
+      try {
+        artist = await getArtist({
+          baseUrl: plexState.baseUrl,
+          plexToken: plexState.plexToken,
+          artistId,
+        });
+      } catch (error) {
+        if (!isPlexNotFoundError(error)) {
+          throw error;
+        }
+      }
+
+      if (!artist) {
+        const fallback = await resolveArtistFromCachedLibrary({
+          accountId: account.id,
+          plexState,
+          request,
+          artistId,
+        });
+        if (fallback?.artist) {
+          artist = fallback.artist;
+        }
+      }
+
+      if (!artist) {
+        return sendSubsonicError(reply, 70, 'Artist not found');
+      }
+
+      const biography = artistBioFromPlex(artist);
+      const musicBrainzId = extractMusicBrainzArtistId(artist);
+      const children = [
+        biography ? node('biography', {}, biography) : '',
+        musicBrainzId ? node('musicBrainzId', {}, musicBrainzId) : '',
+      ]
+        .filter(Boolean)
+        .join('');
+
+      return sendSubsonicOk(reply, node('artistInfo2', {}, children));
+    } catch (error) {
+      request.log.error(error, 'Failed to load artist info2');
+      return sendSubsonicError(reply, 10, 'Failed to load artist info');
+    }
   });
 
   app.get('/rest/getAlbum.view', async (request, reply) => {
@@ -6536,10 +7013,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']),
@@ -319,6 +321,11 @@ function nodeToJson(node) {
     }
   }
 
+  const keys = Object.keys(out);
+  if (keys.length === 1 && keys[0] === 'value') {
+    return out.value;
+  }
+
   if (node.name === 'openSubsonicExtensions') {
     const extensions = out.openSubsonicExtension;
     if (Array.isArray(extensions)) {