feat: add Autoplay and Song Radio features with Plex Pass support

Author: mihaitom

CHANGELOG.md

@@ -6,6 +6,11 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 
+### Added
+
+- Added Autoplay - once the queue is down to its last song or so, similar songs get added automatically so playback never just runs dry. Off by default; toggle it from the icon next to Queue in the player bar, and set how many songs get added per top-up in Settings. Works the same for local playback and casting, and keeps topping the queue up on its own server-side even if nothing's around to do it locally (e.g. a phone's screen is locked)
+- Added Song Radio, Artist Radio, and Autoplay support for Plex (needs an active Plex Pass on the account) - previously Navidrome/Subsonic and Jellyfin only
+
 ### Changed
 
 - Changed the Home view's two "discover" shelves for more headroom and a clearer distinction between them - the library-based one now shows up to 20 albums instead of 15 on wide screens, and both got clearer titles ("Discover in your library" / "New artists to explore") so it's obvious which is drawn from albums you already own and which is brand-new artist suggestions

README.md

@@ -79,11 +79,11 @@ Jellyfin and Plex can both be selected as a server type at login. Neither has a
 | Play history / Stats page                         |           ✅           |    ✅    |   ✅      |
 | Favorites (heart icon)                            |           ✅           |    ✅    |   ❌      |
 | Personal 1-5 star rating                          |           ✅           |    ❌    |   ✅      |
-| Song/Artist Radio and Autoplay                    |           ✅           |    ✅    |   ❌      |
+| Song/Artist Radio and Autoplay                    |           ✅           |    ✅    | ✅ (needs an active Plex Pass) |
 | Create playlists                                  |           ✅           |    ✅    |   ✅      |
 | Trigger a library rescan from Settings            |           ✅           |    ❌    |   ❌      |
 
-A couple of these are real gaps to close, not things Plex is actually incapable of - Plex does have its own sonic-similarity/"Play Similar" mechanism, it just hasn't been bridged into `getSimilarSongs2.view` yet (unlike Jellyfin's InstantMix, which has). Favorites is the one genuine dead end: Plex's core Media Server API has no separate boolean favorite at all - the heart-shaped "Love" seen in Plexamp/mobile is backed by Plex Pass cloud sync (a different API this bridge doesn't talk to), and personal ratings already cover the "mark this" use case for Plex instead.
+Song/Artist Radio and Autoplay on Plex are bridged onto Plex's own Sonic Analysis feature (`/library/metadata/{id}/nearest`, the same thing "Play Similar Tracks" uses in every official Plex client) - but Sonic Analysis itself is a Plex Pass-gated feature server-side, confirmed against Plex's own support docs. Without an active Plex Pass, the buttons and the Autoplay toggle are still there, they just quietly return nothing instead of a real mix. Favorites is the one genuine dead end: Plex's core Media Server API has no separate boolean favorite at all - the heart-shaped "Love" seen in Plexamp/mobile is backed by a different, Plex Pass cloud sync API this bridge doesn't talk to, and personal ratings already cover the "mark this" use case for Plex instead.
 
 ### Remote Control (Electron) and the mobile web UI
 

connect/media/plex.py

@@ -241,6 +241,62 @@ def get_track(self, track_id: str) -> Track:
             album=item.get("parentTitle", ""),
         )
 
+    # /nearest + limit/maxDistance matches python-plexapi's own
+    # Audio.sonicallySimilar() (the library every other unofficial Plex
+    # client's equivalent feature is built on) — see
+    # https://python-plexapi.readthedocs.io/en/latest/modules/audio.html.
+    # Confirmed live against a real server (2026-08-20): the endpoint is
+    # real (403, not 404), and per Plex's own support article
+    # (https://support.plex.tv/articles/sonic-analysis-music/), "Sonic
+    # analysis for music is a premium feature and requires an active Plex
+    # Pass subscription for the Server admin account" — exactly the 403 a
+    # non-Pass test account got back. The server itself having
+    # musicAnalysis enabled isn't enough on its own without that
+    # subscription. The success-path *response shape* was never actually
+    # seen against a Pass-holding account, but there's no real reason to
+    # expect it differs from the MediaContainer.Metadata[] list every other
+    # Plex track-listing endpoint already confirmed uses (search, album/
+    # playlist children — see media/plex_bridge.py's _map_song()) — Plex is
+    # consistent about that shape everywhere else, so this reuses
+    # get_track()'s own field mapping above rather than inventing a second
+    # one. Worth a quick sanity check the first time this actually runs
+    # against a Pass account, but not blocked on it.
+    #
+    # 403 specifically returns [] rather than raising — routes/stream.py's
+    # _maybe_autoplay_topup() would otherwise log a real warning on every
+    # single top-up attempt for every non-Pass Plex account, forever, for a
+    # permanent/expected condition rather than a transient failure worth
+    # flagging. Anything else (network error, malformed response, a genuine
+    # server problem) still raises, same as get_track()/get_stream_url()
+    # above — that caller's own except Exception already logs those.
+    def get_similar_songs2(self, seed_id: str, count: int = 10) -> list[Track]:
+        try:
+            data = self._get(
+                f"/library/metadata/{quote(str(seed_id), safe='')}/nearest",
+                excludeFields="summary",
+                limit=count,
+                maxDistance=0.25,
+            )
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 403:
+                logger.debug(
+                    f"[Plex] Sonic Analysis unavailable (no Plex Pass?) for {seed_id}: {e}"
+                )
+                return []
+            raise
+        items = data.get("MediaContainer", {}).get("Metadata", [])
+        return [
+            Track(
+                id=str(item["ratingKey"]),
+                title=item.get("title", "Unknown"),
+                artist=item.get("grandparentTitle", "Unknown"),
+                duration=int((item.get("duration") or 0) / 1000),
+                cover_art_id=str(item.get("parentRatingKey") or item["ratingKey"]),
+                album=item.get("parentTitle", ""),
+            )
+            for item in items
+        ]
+
     def get_stream_url(self, track_id: str) -> str:
         # Direct play, not the universal transcode endpoint — PLEX_PLAN.md
         # calls for implementing this first and treating transcoding as a

connect/media/plex_bridge.py

@@ -34,6 +34,18 @@
     Revisit only if /library/sections/{id}/genre turns out to carry real
     per-genre counts cheaply (PLEX_PLAN.md flagged this as worth checking,
     not yet done).
+  - getSimilarSongs2.view (Song/Artist Radio, and Autoplay's frontend-side
+    top-up — see stores/playback.ts's maybeAutoplay()) maps onto Plex's own
+    Sonic Analysis (`/library/metadata/{id}/nearest`) — see
+    get_similar_songs2()'s own comment and PlexClient.get_similar_songs2()'s
+    (media/plex.py) identical one for the full story: confirmed live
+    (2026-08-20) that the endpoint is real, but Sonic Analysis itself is a
+    Plex Pass-gated feature server-side (confirmed against Plex's own
+    support docs), not something this bridge can work around — a
+    non-Pass account gets a 403, translated here into an empty result
+    rather than an error. services/capabilities.ts's songRadio is true for
+    Plex accordingly, same as Jellyfin, even though it silently does
+    nothing for a listener without Plex Pass.
 
 Field names below are this module's best understanding of Plex's
 Metadata/MediaContainer JSON shape, not yet fully confirmed against a live
@@ -291,6 +303,45 @@ async def get_song(params: dict, media: PlexClient) -> dict:
     return {"song": _map_song(items[0])}
 
 
+async def get_similar_songs2(params: dict, media: PlexClient) -> dict:
+    """Song/Artist Radio + Autoplay's frontend-facing counterpart to
+    PlexClient.get_similar_songs2() (media/plex.py) — same endpoint, same
+    Plex-Pass caveat and unverified-response-shape note, see that method's
+    own comment for the full explanation. Duplicated rather than shared
+    because that one's synchronous (for connect's own internal Autoplay
+    fallback, see routes/stream.py) and this one's async (this module's
+    handlers all are, see _HANDLERS below) — same split as get_song() above
+    vs. PlexClient.get_track().
+
+    Unlike that one, a 403 here surfaces as `plexPassRequired: true` in the
+    response rather than silently coming back empty — this is the path an
+    actual listener's own request takes (a Song/Artist Radio click, or
+    stores/playback.ts's maybeAutoplay() running for a client that's
+    actually online), so there's someone to actually tell. PlexClient's own
+    version has no equivalent because it's connect's own background
+    fallback for when nobody's around to tell in the first place (see
+    routes/stream.py's _maybe_autoplay_topup())."""
+    item_id = params.get("id", "")
+    if not item_id:
+        raise ValueError("getSimilarSongs2.view requires id")
+    count = params.get("count", "50")
+    try:
+        data = await _px_get(
+            media,
+            f"/library/metadata/{_quote_id(item_id)}/nearest",
+            excludeFields="summary",
+            limit=count,
+            maxDistance="0.25",
+        )
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 403:
+            logger.debug(f"[Plex] Sonic Analysis unavailable (no Plex Pass?) for {item_id}: {e}")
+            return {"similarSongs2": {"song": [], "plexPassRequired": True}}
+        raise
+    songs = data.get("MediaContainer", {}).get("Metadata", [])
+    return {"similarSongs2": {"song": _map_all(_map_song, songs)}}
+
+
 async def get_artists(_params: dict, media: PlexClient) -> dict:
     section = await _music_section(media)
     data = await _px_get(media, f"/library/sections/{section}/all", type="8", sort="titleSort")
@@ -592,6 +643,7 @@ async def delete_playlist(params: dict, media: PlexClient) -> dict:
     "getAlbumList2.view": get_album_list2,
     "getAlbum.view": get_album,
     "getSong.view": get_song,
+    "getSimilarSongs2.view": get_similar_songs2,
     "getArtists.view": get_artists,
     "getArtist.view": get_artist,
     "search3.view": search3,

connect/tests/test_plex.py

@@ -101,6 +101,57 @@ def fake_get(url, **kwargs):
         _client().get_track("missing")
 
 
+# ── get_similar_songs2 (Sonic Analysis, Plex Pass-gated) ─────────────────────
+# See this method's own comment (media/plex.py) for the full story — confirmed
+# live (2026-08-20) that a non-Plex-Pass account gets a real 403 here.
+
+
+def test_get_similar_songs2_parses_items(monkeypatch):
+    item = {
+        "ratingKey": "9002",
+        "title": "Similar Song",
+        "grandparentTitle": "Artist B",
+        "parentTitle": "Another Album",
+        "parentRatingKey": "2002",
+        "duration": 200_000,
+    }
+
+    def fake_get(url, headers=None, params=None, timeout=None):
+        assert url.endswith("/library/metadata/9001/nearest")
+        assert params["limit"] == 10
+        return httpx.Response(
+            200,
+            json={"MediaContainer": {"Metadata": [item]}},
+            request=httpx.Request("GET", url),
+        )
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+    songs = _client().get_similar_songs2("9001", count=10)
+    assert len(songs) == 1
+    assert songs[0].id == "9002"
+    assert songs[0].artist == "Artist B"
+    assert songs[0].duration == 200
+
+
+def test_get_similar_songs2_returns_empty_without_plex_pass(monkeypatch):
+    def fake_get(url, **kwargs):
+        request = httpx.Request("GET", url)
+        return httpx.Response(403, request=request)
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+    assert _client().get_similar_songs2("9001") == []
+
+
+def test_get_similar_songs2_reraises_other_errors(monkeypatch):
+    def fake_get(url, **kwargs):
+        request = httpx.Request("GET", url)
+        return httpx.Response(500, request=request)
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+    with pytest.raises(httpx.HTTPStatusError):
+        _client().get_similar_songs2("9001")
+
+
 # ── get_stream_url resolves Media.Part.key ───────────────────────────────────
 
 

connect/tests/test_plex_bridge.py

@@ -2,6 +2,7 @@
 
 from unittest.mock import AsyncMock, MagicMock
 
+import httpx
 import pytest
 
 from core.session import DEFAULT_SESSION_ID, SessionState
@@ -209,6 +210,61 @@ def test_get_album_list2_returns_mapped_albums(client, plex_session, monkeypatch
     assert sum(1 for _method, url, _params in calls if url.endswith("/library/sections")) == 1
 
 
+def test_get_similar_songs2_returns_mapped_songs(client, plex_session, monkeypatch):
+    fake_client, calls = _fake_px_client(
+        {
+            "/library/metadata/9001/nearest": {
+                "MediaContainer": {
+                    "Metadata": [
+                        {
+                            "ratingKey": "9002",
+                            "title": "Similar Song",
+                            "grandparentTitle": "Artist B",
+                            "parentTitle": "Album B",
+                            "duration": 200_000,
+                        }
+                    ]
+                }
+            },
+        }
+    )
+    monkeypatch.setattr(plex_bridge, "_get_client", lambda: fake_client)
+
+    r = client.get("/rest/getSimilarSongs2.view", params={"id": "9001", "count": "10"})
+    assert r.status_code == 200
+    body = r.json()["subsonic-response"]
+    assert body["status"] == "ok"
+    songs = body["similarSongs2"]["song"]
+    assert len(songs) == 1
+    assert songs[0]["id"] == "9002"
+    assert songs[0]["artist"] == "Artist B"
+    assert "plexPassRequired" not in body["similarSongs2"]
+    assert calls[0][2]["limit"] == "10"
+
+
+def test_get_similar_songs2_flags_plex_pass_required_on_403(client, plex_session, monkeypatch):
+    """Regression for a real live-server finding (2026-08-20): Plex's Sonic
+    Analysis feature this endpoint bridges onto is Plex Pass-gated, and a
+    non-Pass account gets a clean 403 back — surfaced to the frontend as
+    plexPassRequired rather than a thrown error, so stores/playback.ts can
+    tell the listener why instead of that just silently doing nothing (Song/
+    Artist Radio) or logging a warning forever (Autoplay)."""
+
+    async def fake_request(method, url, headers=None, params=None):
+        return httpx.Response(403, request=httpx.Request(method, url))
+
+    fake_client = MagicMock()
+    fake_client.request = fake_request
+    monkeypatch.setattr(plex_bridge, "_get_client", lambda: fake_client)
+
+    r = client.get("/rest/getSimilarSongs2.view", params={"id": "9001"})
+    assert r.status_code == 200
+    body = r.json()["subsonic-response"]
+    assert body["status"] == "ok"
+    assert body["similarSongs2"]["song"] == []
+    assert body["similarSongs2"]["plexPassRequired"] is True
+
+
 def test_get_artist_derives_counts_instead_of_trusting_summary_fields(
     client, plex_session, monkeypatch
 ):

src/renderer/src/i18n/locales/de.ts

@@ -113,6 +113,8 @@ export default {
     songRadioError: 'Song-Radio konnte nicht gestartet werden.',
     artistRadio: 'Artist-Radio',
     artistRadioError: 'Artist-Radio konnte nicht gestartet werden.',
+    plexPassRequired:
+      'Dafür braucht es ein aktives Plex-Pass-Abo - Plex sperrt die eigene Sonic-Analysis-Funktion (Song-/Artist-Radio, Autoplay) selbst dahinter, das kann Beacon nicht umgehen.',
     viewOnService: 'Auf {service} ansehen',
     selected: 'ausgewählt',
     clearSelection: 'Auswahl aufheben',

src/renderer/src/i18n/locales/en.ts

@@ -115,6 +115,8 @@ export default {
     songRadioError: 'Could not start Song Radio.',
     artistRadio: 'Artist Radio',
     artistRadioError: 'Could not start Artist Radio.',
+    plexPassRequired:
+      "This needs an active Plex Pass subscription - it's what Plex's own Sonic Analysis feature (Song/Artist Radio, Autoplay) is gated behind on their side, not something Beacon can work around.",
     viewOnService: 'View on {service}',
     selected: 'selected',
     clearSelection: 'Clear selection',

src/renderer/src/i18n/locales/es.ts

@@ -116,6 +116,8 @@ export default {
     songRadioError: 'No se pudo iniciar la radio de la canción.',
     artistRadio: 'Radio del artista',
     artistRadioError: 'No se pudo iniciar la radio del artista.',
+    plexPassRequired:
+      'Esto necesita una suscripción activa a Plex Pass - Plex bloquea su propia función Sonic Analysis (Radio de canción/artista, Autoplay) detrás de eso, Beacon no puede evitarlo.',
     viewOnService: 'Ver en {service}',
     selected: 'seleccionado(s)',
     clearSelection: 'Borrar selección',

src/renderer/src/i18n/locales/fr.ts

@@ -115,6 +115,8 @@ export default {
     songRadioError: 'Impossible de démarrer la radio du titre.',
     artistRadio: "Radio de l'artiste",
     artistRadioError: "Impossible de démarrer la radio de l'artiste.",
+    plexPassRequired:
+      "Ceci nécessite un abonnement Plex Pass actif - c'est Plex lui-même qui verrouille sa propre fonction Sonic Analysis (Radio par morceau/artiste, Autoplay) derrière cet abonnement, Beacon ne peut pas contourner ça.",
     viewOnService: 'Voir sur {service}',
     selected: 'sélectionné(s)',
     clearSelection: 'Effacer la sélection',