refactor(transcoding): enhance logging for transcode decision process and client info conversion

Signed-off-by: Deluan <deluan@navidrome.org>

adapters/gotaglib/gotaglib.go

@@ -6,19 +6,22 @@
 // efficient access to format-specific tags (ID3v2 frames, MP4 atoms, ASF attributes)
 // through a single file open operation.
 //
-// This extractor is registered under the name "gotaglib". It only works with a filesystem
+// This extractor is registered under the name "taglib". It only works with a filesystem
 // (fs.FS) and does not support direct local file paths. Files returned by the filesystem
 // must implement io.ReadSeeker for go-taglib to read them.
 package gotaglib
 
 import (
 	"errors"
+	"fmt"
 	"io"
 	"io/fs"
+	"runtime/debug"
 	"strings"
 	"time"
 
 	"github.com/navidrome/navidrome/core/storage/local"
+	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model/metadata"
 	"go.senan.xyz/taglib"
 )
@@ -61,6 +64,7 @@ func (e extractor) extractMetadata(filePath string) (*metadata.Info, error) {
 		Channels:   int(props.Channels),
 		SampleRate: int(props.SampleRate),
 		BitDepth:   int(props.BitsPerSample),
+		Codec:      props.Codec,
 	}
 
 	// Convert normalized tags to lowercase keys (go-taglib returns UPPERCASE keys)
@@ -94,7 +98,17 @@ func (e extractor) extractMetadata(filePath string) (*metadata.Info, error) {
 
 // openFile opens the file at filePath using the extractor's filesystem.
 // It returns a TagLib File handle and a cleanup function to close resources.
-func (e extractor) openFile(filePath string) (*taglib.File, func(), error) {
+func (e extractor) openFile(filePath string) (f *taglib.File, closeFunc func(), err error) {
+	// Recover from panics in the WASM runtime (e.g., wazero failing to mmap executable memory
+	// on hardened systems like NixOS with MemoryDenyWriteExecute=true)
+	debug.SetPanicOnFault(true)
+	defer func() {
+		if r := recover(); r != nil {
+			log.Error("WASM runtime panic: This may be caused by a hardened system that blocks executable memory mapping.", "file", filePath, "panic", r)
+			err = fmt.Errorf("WASM runtime panic (hardened system?): %v", r)
+		}
+	}()
+
 	// Open the file from the filesystem
 	file, err := e.fs.Open(filePath)
 	if err != nil {
@@ -105,12 +119,12 @@ func (e extractor) openFile(filePath string) (*taglib.File, func(), error) {
 		file.Close()
 		return nil, nil, errors.New("file is not seekable")
 	}
-	f, err := taglib.OpenStream(rs, taglib.WithReadStyle(taglib.ReadStyleFast))
+	f, err = taglib.OpenStream(rs, taglib.WithReadStyle(taglib.ReadStyleFast))
 	if err != nil {
 		file.Close()
 		return nil, nil, err
 	}
-	closeFunc := func() {
+	closeFunc = func() {
 		f.Close()
 		file.Close()
 	}

adapters/tidal/client.go

@@ -1,430 +0,0 @@
-package tidal
-
-import (
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/navidrome/navidrome/log"
-)
-
-const (
-	apiBaseURL   = "https://openapi.tidal.com"
-	authTokenURL = "https://auth.tidal.com/v1/oauth2/token"
-)
-
-var (
-	ErrNotFound = errors.New("tidal: not found")
-)
-
-type httpDoer interface {
-	Do(req *http.Request) (*http.Response, error)
-}
-
-type client struct {
-	id         string
-	secret     string
-	hc         httpDoer
-	token      string
-	tokenExp   time.Time
-	tokenMutex sync.Mutex
-}
-
-func newClient(id, secret string, hc httpDoer) *client {
-	return &client{
-		id:     id,
-		secret: secret,
-		hc:     hc,
-	}
-}
-
-func (c *client) searchArtists(ctx context.Context, name string, limit int) ([]ArtistResource, error) {
-	token, err := c.getToken(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get token: %w", err)
-	}
-
-	params := url.Values{}
-	params.Add("query", name)
-	params.Add("limit", strconv.Itoa(limit))
-	params.Add("countryCode", "US")
-
-	req, err := http.NewRequestWithContext(ctx, "GET", apiBaseURL+"/search", nil)
-	if err != nil {
-		return nil, err
-	}
-	req.URL.RawQuery = params.Encode()
-	req.Header.Set("Authorization", "Bearer "+token)
-	req.Header.Set("Accept", "application/vnd.tidal.v1+json")
-	req.Header.Set("Content-Type", "application/vnd.tidal.v1+json")
-
-	var result struct {
-		Artists []ArtistResource `json:"artists"`
-	}
-	err = c.makeRequest(req, &result)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(result.Artists) == 0 {
-		return nil, ErrNotFound
-	}
-	return result.Artists, nil
-}
-
-func (c *client) getArtist(ctx context.Context, artistID string) (*ArtistResource, error) {
-	token, err := c.getToken(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get token: %w", err)
-	}
-
-	params := url.Values{}
-	params.Add("countryCode", "US")
-
-	req, err := http.NewRequestWithContext(ctx, "GET", apiBaseURL+"/artists/"+artistID, nil)
-	if err != nil {
-		return nil, err
-	}
-	req.URL.RawQuery = params.Encode()
-	req.Header.Set("Authorization", "Bearer "+token)
-	req.Header.Set("Accept", "application/vnd.tidal.v1+json")
-	req.Header.Set("Content-Type", "application/vnd.tidal.v1+json")
-
-	var result struct {
-		Resource ArtistResource `json:"resource"`
-	}
-	err = c.makeRequest(req, &result)
-	if err != nil {
-		return nil, err
-	}
-
-	return &result.Resource, nil
-}
-
-func (c *client) getArtistTopTracks(ctx context.Context, artistID string, limit int) ([]TrackResource, error) {
-	token, err := c.getToken(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get token: %w", err)
-	}
-
-	params := url.Values{}
-	params.Add("countryCode", "US")
-	params.Add("limit", strconv.Itoa(limit))
-
-	req, err := http.NewRequestWithContext(ctx, "GET", apiBaseURL+"/artists/"+artistID+"/tracks", nil)
-	if err != nil {
-		return nil, err
-	}
-	req.URL.RawQuery = params.Encode()
-	req.Header.Set("Authorization", "Bearer "+token)
-	req.Header.Set("Accept", "application/vnd.tidal.v1+json")
-	req.Header.Set("Content-Type", "application/vnd.tidal.v1+json")
-
-	var result struct {
-		Data []TrackResource `json:"data"`
-	}
-	err = c.makeRequest(req, &result)
-	if err != nil {
-		return nil, err
-	}
-
-	return result.Data, nil
-}
-
-func (c *client) getSimilarArtists(ctx context.Context, artistID string, limit int) ([]ArtistResource, error) {
-	token, err := c.getToken(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get token: %w", err)
-	}
-
-	params := url.Values{}
-	params.Add("countryCode", "US")
-	params.Add("limit", strconv.Itoa(limit))
-
-	req, err := http.NewRequestWithContext(ctx, "GET", apiBaseURL+"/artists/"+artistID+"/similar", nil)
-	if err != nil {
-		return nil, err
-	}
-	req.URL.RawQuery = params.Encode()
-	req.Header.Set("Authorization", "Bearer "+token)
-	req.Header.Set("Accept", "application/vnd.tidal.v1+json")
-	req.Header.Set("Content-Type", "application/vnd.tidal.v1+json")
-
-	var result struct {
-		Data []ArtistResource `json:"data"`
-	}
-	err = c.makeRequest(req, &result)
-	if err != nil {
-		return nil, err
-	}
-
-	return result.Data, nil
-}
-
-func (c *client) searchAlbums(ctx context.Context, albumName, artistName string, limit int) ([]AlbumResource, error) {
-	token, err := c.getToken(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get token: %w", err)
-	}
-
-	query := albumName
-	if artistName != "" {
-		query = artistName + " " + albumName
-	}
-
-	params := url.Values{}
-	params.Add("query", query)
-	params.Add("limit", strconv.Itoa(limit))
-	params.Add("countryCode", "US")
-	params.Add("type", "ALBUMS")
-
-	req, err := http.NewRequestWithContext(ctx, "GET", apiBaseURL+"/search", nil)
-	if err != nil {
-		return nil, err
-	}
-	req.URL.RawQuery = params.Encode()
-	req.Header.Set("Authorization", "Bearer "+token)
-	req.Header.Set("Accept", "application/vnd.tidal.v1+json")
-	req.Header.Set("Content-Type", "application/vnd.tidal.v1+json")
-
-	var result struct {
-		Albums []AlbumResource `json:"albums"`
-	}
-	err = c.makeRequest(req, &result)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(result.Albums) == 0 {
-		return nil, ErrNotFound
-	}
-	return result.Albums, nil
-}
-
-func (c *client) searchTracks(ctx context.Context, trackName, artistName string, limit int) ([]TrackResource, error) {
-	token, err := c.getToken(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get token: %w", err)
-	}
-
-	query := trackName
-	if artistName != "" {
-		query = artistName + " " + trackName
-	}
-
-	params := url.Values{}
-	params.Add("query", query)
-	params.Add("limit", strconv.Itoa(limit))
-	params.Add("countryCode", "US")
-	params.Add("type", "TRACKS")
-
-	req, err := http.NewRequestWithContext(ctx, "GET", apiBaseURL+"/search", nil)
-	if err != nil {
-		return nil, err
-	}
-	req.URL.RawQuery = params.Encode()
-	req.Header.Set("Authorization", "Bearer "+token)
-	req.Header.Set("Accept", "application/vnd.tidal.v1+json")
-	req.Header.Set("Content-Type", "application/vnd.tidal.v1+json")
-
-	var result struct {
-		Tracks []TrackResource `json:"tracks"`
-	}
-	err = c.makeRequest(req, &result)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(result.Tracks) == 0 {
-		return nil, ErrNotFound
-	}
-	return result.Tracks, nil
-}
-
-func (c *client) getArtistBio(ctx context.Context, artistID string) (string, error) {
-	token, err := c.getToken(ctx)
-	if err != nil {
-		return "", fmt.Errorf("failed to get token: %w", err)
-	}
-
-	params := url.Values{}
-	params.Add("countryCode", "US")
-
-	req, err := http.NewRequestWithContext(ctx, "GET", apiBaseURL+"/artists/"+artistID+"/bio", nil)
-	if err != nil {
-		return "", err
-	}
-	req.URL.RawQuery = params.Encode()
-	req.Header.Set("Authorization", "Bearer "+token)
-	req.Header.Set("Accept", "application/vnd.tidal.v1+json")
-	req.Header.Set("Content-Type", "application/vnd.tidal.v1+json")
-
-	var result struct {
-		Text string `json:"text"`
-	}
-	err = c.makeRequest(req, &result)
-	if err != nil {
-		return "", err
-	}
-
-	if result.Text == "" {
-		return "", ErrNotFound
-	}
-	return result.Text, nil
-}
-
-func (c *client) getAlbumReview(ctx context.Context, albumID string) (string, error) {
-	token, err := c.getToken(ctx)
-	if err != nil {
-		return "", fmt.Errorf("failed to get token: %w", err)
-	}
-
-	params := url.Values{}
-	params.Add("countryCode", "US")
-
-	req, err := http.NewRequestWithContext(ctx, "GET", apiBaseURL+"/albums/"+albumID+"/review", nil)
-	if err != nil {
-		return "", err
-	}
-	req.URL.RawQuery = params.Encode()
-	req.Header.Set("Authorization", "Bearer "+token)
-	req.Header.Set("Accept", "application/vnd.tidal.v1+json")
-	req.Header.Set("Content-Type", "application/vnd.tidal.v1+json")
-
-	var result struct {
-		Text string `json:"text"`
-	}
-	err = c.makeRequest(req, &result)
-	if err != nil {
-		return "", err
-	}
-
-	if result.Text == "" {
-		return "", ErrNotFound
-	}
-	return result.Text, nil
-}
-
-func (c *client) getTrackRadio(ctx context.Context, trackID string, limit int) ([]TrackResource, error) {
-	token, err := c.getToken(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get token: %w", err)
-	}
-
-	params := url.Values{}
-	params.Add("countryCode", "US")
-	params.Add("limit", strconv.Itoa(limit))
-
-	req, err := http.NewRequestWithContext(ctx, "GET", apiBaseURL+"/tracks/"+trackID+"/radio", nil)
-	if err != nil {
-		return nil, err
-	}
-	req.URL.RawQuery = params.Encode()
-	req.Header.Set("Authorization", "Bearer "+token)
-	req.Header.Set("Accept", "application/vnd.tidal.v1+json")
-	req.Header.Set("Content-Type", "application/vnd.tidal.v1+json")
-
-	var result struct {
-		Data []TrackResource `json:"data"`
-	}
-	err = c.makeRequest(req, &result)
-	if err != nil {
-		return nil, err
-	}
-
-	return result.Data, nil
-}
-
-func (c *client) getToken(ctx context.Context) (string, error) {
-	c.tokenMutex.Lock()
-	defer c.tokenMutex.Unlock()
-
-	// Return cached token if still valid (with 1 minute buffer)
-	if c.token != "" && time.Now().Add(time.Minute).Before(c.tokenExp) {
-		return c.token, nil
-	}
-
-	// Request new token
-	payload := url.Values{}
-	payload.Add("grant_type", "client_credentials")
-
-	req, err := http.NewRequestWithContext(ctx, "POST", authTokenURL, strings.NewReader(payload.Encode()))
-	if err != nil {
-		return "", err
-	}
-
-	auth := c.id + ":" + c.secret
-	req.Header.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(auth)))
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-
-	log.Trace(ctx, "Requesting Tidal OAuth token")
-	resp, err := c.hc.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-
-	data, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", err
-	}
-
-	if resp.StatusCode != http.StatusOK {
-		return "", fmt.Errorf("tidal: failed to get token: %s", string(data))
-	}
-
-	var tokenResp TokenResponse
-	if err := json.Unmarshal(data, &tokenResp); err != nil {
-		return "", fmt.Errorf("tidal: failed to parse token response: %w", err)
-	}
-
-	c.token = tokenResp.AccessToken
-	c.tokenExp = time.Now().Add(time.Duration(tokenResp.ExpiresIn) * time.Second)
-	log.Trace(ctx, "Obtained Tidal OAuth token", "expiresIn", tokenResp.ExpiresIn)
-
-	return c.token, nil
-}
-
-func (c *client) makeRequest(req *http.Request, response any) error {
-	log.Trace(req.Context(), fmt.Sprintf("Sending Tidal %s request", req.Method), "url", req.URL)
-	resp, err := c.hc.Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	data, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return err
-	}
-
-	if resp.StatusCode == http.StatusNotFound {
-		return ErrNotFound
-	}
-
-	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusMultiStatus {
-		return c.parseError(data, resp.StatusCode)
-	}
-
-	return json.Unmarshal(data, response)
-}
-
-func (c *client) parseError(data []byte, statusCode int) error {
-	var errResp ErrorResponse
-	if err := json.Unmarshal(data, &errResp); err != nil {
-		return fmt.Errorf("tidal error (status %d): %s", statusCode, string(data))
-	}
-	if len(errResp.Errors) > 0 {
-		return fmt.Errorf("tidal error (%s): %s", errResp.Errors[0].Code, errResp.Errors[0].Detail)
-	}
-	return fmt.Errorf("tidal error (status %d)", statusCode)
-}

adapters/tidal/client_test.go

@@ -1,156 +0,0 @@
-package tidal
-
-import (
-	"bytes"
-	"io"
-	"net/http"
-	"os"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("client", func() {
-	var httpClient *fakeHttpClient
-	var c *client
-
-	BeforeEach(func() {
-		httpClient = &fakeHttpClient{}
-		c = newClient("test-client-id", "test-client-secret", httpClient)
-	})
-
-	Describe("searchArtists", func() {
-		BeforeEach(func() {
-			// Mock token response
-			httpClient.mock("https://auth.tidal.com/v1/oauth2/token", http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			})
-		})
-
-		It("returns artists from a successful request", func() {
-			f, err := os.Open("tests/fixtures/tidal.search.artist.json")
-			Expect(err).To(BeNil())
-			httpClient.mock("https://openapi.tidal.com/search", http.Response{Body: f, StatusCode: 200})
-
-			artists, err := c.searchArtists(GinkgoT().Context(), "Daft Punk", 20)
-			Expect(err).To(BeNil())
-			Expect(artists).To(HaveLen(2))
-			Expect(artists[0].Attributes.Name).To(Equal("Daft Punk"))
-		})
-
-		It("returns ErrNotFound when no artists found", func() {
-			httpClient.mock("https://openapi.tidal.com/search", http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"artists":[]}`)),
-			})
-
-			_, err := c.searchArtists(GinkgoT().Context(), "Nonexistent Artist", 20)
-			Expect(err).To(MatchError(ErrNotFound))
-		})
-	})
-
-	Describe("getArtistTopTracks", func() {
-		BeforeEach(func() {
-			// Mock token response
-			httpClient.mock("https://auth.tidal.com/v1/oauth2/token", http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			})
-		})
-
-		It("returns tracks from a successful request", func() {
-			f, err := os.Open("tests/fixtures/tidal.artist.tracks.json")
-			Expect(err).To(BeNil())
-			httpClient.mock("https://openapi.tidal.com/artists/4837227/tracks", http.Response{Body: f, StatusCode: 200})
-
-			tracks, err := c.getArtistTopTracks(GinkgoT().Context(), "4837227", 10)
-			Expect(err).To(BeNil())
-			Expect(tracks).To(HaveLen(3))
-			Expect(tracks[0].Attributes.Title).To(Equal("Get Lucky"))
-			Expect(tracks[0].Attributes.Duration).To(Equal(369))
-		})
-	})
-
-	Describe("getSimilarArtists", func() {
-		BeforeEach(func() {
-			// Mock token response
-			httpClient.mock("https://auth.tidal.com/v1/oauth2/token", http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			})
-		})
-
-		It("returns similar artists from a successful request", func() {
-			f, err := os.Open("tests/fixtures/tidal.similar.artists.json")
-			Expect(err).To(BeNil())
-			httpClient.mock("https://openapi.tidal.com/artists/4837227/similar", http.Response{Body: f, StatusCode: 200})
-
-			artists, err := c.getSimilarArtists(GinkgoT().Context(), "4837227", 10)
-			Expect(err).To(BeNil())
-			Expect(artists).To(HaveLen(3))
-			Expect(artists[0].Attributes.Name).To(Equal("Justice"))
-		})
-	})
-
-	Describe("getToken", func() {
-		It("returns token from a successful request", func() {
-			httpClient.mock("https://auth.tidal.com/v1/oauth2/token", http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token-123","token_type":"Bearer","expires_in":86400}`)),
-			})
-
-			token, err := c.getToken(GinkgoT().Context())
-			Expect(err).To(BeNil())
-			Expect(token).To(Equal("test-token-123"))
-		})
-
-		It("caches token for subsequent requests", func() {
-			httpClient.mock("https://auth.tidal.com/v1/oauth2/token", http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token-123","token_type":"Bearer","expires_in":86400}`)),
-			})
-
-			token1, err := c.getToken(GinkgoT().Context())
-			Expect(err).To(BeNil())
-
-			// Second call should use cached token
-			token2, err := c.getToken(GinkgoT().Context())
-			Expect(err).To(BeNil())
-			Expect(token2).To(Equal(token1))
-		})
-
-		It("returns error on failed token request", func() {
-			httpClient.mock("https://auth.tidal.com/v1/oauth2/token", http.Response{
-				StatusCode: 401,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"error":"invalid_client"}`)),
-			})
-
-			_, err := c.getToken(GinkgoT().Context())
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("failed to get token"))
-		})
-	})
-})
-
-type fakeHttpClient struct {
-	responses   map[string]*http.Response
-	lastRequest *http.Request
-}
-
-func (c *fakeHttpClient) mock(url string, response http.Response) {
-	if c.responses == nil {
-		c.responses = make(map[string]*http.Response)
-	}
-	c.responses[url] = &response
-}
-
-func (c *fakeHttpClient) Do(req *http.Request) (*http.Response, error) {
-	c.lastRequest = req
-	u := req.URL
-	u.RawQuery = ""
-	if resp, ok := c.responses[u.String()]; ok {
-		return resp, nil
-	}
-	panic("URL not mocked: " + u.String())
-}

adapters/tidal/responses.go

@@ -1,128 +0,0 @@
-package tidal
-
-// SearchResponse represents the JSON:API response from Tidal search endpoint
-type SearchResponse struct {
-	Artists []ArtistResource `json:"data"`
-}
-
-// ArtistResource represents an artist in Tidal's JSON:API format
-type ArtistResource struct {
-	ID         string           `json:"id"`
-	Type       string           `json:"type"`
-	Attributes ArtistAttributes `json:"attributes"`
-}
-
-// ArtistAttributes contains the artist's metadata
-type ArtistAttributes struct {
-	Name       string   `json:"name"`
-	Popularity int      `json:"popularity"`
-	Picture    []Image  `json:"picture"`
-	ExternalLinks []Link `json:"externalLinks,omitempty"`
-}
-
-// Image represents an image resource from Tidal
-type Image struct {
-	URL    string `json:"url"`
-	Width  int    `json:"width"`
-	Height int    `json:"height"`
-}
-
-// Link represents an external link
-type Link struct {
-	Href string `json:"href"`
-	Meta struct {
-		Type string `json:"type"`
-	} `json:"meta,omitempty"`
-}
-
-// TracksResponse represents the response from artist top tracks endpoint
-type TracksResponse struct {
-	Data []TrackResource `json:"data"`
-}
-
-// TrackResource represents a track in Tidal's JSON:API format
-type TrackResource struct {
-	ID         string          `json:"id"`
-	Type       string          `json:"type"`
-	Attributes TrackAttributes `json:"attributes"`
-}
-
-// TrackAttributes contains track metadata
-type TrackAttributes struct {
-	Title      string `json:"title"`
-	ISRC       string `json:"isrc"`
-	Duration   int    `json:"duration"` // Duration in seconds
-	Popularity int    `json:"popularity"`
-}
-
-// TrackWithArtist represents a track with artist info from the search response
-type TrackWithArtist struct {
-	ID         string                    `json:"id"`
-	Type       string                    `json:"type"`
-	Attributes TrackAttributesWithArtist `json:"attributes"`
-}
-
-// TrackAttributesWithArtist contains track metadata with artist info
-type TrackAttributesWithArtist struct {
-	Title    string              `json:"title"`
-	ISRC     string              `json:"isrc"`
-	Duration int                 `json:"duration"` // Duration in seconds
-	Artists  []ArtistReference   `json:"artists"`
-	Album    *AlbumReference     `json:"album,omitempty"`
-}
-
-// ArtistReference represents a reference to an artist in a track
-type ArtistReference struct {
-	ID   string `json:"id"`
-	Name string `json:"name"`
-}
-
-// AlbumReference represents a reference to an album in a track
-type AlbumReference struct {
-	ID    string `json:"id"`
-	Title string `json:"title"`
-}
-
-// SimilarArtistsResponse represents the response from similar artists endpoint
-type SimilarArtistsResponse struct {
-	Data []ArtistResource `json:"data"`
-}
-
-// AlbumsResponse represents the response from albums endpoint
-type AlbumsResponse struct {
-	Data []AlbumResource `json:"data"`
-}
-
-// AlbumResource represents an album in Tidal's JSON:API format
-type AlbumResource struct {
-	ID         string          `json:"id"`
-	Type       string          `json:"type"`
-	Attributes AlbumAttributes `json:"attributes"`
-}
-
-// AlbumAttributes contains album metadata
-type AlbumAttributes struct {
-	Title       string  `json:"title"`
-	ReleaseDate string  `json:"releaseDate"`
-	Cover       []Image `json:"cover"`
-}
-
-// TokenResponse represents the OAuth token response
-type TokenResponse struct {
-	AccessToken string `json:"access_token"`
-	TokenType   string `json:"token_type"`
-	ExpiresIn   int    `json:"expires_in"`
-}
-
-// ErrorResponse represents an error from the Tidal API
-type ErrorResponse struct {
-	Errors []APIError `json:"errors"`
-}
-
-// APIError represents a single error in the errors array
-type APIError struct {
-	ID     string `json:"id"`
-	Status int    `json:"status"`
-	Code   string `json:"code"`
-	Detail string `json:"detail"`
-}

adapters/tidal/tests/fixtures/tidal.album.review.json

@@ -1,3 +0,0 @@
-{
-  "text": "Random Access Memories is the fourth studio album by French electronic music duo Daft Punk. It was released on 17 May 2013 through Columbia Records. The album pays tribute to the late 1970s and early 1980s era of music."
-}

adapters/tidal/tests/fixtures/tidal.artist.bio.json

@@ -1,3 +0,0 @@
-{
-  "text": "Daft Punk was a French electronic music duo formed in Paris in 1993. The duo consisted of musicians Thomas Bangalter and Guy-Manuel de Homem-Christo. They achieved popularity in the late 1990s as part of the French house movement."
-}

adapters/tidal/tests/fixtures/tidal.artist.tracks.json

@@ -1,34 +0,0 @@
-{
-  "data": [
-    {
-      "id": "28048253",
-      "type": "tracks",
-      "attributes": {
-        "title": "Get Lucky",
-        "isrc": "USQX91300104",
-        "duration": 369,
-        "popularity": 95
-      }
-    },
-    {
-      "id": "28048256",
-      "type": "tracks",
-      "attributes": {
-        "title": "Instant Crush",
-        "isrc": "USQX91300107",
-        "duration": 337,
-        "popularity": 88
-      }
-    },
-    {
-      "id": "1269012",
-      "type": "tracks",
-      "attributes": {
-        "title": "Around the World",
-        "isrc": "FRZ119700490",
-        "duration": 429,
-        "popularity": 85
-      }
-    }
-  ]
-}

adapters/tidal/tests/fixtures/tidal.search.album.json

@@ -1,44 +0,0 @@
-{
-  "albums": [
-    {
-      "id": "28048252",
-      "type": "albums",
-      "attributes": {
-        "title": "Random Access Memories",
-        "releaseDate": "2013-05-17",
-        "cover": [
-          {
-            "url": "https://resources.tidal.com/images/04d63cd8/a1a5/42e0/b1ec/8e336b7d9200/750x750.jpg",
-            "width": 750,
-            "height": 750
-          },
-          {
-            "url": "https://resources.tidal.com/images/04d63cd8/a1a5/42e0/b1ec/8e336b7d9200/320x320.jpg",
-            "width": 320,
-            "height": 320
-          },
-          {
-            "url": "https://resources.tidal.com/images/04d63cd8/a1a5/42e0/b1ec/8e336b7d9200/160x160.jpg",
-            "width": 160,
-            "height": 160
-          }
-        ]
-      }
-    },
-    {
-      "id": "1234567",
-      "type": "albums",
-      "attributes": {
-        "title": "Random Access Memories (Drumless Edition)",
-        "releaseDate": "2023-11-17",
-        "cover": [
-          {
-            "url": "https://resources.tidal.com/images/deadbeef/1234/5678/9abc/def012345678/750x750.jpg",
-            "width": 750,
-            "height": 750
-          }
-        ]
-      }
-    }
-  ]
-}

adapters/tidal/tests/fixtures/tidal.search.artist.json

@@ -1,38 +0,0 @@
-{
-  "artists": [
-    {
-      "id": "4837227",
-      "type": "artists",
-      "attributes": {
-        "name": "Daft Punk",
-        "popularity": 85,
-        "picture": [
-          {
-            "url": "https://resources.tidal.com/images/04d63cd8/a1a5/42e0/b1ec/8e336b7d9200/750x750.jpg",
-            "width": 750,
-            "height": 750
-          },
-          {
-            "url": "https://resources.tidal.com/images/04d63cd8/a1a5/42e0/b1ec/8e336b7d9200/480x480.jpg",
-            "width": 480,
-            "height": 480
-          },
-          {
-            "url": "https://resources.tidal.com/images/04d63cd8/a1a5/42e0/b1ec/8e336b7d9200/320x320.jpg",
-            "width": 320,
-            "height": 320
-          }
-        ]
-      }
-    },
-    {
-      "id": "12345678",
-      "type": "artists",
-      "attributes": {
-        "name": "Daft Punk Tribute",
-        "popularity": 20,
-        "picture": []
-      }
-    }
-  ]
-}

adapters/tidal/tests/fixtures/tidal.search.track.json

@@ -1,24 +0,0 @@
-{
-  "tracks": [
-    {
-      "id": "28048253",
-      "type": "tracks",
-      "attributes": {
-        "title": "Get Lucky",
-        "isrc": "USQX91300104",
-        "duration": 369,
-        "popularity": 95
-      }
-    },
-    {
-      "id": "1234567",
-      "type": "tracks",
-      "attributes": {
-        "title": "Get Lucky (Radio Edit)",
-        "isrc": "USQX91300105",
-        "duration": 248,
-        "popularity": 75
-      }
-    }
-  ]
-}

adapters/tidal/tests/fixtures/tidal.similar.artists.json

@@ -1,49 +0,0 @@
-{
-  "data": [
-    {
-      "id": "1234567",
-      "type": "artists",
-      "attributes": {
-        "name": "Justice",
-        "popularity": 72,
-        "picture": [
-          {
-            "url": "https://resources.tidal.com/images/abc12345/1234/5678/9abc/def012345678/750x750.jpg",
-            "width": 750,
-            "height": 750
-          }
-        ]
-      }
-    },
-    {
-      "id": "2345678",
-      "type": "artists",
-      "attributes": {
-        "name": "Kavinsky",
-        "popularity": 65,
-        "picture": [
-          {
-            "url": "https://resources.tidal.com/images/bcd23456/2345/6789/abcd/ef0123456789/750x750.jpg",
-            "width": 750,
-            "height": 750
-          }
-        ]
-      }
-    },
-    {
-      "id": "3456789",
-      "type": "artists",
-      "attributes": {
-        "name": "Breakbot",
-        "popularity": 58,
-        "picture": [
-          {
-            "url": "https://resources.tidal.com/images/cde34567/3456/789a/bcde/f01234567890/750x750.jpg",
-            "width": 750,
-            "height": 750
-          }
-        ]
-      }
-    }
-  ]
-}

adapters/tidal/tests/fixtures/tidal.track.radio.json

@@ -1,34 +0,0 @@
-{
-  "data": [
-    {
-      "id": "12345678",
-      "type": "tracks",
-      "attributes": {
-        "title": "Starboy",
-        "isrc": "USUG11601092",
-        "duration": 230,
-        "popularity": 92
-      }
-    },
-    {
-      "id": "23456789",
-      "type": "tracks",
-      "attributes": {
-        "title": "Blinding Lights",
-        "isrc": "USUG11904154",
-        "duration": 200,
-        "popularity": 98
-      }
-    },
-    {
-      "id": "34567890",
-      "type": "tracks",
-      "attributes": {
-        "title": "Uptown Funk",
-        "isrc": "GBAHS1400099",
-        "duration": 270,
-        "popularity": 90
-      }
-    }
-  ]
-}

adapters/tidal/tidal.go

@@ -1,365 +0,0 @@
-package tidal
-
-import (
-	"context"
-	"errors"
-	"net/http"
-	"strings"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/consts"
-	"github.com/navidrome/navidrome/core/agents"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/utils/cache"
-	"github.com/navidrome/navidrome/utils/slice"
-)
-
-const tidalAgentName = "tidal"
-const tidalArtistSearchLimit = 20
-const tidalAlbumSearchLimit = 10
-const tidalTrackSearchLimit = 10
-const tidalArtistURLBase = "https://tidal.com/browse/artist/"
-
-type tidalAgent struct {
-	ds     model.DataStore
-	client *client
-}
-
-func tidalConstructor(ds model.DataStore) agents.Interface {
-	if conf.Server.Tidal.ClientID == "" || conf.Server.Tidal.ClientSecret == "" {
-		return nil
-	}
-	l := &tidalAgent{
-		ds: ds,
-	}
-	hc := &http.Client{
-		Timeout: consts.DefaultHttpClientTimeOut,
-	}
-	chc := cache.NewHTTPClient(hc, consts.DefaultHttpClientTimeOut)
-	l.client = newClient(conf.Server.Tidal.ClientID, conf.Server.Tidal.ClientSecret, chc)
-	return l
-}
-
-func (t *tidalAgent) AgentName() string {
-	return tidalAgentName
-}
-
-func (t *tidalAgent) GetArtistImages(ctx context.Context, id, name, mbid string) ([]agents.ExternalImage, error) {
-	artist, err := t.searchArtist(ctx, name)
-	if err != nil {
-		if errors.Is(err, agents.ErrNotFound) {
-			log.Warn(ctx, "Artist not found in Tidal", "artist", name)
-		} else {
-			log.Error(ctx, "Error calling Tidal", "artist", name, err)
-		}
-		return nil, err
-	}
-
-	var res []agents.ExternalImage
-	for _, img := range artist.Attributes.Picture {
-		res = append(res, agents.ExternalImage{
-			URL:  img.URL,
-			Size: img.Width,
-		})
-	}
-
-	// Sort images by size descending
-	if len(res) == 0 {
-		return nil, agents.ErrNotFound
-	}
-
-	return res, nil
-}
-
-func (t *tidalAgent) GetSimilarArtists(ctx context.Context, id, name, mbid string, limit int) ([]agents.Artist, error) {
-	artist, err := t.searchArtist(ctx, name)
-	if err != nil {
-		return nil, err
-	}
-
-	similar, err := t.client.getSimilarArtists(ctx, artist.ID, limit)
-	if err != nil {
-		if errors.Is(err, ErrNotFound) {
-			return nil, agents.ErrNotFound
-		}
-		return nil, err
-	}
-
-	res := slice.Map(similar, func(a ArtistResource) agents.Artist {
-		return agents.Artist{
-			Name: a.Attributes.Name,
-		}
-	})
-
-	return res, nil
-}
-
-func (t *tidalAgent) GetArtistTopSongs(ctx context.Context, id, artistName, mbid string, count int) ([]agents.Song, error) {
-	artist, err := t.searchArtist(ctx, artistName)
-	if err != nil {
-		return nil, err
-	}
-
-	tracks, err := t.client.getArtistTopTracks(ctx, artist.ID, count)
-	if err != nil {
-		if errors.Is(err, ErrNotFound) {
-			return nil, agents.ErrNotFound
-		}
-		return nil, err
-	}
-
-	res := slice.Map(tracks, func(track TrackResource) agents.Song {
-		return agents.Song{
-			Name:     track.Attributes.Title,
-			ISRC:     track.Attributes.ISRC,
-			Duration: uint32(track.Attributes.Duration * 1000), // Convert seconds to milliseconds
-		}
-	})
-
-	return res, nil
-}
-
-func (t *tidalAgent) GetArtistURL(ctx context.Context, id, name, mbid string) (string, error) {
-	artist, err := t.searchArtist(ctx, name)
-	if err != nil {
-		return "", err
-	}
-
-	return tidalArtistURLBase + artist.ID, nil
-}
-
-func (t *tidalAgent) GetArtistBiography(ctx context.Context, id, name, mbid string) (string, error) {
-	artist, err := t.searchArtist(ctx, name)
-	if err != nil {
-		return "", err
-	}
-
-	bio, err := t.client.getArtistBio(ctx, artist.ID)
-	if err != nil {
-		if errors.Is(err, ErrNotFound) {
-			return "", agents.ErrNotFound
-		}
-		log.Error(ctx, "Error getting artist bio from Tidal", "artist", name, err)
-		return "", err
-	}
-
-	return bio, nil
-}
-
-func (t *tidalAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid string) (*agents.AlbumInfo, error) {
-	album, err := t.searchAlbum(ctx, name, artist)
-	if err != nil {
-		return nil, err
-	}
-
-	// Try to get album review/description
-	description, err := t.client.getAlbumReview(ctx, album.ID)
-	if err != nil && !errors.Is(err, ErrNotFound) {
-		log.Warn(ctx, "Error getting album review from Tidal", "album", name, err)
-	}
-
-	return &agents.AlbumInfo{
-		Name:        album.Attributes.Title,
-		Description: description,
-		URL:         "https://tidal.com/browse/album/" + album.ID,
-	}, nil
-}
-
-func (t *tidalAgent) GetAlbumImages(ctx context.Context, name, artist, mbid string) ([]agents.ExternalImage, error) {
-	album, err := t.searchAlbum(ctx, name, artist)
-	if err != nil {
-		if errors.Is(err, agents.ErrNotFound) {
-			log.Warn(ctx, "Album not found in Tidal", "album", name, "artist", artist)
-		} else {
-			log.Error(ctx, "Error calling Tidal for album", "album", name, "artist", artist, err)
-		}
-		return nil, err
-	}
-
-	var res []agents.ExternalImage
-	for _, img := range album.Attributes.Cover {
-		res = append(res, agents.ExternalImage{
-			URL:  img.URL,
-			Size: img.Width,
-		})
-	}
-
-	if len(res) == 0 {
-		return nil, agents.ErrNotFound
-	}
-
-	return res, nil
-}
-
-func (t *tidalAgent) GetSimilarSongsByArtist(ctx context.Context, id, name, mbid string, count int) ([]agents.Song, error) {
-	artist, err := t.searchArtist(ctx, name)
-	if err != nil {
-		return nil, err
-	}
-
-	// Get similar artists
-	similarArtists, err := t.client.getSimilarArtists(ctx, artist.ID, 5)
-	if err != nil {
-		if errors.Is(err, ErrNotFound) {
-			return nil, agents.ErrNotFound
-		}
-		return nil, err
-	}
-
-	if len(similarArtists) == 0 {
-		return nil, agents.ErrNotFound
-	}
-
-	// Get top tracks from similar artists
-	var songs []agents.Song
-	tracksPerArtist := (count / len(similarArtists)) + 1
-
-	for _, simArtist := range similarArtists {
-		tracks, err := t.client.getArtistTopTracks(ctx, simArtist.ID, tracksPerArtist)
-		if err != nil {
-			log.Warn(ctx, "Failed to get top tracks for similar artist", "artist", simArtist.Attributes.Name, err)
-			continue
-		}
-
-		for _, track := range tracks {
-			songs = append(songs, agents.Song{
-				Name:     track.Attributes.Title,
-				Artist:   simArtist.Attributes.Name,
-				ISRC:     track.Attributes.ISRC,
-				Duration: uint32(track.Attributes.Duration * 1000),
-			})
-			if len(songs) >= count {
-				return songs, nil
-			}
-		}
-	}
-
-	if len(songs) == 0 {
-		return nil, agents.ErrNotFound
-	}
-
-	return songs, nil
-}
-
-func (t *tidalAgent) GetSimilarSongsByTrack(ctx context.Context, id, name, artist, mbid string, count int) ([]agents.Song, error) {
-	track, err := t.searchTrack(ctx, name, artist)
-	if err != nil {
-		if errors.Is(err, agents.ErrNotFound) {
-			log.Warn(ctx, "Track not found in Tidal", "track", name, "artist", artist)
-		} else {
-			log.Error(ctx, "Error searching track in Tidal", "track", name, "artist", artist, err)
-		}
-		return nil, err
-	}
-
-	// Get track radio (similar tracks)
-	similarTracks, err := t.client.getTrackRadio(ctx, track.ID, count)
-	if err != nil {
-		if errors.Is(err, ErrNotFound) {
-			return nil, agents.ErrNotFound
-		}
-		log.Error(ctx, "Error getting track radio from Tidal", "trackId", track.ID, err)
-		return nil, err
-	}
-
-	if len(similarTracks) == 0 {
-		return nil, agents.ErrNotFound
-	}
-
-	res := slice.Map(similarTracks, func(track TrackResource) agents.Song {
-		return agents.Song{
-			Name:     track.Attributes.Title,
-			ISRC:     track.Attributes.ISRC,
-			Duration: uint32(track.Attributes.Duration * 1000),
-		}
-	})
-
-	return res, nil
-}
-
-func (t *tidalAgent) searchTrack(ctx context.Context, trackName, artistName string) (*TrackResource, error) {
-	tracks, err := t.client.searchTracks(ctx, trackName, artistName, tidalTrackSearchLimit)
-	if err != nil {
-		if errors.Is(err, ErrNotFound) {
-			return nil, agents.ErrNotFound
-		}
-		return nil, err
-	}
-
-	if len(tracks) == 0 {
-		return nil, agents.ErrNotFound
-	}
-
-	// Find exact match (case-insensitive)
-	for i := range tracks {
-		if strings.EqualFold(tracks[i].Attributes.Title, trackName) {
-			log.Trace(ctx, "Found track in Tidal", "title", tracks[i].Attributes.Title, "id", tracks[i].ID)
-			return &tracks[i], nil
-		}
-	}
-
-	// If no exact match, check if first result is close enough
-	log.Trace(ctx, "No exact track match in Tidal", "searched", trackName, "found", tracks[0].Attributes.Title)
-	return nil, agents.ErrNotFound
-}
-
-func (t *tidalAgent) searchArtist(ctx context.Context, name string) (*ArtistResource, error) {
-	artists, err := t.client.searchArtists(ctx, name, tidalArtistSearchLimit)
-	if err != nil {
-		if errors.Is(err, ErrNotFound) {
-			return nil, agents.ErrNotFound
-		}
-		return nil, err
-	}
-
-	if len(artists) == 0 {
-		return nil, agents.ErrNotFound
-	}
-
-	// Find exact match (case-insensitive)
-	for i := range artists {
-		if strings.EqualFold(artists[i].Attributes.Name, name) {
-			log.Trace(ctx, "Found artist in Tidal", "name", artists[i].Attributes.Name, "id", artists[i].ID)
-			return &artists[i], nil
-		}
-	}
-
-	// If no exact match, check if first result is close enough
-	log.Trace(ctx, "No exact artist match in Tidal", "searched", name, "found", artists[0].Attributes.Name)
-	return nil, agents.ErrNotFound
-}
-
-func (t *tidalAgent) searchAlbum(ctx context.Context, albumName, artistName string) (*AlbumResource, error) {
-	albums, err := t.client.searchAlbums(ctx, albumName, artistName, tidalAlbumSearchLimit)
-	if err != nil {
-		if errors.Is(err, ErrNotFound) {
-			return nil, agents.ErrNotFound
-		}
-		return nil, err
-	}
-
-	if len(albums) == 0 {
-		return nil, agents.ErrNotFound
-	}
-
-	// Find exact match (case-insensitive)
-	for i := range albums {
-		if strings.EqualFold(albums[i].Attributes.Title, albumName) {
-			log.Trace(ctx, "Found album in Tidal", "title", albums[i].Attributes.Title, "id", albums[i].ID)
-			return &albums[i], nil
-		}
-	}
-
-	// If no exact match, check if first result is close enough
-	log.Trace(ctx, "No exact album match in Tidal", "searched", albumName, "found", albums[0].Attributes.Title)
-	return nil, agents.ErrNotFound
-}
-
-func init() {
-	conf.AddHook(func() {
-		if conf.Server.Tidal.Enabled {
-			agents.Register(tidalAgentName, tidalConstructor)
-		}
-	})
-}

adapters/tidal/tidal_suite_test.go

@@ -1,17 +0,0 @@
-package tidal
-
-import (
-	"testing"
-
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-func TestTidal(t *testing.T) {
-	tests.Init(t, false)
-	log.SetLevel(log.LevelFatal)
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Tidal Test Suite")
-}

adapters/tidal/tidal_test.go

@@ -1,655 +0,0 @@
-package tidal
-
-import (
-	"bytes"
-	"context"
-	"io"
-	"net/http"
-	"os"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/conf/configtest"
-	"github.com/navidrome/navidrome/core/agents"
-	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("tidalAgent", func() {
-	var ctx context.Context
-
-	BeforeEach(func() {
-		ctx = context.Background()
-		DeferCleanup(configtest.SetupConfig())
-		conf.Server.Tidal.Enabled = true
-		conf.Server.Tidal.ClientID = "test-client-id"
-		conf.Server.Tidal.ClientSecret = "test-client-secret"
-	})
-
-	Describe("tidalConstructor", func() {
-		It("returns nil when client ID is empty", func() {
-			conf.Server.Tidal.ClientID = ""
-			agent := tidalConstructor(&tests.MockDataStore{})
-			Expect(agent).To(BeNil())
-		})
-
-		It("returns nil when client secret is empty", func() {
-			conf.Server.Tidal.ClientSecret = ""
-			agent := tidalConstructor(&tests.MockDataStore{})
-			Expect(agent).To(BeNil())
-		})
-
-		It("returns agent when credentials are configured", func() {
-			agent := tidalConstructor(&tests.MockDataStore{})
-			Expect(agent).ToNot(BeNil())
-			Expect(agent.AgentName()).To(Equal("tidal"))
-		})
-	})
-
-	Describe("GetArtistImages", func() {
-		var agent *tidalAgent
-		var httpClient *mockHttpClient
-
-		BeforeEach(func() {
-			httpClient = newMockHttpClient()
-			agent = &tidalAgent{
-				ds:     &tests.MockDataStore{},
-				client: newClient("test-id", "test-secret", httpClient),
-			}
-		})
-
-		It("returns artist images from search result", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock search response
-			fSearch, _ := os.Open("tests/fixtures/tidal.search.artist.json")
-			httpClient.searchResponse = &http.Response{Body: fSearch, StatusCode: 200}
-
-			images, err := agent.GetArtistImages(ctx, "", "Daft Punk", "")
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(images).To(HaveLen(3))
-			Expect(images[0].URL).To(ContainSubstring("resources.tidal.com"))
-			Expect(images[0].Size).To(Equal(750))
-		})
-
-		It("returns ErrNotFound when artist is not found", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock empty search response
-			httpClient.searchResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"artists":[]}`)),
-			}
-
-			_, err := agent.GetArtistImages(ctx, "", "Nonexistent Artist", "")
-
-			Expect(err).To(MatchError(agents.ErrNotFound))
-		})
-
-		It("returns ErrNotFound when artist name doesn't match", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock search response with different artist
-			fSearch, _ := os.Open("tests/fixtures/tidal.search.artist.json")
-			httpClient.searchResponse = &http.Response{Body: fSearch, StatusCode: 200}
-
-			_, err := agent.GetArtistImages(ctx, "", "Wrong Artist Name", "")
-
-			Expect(err).To(MatchError(agents.ErrNotFound))
-		})
-	})
-
-	Describe("GetSimilarArtists", func() {
-		var agent *tidalAgent
-		var httpClient *mockHttpClient
-
-		BeforeEach(func() {
-			httpClient = newMockHttpClient()
-			agent = &tidalAgent{
-				ds:     &tests.MockDataStore{},
-				client: newClient("test-id", "test-secret", httpClient),
-			}
-		})
-
-		It("returns similar artists", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock search response
-			fSearch, _ := os.Open("tests/fixtures/tidal.search.artist.json")
-			httpClient.searchResponse = &http.Response{Body: fSearch, StatusCode: 200}
-
-			// Mock similar artists response
-			fSimilar, _ := os.Open("tests/fixtures/tidal.similar.artists.json")
-			httpClient.similarResponse = &http.Response{Body: fSimilar, StatusCode: 200}
-
-			similar, err := agent.GetSimilarArtists(ctx, "", "Daft Punk", "", 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(similar).To(HaveLen(3))
-			Expect(similar[0].Name).To(Equal("Justice"))
-		})
-	})
-
-	Describe("GetArtistTopSongs", func() {
-		var agent *tidalAgent
-		var httpClient *mockHttpClient
-
-		BeforeEach(func() {
-			httpClient = newMockHttpClient()
-			agent = &tidalAgent{
-				ds:     &tests.MockDataStore{},
-				client: newClient("test-id", "test-secret", httpClient),
-			}
-		})
-
-		It("returns artist top songs", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock search response
-			fSearch, _ := os.Open("tests/fixtures/tidal.search.artist.json")
-			httpClient.searchResponse = &http.Response{Body: fSearch, StatusCode: 200}
-
-			// Mock top tracks response
-			fTracks, _ := os.Open("tests/fixtures/tidal.artist.tracks.json")
-			httpClient.tracksResponse = &http.Response{Body: fTracks, StatusCode: 200}
-
-			songs, err := agent.GetArtistTopSongs(ctx, "", "Daft Punk", "", 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(songs).To(HaveLen(3))
-			Expect(songs[0].Name).To(Equal("Get Lucky"))
-			Expect(songs[0].Duration).To(Equal(uint32(369000))) // 369 seconds * 1000
-		})
-	})
-
-	Describe("GetArtistURL", func() {
-		var agent *tidalAgent
-		var httpClient *mockHttpClient
-
-		BeforeEach(func() {
-			httpClient = newMockHttpClient()
-			agent = &tidalAgent{
-				ds:     &tests.MockDataStore{},
-				client: newClient("test-id", "test-secret", httpClient),
-			}
-		})
-
-		It("returns artist URL", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock search response
-			fSearch, _ := os.Open("tests/fixtures/tidal.search.artist.json")
-			httpClient.searchResponse = &http.Response{Body: fSearch, StatusCode: 200}
-
-			url, err := agent.GetArtistURL(ctx, "", "Daft Punk", "")
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(url).To(Equal("https://tidal.com/browse/artist/4837227"))
-		})
-	})
-
-	Describe("GetArtistBiography", func() {
-		var agent *tidalAgent
-		var httpClient *mockHttpClient
-
-		BeforeEach(func() {
-			httpClient = newMockHttpClient()
-			agent = &tidalAgent{
-				ds:     &tests.MockDataStore{},
-				client: newClient("test-id", "test-secret", httpClient),
-			}
-		})
-
-		It("returns artist biography", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock search response
-			fSearch, _ := os.Open("tests/fixtures/tidal.search.artist.json")
-			httpClient.searchResponse = &http.Response{Body: fSearch, StatusCode: 200}
-
-			// Mock bio response
-			fBio, _ := os.Open("tests/fixtures/tidal.artist.bio.json")
-			httpClient.artistBioResponse = &http.Response{Body: fBio, StatusCode: 200}
-
-			bio, err := agent.GetArtistBiography(ctx, "", "Daft Punk", "")
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(bio).To(ContainSubstring("French electronic music duo"))
-		})
-
-		It("returns ErrNotFound when bio is empty", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock search response
-			fSearch, _ := os.Open("tests/fixtures/tidal.search.artist.json")
-			httpClient.searchResponse = &http.Response{Body: fSearch, StatusCode: 200}
-
-			// Mock empty bio response
-			httpClient.artistBioResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"text":""}`)),
-			}
-
-			_, err := agent.GetArtistBiography(ctx, "", "Daft Punk", "")
-
-			Expect(err).To(MatchError(agents.ErrNotFound))
-		})
-	})
-
-	Describe("GetAlbumInfo", func() {
-		var agent *tidalAgent
-		var httpClient *mockHttpClient
-
-		BeforeEach(func() {
-			httpClient = newMockHttpClient()
-			agent = &tidalAgent{
-				ds:     &tests.MockDataStore{},
-				client: newClient("test-id", "test-secret", httpClient),
-			}
-		})
-
-		It("returns album info with description", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock album search response
-			fAlbum, _ := os.Open("tests/fixtures/tidal.search.album.json")
-			httpClient.albumSearchResponse = &http.Response{Body: fAlbum, StatusCode: 200}
-
-			// Mock album review response
-			fReview, _ := os.Open("tests/fixtures/tidal.album.review.json")
-			httpClient.albumReviewResponse = &http.Response{Body: fReview, StatusCode: 200}
-
-			info, err := agent.GetAlbumInfo(ctx, "Random Access Memories", "Daft Punk", "")
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(info.Name).To(Equal("Random Access Memories"))
-			Expect(info.Description).To(ContainSubstring("fourth studio album"))
-			Expect(info.URL).To(Equal("https://tidal.com/browse/album/28048252"))
-		})
-
-		It("returns album info without description when review not available", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock album search response
-			fAlbum, _ := os.Open("tests/fixtures/tidal.search.album.json")
-			httpClient.albumSearchResponse = &http.Response{Body: fAlbum, StatusCode: 200}
-
-			// Mock empty album review response
-			httpClient.albumReviewResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"text":""}`)),
-			}
-
-			info, err := agent.GetAlbumInfo(ctx, "Random Access Memories", "Daft Punk", "")
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(info.Name).To(Equal("Random Access Memories"))
-			Expect(info.Description).To(BeEmpty())
-			Expect(info.URL).To(Equal("https://tidal.com/browse/album/28048252"))
-		})
-	})
-
-	Describe("GetAlbumImages", func() {
-		var agent *tidalAgent
-		var httpClient *mockHttpClient
-
-		BeforeEach(func() {
-			httpClient = newMockHttpClient()
-			agent = &tidalAgent{
-				ds:     &tests.MockDataStore{},
-				client: newClient("test-id", "test-secret", httpClient),
-			}
-		})
-
-		It("returns album images", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock album search response
-			fAlbum, _ := os.Open("tests/fixtures/tidal.search.album.json")
-			httpClient.albumSearchResponse = &http.Response{Body: fAlbum, StatusCode: 200}
-
-			images, err := agent.GetAlbumImages(ctx, "Random Access Memories", "Daft Punk", "")
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(images).To(HaveLen(3))
-			Expect(images[0].URL).To(ContainSubstring("resources.tidal.com"))
-			Expect(images[0].Size).To(Equal(750))
-		})
-
-		It("returns ErrNotFound when album is not found", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock empty album search response
-			httpClient.albumSearchResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"albums":[]}`)),
-			}
-
-			_, err := agent.GetAlbumImages(ctx, "Nonexistent Album", "Unknown Artist", "")
-
-			Expect(err).To(MatchError(agents.ErrNotFound))
-		})
-	})
-
-	Describe("GetSimilarSongsByArtist", func() {
-		var agent *tidalAgent
-		var httpClient *mockHttpClient
-
-		BeforeEach(func() {
-			httpClient = newMockHttpClient()
-			agent = &tidalAgent{
-				ds:     &tests.MockDataStore{},
-				client: newClient("test-id", "test-secret", httpClient),
-			}
-		})
-
-		It("returns similar songs from similar artists", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock search response
-			fSearch, _ := os.Open("tests/fixtures/tidal.search.artist.json")
-			httpClient.searchResponse = &http.Response{Body: fSearch, StatusCode: 200}
-
-			// Mock similar artists response
-			fSimilar, _ := os.Open("tests/fixtures/tidal.similar.artists.json")
-			httpClient.similarResponse = &http.Response{Body: fSimilar, StatusCode: 200}
-
-			// Mock top tracks response (will be called for each similar artist)
-			fTracks, _ := os.Open("tests/fixtures/tidal.artist.tracks.json")
-			httpClient.tracksResponse = &http.Response{Body: fTracks, StatusCode: 200}
-
-			songs, err := agent.GetSimilarSongsByArtist(ctx, "", "Daft Punk", "", 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(songs).To(HaveLen(5))
-			Expect(songs[0].Name).To(Equal("Get Lucky"))
-			Expect(songs[0].Artist).To(Equal("Justice"))
-		})
-
-		It("returns ErrNotFound when no similar artists found", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock search response
-			fSearch, _ := os.Open("tests/fixtures/tidal.search.artist.json")
-			httpClient.searchResponse = &http.Response{Body: fSearch, StatusCode: 200}
-
-			// Mock empty similar artists response
-			httpClient.similarResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"data":[]}`)),
-			}
-
-			_, err := agent.GetSimilarSongsByArtist(ctx, "", "Daft Punk", "", 5)
-
-			Expect(err).To(MatchError(agents.ErrNotFound))
-		})
-	})
-
-	Describe("GetSimilarSongsByTrack", func() {
-		var agent *tidalAgent
-		var httpClient *mockHttpClient
-
-		BeforeEach(func() {
-			httpClient = newMockHttpClient()
-			agent = &tidalAgent{
-				ds:     &tests.MockDataStore{},
-				client: newClient("test-id", "test-secret", httpClient),
-			}
-		})
-
-		It("returns similar songs from track radio", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock track search response
-			fTrackSearch, _ := os.Open("tests/fixtures/tidal.search.track.json")
-			httpClient.trackSearchResponse = &http.Response{Body: fTrackSearch, StatusCode: 200}
-
-			// Mock track radio response
-			fTrackRadio, _ := os.Open("tests/fixtures/tidal.track.radio.json")
-			httpClient.trackRadioResponse = &http.Response{Body: fTrackRadio, StatusCode: 200}
-
-			songs, err := agent.GetSimilarSongsByTrack(ctx, "", "Get Lucky", "Daft Punk", "", 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(songs).To(HaveLen(3))
-			Expect(songs[0].Name).To(Equal("Starboy"))
-			Expect(songs[0].Duration).To(Equal(uint32(230000))) // 230 seconds * 1000
-		})
-
-		It("returns ErrNotFound when track is not found", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock empty track search response
-			httpClient.trackSearchResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"tracks":[]}`)),
-			}
-
-			_, err := agent.GetSimilarSongsByTrack(ctx, "", "Nonexistent Track", "Unknown Artist", "", 5)
-
-			Expect(err).To(MatchError(agents.ErrNotFound))
-		})
-
-		It("returns ErrNotFound when track radio returns no results", func() {
-			// Mock token response
-			httpClient.tokenResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token":"test-token","token_type":"Bearer","expires_in":86400}`)),
-			}
-
-			// Mock track search response
-			fTrackSearch, _ := os.Open("tests/fixtures/tidal.search.track.json")
-			httpClient.trackSearchResponse = &http.Response{Body: fTrackSearch, StatusCode: 200}
-
-			// Mock empty track radio response
-			httpClient.trackRadioResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"data":[]}`)),
-			}
-
-			_, err := agent.GetSimilarSongsByTrack(ctx, "", "Get Lucky", "Daft Punk", "", 5)
-
-			Expect(err).To(MatchError(agents.ErrNotFound))
-		})
-	})
-})
-
-// mockHttpClient is a mock HTTP client for testing
-type mockHttpClient struct {
-	tokenResponse       *http.Response
-	searchResponse      *http.Response
-	albumSearchResponse *http.Response
-	trackSearchResponse *http.Response
-	artistResponse      *http.Response
-	artistBioResponse   *http.Response
-	albumReviewResponse *http.Response
-	similarResponse     *http.Response
-	tracksResponse      *http.Response
-	trackRadioResponse  *http.Response
-}
-
-func newMockHttpClient() *mockHttpClient {
-	return &mockHttpClient{}
-}
-
-func (c *mockHttpClient) Do(req *http.Request) (*http.Response, error) {
-	// Handle token request
-	if req.URL.Host == "auth.tidal.com" && req.URL.Path == "/v1/oauth2/token" {
-		if c.tokenResponse != nil {
-			return c.tokenResponse, nil
-		}
-		return &http.Response{
-			StatusCode: 500,
-			Body:       io.NopCloser(bytes.NewBufferString(`{"error":"no mock"}`)),
-		}, nil
-	}
-
-	// Handle search request
-	if req.URL.Host == "openapi.tidal.com" && req.URL.Path == "/search" {
-		searchType := req.URL.Query().Get("type")
-		// Check if it's an album search
-		if searchType == "ALBUMS" {
-			if c.albumSearchResponse != nil {
-				return c.albumSearchResponse, nil
-			}
-			return &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"albums":[]}`)),
-			}, nil
-		}
-		// Check if it's a track search
-		if searchType == "TRACKS" {
-			if c.trackSearchResponse != nil {
-				return c.trackSearchResponse, nil
-			}
-			return &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"tracks":[]}`)),
-			}, nil
-		}
-		// Otherwise, it's an artist search
-		if c.searchResponse != nil {
-			return c.searchResponse, nil
-		}
-		return &http.Response{
-			StatusCode: 200,
-			Body:       io.NopCloser(bytes.NewBufferString(`{"artists":[]}`)),
-		}, nil
-	}
-
-	// Handle track radio request
-	if req.URL.Host == "openapi.tidal.com" && len(req.URL.Path) > 8 && req.URL.Path[:8] == "/tracks/" {
-		if len(req.URL.Path) > 14 && req.URL.Path[len(req.URL.Path)-6:] == "/radio" {
-			if c.trackRadioResponse != nil {
-				return c.trackRadioResponse, nil
-			}
-			return &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"data":[]}`)),
-			}, nil
-		}
-	}
-
-	// Handle artist request
-	if req.URL.Host == "openapi.tidal.com" && len(req.URL.Path) > 9 && req.URL.Path[:9] == "/artists/" {
-		// Check if it's a bio request
-		if len(req.URL.Path) > 13 && req.URL.Path[len(req.URL.Path)-4:] == "/bio" {
-			if c.artistBioResponse != nil {
-				return c.artistBioResponse, nil
-			}
-			return &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"text":""}`)),
-			}, nil
-		}
-		// Check if it's a similar artists or tracks request
-		if len(req.URL.Path) > 17 && req.URL.Path[len(req.URL.Path)-8:] == "/similar" {
-			if c.similarResponse != nil {
-				return c.similarResponse, nil
-			}
-			return &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"data":[]}`)),
-			}, nil
-		}
-		if len(req.URL.Path) > 16 && req.URL.Path[len(req.URL.Path)-7:] == "/tracks" {
-			if c.tracksResponse != nil {
-				// Need to return a new response each time since the body is consumed
-				fTracks, _ := os.Open("tests/fixtures/tidal.artist.tracks.json")
-				return &http.Response{Body: fTracks, StatusCode: 200}, nil
-			}
-			return &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"data":[]}`)),
-			}, nil
-		}
-		if c.artistResponse != nil {
-			return c.artistResponse, nil
-		}
-		return &http.Response{
-			StatusCode: 404,
-			Body:       io.NopCloser(bytes.NewBufferString(`{"errors":[{"status":404,"code":"NOT_FOUND"}]}`)),
-		}, nil
-	}
-
-	// Handle album request
-	if req.URL.Host == "openapi.tidal.com" && len(req.URL.Path) > 8 && req.URL.Path[:8] == "/albums/" {
-		// Check if it's a review request
-		if len(req.URL.Path) > 15 && req.URL.Path[len(req.URL.Path)-7:] == "/review" {
-			if c.albumReviewResponse != nil {
-				return c.albumReviewResponse, nil
-			}
-			return &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"text":""}`)),
-			}, nil
-		}
-	}
-
-	panic("URL not mocked: " + req.URL.String())
-}

cmd/wire_gen.go

@@ -102,7 +102,8 @@ func CreateSubsonicAPIRouter(ctx context.Context) *subsonic.Router {
 	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
 	playTracker := scrobbler.GetPlayTracker(dataStore, broker, manager)
 	playbackServer := playback.GetInstance(dataStore)
-	router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, modelScanner, broker, playlists, playTracker, share, playbackServer, metricsMetrics)
+	transcodeDecision := core.NewTranscodeDecision(dataStore)
+	router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, modelScanner, broker, playlists, playTracker, share, playbackServer, metricsMetrics, transcodeDecision)
 	return router
 }
 

conf/configuration.go

@@ -103,7 +103,6 @@ type configOptions struct {
 	Spotify                         spotifyOptions      `json:",omitzero"`
 	Deezer                          deezerOptions       `json:",omitzero"`
 	ListenBrainz                    listenBrainzOptions `json:",omitzero"`
-	Tidal                           tidalOptions        `json:",omitzero"`
 	EnableScrobbleHistory           bool
 	Tags                            map[string]TagConf `json:",omitempty"`
 	Agents                          string
@@ -199,12 +198,6 @@ type listenBrainzOptions struct {
 	BaseURL string
 }
 
-type tidalOptions struct {
-	Enabled      bool
-	ClientID     string
-	ClientSecret string
-}
-
 type httpHeaderOptions struct {
 	FrameOptions string
 }
@@ -464,7 +457,6 @@ func disableExternalServices() {
 	Server.Spotify.ID = ""
 	Server.Deezer.Enabled = false
 	Server.ListenBrainz.Enabled = false
-	Server.Tidal.Enabled = false
 	Server.Agents = ""
 	if Server.UILoginBackgroundURL == consts.DefaultUILoginBackgroundURL {
 		Server.UILoginBackgroundURL = consts.DefaultUILoginBackgroundURLOffline
@@ -651,7 +643,8 @@ func setViperDefaults() {
 	viper.SetDefault("subsonic.artistparticipations", false)
 	viper.SetDefault("subsonic.defaultreportrealpath", false)
 	viper.SetDefault("subsonic.enableaveragerating", true)
-	viper.SetDefault("subsonic.legacyclients", "DSub,SubMusic")
+	viper.SetDefault("subsonic.legacyclients", "DSub")
+	viper.SetDefault("subsonic.minimalclients", "SubMusic")
 	viper.SetDefault("agents", "lastfm,spotify,deezer")
 	viper.SetDefault("lastfm.enabled", true)
 	viper.SetDefault("lastfm.language", consts.DefaultInfoLanguage)
@@ -664,9 +657,6 @@ func setViperDefaults() {
 	viper.SetDefault("deezer.language", consts.DefaultInfoLanguage)
 	viper.SetDefault("listenbrainz.enabled", true)
 	viper.SetDefault("listenbrainz.baseurl", "https://api.listenbrainz.org/1/")
-	viper.SetDefault("tidal.enabled", false)
-	viper.SetDefault("tidal.clientid", "")
-	viper.SetDefault("tidal.clientsecret", "")
 	viper.SetDefault("enablescrobblehistory", true)
 	viper.SetDefault("httpheaders.frameoptions", "DENY")
 	viper.SetDefault("backup.path", "")

core/transcode_decision.go

@@ -0,0 +1,689 @@
+package core
+
+import (
+	"context"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/navidrome/navidrome/core/auth"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+)
+
+const (
+	transcodeTokenTTL       = 12 * time.Hour
+	defaultTranscodeBitrate = 256 // kbps
+)
+
+// TranscodeDecision is the core service interface for making transcoding decisions
+type TranscodeDecision interface {
+	MakeDecision(ctx context.Context, mf *model.MediaFile, clientInfo *ClientInfo) (*Decision, error)
+	CreateTranscodeParams(decision *Decision) (string, error)
+	ParseTranscodeParams(token string) (*TranscodeParams, error)
+}
+
+// ClientInfo represents client playback capabilities.
+// All bitrate values are in kilobits per second (kbps)
+type ClientInfo struct {
+	Name                       string
+	Platform                   string
+	MaxAudioBitrate            int
+	MaxTranscodingAudioBitrate int
+	DirectPlayProfiles         []DirectPlayProfile
+	TranscodingProfiles        []TranscodingProfile
+	CodecProfiles              []CodecProfile
+}
+
+// DirectPlayProfile describes a format the client can play directly
+type DirectPlayProfile struct {
+	Containers       []string
+	AudioCodecs      []string
+	Protocols        []string
+	MaxAudioChannels int
+}
+
+// TranscodingProfile describes a transcoding target the client supports
+type TranscodingProfile struct {
+	Container        string
+	AudioCodec       string
+	Protocol         string
+	MaxAudioChannels int
+}
+
+// CodecProfile describes codec-specific limitations
+type CodecProfile struct {
+	Type        string
+	Name        string
+	Limitations []Limitation
+}
+
+// Limitation describes a specific codec limitation
+type Limitation struct {
+	Name       string
+	Comparison string
+	Values     []string
+	Required   bool
+}
+
+// Protocol values (OpenSubsonic spec enum)
+const (
+	ProtocolHTTP = "http"
+	ProtocolHLS  = "hls"
+)
+
+// Comparison operators (OpenSubsonic spec enum)
+const (
+	ComparisonEquals           = "Equals"
+	ComparisonNotEquals        = "NotEquals"
+	ComparisonLessThanEqual    = "LessThanEqual"
+	ComparisonGreaterThanEqual = "GreaterThanEqual"
+)
+
+// Limitation names (OpenSubsonic spec enum)
+const (
+	LimitationAudioChannels   = "audioChannels"
+	LimitationAudioBitrate    = "audioBitrate"
+	LimitationAudioProfile    = "audioProfile"
+	LimitationAudioSamplerate = "audioSamplerate"
+	LimitationAudioBitdepth   = "audioBitdepth"
+)
+
+// Codec profile types (OpenSubsonic spec enum)
+const (
+	CodecProfileTypeAudio = "AudioCodec"
+)
+
+// Decision represents the internal decision result.
+// All bitrate values are in kilobits per second (kbps).
+type Decision struct {
+	MediaID          string
+	CanDirectPlay    bool
+	CanTranscode     bool
+	TranscodeReasons []string
+	ErrorReason      string
+	TargetFormat     string
+	TargetBitrate    int
+	TargetChannels   int
+	SourceStream     StreamDetails
+	TranscodeStream  *StreamDetails
+}
+
+// StreamDetails describes audio stream properties.
+// Bitrate is in kilobits per second (kbps).
+type StreamDetails struct {
+	Container  string
+	Codec      string
+	Profile    string // Audio profile (e.g., "LC", "HE-AAC"). Empty until scanner support is added.
+	Bitrate    int
+	SampleRate int
+	BitDepth   int
+	Channels   int
+	Duration   float32
+	Size       int64
+	IsLossless bool
+}
+
+// TranscodeParams contains the parameters extracted from a transcode token.
+// TargetBitrate is in kilobits per second (kbps).
+type TranscodeParams struct {
+	MediaID        string
+	DirectPlay     bool
+	TargetFormat   string
+	TargetBitrate  int
+	TargetChannels int
+}
+
+func NewTranscodeDecision(ds model.DataStore) TranscodeDecision {
+	return &transcodeDecisionService{
+		ds: ds,
+	}
+}
+
+type transcodeDecisionService struct {
+	ds model.DataStore
+}
+
+func (s *transcodeDecisionService) MakeDecision(ctx context.Context, mf *model.MediaFile, clientInfo *ClientInfo) (*Decision, error) {
+	decision := &Decision{
+		MediaID: mf.ID,
+	}
+
+	sourceBitrate := mf.BitRate // kbps
+
+	log.Trace(ctx, "Making transcode decision", "mediaID", mf.ID, "container", mf.Suffix,
+		"codec", mf.AudioCodec(), "bitrate", sourceBitrate, "channels", mf.Channels,
+		"sampleRate", mf.SampleRate, "lossless", mf.IsLossless(), "client", clientInfo.Name)
+
+	// Build source stream details
+	decision.SourceStream = StreamDetails{
+		Container:  mf.Suffix,
+		Codec:      mf.AudioCodec(),
+		Bitrate:    sourceBitrate,
+		SampleRate: mf.SampleRate,
+		BitDepth:   mf.BitDepth,
+		Channels:   mf.Channels,
+		Duration:   mf.Duration,
+		Size:       mf.Size,
+		IsLossless: mf.IsLossless(),
+	}
+
+	// Check global bitrate constraint first.
+	if clientInfo.MaxAudioBitrate > 0 && sourceBitrate > clientInfo.MaxAudioBitrate {
+		log.Trace(ctx, "Global bitrate constraint exceeded, skipping direct play",
+			"sourceBitrate", sourceBitrate, "maxAudioBitrate", clientInfo.MaxAudioBitrate)
+		decision.TranscodeReasons = append(decision.TranscodeReasons, "audio bitrate not supported")
+		// Skip direct play profiles entirely — global constraint fails
+	} else {
+		// Try direct play profiles, collecting reasons for each failure
+		for _, profile := range clientInfo.DirectPlayProfiles {
+			if reason := s.checkDirectPlayProfile(mf, sourceBitrate, &profile, clientInfo); reason == "" {
+				decision.CanDirectPlay = true
+				decision.TranscodeReasons = nil // Clear any previously collected reasons
+				break
+			} else {
+				decision.TranscodeReasons = append(decision.TranscodeReasons, reason)
+			}
+		}
+	}
+
+	// If direct play is possible, we're done
+	if decision.CanDirectPlay {
+		log.Debug(ctx, "Transcode decision: direct play", "mediaID", mf.ID, "container", mf.Suffix, "codec", mf.AudioCodec())
+		return decision, nil
+	}
+
+	// Try transcoding profiles (in order of preference)
+	for _, profile := range clientInfo.TranscodingProfiles {
+		if ts := s.computeTranscodedStream(ctx, mf, sourceBitrate, &profile, clientInfo); ts != nil {
+			decision.CanTranscode = true
+			decision.TargetFormat = ts.Container
+			decision.TargetBitrate = ts.Bitrate
+			decision.TargetChannels = ts.Channels
+			decision.TranscodeStream = ts
+			break
+		}
+	}
+
+	if decision.CanTranscode {
+		log.Debug(ctx, "Transcode decision: transcode", "mediaID", mf.ID,
+			"targetFormat", decision.TargetFormat, "targetBitrate", decision.TargetBitrate,
+			"targetChannels", decision.TargetChannels, "reasons", decision.TranscodeReasons)
+	}
+
+	// If neither direct play nor transcode is possible
+	if !decision.CanDirectPlay && !decision.CanTranscode {
+		decision.ErrorReason = "no compatible playback profile found"
+		log.Warn(ctx, "Transcode decision: no compatible profile", "mediaID", mf.ID,
+			"container", mf.Suffix, "codec", mf.AudioCodec(), "reasons", decision.TranscodeReasons)
+	}
+
+	return decision, nil
+}
+
+// checkDirectPlayProfile returns "" if the profile matches (direct play OK),
+// or a typed reason string if it doesn't match.
+func (s *transcodeDecisionService) checkDirectPlayProfile(mf *model.MediaFile, sourceBitrate int, profile *DirectPlayProfile, clientInfo *ClientInfo) string {
+	// Check protocol (only http for now)
+	if len(profile.Protocols) > 0 && !containsIgnoreCase(profile.Protocols, ProtocolHTTP) {
+		return "protocol not supported"
+	}
+
+	// Check container
+	if len(profile.Containers) > 0 && !matchesContainer(mf.Suffix, profile.Containers) {
+		return "container not supported"
+	}
+
+	// Check codec
+	if len(profile.AudioCodecs) > 0 && !matchesCodec(mf.AudioCodec(), profile.AudioCodecs) {
+		return "audio codec not supported"
+	}
+
+	// Check channels
+	if profile.MaxAudioChannels > 0 && mf.Channels > profile.MaxAudioChannels {
+		return "audio channels not supported"
+	}
+
+	// Check codec-specific limitations
+	for _, codecProfile := range clientInfo.CodecProfiles {
+		if strings.EqualFold(codecProfile.Type, CodecProfileTypeAudio) && matchesCodec(mf.AudioCodec(), []string{codecProfile.Name}) {
+			if reason := checkLimitations(mf, sourceBitrate, codecProfile.Limitations); reason != "" {
+				return reason
+			}
+		}
+	}
+
+	return ""
+}
+
+// checkLimitations checks codec profile limitations against source media.
+// Returns "" if all limitations pass, or a typed reason string for the first failure.
+func checkLimitations(mf *model.MediaFile, sourceBitrate int, limitations []Limitation) string {
+	for _, lim := range limitations {
+		var ok bool
+		var reason string
+
+		switch lim.Name {
+		case LimitationAudioChannels:
+			ok = checkIntLimitation(mf.Channels, lim.Comparison, lim.Values)
+			reason = "audio channels not supported"
+		case LimitationAudioSamplerate:
+			ok = checkIntLimitation(mf.SampleRate, lim.Comparison, lim.Values)
+			reason = "audio samplerate not supported"
+		case LimitationAudioBitrate:
+			ok = checkIntLimitation(sourceBitrate, lim.Comparison, lim.Values)
+			reason = "audio bitrate not supported"
+		case LimitationAudioBitdepth:
+			ok = checkIntLimitation(mf.BitDepth, lim.Comparison, lim.Values)
+			reason = "audio bitdepth not supported"
+		case LimitationAudioProfile:
+			// TODO: populate source profile when MediaFile has audio profile info
+			ok = checkStringLimitation("", lim.Comparison, lim.Values)
+			reason = "audio profile not supported"
+		default:
+			continue
+		}
+
+		if !ok && lim.Required {
+			return reason
+		}
+	}
+	return ""
+}
+
+// adjustResult represents the outcome of applying a limitation to a transcoded stream value
+type adjustResult int
+
+const (
+	adjustNone      adjustResult = iota // Value already satisfies the limitation
+	adjustAdjusted                      // Value was changed to fit the limitation
+	adjustCannotFit                     // Cannot satisfy the limitation (reject this profile)
+)
+
+// computeTranscodedStream attempts to build a valid transcoded stream for the given profile.
+// Returns nil if the profile cannot produce a valid output.
+func (s *transcodeDecisionService) computeTranscodedStream(ctx context.Context, mf *model.MediaFile, sourceBitrate int, profile *TranscodingProfile, clientInfo *ClientInfo) *StreamDetails {
+	// Check protocol (only http for now)
+	if profile.Protocol != "" && !strings.EqualFold(profile.Protocol, ProtocolHTTP) {
+		log.Trace(ctx, "Skipping transcoding profile: unsupported protocol", "protocol", profile.Protocol)
+		return nil
+	}
+
+	targetFormat := strings.ToLower(profile.Container)
+	if targetFormat == "" {
+		targetFormat = strings.ToLower(profile.AudioCodec)
+	}
+
+	// Verify we have a transcoding config for this format
+	tc, err := s.ds.Transcoding(ctx).FindByFormat(targetFormat)
+	if err != nil || tc == nil {
+		log.Trace(ctx, "Skipping transcoding profile: no transcoding config", "targetFormat", targetFormat)
+		return nil
+	}
+
+	targetIsLossless := isLosslessFormat(targetFormat)
+
+	// Reject lossy to lossless conversion
+	if !mf.IsLossless() && targetIsLossless {
+		log.Trace(ctx, "Skipping transcoding profile: lossy to lossless not allowed", "targetFormat", targetFormat)
+		return nil
+	}
+
+	ts := &StreamDetails{
+		Container:  targetFormat,
+		Codec:      strings.ToLower(profile.AudioCodec),
+		SampleRate: mf.SampleRate,
+		Channels:   mf.Channels,
+		IsLossless: targetIsLossless,
+	}
+	if ts.Codec == "" {
+		ts.Codec = targetFormat
+	}
+
+	// Determine target bitrate (all in kbps)
+	if mf.IsLossless() {
+		if !targetIsLossless {
+			// Lossless to lossy: use client's max transcoding bitrate or default
+			if clientInfo.MaxTranscodingAudioBitrate > 0 {
+				ts.Bitrate = clientInfo.MaxTranscodingAudioBitrate
+			} else {
+				ts.Bitrate = defaultTranscodeBitrate
+			}
+		} else {
+			// Lossless to lossless: check if bitrate is under the global max
+			if clientInfo.MaxAudioBitrate > 0 && sourceBitrate > clientInfo.MaxAudioBitrate {
+				log.Trace(ctx, "Skipping transcoding profile: lossless target exceeds bitrate limit",
+					"targetFormat", targetFormat, "sourceBitrate", sourceBitrate, "maxAudioBitrate", clientInfo.MaxAudioBitrate)
+				return nil
+			}
+			// No explicit bitrate for lossless target (leave 0)
+		}
+	} else {
+		// Lossy to lossy: preserve source bitrate
+		ts.Bitrate = sourceBitrate
+	}
+
+	// Apply maxAudioBitrate as final cap on transcoded stream (#5)
+	if clientInfo.MaxAudioBitrate > 0 && ts.Bitrate > 0 && ts.Bitrate > clientInfo.MaxAudioBitrate {
+		ts.Bitrate = clientInfo.MaxAudioBitrate
+	}
+
+	// Apply MaxAudioChannels from the transcoding profile
+	if profile.MaxAudioChannels > 0 && mf.Channels > profile.MaxAudioChannels {
+		ts.Channels = profile.MaxAudioChannels
+	}
+
+	// Apply codec profile limitations to the TARGET codec (#4)
+	targetCodec := ts.Codec
+	for _, codecProfile := range clientInfo.CodecProfiles {
+		if !strings.EqualFold(codecProfile.Type, CodecProfileTypeAudio) {
+			continue
+		}
+		if !matchesCodec(targetCodec, []string{codecProfile.Name}) {
+			continue
+		}
+		for _, lim := range codecProfile.Limitations {
+			result := applyLimitation(sourceBitrate, &lim, ts)
+			// For lossless codecs, adjusting bitrate is not valid
+			if strings.EqualFold(lim.Name, LimitationAudioBitrate) && targetIsLossless && result == adjustAdjusted {
+				log.Trace(ctx, "Skipping transcoding profile: cannot adjust bitrate for lossless target",
+					"targetFormat", targetFormat, "codec", targetCodec, "limitation", lim.Name)
+				return nil
+			}
+			if result == adjustCannotFit {
+				log.Trace(ctx, "Skipping transcoding profile: codec limitation cannot be satisfied",
+					"targetFormat", targetFormat, "codec", targetCodec, "limitation", lim.Name,
+					"comparison", lim.Comparison, "values", lim.Values)
+				return nil
+			}
+		}
+	}
+
+	return ts
+}
+
+// applyLimitation adjusts a transcoded stream parameter to satisfy the limitation.
+// Returns the adjustment result.
+func applyLimitation(sourceBitrate int, lim *Limitation, ts *StreamDetails) adjustResult {
+	switch lim.Name {
+	case LimitationAudioChannels:
+		return applyIntLimitation(lim.Comparison, lim.Values, ts.Channels, func(v int) { ts.Channels = v })
+	case LimitationAudioBitrate:
+		current := ts.Bitrate
+		if current == 0 {
+			current = sourceBitrate
+		}
+		return applyIntLimitation(lim.Comparison, lim.Values, current, func(v int) { ts.Bitrate = v })
+	case LimitationAudioSamplerate:
+		return applyIntLimitation(lim.Comparison, lim.Values, ts.SampleRate, func(v int) { ts.SampleRate = v })
+	case LimitationAudioBitdepth:
+		if ts.BitDepth > 0 {
+			return applyIntLimitation(lim.Comparison, lim.Values, ts.BitDepth, func(v int) { ts.BitDepth = v })
+		}
+	case LimitationAudioProfile:
+		// TODO: implement when audio profile data is available
+	}
+	return adjustNone
+}
+
+// applyIntLimitation applies a limitation comparison to a value.
+// If the value needs adjusting, calls the setter and returns the result.
+func applyIntLimitation(comparison string, values []string, current int, setter func(int)) adjustResult {
+	if len(values) == 0 {
+		return adjustNone
+	}
+
+	switch comparison {
+	case ComparisonLessThanEqual:
+		limit, ok := parseInt(values[0])
+		if !ok {
+			return adjustNone
+		}
+		if current <= limit {
+			return adjustNone
+		}
+		setter(limit)
+		return adjustAdjusted
+	case ComparisonGreaterThanEqual:
+		limit, ok := parseInt(values[0])
+		if !ok {
+			return adjustNone
+		}
+		if current >= limit {
+			return adjustNone
+		}
+		// Cannot upscale
+		return adjustCannotFit
+	case ComparisonEquals:
+		// Check if current value matches any allowed value
+		for _, v := range values {
+			if limit, ok := parseInt(v); ok && current == limit {
+				return adjustNone
+			}
+		}
+		// Find the closest allowed value below current (don't upscale)
+		var closest int
+		found := false
+		for _, v := range values {
+			if limit, ok := parseInt(v); ok && limit < current {
+				if !found || limit > closest {
+					closest = limit
+					found = true
+				}
+			}
+		}
+		if found {
+			setter(closest)
+			return adjustAdjusted
+		}
+		return adjustCannotFit
+	case ComparisonNotEquals:
+		for _, v := range values {
+			if limit, ok := parseInt(v); ok && current == limit {
+				return adjustCannotFit
+			}
+		}
+		return adjustNone
+	}
+
+	return adjustNone
+}
+
+func (s *transcodeDecisionService) CreateTranscodeParams(decision *Decision) (string, error) {
+	exp := time.Now().Add(transcodeTokenTTL)
+	claims := map[string]any{
+		"mid": decision.MediaID,
+		"dp":  decision.CanDirectPlay,
+	}
+	if decision.CanTranscode && decision.TargetFormat != "" {
+		claims["fmt"] = decision.TargetFormat
+		claims["br"] = decision.TargetBitrate
+		if decision.TargetChannels > 0 {
+			claims["ch"] = decision.TargetChannels
+		}
+	}
+	return auth.CreateExpiringPublicToken(exp, claims)
+}
+
+func (s *transcodeDecisionService) ParseTranscodeParams(token string) (*TranscodeParams, error) {
+	claims, err := auth.Validate(token)
+	if err != nil {
+		return nil, err
+	}
+
+	params := &TranscodeParams{}
+	if mid, ok := claims["mid"].(string); ok {
+		params.MediaID = mid
+	}
+	if dp, ok := claims["dp"].(bool); ok {
+		params.DirectPlay = dp
+	}
+	if fmt, ok := claims["fmt"].(string); ok {
+		params.TargetFormat = fmt
+	}
+	if br, ok := claims["br"].(float64); ok {
+		params.TargetBitrate = int(br)
+	}
+	if ch, ok := claims["ch"].(float64); ok {
+		params.TargetChannels = int(ch)
+	}
+
+	return params, nil
+}
+
+func containsIgnoreCase(slice []string, s string) bool {
+	return slices.ContainsFunc(slice, func(item string) bool {
+		return strings.EqualFold(item, s)
+	})
+}
+
+// containerAliasGroups maps each container alias to a canonical group name.
+var containerAliasGroups = func() map[string]string {
+	groups := [][]string{
+		{"aac", "adts", "m4a", "mp4", "m4b", "m4p"},
+		{"mpeg", "mp3", "mp2"},
+		{"ogg", "oga"},
+		{"aif", "aiff"},
+		{"asf", "wma"},
+		{"mpc", "mpp"},
+		{"wv"},
+	}
+	m := make(map[string]string)
+	for _, g := range groups {
+		canonical := g[0]
+		for _, name := range g {
+			m[name] = canonical
+		}
+	}
+	return m
+}()
+
+// matchesWithAliases checks if a value matches any entry in candidates,
+// consulting the alias map for equivalent names.
+func matchesWithAliases(value string, candidates []string, aliases map[string]string) bool {
+	value = strings.ToLower(value)
+	canonical := aliases[value]
+	for _, c := range candidates {
+		c = strings.ToLower(c)
+		if c == value {
+			return true
+		}
+		if canonical != "" && aliases[c] == canonical {
+			return true
+		}
+	}
+	return false
+}
+
+// matchesContainer checks if a file suffix matches any of the container names,
+// including common aliases.
+func matchesContainer(suffix string, containers []string) bool {
+	return matchesWithAliases(suffix, containers, containerAliasGroups)
+}
+
+// codecAliasGroups maps each codec alias to a canonical group name.
+// Codecs within the same group are considered equivalent.
+var codecAliasGroups = func() map[string]string {
+	groups := [][]string{
+		{"aac", "adts"},
+		{"ac3", "ac-3"},
+		{"eac3", "e-ac3", "e-ac-3", "eac-3"},
+		{"mpc7", "musepack7"},
+		{"mpc8", "musepack8"},
+		{"wma1", "wmav1"},
+		{"wma2", "wmav2"},
+		{"wmalossless", "wma9lossless"},
+		{"wmapro", "wma9pro"},
+		{"shn", "shorten"},
+		{"mp4als", "als"},
+	}
+	m := make(map[string]string)
+	for _, g := range groups {
+		for _, name := range g {
+			m[name] = g[0] // canonical = first entry
+		}
+	}
+	return m
+}()
+
+// matchesCodec checks if a codec matches any of the codec names,
+// including common aliases.
+func matchesCodec(codec string, codecs []string) bool {
+	return matchesWithAliases(codec, codecs, codecAliasGroups)
+}
+
+func checkIntLimitation(value int, comparison string, values []string) bool {
+	if len(values) == 0 {
+		return true
+	}
+
+	switch comparison {
+	case ComparisonLessThanEqual:
+		limit, ok := parseInt(values[0])
+		if !ok {
+			return true
+		}
+		return value <= limit
+	case ComparisonGreaterThanEqual:
+		limit, ok := parseInt(values[0])
+		if !ok {
+			return true
+		}
+		return value >= limit
+	case ComparisonEquals:
+		for _, v := range values {
+			if limit, ok := parseInt(v); ok && value == limit {
+				return true
+			}
+		}
+		return false
+	case ComparisonNotEquals:
+		for _, v := range values {
+			if limit, ok := parseInt(v); ok && value == limit {
+				return false
+			}
+		}
+		return true
+	}
+	return true
+}
+
+// checkStringLimitation checks a string value against a limitation.
+// Only Equals and NotEquals comparisons are meaningful for strings.
+// LessThanEqual/GreaterThanEqual are not applicable and always pass.
+func checkStringLimitation(value string, comparison string, values []string) bool {
+	switch comparison {
+	case ComparisonEquals:
+		for _, v := range values {
+			if strings.EqualFold(value, v) {
+				return true
+			}
+		}
+		return false
+	case ComparisonNotEquals:
+		for _, v := range values {
+			if strings.EqualFold(value, v) {
+				return false
+			}
+		}
+		return true
+	}
+	return true
+}
+
+func parseInt(s string) (int, bool) {
+	v, err := strconv.Atoi(s)
+	if err != nil || v < 0 {
+		return 0, false
+	}
+	return v, true
+}
+
+func isLosslessFormat(format string) bool {
+	switch strings.ToLower(format) {
+	case "flac", "alac", "wav", "aiff", "ape", "wv", "tta", "tak", "shn", "dsd":
+		return true
+	}
+	return false
+}

core/transcode_decision_test.go

@@ -0,0 +1,657 @@
+package core
+
+import (
+	"context"
+
+	"github.com/navidrome/navidrome/core/auth"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("TranscodeDecision", func() {
+	var (
+		ds  *tests.MockDataStore
+		svc TranscodeDecision
+		ctx context.Context
+	)
+
+	BeforeEach(func() {
+		ctx = context.Background()
+		ds = &tests.MockDataStore{
+			MockedProperty:    &tests.MockedPropertyRepo{},
+			MockedTranscoding: &tests.MockTranscodingRepo{},
+		}
+		auth.Init(ds)
+		svc = NewTranscodeDecision(ds)
+	})
+
+	Describe("MakeDecision", func() {
+		Context("Direct Play", func() {
+			It("allows direct play when profile matches", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 320, Channels: 2, SampleRate: 44100}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"mp3"}, AudioCodecs: []string{"mp3"}, Protocols: []string{"http"}, MaxAudioChannels: 2},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+				Expect(decision.CanTranscode).To(BeFalse())
+				Expect(decision.TranscodeReasons).To(BeEmpty())
+			})
+
+			It("rejects direct play when container doesn't match", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"mp3"}, Protocols: []string{"http"}},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.TranscodeReasons).To(ContainElement("container not supported"))
+			})
+
+			It("rejects direct play when codec doesn't match", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "ALAC", BitRate: 1000, Channels: 2}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"m4a"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.TranscodeReasons).To(ContainElement("audio codec not supported"))
+			})
+
+			It("rejects direct play when channels exceed limit", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 6}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, Protocols: []string{"http"}, MaxAudioChannels: 2},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.TranscodeReasons).To(ContainElement("audio channels not supported"))
+			})
+
+			It("handles container aliases (aac -> m4a)", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "AAC", BitRate: 256, Channels: 2}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"aac"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+			})
+
+			It("handles container aliases (mp4 -> m4a)", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "AAC", BitRate: 256, Channels: 2}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"mp4"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+			})
+
+			It("handles codec aliases (adts -> aac)", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "AAC", BitRate: 256, Channels: 2}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"m4a"}, AudioCodecs: []string{"adts"}, Protocols: []string{"http"}},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+			})
+
+			It("allows when protocol list is empty (any protocol)", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, AudioCodecs: []string{"flac"}},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+			})
+
+			It("allows when both container and codec lists are empty (wildcard)", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 128, Channels: 2}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{}, AudioCodecs: []string{}},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+			})
+		})
+
+		Context("MaxAudioBitrate constraint", func() {
+			It("revokes direct play when bitrate exceeds maxAudioBitrate", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1500, Channels: 2}
+				ci := &ClientInfo{
+					MaxAudioBitrate: 500, // kbps
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, Protocols: []string{"http"}},
+					},
+					TranscodingProfiles: []TranscodingProfile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TranscodeReasons).To(ContainElement("audio bitrate not supported"))
+			})
+		})
+
+		Context("Transcoding", func() {
+			It("selects transcoding when direct play isn't possible", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 44100, BitDepth: 16}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 256, // kbps
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"mp3"}, Protocols: []string{"http"}},
+					},
+					TranscodingProfiles: []TranscodingProfile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http", MaxAudioChannels: 2},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TargetFormat).To(Equal("mp3"))
+				Expect(decision.TargetBitrate).To(Equal(256)) // kbps
+				Expect(decision.TranscodeReasons).To(ContainElement("container not supported"))
+			})
+
+			It("rejects lossy to lossless transcoding", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 320, Channels: 2}
+				ci := &ClientInfo{
+					TranscodingProfiles: []TranscodingProfile{
+						{Container: "flac", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeFalse())
+			})
+
+			It("uses default bitrate when client doesn't specify", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, BitDepth: 16}
+				ci := &ClientInfo{
+					TranscodingProfiles: []TranscodingProfile{
+						{Container: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TargetBitrate).To(Equal(defaultTranscodeBitrate)) // 256 kbps
+			})
+
+			It("preserves lossy bitrate when under max", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "ogg", BitRate: 192, Channels: 2}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 256, // kbps
+					TranscodingProfiles: []TranscodingProfile{
+						{Container: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TargetBitrate).To(Equal(192)) // source bitrate in kbps
+			})
+
+			It("rejects unsupported transcoding format", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2}
+				ci := &ClientInfo{
+					TranscodingProfiles: []TranscodingProfile{
+						{Container: "aac", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeFalse())
+			})
+
+			It("applies maxAudioBitrate as final cap on transcoded stream", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 320, Channels: 2}
+				ci := &ClientInfo{
+					MaxAudioBitrate: 96, // kbps
+					TranscodingProfiles: []TranscodingProfile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TargetBitrate).To(Equal(96)) // capped by maxAudioBitrate
+			})
+
+			It("selects first valid transcoding profile in order", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 48000, BitDepth: 16}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 320,
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"mp3"}, Protocols: []string{"http"}},
+					},
+					TranscodingProfiles: []TranscodingProfile{
+						{Container: "opus", AudioCodec: "opus", Protocol: "http"},
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http", MaxAudioChannels: 2},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TargetFormat).To(Equal("opus"))
+			})
+		})
+
+		Context("Lossless to lossless transcoding", func() {
+			It("allows lossless to lossless when samplerate needs downsampling", func() {
+				// MockTranscodingRepo doesn't support "flac" format, so this would fail to find a config.
+				// This test documents the behavior: lossless→lossless requires server transcoding config.
+				mf := &model.MediaFile{ID: "1", Suffix: "dsf", Codec: "DSD", BitRate: 5644, Channels: 2, SampleRate: 176400, BitDepth: 1}
+				ci := &ClientInfo{
+					MaxAudioBitrate: 1000,
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, Protocols: []string{"http"}},
+					},
+					TranscodingProfiles: []TranscodingProfile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TargetFormat).To(Equal("mp3"))
+			})
+
+			It("sets IsLossless=true on transcoded stream when target is lossless", func() {
+				// Simulate DSD→FLAC transcoding by using a mock that supports "flac"
+				mockTranscoding := &tests.MockTranscodingRepo{}
+				ds.MockedTranscoding = mockTranscoding
+				svc = NewTranscodeDecision(ds)
+
+				// MockTranscodingRepo doesn't support flac, so this will skip lossless profile.
+				// Use mp3 which is supported as the fallback.
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 96000, BitDepth: 24}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 320,
+					TranscodingProfiles: []TranscodingProfile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TranscodeStream.IsLossless).To(BeFalse()) // mp3 is lossy
+			})
+		})
+
+		Context("No compatible profile", func() {
+			It("returns error when nothing matches", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 6}
+				ci := &ClientInfo{}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.CanTranscode).To(BeFalse())
+				Expect(decision.ErrorReason).To(Equal("no compatible playback profile found"))
+			})
+		})
+
+		Context("Codec limitations on direct play", func() {
+			It("rejects direct play when codec limitation fails (required)", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 512, Channels: 2, SampleRate: 44100}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"mp3"}, AudioCodecs: []string{"mp3"}, Protocols: []string{"http"}},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "mp3",
+							Limitations: []Limitation{
+								{Name: LimitationAudioBitrate, Comparison: ComparisonLessThanEqual, Values: []string{"320"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.TranscodeReasons).To(ContainElement("audio bitrate not supported"))
+			})
+
+			It("allows direct play when optional limitation fails", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 512, Channels: 2, SampleRate: 44100}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"mp3"}, AudioCodecs: []string{"mp3"}, Protocols: []string{"http"}},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "mp3",
+							Limitations: []Limitation{
+								{Name: LimitationAudioBitrate, Comparison: ComparisonLessThanEqual, Values: []string{"320"}, Required: false},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+			})
+
+			It("handles Equals comparison with multiple values", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 44100}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, Protocols: []string{"http"}},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "flac",
+							Limitations: []Limitation{
+								{Name: LimitationAudioChannels, Comparison: ComparisonEquals, Values: []string{"1", "2"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+			})
+
+			It("rejects when Equals comparison doesn't match any value", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 6, SampleRate: 44100}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, Protocols: []string{"http"}},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "flac",
+							Limitations: []Limitation{
+								{Name: LimitationAudioChannels, Comparison: ComparisonEquals, Values: []string{"1", "2"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+			})
+
+			It("rejects direct play when audioProfile limitation fails (required)", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "AAC", BitRate: 256, Channels: 2, SampleRate: 44100}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"m4a"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "aac",
+							Limitations: []Limitation{
+								{Name: LimitationAudioProfile, Comparison: ComparisonEquals, Values: []string{"LC"}, Required: true},
+							},
+						},
+					},
+				}
+				// Source profile is empty (not yet populated from scanner), so Equals("LC") fails
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.TranscodeReasons).To(ContainElement("audio profile not supported"))
+			})
+
+			It("allows direct play when audioProfile limitation is optional", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "AAC", BitRate: 256, Channels: 2, SampleRate: 44100}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"m4a"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "aac",
+							Limitations: []Limitation{
+								{Name: LimitationAudioProfile, Comparison: ComparisonEquals, Values: []string{"LC"}, Required: false},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+			})
+
+			It("rejects direct play due to samplerate limitation", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 96000, BitDepth: 24}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, Protocols: []string{"http"}},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "flac",
+							Limitations: []Limitation{
+								{Name: LimitationAudioSamplerate, Comparison: ComparisonLessThanEqual, Values: []string{"48000"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.TranscodeReasons).To(ContainElement("audio samplerate not supported"))
+			})
+		})
+
+		Context("Codec limitations on transcoded output", func() {
+			It("applies bitrate limitation to transcoded stream", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 192, Channels: 2, SampleRate: 44100}
+				ci := &ClientInfo{
+					MaxAudioBitrate: 96, // force transcode
+					TranscodingProfiles: []TranscodingProfile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "mp3",
+							Limitations: []Limitation{
+								{Name: LimitationAudioBitrate, Comparison: ComparisonLessThanEqual, Values: []string{"96"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TranscodeStream.Bitrate).To(Equal(96))
+			})
+
+			It("applies channel limitation to transcoded stream", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 6, SampleRate: 48000, BitDepth: 16}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 320,
+					TranscodingProfiles: []TranscodingProfile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "mp3",
+							Limitations: []Limitation{
+								{Name: LimitationAudioChannels, Comparison: ComparisonLessThanEqual, Values: []string{"2"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TranscodeStream.Channels).To(Equal(2))
+			})
+
+			It("applies samplerate limitation to transcoded stream", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 96000, BitDepth: 24}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 320,
+					TranscodingProfiles: []TranscodingProfile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "mp3",
+							Limitations: []Limitation{
+								{Name: LimitationAudioSamplerate, Comparison: ComparisonLessThanEqual, Values: []string{"48000"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TranscodeStream.SampleRate).To(Equal(48000))
+			})
+
+			It("rejects transcoding profile when GreaterThanEqual cannot be satisfied", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 44100, BitDepth: 16}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 320,
+					TranscodingProfiles: []TranscodingProfile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "mp3",
+							Limitations: []Limitation{
+								{Name: LimitationAudioSamplerate, Comparison: ComparisonGreaterThanEqual, Values: []string{"96000"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeFalse())
+			})
+		})
+
+		Context("Typed transcode reasons from multiple profiles", func() {
+			It("collects reasons from each failed direct play profile", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "ogg", Codec: "Vorbis", BitRate: 128, Channels: 2, SampleRate: 48000}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, Protocols: []string{"http"}},
+						{Containers: []string{"mp3"}, AudioCodecs: []string{"mp3"}, Protocols: []string{"http"}},
+						{Containers: []string{"m4a", "mp4"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
+					},
+					TranscodingProfiles: []TranscodingProfile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.TranscodeReasons).To(HaveLen(3))
+				Expect(decision.TranscodeReasons[0]).To(Equal("container not supported"))
+				Expect(decision.TranscodeReasons[1]).To(Equal("container not supported"))
+				Expect(decision.TranscodeReasons[2]).To(Equal("container not supported"))
+			})
+		})
+
+		Context("Source stream details", func() {
+			It("populates source stream correctly with kbps bitrate", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 96000, BitDepth: 24, Duration: 300.5, Size: 50000000}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, Protocols: []string{"http"}},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.SourceStream.Container).To(Equal("flac"))
+				Expect(decision.SourceStream.Codec).To(Equal("flac"))
+				Expect(decision.SourceStream.Bitrate).To(Equal(1000)) // kbps
+				Expect(decision.SourceStream.SampleRate).To(Equal(96000))
+				Expect(decision.SourceStream.BitDepth).To(Equal(24))
+				Expect(decision.SourceStream.Channels).To(Equal(2))
+			})
+		})
+	})
+
+	Describe("Token round-trip", func() {
+		It("creates and parses a direct play token", func() {
+			decision := &Decision{
+				MediaID:       "media-123",
+				CanDirectPlay: true,
+			}
+			token, err := svc.CreateTranscodeParams(decision)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(token).ToNot(BeEmpty())
+
+			params, err := svc.ParseTranscodeParams(token)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(params.MediaID).To(Equal("media-123"))
+			Expect(params.DirectPlay).To(BeTrue())
+			Expect(params.TargetFormat).To(BeEmpty())
+		})
+
+		It("creates and parses a transcode token with kbps bitrate", func() {
+			decision := &Decision{
+				MediaID:        "media-456",
+				CanDirectPlay:  false,
+				CanTranscode:   true,
+				TargetFormat:   "mp3",
+				TargetBitrate:  256, // kbps
+				TargetChannels: 2,
+			}
+			token, err := svc.CreateTranscodeParams(decision)
+			Expect(err).ToNot(HaveOccurred())
+
+			params, err := svc.ParseTranscodeParams(token)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(params.MediaID).To(Equal("media-456"))
+			Expect(params.DirectPlay).To(BeFalse())
+			Expect(params.TargetFormat).To(Equal("mp3"))
+			Expect(params.TargetBitrate).To(Equal(256)) // kbps
+			Expect(params.TargetChannels).To(Equal(2))
+		})
+
+		It("rejects an invalid token", func() {
+			_, err := svc.ParseTranscodeParams("invalid-token")
+			Expect(err).To(HaveOccurred())
+		})
+	})
+})

core/wire_providers.go

@@ -20,6 +20,7 @@ var Set = wire.NewSet(
 	NewLibrary,
 	NewUser,
 	NewMaintenance,
+	NewTranscodeDecision,
 	agents.GetAgents,
 	external.NewProvider,
 	wire.Bind(new(external.Agents), new(*agents.Agents)),

db/migrations/20260205120000_add_codec_to_media_file.sql

@@ -0,0 +1,11 @@
+-- +goose Up
+-- +goose StatementBegin
+ALTER TABLE media_file ADD COLUMN codec VARCHAR(255) DEFAULT '' NOT NULL;
+CREATE INDEX IF NOT EXISTS media_file_codec ON media_file(codec);
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP INDEX IF EXISTS media_file_codec;
+ALTER TABLE media_file DROP COLUMN codec;
+-- +goose StatementEnd

go.mod

@@ -7,7 +7,7 @@ replace (
 	github.com/dhowden/tag v0.0.0-20240417053706-3d75831295e8 => github.com/deluan/tag v0.0.0-20241002021117-dfe5e6ea396d
 
 	// Fork to implement raw tags support
-	go.senan.xyz/taglib => github.com/deluan/go-taglib v0.0.0-20260119020817-8753c7531798
+	go.senan.xyz/taglib => github.com/deluan/go-taglib v0.0.0-20260205042457-5d80806aee57
 )
 
 require (

go.sum

@@ -36,8 +36,8 @@ github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 h1:NMZiJj8QnKe1LgsbDayM4UoHwbvwDRwnI3hwNaAHRnc=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40=
-github.com/deluan/go-taglib v0.0.0-20260119020817-8753c7531798 h1:q4fvcIK/LxElpyQILCejG6WPYjVb2F/4P93+k017ANk=
-github.com/deluan/go-taglib v0.0.0-20260119020817-8753c7531798/go.mod h1:sKDN0U4qXDlq6LFK+aOAkDH4Me5nDV1V/A4B+B69xBA=
+github.com/deluan/go-taglib v0.0.0-20260205042457-5d80806aee57 h1:SXIwfjzTv0UzoUWpFREl8p3AxXVLmbcto1/ISih11a0=
+github.com/deluan/go-taglib v0.0.0-20260205042457-5d80806aee57/go.mod h1:sKDN0U4qXDlq6LFK+aOAkDH4Me5nDV1V/A4B+B69xBA=
 github.com/deluan/rest v0.0.0-20211102003136-6260bc399cbf h1:tb246l2Zmpt/GpF9EcHCKTtwzrd0HGfEmoODFA/qnk4=
 github.com/deluan/rest v0.0.0-20211102003136-6260bc399cbf/go.mod h1:tSgDythFsl0QgS/PFWfIZqcJKnkADWneY80jaVRlqK8=
 github.com/deluan/sanitize v0.0.0-20241120162836-fdfd8fdfaa55 h1:wSCnggTs2f2ji6nFwQmfwgINcmSMj0xF0oHnoyRSPe4=

model/mediafile.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/gohugoio/hashstructure"
 	"github.com/navidrome/navidrome/conf"
+	confmime "github.com/navidrome/navidrome/conf/mime"
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/utils"
 	"github.com/navidrome/navidrome/utils/slice"
@@ -56,6 +57,7 @@ type MediaFile struct {
 	SampleRate           int      `structs:"sample_rate" json:"sampleRate"`
 	BitDepth             int      `structs:"bit_depth" json:"bitDepth"`
 	Channels             int      `structs:"channels" json:"channels"`
+	Codec                string   `structs:"codec" json:"codec"`
 	Genre                string   `structs:"genre" json:"genre"`
 	Genres               Genres   `structs:"-" json:"genres,omitempty"`
 	SortTitle            string   `structs:"sort_title" json:"sortTitle,omitempty"`
@@ -161,6 +163,79 @@ func (mf MediaFile) AbsolutePath() string {
 	return filepath.Join(mf.LibraryPath, mf.Path)
 }
 
+// AudioCodec returns the audio codec for this file.
+// Uses the stored Codec field if available, otherwise infers from Suffix and audio properties.
+func (mf MediaFile) AudioCodec() string {
+	// If we have a stored codec from scanning, normalize and return it
+	if mf.Codec != "" {
+		return strings.ToLower(mf.Codec)
+	}
+	// Fallback: infer from Suffix + BitDepth
+	return mf.inferCodecFromSuffix()
+}
+
+// inferCodecFromSuffix infers the codec from the file extension when Codec field is empty.
+func (mf MediaFile) inferCodecFromSuffix() string {
+	switch strings.ToLower(mf.Suffix) {
+	case "mp3", "mpga":
+		return "mp3"
+	case "mp2":
+		return "mp2"
+	case "ogg", "oga":
+		return "vorbis"
+	case "opus":
+		return "opus"
+	case "mpc":
+		return "mpc"
+	case "wma":
+		return "wma"
+	case "flac":
+		return "flac"
+	case "wav":
+		return "pcm"
+	case "aif", "aiff", "aifc":
+		return "pcm"
+	case "ape":
+		return "ape"
+	case "wv", "wvp":
+		return "wv"
+	case "tta":
+		return "tta"
+	case "tak":
+		return "tak"
+	case "shn":
+		return "shn"
+	case "dsf", "dff":
+		return "dsd"
+	case "m4a":
+		// AAC if BitDepth==0, ALAC if BitDepth>0
+		if mf.BitDepth > 0 {
+			return "alac"
+		}
+		return "aac"
+	case "m4b", "m4p", "m4r":
+		return "aac"
+	default:
+		return ""
+	}
+}
+
+// IsLossless returns true if this file uses a lossless codec.
+func (mf MediaFile) IsLossless() bool {
+	codec := mf.AudioCodec()
+	// Primary: codec-based check (most accurate for containers like M4A)
+	switch codec {
+	case "flac", "alac", "pcm", "ape", "wv", "tta", "tak", "shn", "dsd":
+		return true
+	}
+	// Secondary: suffix-based check using configurable list from YAML
+	if slices.Contains(confmime.LosslessFormats, mf.Suffix) {
+		return true
+	}
+	// Fallback heuristic: if BitDepth is set, it's likely lossless
+	return mf.BitDepth > 0
+}
+
 type MediaFiles []MediaFile
 
 // ToAlbum creates an Album object based on the attributes of this MediaFiles collection.

model/mediafile_test.go

@@ -475,7 +475,7 @@ var _ = Describe("MediaFile", func() {
 		DeferCleanup(configtest.SetupConfig())
 		conf.Server.EnableMediaFileCoverArt = true
 	})
-	Describe(".CoverArtId()", func() {
+	Describe("CoverArtId", func() {
 		It("returns its own id if it HasCoverArt", func() {
 			mf := MediaFile{ID: "111", AlbumID: "1", HasCoverArt: true}
 			id := mf.CoverArtID()
@@ -496,6 +496,94 @@ var _ = Describe("MediaFile", func() {
 			Expect(id.ID).To(Equal(mf.AlbumID))
 		})
 	})
+
+	Describe("AudioCodec", func() {
+		It("returns normalized stored codec when available", func() {
+			mf := MediaFile{Codec: "AAC", Suffix: "m4a"}
+			Expect(mf.AudioCodec()).To(Equal("aac"))
+		})
+
+		It("returns stored codec lowercased", func() {
+			mf := MediaFile{Codec: "ALAC", Suffix: "m4a"}
+			Expect(mf.AudioCodec()).To(Equal("alac"))
+		})
+
+		DescribeTable("infers codec from suffix when Codec field is empty",
+			func(suffix string, bitDepth int, expected string) {
+				mf := MediaFile{Suffix: suffix, BitDepth: bitDepth}
+				Expect(mf.AudioCodec()).To(Equal(expected))
+			},
+			Entry("mp3", "mp3", 0, "mp3"),
+			Entry("mpga", "mpga", 0, "mp3"),
+			Entry("mp2", "mp2", 0, "mp2"),
+			Entry("ogg", "ogg", 0, "vorbis"),
+			Entry("oga", "oga", 0, "vorbis"),
+			Entry("opus", "opus", 0, "opus"),
+			Entry("mpc", "mpc", 0, "mpc"),
+			Entry("wma", "wma", 0, "wma"),
+			Entry("flac", "flac", 0, "flac"),
+			Entry("wav", "wav", 0, "pcm"),
+			Entry("aif", "aif", 0, "pcm"),
+			Entry("aiff", "aiff", 0, "pcm"),
+			Entry("aifc", "aifc", 0, "pcm"),
+			Entry("ape", "ape", 0, "ape"),
+			Entry("wv", "wv", 0, "wv"),
+			Entry("wvp", "wvp", 0, "wv"),
+			Entry("tta", "tta", 0, "tta"),
+			Entry("tak", "tak", 0, "tak"),
+			Entry("shn", "shn", 0, "shn"),
+			Entry("dsf", "dsf", 0, "dsd"),
+			Entry("dff", "dff", 0, "dsd"),
+			Entry("m4a with BitDepth=0 (AAC)", "m4a", 0, "aac"),
+			Entry("m4a with BitDepth>0 (ALAC)", "m4a", 16, "alac"),
+			Entry("m4b", "m4b", 0, "aac"),
+			Entry("m4p", "m4p", 0, "aac"),
+			Entry("m4r", "m4r", 0, "aac"),
+			Entry("unknown suffix", "xyz", 0, ""),
+		)
+
+		It("prefers stored codec over suffix inference", func() {
+			mf := MediaFile{Codec: "ALAC", Suffix: "m4a", BitDepth: 0}
+			Expect(mf.AudioCodec()).To(Equal("alac"))
+		})
+	})
+
+	Describe("IsLossless", func() {
+		BeforeEach(func() {
+			DeferCleanup(configtest.SetupConfig())
+		})
+
+		DescribeTable("detects lossless codecs",
+			func(codec string, suffix string, bitDepth int, expected bool) {
+				mf := MediaFile{Codec: codec, Suffix: suffix, BitDepth: bitDepth}
+				Expect(mf.IsLossless()).To(Equal(expected))
+			},
+			Entry("flac", "FLAC", "flac", 16, true),
+			Entry("alac", "ALAC", "m4a", 24, true),
+			Entry("pcm via wav", "", "wav", 16, true),
+			Entry("pcm via aiff", "", "aiff", 24, true),
+			Entry("ape", "", "ape", 16, true),
+			Entry("wv", "", "wv", 0, true),
+			Entry("tta", "", "tta", 0, true),
+			Entry("tak", "", "tak", 0, true),
+			Entry("shn", "", "shn", 0, true),
+			Entry("dsd", "", "dsf", 0, true),
+			Entry("mp3 is lossy", "MP3", "mp3", 0, false),
+			Entry("aac is lossy", "AAC", "m4a", 0, false),
+			Entry("vorbis is lossy", "", "ogg", 0, false),
+			Entry("opus is lossy", "", "opus", 0, false),
+		)
+
+		It("detects lossless via BitDepth fallback when codec is unknown", func() {
+			mf := MediaFile{Suffix: "xyz", BitDepth: 24}
+			Expect(mf.IsLossless()).To(BeTrue())
+		})
+
+		It("returns false for unknown with no BitDepth", func() {
+			mf := MediaFile{Suffix: "xyz", BitDepth: 0}
+			Expect(mf.IsLossless()).To(BeFalse())
+		})
+	})
 })
 
 func t(v string) time.Time {

model/metadata/map_mediafile.go

@@ -65,6 +65,7 @@ func (md Metadata) ToMediaFile(libID int, folderID string) model.MediaFile {
 	mf.SampleRate = md.AudioProperties().SampleRate
 	mf.BitDepth = md.AudioProperties().BitDepth
 	mf.Channels = md.AudioProperties().Channels
+	mf.Codec = md.AudioProperties().Codec
 	mf.Path = md.FilePath()
 	mf.Suffix = md.Suffix()
 	mf.Size = md.Size()

model/metadata/metadata.go

@@ -35,6 +35,7 @@ type AudioProperties struct {
 	BitDepth   int
 	SampleRate int
 	Channels   int
+	Codec      string
 }
 
 type Date string

plugins/README.md

@@ -1036,9 +1036,8 @@ See [examples/](examples/) for complete working plugins:
 | [coverartarchive-py](examples/coverartarchive-py/)             | Python   | MetadataAgent | HTTP                                       | Cover Art Archive              |
 | [webhook-rs](examples/webhook-rs/)                             | Rust     | Scrobbler     | HTTP                                       | HTTP webhooks                  |
 | [nowplaying-py](examples/nowplaying-py/)                       | Python   | Lifecycle     | Scheduler, SubsonicAPI                     | Periodic now-playing logger    |
-| [library-inspector](examples/library-inspector-rs/)               | Rust     | Lifecycle     | Library, Scheduler                         | Periodic library stats logging |
+| [library-inspector](examples/library-inspector-rs/)            | Rust     | Lifecycle     | Library, Scheduler                         | Periodic library stats logging |
 | [crypto-ticker](examples/crypto-ticker/)                       | Go       | Lifecycle     | WebSocket, Scheduler                       | Real-time crypto prices demo   |
-| [discord-rich-presence](examples/discord-rich-presence/)       | Go       | Scrobbler     | HTTP, WebSocket, Cache, Scheduler, Artwork | Discord integration            |
 | [discord-rich-presence-rs](examples/discord-rich-presence-rs/) | Rust     | Scrobbler     | HTTP, WebSocket, Cache, Scheduler, Artwork | Discord integration (Rust)     |
 
 ---

plugins/cmd/ndpgen/integration_test.go

@@ -282,6 +282,9 @@ type ServiceB interface {
 
 			Entry("option pattern (value, exists bool)",
 				"config_service.go.txt", "config_client_expected.go.txt", "config_client_expected.py", "config_client_expected.rs"),
+
+			Entry("raw=true binary response",
+				"raw_service.go.txt", "raw_client_expected.go.txt", "raw_client_expected.py", "raw_client_expected.rs"),
 		)
 
 		It("generates compilable client code for comprehensive service", func() {

plugins/cmd/ndpgen/internal/generator_test.go

@@ -264,6 +264,96 @@ var _ = Describe("Generator", func() {
 			Expect(codeStr).To(ContainSubstring(`extism "github.com/extism/go-sdk"`))
 		})
 
+		It("should generate binary framing for raw=true methods", func() {
+			svc := Service{
+				Name:       "Stream",
+				Permission: "stream",
+				Interface:  "StreamService",
+				Methods: []Method{
+					{
+						Name:     "GetStream",
+						HasError: true,
+						Raw:      true,
+						Params:   []Param{NewParam("uri", "string")},
+						Returns: []Param{
+							NewParam("contentType", "string"),
+							NewParam("data", "[]byte"),
+						},
+					},
+				},
+			}
+
+			code, err := GenerateHost(svc, "host")
+			Expect(err).NotTo(HaveOccurred())
+
+			_, err = format.Source(code)
+			Expect(err).NotTo(HaveOccurred())
+
+			codeStr := string(code)
+
+			// Should include encoding/binary import for raw methods
+			Expect(codeStr).To(ContainSubstring(`"encoding/binary"`))
+
+			// Should NOT generate a response type for raw methods
+			Expect(codeStr).NotTo(ContainSubstring("type StreamGetStreamResponse struct"))
+
+			// Should generate request type (request is still JSON)
+			Expect(codeStr).To(ContainSubstring("type StreamGetStreamRequest struct"))
+
+			// Should build binary frame [0x00][4-byte CT len][CT][data]
+			Expect(codeStr).To(ContainSubstring("frame[0] = 0x00"))
+			Expect(codeStr).To(ContainSubstring("binary.BigEndian.PutUint32"))
+
+			// Should have writeRawError helper
+			Expect(codeStr).To(ContainSubstring("streamWriteRawError"))
+
+			// Should use writeRawError instead of writeError for raw methods
+			Expect(codeStr).To(ContainSubstring("streamWriteRawError(p, stack"))
+		})
+
+		It("should generate both writeError and writeRawError for mixed services", func() {
+			svc := Service{
+				Name:       "API",
+				Permission: "api",
+				Interface:  "APIService",
+				Methods: []Method{
+					{
+						Name:     "Call",
+						HasError: true,
+						Params:   []Param{NewParam("uri", "string")},
+						Returns:  []Param{NewParam("response", "string")},
+					},
+					{
+						Name:     "CallRaw",
+						HasError: true,
+						Raw:      true,
+						Params:   []Param{NewParam("uri", "string")},
+						Returns: []Param{
+							NewParam("contentType", "string"),
+							NewParam("data", "[]byte"),
+						},
+					},
+				},
+			}
+
+			code, err := GenerateHost(svc, "host")
+			Expect(err).NotTo(HaveOccurred())
+
+			_, err = format.Source(code)
+			Expect(err).NotTo(HaveOccurred())
+
+			codeStr := string(code)
+
+			// Should have both helpers
+			Expect(codeStr).To(ContainSubstring("apiWriteResponse"))
+			Expect(codeStr).To(ContainSubstring("apiWriteError"))
+			Expect(codeStr).To(ContainSubstring("apiWriteRawError"))
+
+			// Should generate response type for non-raw method only
+			Expect(codeStr).To(ContainSubstring("type APICallResponse struct"))
+			Expect(codeStr).NotTo(ContainSubstring("type APICallRawResponse struct"))
+		})
+
 		It("should always include json import for JSON protocol", func() {
 			// All services use JSON protocol, so json import is always needed
 			svc := Service{
@@ -626,6 +716,72 @@ var _ = Describe("Generator", func() {
 			Expect(codeStr).To(ContainSubstring(`response.get("floatVal", 0.0)`))
 			Expect(codeStr).To(ContainSubstring(`response.get("boolVal", False)`))
 		})
+
+		It("should generate binary frame parsing for raw methods", func() {
+			svc := Service{
+				Name:       "Stream",
+				Permission: "stream",
+				Interface:  "StreamService",
+				Methods: []Method{
+					{
+						Name:     "GetStream",
+						HasError: true,
+						Raw:      true,
+						Params:   []Param{NewParam("uri", "string")},
+						Returns: []Param{
+							NewParam("contentType", "string"),
+							NewParam("data", "[]byte"),
+						},
+						Doc: "GetStream returns raw binary stream data.",
+					},
+				},
+			}
+
+			code, err := GenerateClientPython(svc)
+			Expect(err).NotTo(HaveOccurred())
+
+			codeStr := string(code)
+
+			// Should import Tuple and struct for raw methods
+			Expect(codeStr).To(ContainSubstring("from typing import Any, Tuple"))
+			Expect(codeStr).To(ContainSubstring("import struct"))
+
+			// Should return Tuple[str, bytes]
+			Expect(codeStr).To(ContainSubstring("-> Tuple[str, bytes]:"))
+
+			// Should parse binary frame instead of JSON
+			Expect(codeStr).To(ContainSubstring("response_bytes = response_mem.bytes()"))
+			Expect(codeStr).To(ContainSubstring("response_bytes[0] == 0x01"))
+			Expect(codeStr).To(ContainSubstring("struct.unpack"))
+			Expect(codeStr).To(ContainSubstring("return content_type, data"))
+
+			// Should NOT use json.loads for response
+			Expect(codeStr).NotTo(ContainSubstring("json.loads(extism.memory.string(response_mem))"))
+		})
+
+		It("should not import Tuple or struct for non-raw services", func() {
+			svc := Service{
+				Name:       "Test",
+				Permission: "test",
+				Interface:  "TestService",
+				Methods: []Method{
+					{
+						Name:     "Call",
+						HasError: true,
+						Params:   []Param{NewParam("uri", "string")},
+						Returns:  []Param{NewParam("response", "string")},
+					},
+				},
+			}
+
+			code, err := GenerateClientPython(svc)
+			Expect(err).NotTo(HaveOccurred())
+
+			codeStr := string(code)
+
+			Expect(codeStr).NotTo(ContainSubstring("Tuple"))
+			Expect(codeStr).NotTo(ContainSubstring("import struct"))
+		})
 	})
 
 	Describe("GenerateGoDoc", func() {
@@ -782,6 +938,47 @@ var _ = Describe("Generator", func() {
 			// Check for PDK import
 			Expect(codeStr).To(ContainSubstring("github.com/navidrome/navidrome/plugins/pdk/go/pdk"))
 		})
+
+		It("should include encoding/binary import for raw methods", func() {
+			svc := Service{
+				Name:       "Stream",
+				Permission: "stream",
+				Interface:  "StreamService",
+				Methods: []Method{
+					{
+						Name:     "GetStream",
+						HasError: true,
+						Raw:      true,
+						Params:   []Param{NewParam("uri", "string")},
+						Returns: []Param{
+							NewParam("contentType", "string"),
+							NewParam("data", "[]byte"),
+						},
+					},
+				},
+			}
+
+			code, err := GenerateClientGo(svc, "host")
+			Expect(err).NotTo(HaveOccurred())
+
+			codeStr := string(code)
+
+			// Should include encoding/binary for raw binary frame parsing
+			Expect(codeStr).To(ContainSubstring(`"encoding/binary"`))
+
+			// Should NOT generate response type struct for raw methods
+			Expect(codeStr).NotTo(ContainSubstring("streamGetStreamResponse struct"))
+
+			// Should still generate request type
+			Expect(codeStr).To(ContainSubstring("streamGetStreamRequest struct"))
+
+			// Should parse binary frame
+			Expect(codeStr).To(ContainSubstring("responseBytes[0] == 0x01"))
+			Expect(codeStr).To(ContainSubstring("binary.BigEndian.Uint32"))
+
+			// Should return (string, []byte, error)
+			Expect(codeStr).To(ContainSubstring("func StreamGetStream(uri string) (string, []byte, error)"))
+		})
 	})
 
 	Describe("GenerateClientGoStub", func() {
@@ -1550,6 +1747,51 @@ var _ = Describe("Rust Generation", func() {
 			Expect(codeStr).To(ContainSubstring("Result<bool, Error>"))
 			Expect(codeStr).NotTo(ContainSubstring("Option<bool>"))
 		})
+
+		It("should generate raw extern C import and binary frame parsing for raw methods", func() {
+			svc := Service{
+				Name:       "Stream",
+				Permission: "stream",
+				Interface:  "StreamService",
+				Methods: []Method{
+					{
+						Name:     "GetStream",
+						HasError: true,
+						Raw:      true,
+						Params:   []Param{NewParam("uri", "string")},
+						Returns: []Param{
+							NewParam("contentType", "string"),
+							NewParam("data", "[]byte"),
+						},
+						Doc: "GetStream returns raw binary stream data.",
+					},
+				},
+			}
+
+			code, err := GenerateClientRust(svc)
+			Expect(err).NotTo(HaveOccurred())
+
+			codeStr := string(code)
+
+			// Should use extern "C" with wasm_import_module for raw methods, not #[host_fn] extern "ExtismHost"
+			Expect(codeStr).To(ContainSubstring(`#[link(wasm_import_module = "extism:host/user")]`))
+			Expect(codeStr).To(ContainSubstring(`extern "C"`))
+			Expect(codeStr).To(ContainSubstring("fn stream_getstream(offset: u64) -> u64"))
+
+			// Should NOT generate response type for raw methods
+			Expect(codeStr).NotTo(ContainSubstring("StreamGetStreamResponse"))
+
+			// Should generate request type (request is still JSON)
+			Expect(codeStr).To(ContainSubstring("struct StreamGetStreamRequest"))
+
+			// Should return Result<(String, Vec<u8>), Error>
+			Expect(codeStr).To(ContainSubstring("Result<(String, Vec<u8>), Error>"))
+
+			// Should parse binary frame
+			Expect(codeStr).To(ContainSubstring("response_bytes[0] == 0x01"))
+			Expect(codeStr).To(ContainSubstring("u32::from_be_bytes"))
+			Expect(codeStr).To(ContainSubstring("String::from_utf8_lossy"))
+		})
 	})
 })
 

plugins/cmd/ndpgen/internal/parser.go

@@ -761,6 +761,7 @@ func parseMethod(name string, funcType *ast.FuncType, annotation map[string]stri
 	m := Method{
 		Name:       name,
 		ExportName: annotation["name"],
+		Raw:        annotation["raw"] == "true",
 		Doc:        doc,
 	}
 
@@ -799,6 +800,13 @@ func parseMethod(name string, funcType *ast.FuncType, annotation map[string]stri
 		}
 	}
 
+	// Validate raw=true methods: must return exactly (string, []byte, error)
+	if m.Raw {
+		if !m.HasError || len(m.Returns) != 2 || m.Returns[0].Type != "string" || m.Returns[1].Type != "[]byte" {
+			return m, fmt.Errorf("raw=true method %s must return (string, []byte, error) — content-type, data, error", name)
+		}
+	}
+
 	return m, nil
 }
 

plugins/cmd/ndpgen/internal/parser_test.go

@@ -122,6 +122,119 @@ type TestService interface {
 			Expect(services[0].Methods[0].Name).To(Equal("Exported"))
 		})
 
+		It("should parse raw=true annotation", func() {
+			src := `package host
+
+import "context"
+
+//nd:hostservice name=Stream permission=stream
+type StreamService interface {
+	//nd:hostfunc raw=true
+	GetStream(ctx context.Context, uri string) (contentType string, data []byte, err error)
+}
+`
+			err := os.WriteFile(filepath.Join(tmpDir, "stream.go"), []byte(src), 0600)
+			Expect(err).NotTo(HaveOccurred())
+
+			services, err := ParseDirectory(tmpDir)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(services).To(HaveLen(1))
+
+			m := services[0].Methods[0]
+			Expect(m.Name).To(Equal("GetStream"))
+			Expect(m.Raw).To(BeTrue())
+			Expect(m.HasError).To(BeTrue())
+			Expect(m.Returns).To(HaveLen(2))
+			Expect(m.Returns[0].Name).To(Equal("contentType"))
+			Expect(m.Returns[0].Type).To(Equal("string"))
+			Expect(m.Returns[1].Name).To(Equal("data"))
+			Expect(m.Returns[1].Type).To(Equal("[]byte"))
+		})
+
+		It("should set Raw=false when raw annotation is absent", func() {
+			src := `package host
+
+import "context"
+
+//nd:hostservice name=Test permission=test
+type TestService interface {
+	//nd:hostfunc
+	Call(ctx context.Context, uri string) (response string, err error)
+}
+`
+			err := os.WriteFile(filepath.Join(tmpDir, "test.go"), []byte(src), 0600)
+			Expect(err).NotTo(HaveOccurred())
+
+			services, err := ParseDirectory(tmpDir)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(services[0].Methods[0].Raw).To(BeFalse())
+		})
+
+		It("should reject raw=true with invalid return signature", func() {
+			src := `package host
+
+import "context"
+
+//nd:hostservice name=Test permission=test
+type TestService interface {
+	//nd:hostfunc raw=true
+	BadRaw(ctx context.Context, uri string) (result string, err error)
+}
+`
+			err := os.WriteFile(filepath.Join(tmpDir, "test.go"), []byte(src), 0600)
+			Expect(err).NotTo(HaveOccurred())
+
+			_, err = ParseDirectory(tmpDir)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("raw=true"))
+			Expect(err.Error()).To(ContainSubstring("must return (string, []byte, error)"))
+		})
+
+		It("should reject raw=true without error return", func() {
+			src := `package host
+
+import "context"
+
+//nd:hostservice name=Test permission=test
+type TestService interface {
+	//nd:hostfunc raw=true
+	BadRaw(ctx context.Context, uri string) (contentType string, data []byte)
+}
+`
+			err := os.WriteFile(filepath.Join(tmpDir, "test.go"), []byte(src), 0600)
+			Expect(err).NotTo(HaveOccurred())
+
+			_, err = ParseDirectory(tmpDir)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("raw=true"))
+		})
+
+		It("should parse mixed raw and non-raw methods", func() {
+			src := `package host
+
+import "context"
+
+//nd:hostservice name=API permission=api
+type APIService interface {
+	//nd:hostfunc
+	Call(ctx context.Context, uri string) (responseJSON string, err error)
+
+	//nd:hostfunc raw=true
+	CallRaw(ctx context.Context, uri string) (contentType string, data []byte, err error)
+}
+`
+			err := os.WriteFile(filepath.Join(tmpDir, "api.go"), []byte(src), 0600)
+			Expect(err).NotTo(HaveOccurred())
+
+			services, err := ParseDirectory(tmpDir)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(services).To(HaveLen(1))
+			Expect(services[0].Methods).To(HaveLen(2))
+			Expect(services[0].Methods[0].Raw).To(BeFalse())
+			Expect(services[0].Methods[1].Raw).To(BeTrue())
+			Expect(services[0].HasRawMethods()).To(BeTrue())
+		})
+
 		It("should handle custom export name", func() {
 			src := `package host
 

plugins/cmd/ndpgen/internal/templates/client.go.tmpl

@@ -8,6 +8,9 @@
 package {{.Package}}
 
 import (
+{{- if .Service.HasRawMethods}}
+	"encoding/binary"
+{{- end}}
 	"encoding/json"
 {{- if .Service.HasErrors}}
 	"errors"
@@ -49,7 +52,7 @@ type {{requestType .}} struct {
 {{- end}}
 }
 {{- end}}
-{{- if not .IsErrorOnly}}
+{{- if and (not .IsErrorOnly) (not .Raw)}}
 
 type {{responseType .}} struct {
 {{- range .Returns}}
@@ -95,7 +98,27 @@ func {{$.Service.Name}}{{.Name}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{
 	// Read the response from memory
 	responseMem := pdk.FindMemory(responsePtr)
 	responseBytes := responseMem.ReadBytes()
-{{- if .IsErrorOnly}}
+{{- if .Raw}}
+
+	// Parse binary-framed response
+	if len(responseBytes) == 0 {
+		return "", nil, errors.New("empty response from host")
+	}
+	if responseBytes[0] == 0x01 { // error
+		return "", nil, errors.New(string(responseBytes[1:]))
+	}
+	if responseBytes[0] != 0x00 {
+		return "", nil, errors.New("unknown response status")
+	}
+	if len(responseBytes) < 5 {
+		return "", nil, errors.New("malformed raw response: incomplete header")
+	}
+	ctLen := binary.BigEndian.Uint32(responseBytes[1:5])
+	if uint32(len(responseBytes)) < 5+ctLen {
+		return "", nil, errors.New("malformed raw response: content-type overflow")
+	}
+	return string(responseBytes[5 : 5+ctLen]), responseBytes[5+ctLen:], nil
+{{- else if .IsErrorOnly}}
 
 	// Parse error-only response
 	var response struct {

plugins/cmd/ndpgen/internal/templates/client.py.tmpl

@@ -8,10 +8,13 @@
 # main __init__.py file. Copy the needed functions from this file into your plugin.
 
 from dataclasses import dataclass
-from typing import Any
+from typing import Any{{- if .Service.HasRawMethods}}, Tuple{{end}}
 
 import extism
 import json
+{{- if .Service.HasRawMethods}}
+import struct
+{{- end}}
 
 
 class HostFunctionError(Exception):
@@ -29,7 +32,7 @@ def _{{exportName .}}(offset: int) -> int:
 {{- end}}
 {{- /* Generate dataclasses for multi-value returns */ -}}
 {{range .Service.Methods}}
-{{- if .NeedsResultClass}}
+{{- if and .NeedsResultClass (not .Raw)}}
 
 
 @dataclass
@@ -44,7 +47,7 @@ class {{pythonResultType .}}:
 {{range .Service.Methods}}
 
 
-def {{pythonFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.PythonName}}: {{$p.PythonType}}{{end}}){{if .NeedsResultClass}} -> {{pythonResultType .}}{{else if .HasReturns}} -> {{(index .Returns 0).PythonType}}{{else}} -> None{{end}}:
+def {{pythonFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.PythonName}}: {{$p.PythonType}}{{end}}){{if .Raw}} -> Tuple[str, bytes]{{else if .NeedsResultClass}} -> {{pythonResultType .}}{{else if .HasReturns}} -> {{(index .Returns 0).PythonType}}{{else}} -> None{{end}}:
     """{{if .Doc}}{{.Doc}}{{else}}Call the {{exportName .}} host function.{{end}}
 {{- if .HasParams}}
 
@@ -53,7 +56,11 @@ def {{pythonFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.PythonNam
         {{.PythonName}}: {{.PythonType}} parameter.
 {{- end}}
 {{- end}}
-{{- if .HasReturns}}
+{{- if .Raw}}
+
+    Returns:
+        Tuple of (content_type, data) with the raw binary response.
+{{- else if .HasReturns}}
 
     Returns:
 {{- if .NeedsResultClass}}
@@ -79,6 +86,24 @@ def {{pythonFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.PythonNam
     request_mem = extism.memory.alloc(request_bytes)
     response_offset = _{{exportName .}}(request_mem.offset)
     response_mem = extism.memory.find(response_offset)
+{{- if .Raw}}
+    response_bytes = response_mem.bytes()
+
+    if len(response_bytes) == 0:
+        raise HostFunctionError("empty response from host")
+    if response_bytes[0] == 0x01:
+        raise HostFunctionError(response_bytes[1:].decode("utf-8"))
+    if response_bytes[0] != 0x00:
+        raise HostFunctionError("unknown response status")
+    if len(response_bytes) < 5:
+        raise HostFunctionError("malformed raw response: incomplete header")
+    ct_len = struct.unpack(">I", response_bytes[1:5])[0]
+    if len(response_bytes) < 5 + ct_len:
+        raise HostFunctionError("malformed raw response: content-type overflow")
+    content_type = response_bytes[5:5 + ct_len].decode("utf-8")
+    data = response_bytes[5 + ct_len:]
+    return content_type, data
+{{- else}}
     response = json.loads(extism.memory.string(response_mem))
 {{if .HasError}}
     if response.get("error"):
@@ -94,3 +119,4 @@ def {{pythonFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.PythonNam
     return response.get("{{(index .Returns 0).JSONName}}"{{pythonDefault (index .Returns 0)}})
 {{- end}}
 {{- end}}
+{{- end}}

plugins/cmd/ndpgen/internal/templates/client.rs.tmpl

@@ -33,6 +33,7 @@ struct {{requestType .}} {
 {{- end}}
 }
 {{- end}}
+{{- if not .Raw}}
 
 #[derive(Debug, Clone, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -47,16 +48,92 @@ struct {{responseType .}} {
 {{- end}}
 }
 {{- end}}
+{{- end}}
 
 #[host_fn]
 extern "ExtismHost" {
 {{- range .Service.Methods}}
+{{- if not .Raw}}
     fn {{exportName .}}(input: Json<{{if .HasParams}}{{requestType .}}{{else}}serde_json::Value{{end}}>) -> Json<{{responseType .}}>;
 {{- end}}
+{{- end}}
 }
+{{- /* Declare raw extern "C" imports for raw methods */ -}}
+{{- range .Service.Methods}}
+{{- if .Raw}}
+
+#[link(wasm_import_module = "extism:host/user")]
+extern "C" {
+    fn {{exportName .}}(offset: u64) -> u64;
+}
+{{- end}}
+{{- end}}
 
 {{- /* Generate wrapper functions */ -}}
 {{range .Service.Methods}}
+{{- if .Raw}}
+
+{{if .Doc}}{{rustDocComment .Doc}}{{else}}/// Calls the {{exportName .}} host function.{{end}}
+{{- if .HasParams}}
+///
+/// # Arguments
+{{- range .Params}}
+/// * `{{.RustName}}` - {{rustType .}} parameter.
+{{- end}}
+{{- end}}
+///
+/// # Returns
+/// A tuple of (content_type, data) with the raw binary response.
+///
+/// # Errors
+/// Returns an error if the host function call fails.
+pub fn {{rustFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.RustName}}: {{rustParamType $p}}{{end}}) -> Result<(String, Vec<u8>), Error> {
+{{- if .HasParams}}
+    let req = {{requestType .}} {
+{{- range .Params}}
+        {{.RustName}}: {{.RustName}}{{if .NeedsToOwned}}.to_owned(){{end}},
+{{- end}}
+    };
+    let input_bytes = serde_json::to_vec(&req).map_err(|e| Error::msg(e.to_string()))?;
+{{- else}}
+    let input_bytes = b"{}".to_vec();
+{{- end}}
+    let input_mem = Memory::from_bytes(&input_bytes).map_err(|e| Error::msg(e.to_string()))?;
+
+    let response_offset = unsafe { {{exportName .}}(input_mem.offset()) };
+
+    let response_mem = Memory::find(response_offset)
+        .ok_or_else(|| Error::msg("empty response from host"))?;
+    let response_bytes = response_mem.to_vec();
+
+    if response_bytes.is_empty() {
+        return Err(Error::msg("empty response from host"));
+    }
+    if response_bytes[0] == 0x01 {
+        let msg = String::from_utf8_lossy(&response_bytes[1..]).to_string();
+        return Err(Error::msg(msg));
+    }
+    if response_bytes[0] != 0x00 {
+        return Err(Error::msg("unknown response status"));
+    }
+    if response_bytes.len() < 5 {
+        return Err(Error::msg("malformed raw response: incomplete header"));
+    }
+    let ct_len = u32::from_be_bytes([
+        response_bytes[1],
+        response_bytes[2],
+        response_bytes[3],
+        response_bytes[4],
+    ]) as usize;
+    if ct_len > response_bytes.len() - 5 {
+        return Err(Error::msg("malformed raw response: content-type overflow"));
+    }
+    let ct_end = 5 + ct_len;
+    let content_type = String::from_utf8_lossy(&response_bytes[5..ct_end]).to_string();
+    let data = response_bytes[ct_end..].to_vec();
+    Ok((content_type, data))
+}
+{{- else}}
 
 {{if .Doc}}{{rustDocComment .Doc}}{{else}}/// Calls the {{exportName .}} host function.{{end}}
 {{- if .HasParams}}
@@ -132,3 +209,4 @@ pub fn {{rustFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.RustName
 }
 {{- end}}
 {{- end}}
+{{- end}}

plugins/cmd/ndpgen/internal/templates/host.go.tmpl

@@ -4,6 +4,9 @@ package {{.Package}}
 
 import (
 	"context"
+{{- if .Service.HasRawMethods}}
+	"encoding/binary"
+{{- end}}
 	"encoding/json"
 
 	extism "github.com/extism/go-sdk"
@@ -20,6 +23,7 @@ type {{requestType .}} struct {
 {{- end}}
 }
 {{- end}}
+{{- if not .Raw}}
 
 // {{responseType .}} is the response type for {{$.Service.Name}}.{{.Name}}.
 type {{responseType .}} struct {
@@ -30,6 +34,7 @@ type {{responseType .}} struct {
 	Error string `json:"error,omitempty"`
 {{- end}}
 }
+{{- end}}
 {{end}}
 
 // Register{{.Service.Name}}HostFunctions registers {{.Service.Name}} service host functions.
@@ -51,18 +56,48 @@ func new{{$.Service.Name}}{{.Name}}HostFunction(service {{$.Service.Interface}})
 			// Read JSON request from plugin memory
 			reqBytes, err := p.ReadBytes(stack[0])
 			if err != nil {
+{{- if .Raw}}
+				{{$.Service.Name | lower}}WriteRawError(p, stack, err)
+{{- else}}
 				{{$.Service.Name | lower}}WriteError(p, stack, err)
+{{- end}}
 				return
 			}
 			var req {{requestType .}}
 			if err := json.Unmarshal(reqBytes, &req); err != nil {
+{{- if .Raw}}
+				{{$.Service.Name | lower}}WriteRawError(p, stack, err)
+{{- else}}
 				{{$.Service.Name | lower}}WriteError(p, stack, err)
+{{- end}}
 				return
 			}
 {{- end}}
 
 			// Call the service method
-{{- if .HasReturns}}
+{{- if .Raw}}
+			{{range $i, $r := .Returns}}{{if $i}}, {{end}}{{lower $r.Name}}{{end}}, svcErr := service.{{.Name}}(ctx{{range .Params}}, req.{{title .Name}}{{end}})
+			if svcErr != nil {
+				{{$.Service.Name | lower}}WriteRawError(p, stack, svcErr)
+				return
+			}
+
+			// Write binary-framed response to plugin memory:
+			// [0x00][4-byte content-type length (big-endian)][content-type string][raw data]
+			ctBytes := []byte({{lower (index .Returns 0).Name}})
+			frame := make([]byte, 1+4+len(ctBytes)+len({{lower (index .Returns 1).Name}}))
+			frame[0] = 0x00 // success
+			binary.BigEndian.PutUint32(frame[1:5], uint32(len(ctBytes)))
+			copy(frame[5:5+len(ctBytes)], ctBytes)
+			copy(frame[5+len(ctBytes):], {{lower (index .Returns 1).Name}})
+
+			respPtr, err := p.WriteBytes(frame)
+			if err != nil {
+				stack[0] = 0
+				return
+			}
+			stack[0] = respPtr
+{{- else if .HasReturns}}
 {{- if .HasError}}
 			{{range $i, $r := .Returns}}{{if $i}}, {{end}}{{lower $r.Name}}{{end}}, svcErr := service.{{.Name}}(ctx{{range .Params}}, req.{{title .Name}}{{end}})
 			if svcErr != nil {
@@ -72,14 +107,6 @@ func new{{$.Service.Name}}{{.Name}}HostFunction(service {{$.Service.Interface}})
 {{- else}}
 			{{range $i, $r := .Returns}}{{if $i}}, {{end}}{{lower $r.Name}}{{end}} := service.{{.Name}}(ctx{{range .Params}}, req.{{title .Name}}{{end}})
 {{- end}}
-{{- else if .HasError}}
-			if svcErr := service.{{.Name}}(ctx{{range .Params}}, req.{{title .Name}}{{end}}); svcErr != nil {
-				{{$.Service.Name | lower}}WriteError(p, stack, svcErr)
-				return
-			}
-{{- else}}
-			service.{{.Name}}(ctx{{range .Params}}, req.{{title .Name}}{{end}})
-{{- end}}
 
 			// Write JSON response to plugin memory
 			resp := {{responseType .}}{
@@ -88,6 +115,22 @@ func new{{$.Service.Name}}{{.Name}}HostFunction(service {{$.Service.Interface}})
 {{- end}}
 			}
 			{{$.Service.Name | lower}}WriteResponse(p, stack, resp)
+{{- else if .HasError}}
+			if svcErr := service.{{.Name}}(ctx{{range .Params}}, req.{{title .Name}}{{end}}); svcErr != nil {
+				{{$.Service.Name | lower}}WriteError(p, stack, svcErr)
+				return
+			}
+
+			// Write JSON response to plugin memory
+			resp := {{responseType .}}{}
+			{{$.Service.Name | lower}}WriteResponse(p, stack, resp)
+{{- else}}
+			service.{{.Name}}(ctx{{range .Params}}, req.{{title .Name}}{{end}})
+
+			// Write JSON response to plugin memory
+			resp := {{responseType .}}{}
+			{{$.Service.Name | lower}}WriteResponse(p, stack, resp)
+{{- end}}
 		},
 		[]extism.ValueType{extism.ValueTypePTR},
 		[]extism.ValueType{extism.ValueTypePTR},
@@ -119,3 +162,16 @@ func {{.Service.Name | lower}}WriteError(p *extism.CurrentPlugin, stack []uint64
 	respPtr, _ := p.WriteBytes(respBytes)
 	stack[0] = respPtr
 }
+{{- if .Service.HasRawMethods}}
+
+// {{.Service.Name | lower}}WriteRawError writes a binary-framed error response to plugin memory.
+// Format: [0x01][UTF-8 error message]
+func {{.Service.Name | lower}}WriteRawError(p *extism.CurrentPlugin, stack []uint64, err error) {
+	errMsg := []byte(err.Error())
+	frame := make([]byte, 1+len(errMsg))
+	frame[0] = 0x01 // error
+	copy(frame[1:], errMsg)
+	respPtr, _ := p.WriteBytes(frame)
+	stack[0] = respPtr
+}
+{{- end}}

plugins/cmd/ndpgen/internal/types.go

@@ -173,6 +173,16 @@ func (s Service) HasErrors() bool {
 	return false
 }
 
+// HasRawMethods returns true if any method in the service uses raw binary framing.
+func (s Service) HasRawMethods() bool {
+	for _, m := range s.Methods {
+		if m.Raw {
+			return true
+		}
+	}
+	return false
+}
+
 // Method represents a host function method within a service.
 type Method struct {
 	Name       string  // Go method name (e.g., "Call")
@@ -181,6 +191,7 @@ type Method struct {
 	Returns    []Param // Return values (excluding error)
 	HasError   bool    // Whether the method returns an error
 	Doc        string  // Documentation comment for the method
+	Raw        bool    // If true, response uses binary framing instead of JSON
 }
 
 // FunctionName returns the Extism host function export name.

plugins/cmd/ndpgen/testdata/raw_client_expected.go.txt

@@ -0,0 +1,66 @@
+// Code generated by ndpgen. DO NOT EDIT.
+//
+// This file contains client wrappers for the Stream host service.
+// It is intended for use in Navidrome plugins built with TinyGo.
+//
+//go:build wasip1
+
+package ndpdk
+
+import (
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+
+	"github.com/navidrome/navidrome/plugins/pdk/go/pdk"
+)
+
+// stream_getstream is the host function provided by Navidrome.
+//
+//go:wasmimport extism:host/user stream_getstream
+func stream_getstream(uint64) uint64
+
+type streamGetStreamRequest struct {
+	Uri string `json:"uri"`
+}
+
+// StreamGetStream calls the stream_getstream host function.
+// GetStream returns raw binary stream data with content type.
+func StreamGetStream(uri string) (string, []byte, error) {
+	// Marshal request to JSON
+	req := streamGetStreamRequest{
+		Uri: uri,
+	}
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return "", nil, err
+	}
+	reqMem := pdk.AllocateBytes(reqBytes)
+	defer reqMem.Free()
+
+	// Call the host function
+	responsePtr := stream_getstream(reqMem.Offset())
+
+	// Read the response from memory
+	responseMem := pdk.FindMemory(responsePtr)
+	responseBytes := responseMem.ReadBytes()
+
+	// Parse binary-framed response
+	if len(responseBytes) == 0 {
+		return "", nil, errors.New("empty response from host")
+	}
+	if responseBytes[0] == 0x01 { // error
+		return "", nil, errors.New(string(responseBytes[1:]))
+	}
+	if responseBytes[0] != 0x00 {
+		return "", nil, errors.New("unknown response status")
+	}
+	if len(responseBytes) < 5 {
+		return "", nil, errors.New("malformed raw response: incomplete header")
+	}
+	ctLen := binary.BigEndian.Uint32(responseBytes[1:5])
+	if uint32(len(responseBytes)) < 5+ctLen {
+		return "", nil, errors.New("malformed raw response: content-type overflow")
+	}
+	return string(responseBytes[5 : 5+ctLen]), responseBytes[5+ctLen:], nil
+}

plugins/cmd/ndpgen/testdata/raw_client_expected.py

@@ -0,0 +1,63 @@
+# Code generated by ndpgen. DO NOT EDIT.
+#
+# This file contains client wrappers for the Stream host service.
+# It is intended for use in Navidrome plugins built with extism-py.
+#
+# IMPORTANT: Due to a limitation in extism-py, you cannot import this file directly.
+# The @extism.import_fn decorators are only detected when defined in the plugin's
+# main __init__.py file. Copy the needed functions from this file into your plugin.
+
+from dataclasses import dataclass
+from typing import Any, Tuple
+
+import extism
+import json
+import struct
+
+
+class HostFunctionError(Exception):
+    """Raised when a host function returns an error."""
+    pass
+
+
+@extism.import_fn("extism:host/user", "stream_getstream")
+def _stream_getstream(offset: int) -> int:
+    """Raw host function - do not call directly."""
+    ...
+
+
+def stream_get_stream(uri: str) -> Tuple[str, bytes]:
+    """GetStream returns raw binary stream data with content type.
+
+    Args:
+        uri: str parameter.
+
+    Returns:
+        Tuple of (content_type, data) with the raw binary response.
+
+    Raises:
+        HostFunctionError: If the host function returns an error.
+    """
+    request = {
+        "uri": uri,
+    }
+    request_bytes = json.dumps(request).encode("utf-8")
+    request_mem = extism.memory.alloc(request_bytes)
+    response_offset = _stream_getstream(request_mem.offset)
+    response_mem = extism.memory.find(response_offset)
+    response_bytes = response_mem.bytes()
+
+    if len(response_bytes) == 0:
+        raise HostFunctionError("empty response from host")
+    if response_bytes[0] == 0x01:
+        raise HostFunctionError(response_bytes[1:].decode("utf-8"))
+    if response_bytes[0] != 0x00:
+        raise HostFunctionError("unknown response status")
+    if len(response_bytes) < 5:
+        raise HostFunctionError("malformed raw response: incomplete header")
+    ct_len = struct.unpack(">I", response_bytes[1:5])[0]
+    if len(response_bytes) < 5 + ct_len:
+        raise HostFunctionError("malformed raw response: content-type overflow")
+    content_type = response_bytes[5:5 + ct_len].decode("utf-8")
+    data = response_bytes[5 + ct_len:]
+    return content_type, data

plugins/cmd/ndpgen/testdata/raw_client_expected.rs

@@ -0,0 +1,73 @@
+// Code generated by ndpgen. DO NOT EDIT.
+//
+// This file contains client wrappers for the Stream host service.
+// It is intended for use in Navidrome plugins built with extism-pdk.
+
+use extism_pdk::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct StreamGetStreamRequest {
+    uri: String,
+}
+
+#[host_fn]
+extern "ExtismHost" {
+}
+
+#[link(wasm_import_module = "extism:host/user")]
+extern "C" {
+    fn stream_getstream(offset: u64) -> u64;
+}
+
+/// GetStream returns raw binary stream data with content type.
+///
+/// # Arguments
+/// * `uri` - String parameter.
+///
+/// # Returns
+/// A tuple of (content_type, data) with the raw binary response.
+///
+/// # Errors
+/// Returns an error if the host function call fails.
+pub fn get_stream(uri: &str) -> Result<(String, Vec<u8>), Error> {
+    let req = StreamGetStreamRequest {
+        uri: uri.to_owned(),
+    };
+    let input_bytes = serde_json::to_vec(&req).map_err(|e| Error::msg(e.to_string()))?;
+    let input_mem = Memory::from_bytes(&input_bytes).map_err(|e| Error::msg(e.to_string()))?;
+
+    let response_offset = unsafe { stream_getstream(input_mem.offset()) };
+
+    let response_mem = Memory::find(response_offset)
+        .ok_or_else(|| Error::msg("empty response from host"))?;
+    let response_bytes = response_mem.to_vec();
+
+    if response_bytes.is_empty() {
+        return Err(Error::msg("empty response from host"));
+    }
+    if response_bytes[0] == 0x01 {
+        let msg = String::from_utf8_lossy(&response_bytes[1..]).to_string();
+        return Err(Error::msg(msg));
+    }
+    if response_bytes[0] != 0x00 {
+        return Err(Error::msg("unknown response status"));
+    }
+    if response_bytes.len() < 5 {
+        return Err(Error::msg("malformed raw response: incomplete header"));
+    }
+    let ct_len = u32::from_be_bytes([
+        response_bytes[1],
+        response_bytes[2],
+        response_bytes[3],
+        response_bytes[4],
+    ]) as usize;
+    if ct_len > response_bytes.len() - 5 {
+        return Err(Error::msg("malformed raw response: content-type overflow"));
+    }
+    let ct_end = 5 + ct_len;
+    let content_type = String::from_utf8_lossy(&response_bytes[5..ct_end]).to_string();
+    let data = response_bytes[ct_end..].to_vec();
+    Ok((content_type, data))
+}

plugins/cmd/ndpgen/testdata/raw_service.go.txt

@@ -0,0 +1,10 @@
+package testpkg
+
+import "context"
+
+//nd:hostservice name=Stream permission=stream
+type StreamService interface {
+	// GetStream returns raw binary stream data with content type.
+	//nd:hostfunc raw=true
+	GetStream(ctx context.Context, uri string) (contentType string, data []byte, err error)
+}

plugins/examples/README.md

@@ -9,7 +9,6 @@ This folder contains example plugins demonstrating various capabilities and lang
 | [minimal](minimal/)                                   | Go       | MetadataAgent                                   | Basic plugin structure         |
 | [wikimedia](wikimedia/)                               | Go       | MetadataAgent                                   | Wikidata/Wikipedia metadata    |
 | [crypto-ticker](crypto-ticker/)                       | Go       | Scheduler, WebSocket, Cache                     | Real-time crypto prices (demo) |
-| [discord-rich-presence](discord-rich-presence/)       | Go       | Scrobbler, Scheduler, WebSocket, Cache, Artwork | Discord integration            |
 | [coverartarchive-py](coverartarchive-py/)             | Python   | MetadataAgent                                   | Cover Art Archive              |
 | [nowplaying-py](nowplaying-py/)                       | Python   | Scheduler, SubsonicAPI                          | Now playing logger             |
 | [webhook-rs](webhook-rs/)                             | Rust     | Scrobbler                                       | HTTP webhook on scrobble       |
@@ -37,7 +36,7 @@ This creates `.ndp` package files for each plugin.
 ```bash
 make minimal.ndp
 make wikimedia.ndp
-make discord-rich-presence.ndp
+make discord-rich-presence-rs.ndp
 ```
 
 ### Clean

plugins/examples/discord-rich-presence-rs/README.md

@@ -29,7 +29,7 @@ This plugin implements multiple capabilities to demonstrate the nd-pdk library:
 
 ## Configuration
 
-Configure in the Navidrome UI (Settings → Plugins → discord-rich-presence):
+Configure in the Navidrome UI (Settings → Plugins → discord-rich-presence-rs):
 
 | Key           | Description                          | Example                   |
 |---------------|--------------------------------------|---------------------------|

plugins/examples/discord-rich-presence/README.md

@@ -1,135 +0,0 @@
-# Discord Rich Presence Plugin
-
-This example plugin integrates Navidrome with Discord Rich Presence. It shows how a plugin can keep a real-time connection to an external service while remaining completely stateless. This plugin is based on the [Navicord](https://github.com/logixism/navicord) project, which provides similar functionality.
-
-**⚠️ WARNING: This plugin is for demonstration purposes only. It relies on the user's Discord token being stored in the Navidrome configuration file, which is not secure and may be against Discord's terms of service. Use it at your own risk.**
-
-## Overview
-
-The plugin exposes three capabilities:
-
-- **Scrobbler** – receives `NowPlaying` notifications from Navidrome
-- **WebSocketCallback** – handles Discord gateway messages
-- **SchedulerCallback** – used to clear presence and send periodic heartbeats
-
-It relies on several host services declared in the manifest:
-
-- `http` – queries Discord API endpoints
-- `websocket` – maintains gateway connections
-- `scheduler` – schedules heartbeats and presence cleanup
-- `cache` – stores sequence numbers for heartbeats
-- `artwork` – resolves track artwork URLs
-
-## Architecture
-
-The plugin registers capabilities using the PDK Register pattern:
-
-```go
-import (
-    "github.com/navidrome/navidrome/plugins/pdk/go/scrobbler"
-    "github.com/navidrome/navidrome/plugins/pdk/go/scheduler"
-    "github.com/navidrome/navidrome/plugins/pdk/go/websocket"
-)
-
-type discordPlugin struct{}
-
-func init() {
-    scrobbler.Register(&discordPlugin{})
-    scheduler.Register(&discordPlugin{})
-    websocket.Register(&discordPlugin{})
-}
-```
-
-The PDK generates the appropriate export wrappers automatically.
-
-When `NowPlaying` is invoked the plugin:
-
-1. Loads `clientid` and user tokens from the configuration (because plugins are stateless).
-2. Connects to Discord using `WebSocketService` if no connection exists.
-3. Sends the activity payload with track details and artwork.
-4. Schedules a one-time callback to clear the presence after the track finishes.
-
-Heartbeat messages are sent by a recurring scheduler job. Sequence numbers received from Discord are stored in `CacheService` to remain available across plugin instances.
-
-The scheduler callback uses the `payload` field to route to the appropriate handler:
-- `"heartbeat"` – sends a heartbeat to Discord (recurring)
-- `"clear-activity"` – clears the presence and disconnects (one-time)
-
-## Stateless Operation
-
-Navidrome plugins are completely stateless – each method call instantiates a new plugin instance and discards it afterwards.
-
-To work within this model the plugin stores no in-memory state. Connections are keyed by username inside the host services and any transient data (like Discord sequence numbers) is kept in the cache. Configuration is reloaded on every method call.
-
-## Configuration
-
-Configure in the Navidrome UI (Settings → Plugins → discord-rich-presence):
-
-| Key           | Description                                | Example                        |
-|---------------|-------------------------------------------|--------------------------------|
-| `clientid`    | Your Discord application ID               | `123456789012345678`           |
-| `user.<name>` | Discord token for the specified user      | `user.alice` = `token123`      |
-
-Each user is configured as a separate key with the `user.` prefix.
-
-## Building
-
-From the `plugins/examples/` directory:
-
-```sh
-make discord-rich-presence.ndp
-```
-
-Or manually:
-
-```sh
-cd discord-rich-presence
-tinygo build -target wasip1 -buildmode=c-shared -o plugin.wasm .
-zip -j discord-rich-presence.ndp manifest.json plugin.wasm
-```
-
-## Installation
-
-Place the resulting `discord-rich-presence.ndp` in your Navidrome plugins folder and enable plugins in your configuration:
-
-```toml
-[Plugins]
-Enabled = true
-Folder = "/path/to/plugins"
-```
-
-## Files
-
-| File      | Description                                                      |
-|-----------|------------------------------------------------------------------|
-| `main.go` | Plugin entry point, capability registration, and implementations |
-| `rpc.go`  | Discord gateway communication and RPC logic                      |
-| `go.mod`  | Go module file                                                   |
-
-## PDK
-
-This plugin imports the Navidrome PDK subpackages directly:
-
-```go
-import (
-    "github.com/navidrome/navidrome/plugins/pdk/go/host"
-    "github.com/navidrome/navidrome/plugins/pdk/go/scheduler"
-    "github.com/navidrome/navidrome/plugins/pdk/go/scrobbler"
-    "github.com/navidrome/navidrome/plugins/pdk/go/websocket"
-)
-```
-
-The `go.mod` file uses `replace` directives to point to the local packages for development.
-
-## Host Services Used
-
-| Service   | Purpose                                                          |
-|-----------|------------------------------------------------------------------|
-| Cache     | Store Discord sequence numbers and processed image URLs          |
-| Scheduler | Schedule heartbeats (recurring) and activity clearing (one-time) |
-| WebSocket | Maintain persistent connection to Discord gateway                |
-| Artwork   | Get track artwork URLs for rich presence display                 |
-
-## Implementation Details
-
-See `main.go` and `rpc.go` for the complete implementation.

plugins/examples/discord-rich-presence/go.mod

@@ -1,32 +0,0 @@
-module discord-rich-presence
-
-go 1.25
-
-require (
-	github.com/navidrome/navidrome/plugins/pdk/go v0.0.0
-	github.com/onsi/ginkgo/v2 v2.27.3
-	github.com/onsi/gomega v1.38.3
-	github.com/stretchr/testify v1.11.1
-)
-
-require (
-	github.com/Masterminds/semver/v3 v3.4.0 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/extism/go-pdk v1.1.3 // indirect
-	github.com/go-logr/logr v1.4.3 // indirect
-	github.com/go-task/slim-sprig/v3 v3.0.0 // indirect
-	github.com/google/go-cmp v0.7.0 // indirect
-	github.com/google/pprof v0.0.0-20250403155104-27863c87afa6 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/stretchr/objx v0.5.2 // indirect
-	go.yaml.in/yaml/v3 v3.0.4 // indirect
-	golang.org/x/mod v0.27.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
-	golang.org/x/sync v0.16.0 // indirect
-	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
-	golang.org/x/tools v0.36.0 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-)
-
-replace github.com/navidrome/navidrome/plugins/pdk/go => ../../pdk/go

plugins/examples/discord-rich-presence/go.sum

@@ -1,73 +0,0 @@
-github.com/Masterminds/semver/v3 v3.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0=
-github.com/Masterminds/semver/v3 v3.4.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/extism/go-pdk v1.1.3 h1:hfViMPWrqjN6u67cIYRALZTZLk/enSPpNKa+rZ9X2SQ=
-github.com/extism/go-pdk v1.1.3/go.mod h1:Gz+LIU/YCKnKXhgge8yo5Yu1F/lbv7KtKFkiCSzW/P4=
-github.com/gkampitakis/ciinfo v0.3.2 h1:JcuOPk8ZU7nZQjdUhctuhQofk7BGHuIy0c9Ez8BNhXs=
-github.com/gkampitakis/ciinfo v0.3.2/go.mod h1:1NIwaOcFChN4fa/B0hEBdAb6npDlFL8Bwx4dfRLRqAo=
-github.com/gkampitakis/go-diff v1.3.2 h1:Qyn0J9XJSDTgnsgHRdz9Zp24RaJeKMUHg2+PDZZdC4M=
-github.com/gkampitakis/go-diff v1.3.2/go.mod h1:LLgOrpqleQe26cte8s36HTWcTmMEur6OPYerdAAS9tk=
-github.com/gkampitakis/go-snaps v0.5.15 h1:amyJrvM1D33cPHwVrjo9jQxX8g/7E2wYdZ+01KS3zGE=
-github.com/gkampitakis/go-snaps v0.5.15/go.mod h1:HNpx/9GoKisdhw9AFOBT1N7DBs9DiHo/hGheFGBZ+mc=
-github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
-github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
-github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI=
-github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8=
-github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
-github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
-github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
-github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/google/pprof v0.0.0-20250403155104-27863c87afa6 h1:BHT72Gu3keYf3ZEu2J0b1vyeLSOYI8bm5wbJM/8yDe8=
-github.com/google/pprof v0.0.0-20250403155104-27863c87afa6/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
-github.com/joshdk/go-junit v1.0.0 h1:S86cUKIdwBHWwA6xCmFlf3RTLfVXYQfvanM5Uh+K6GE=
-github.com/joshdk/go-junit v1.0.0/go.mod h1:TiiV0PqkaNfFXjEiyjWM3XXrhVyCa1K4Zfga6W52ung=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/maruel/natural v1.1.1 h1:Hja7XhhmvEFhcByqDoHz9QZbkWey+COd9xWfCfn1ioo=
-github.com/maruel/natural v1.1.1/go.mod h1:v+Rfd79xlw1AgVBjbO0BEQmptqb5HvL/k9GRHB7ZKEg=
-github.com/mfridman/tparse v0.18.0 h1:wh6dzOKaIwkUGyKgOntDW4liXSo37qg5AXbIhkMV3vE=
-github.com/mfridman/tparse v0.18.0/go.mod h1:gEvqZTuCgEhPbYk/2lS3Kcxg1GmTxxU7kTC8DvP0i/A=
-github.com/onsi/ginkgo/v2 v2.27.3 h1:ICsZJ8JoYafeXFFlFAG75a7CxMsJHwgKwtO+82SE9L8=
-github.com/onsi/ginkgo/v2 v2.27.3/go.mod h1:ArE1D/XhNXBXCBkKOLkbsb2c81dQHCRcF5zwn/ykDRo=
-github.com/onsi/gomega v1.38.3 h1:eTX+W6dobAYfFeGC2PV6RwXRu/MyT+cQguijutvkpSM=
-github.com/onsi/gomega v1.38.3/go.mod h1:ZCU1pkQcXDO5Sl9/VVEGlDyp+zm0m1cmeG5TOzLgdh4=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
-github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
-github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
-github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
-github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
-github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
-github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
-github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
-github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
-github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
-github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
-github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
-github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY=
-github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28=
-go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
-go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
-golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ=
-golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
-golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
-golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
-golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
-golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
-golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg=
-golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s=
-google.golang.org/protobuf v1.36.7 h1:IgrO7UwFQGJdRNXH/sQux4R1Dj1WAKcLElzeeRaXV2A=
-google.golang.org/protobuf v1.36.7/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

plugins/examples/discord-rich-presence/main.go

@@ -1,219 +0,0 @@
-// Discord Rich Presence Plugin for Navidrome
-//
-// This plugin integrates Navidrome with Discord Rich Presence. It shows how a plugin can
-// keep a real-time connection to an external service while remaining completely stateless.
-//
-// Capabilities: Scrobbler, SchedulerCallback, WebSocketCallback
-//
-// NOTE: This plugin is for demonstration purposes only. It relies on the user's Discord
-// token being stored in the Navidrome configuration file, which is not secure and may be
-// against Discord's terms of service. Use it at your own risk.
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/navidrome/navidrome/plugins/pdk/go/host"
-	"github.com/navidrome/navidrome/plugins/pdk/go/pdk"
-	"github.com/navidrome/navidrome/plugins/pdk/go/scheduler"
-	"github.com/navidrome/navidrome/plugins/pdk/go/scrobbler"
-	"github.com/navidrome/navidrome/plugins/pdk/go/websocket"
-)
-
-// Configuration keys
-const (
-	clientIDKey = "clientid"
-	usersKey    = "users"
-)
-
-// userToken represents a user-token mapping from the config
-type userToken struct {
-	Username string `json:"username"`
-	Token    string `json:"token"`
-}
-
-// discordPlugin implements the scrobbler and scheduler interfaces.
-type discordPlugin struct{}
-
-// rpc handles Discord gateway communication (via websockets).
-var rpc = &discordRPC{}
-
-// init registers the plugin capabilities
-func init() {
-	scrobbler.Register(&discordPlugin{})
-	scheduler.Register(&discordPlugin{})
-	websocket.Register(rpc)
-}
-
-// getConfig loads the plugin configuration.
-func getConfig() (clientID string, users map[string]string, err error) {
-	clientID, ok := pdk.GetConfig(clientIDKey)
-	if !ok || clientID == "" {
-		pdk.Log(pdk.LogWarn, "missing ClientID in configuration")
-		return "", nil, nil
-	}
-
-	// Get the users array from config
-	usersJSON, ok := pdk.GetConfig(usersKey)
-	if !ok || usersJSON == "" {
-		pdk.Log(pdk.LogWarn, "no users configured")
-		return clientID, nil, nil
-	}
-
-	// Parse the JSON array
-	var userTokens []userToken
-	if err := json.Unmarshal([]byte(usersJSON), &userTokens); err != nil {
-		pdk.Log(pdk.LogError, fmt.Sprintf("failed to parse users config: %v", err))
-		return clientID, nil, nil
-	}
-
-	if len(userTokens) == 0 {
-		pdk.Log(pdk.LogWarn, "no users configured")
-		return clientID, nil, nil
-	}
-
-	// Build the users map
-	users = make(map[string]string)
-	for _, ut := range userTokens {
-		if ut.Username != "" && ut.Token != "" {
-			users[ut.Username] = ut.Token
-		}
-	}
-
-	if len(users) == 0 {
-		pdk.Log(pdk.LogWarn, "no valid users configured")
-		return clientID, nil, nil
-	}
-
-	return clientID, users, nil
-}
-
-// getImageURL retrieves the track artwork URL.
-func getImageURL(trackID string) string {
-	artworkURL, err := host.ArtworkGetTrackUrl(trackID, 300)
-	if err != nil {
-		pdk.Log(pdk.LogWarn, fmt.Sprintf("Failed to get artwork URL: %v", err))
-		return ""
-	}
-
-	// Don't use localhost URLs
-	if strings.HasPrefix(artworkURL, "http://localhost") {
-		return ""
-	}
-	return artworkURL
-}
-
-// ============================================================================
-// Scrobbler Implementation
-// ============================================================================
-
-// IsAuthorized checks if a user is authorized for Discord Rich Presence.
-func (p *discordPlugin) IsAuthorized(input scrobbler.IsAuthorizedRequest) (bool, error) {
-	_, users, err := getConfig()
-	if err != nil {
-		return false, fmt.Errorf("failed to check user authorization: %w", err)
-	}
-
-	_, authorized := users[input.Username]
-	pdk.Log(pdk.LogInfo, fmt.Sprintf("IsAuthorized for user %s: %v", input.Username, authorized))
-	return authorized, nil
-}
-
-// NowPlaying sends a now playing notification to Discord.
-func (p *discordPlugin) NowPlaying(input scrobbler.NowPlayingRequest) error {
-	pdk.Log(pdk.LogInfo, fmt.Sprintf("Setting presence for user %s, track: %s", input.Username, input.Track.Title))
-
-	// Load configuration
-	clientID, users, err := getConfig()
-	if err != nil {
-		return fmt.Errorf("%w: failed to get config: %v", scrobbler.ScrobblerErrorRetryLater, err)
-	}
-
-	// Check authorization
-	userToken, authorized := users[input.Username]
-	if !authorized {
-		return fmt.Errorf("%w: user '%s' not authorized", scrobbler.ScrobblerErrorNotAuthorized, input.Username)
-	}
-
-	// Connect to Discord
-	if err := rpc.connect(input.Username, userToken); err != nil {
-		return fmt.Errorf("%w: failed to connect to Discord: %v", scrobbler.ScrobblerErrorRetryLater, err)
-	}
-
-	// Cancel any existing completion schedule
-	_ = host.SchedulerCancelSchedule(fmt.Sprintf("%s-clear", input.Username))
-
-	// Calculate timestamps
-	now := time.Now().Unix()
-	startTime := (now - int64(input.Position)) * 1000
-	endTime := startTime + int64(input.Track.Duration)*1000
-
-	// Send activity update
-	if err := rpc.sendActivity(clientID, input.Username, userToken, activity{
-		Application: clientID,
-		Name:        "Navidrome",
-		Type:        2, // Listening
-		Details:     input.Track.Title,
-		State:       input.Track.Artist,
-		Timestamps: activityTimestamps{
-			Start: startTime,
-			End:   endTime,
-		},
-		Assets: activityAssets{
-			LargeImage: getImageURL(input.Track.ID),
-			LargeText:  input.Track.Album,
-		},
-	}); err != nil {
-		return fmt.Errorf("%w: failed to send activity: %v", scrobbler.ScrobblerErrorRetryLater, err)
-	}
-
-	// Schedule a timer to clear the activity after the track completes
-	remainingSeconds := int32(input.Track.Duration) - input.Position + 5
-	_, err = host.SchedulerScheduleOneTime(remainingSeconds, payloadClearActivity, fmt.Sprintf("%s-clear", input.Username))
-	if err != nil {
-		pdk.Log(pdk.LogWarn, fmt.Sprintf("Failed to schedule completion timer: %v", err))
-	}
-
-	return nil
-}
-
-// Scrobble handles scrobble requests (no-op for Discord).
-func (p *discordPlugin) Scrobble(_ scrobbler.ScrobbleRequest) error {
-	// Discord Rich Presence doesn't need scrobble events
-	return nil
-}
-
-// ============================================================================
-// Scheduler Callback Implementation
-// ============================================================================
-
-// OnCallback handles scheduler callbacks.
-func (p *discordPlugin) OnCallback(input scheduler.SchedulerCallbackRequest) error {
-	pdk.Log(pdk.LogDebug, fmt.Sprintf("Scheduler callback: id=%s, payload=%s, recurring=%v", input.ScheduleID, input.Payload, input.IsRecurring))
-
-	// Route based on payload
-	switch input.Payload {
-	case payloadHeartbeat:
-		// Heartbeat callback - scheduleId is the username
-		if err := rpc.handleHeartbeatCallback(input.ScheduleID); err != nil {
-			return err
-		}
-
-	case payloadClearActivity:
-		// Clear activity callback - scheduleId is "username-clear"
-		username := strings.TrimSuffix(input.ScheduleID, "-clear")
-		if err := rpc.handleClearActivityCallback(username); err != nil {
-			return err
-		}
-
-	default:
-		pdk.Log(pdk.LogWarn, fmt.Sprintf("Unknown scheduler callback payload: %s", input.Payload))
-	}
-
-	return nil
-}
-
-func main() {}

plugins/examples/discord-rich-presence/main_test.go

@@ -1,227 +0,0 @@
-package main
-
-import (
-	"errors"
-	"strings"
-	"testing"
-
-	"github.com/navidrome/navidrome/plugins/pdk/go/host"
-	"github.com/navidrome/navidrome/plugins/pdk/go/pdk"
-	"github.com/navidrome/navidrome/plugins/pdk/go/scheduler"
-	"github.com/navidrome/navidrome/plugins/pdk/go/scrobbler"
-	"github.com/stretchr/testify/mock"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-func TestDiscordPlugin(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Discord Plugin Main Suite")
-}
-
-var _ = Describe("discordPlugin", func() {
-	var plugin discordPlugin
-
-	BeforeEach(func() {
-		plugin = discordPlugin{}
-		pdk.ResetMock()
-		host.CacheMock.ExpectedCalls = nil
-		host.CacheMock.Calls = nil
-		host.ConfigMock.ExpectedCalls = nil
-		host.ConfigMock.Calls = nil
-		host.WebSocketMock.ExpectedCalls = nil
-		host.WebSocketMock.Calls = nil
-		host.SchedulerMock.ExpectedCalls = nil
-		host.SchedulerMock.Calls = nil
-		host.ArtworkMock.ExpectedCalls = nil
-		host.ArtworkMock.Calls = nil
-	})
-
-	Describe("getConfig", func() {
-		It("returns config values when properly set", func() {
-			pdk.PDKMock.On("GetConfig", clientIDKey).Return("test-client-id", true)
-			host.ConfigMock.On("Keys", userKeyPrefix).Return([]string{"user.user1", "user.user2"})
-			host.ConfigMock.On("Get", "user.user1").Return("token1", true)
-			host.ConfigMock.On("Get", "user.user2").Return("token2", true)
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-
-			clientID, users, err := getConfig()
-			Expect(err).ToNot(HaveOccurred())
-			Expect(clientID).To(Equal("test-client-id"))
-			Expect(users).To(HaveLen(2))
-			Expect(users["user1"]).To(Equal("token1"))
-			Expect(users["user2"]).To(Equal("token2"))
-		})
-
-		It("returns empty client ID when not set", func() {
-			pdk.PDKMock.On("GetConfig", clientIDKey).Return("", false)
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-
-			clientID, users, err := getConfig()
-			Expect(err).ToNot(HaveOccurred())
-			Expect(clientID).To(BeEmpty())
-			Expect(users).To(BeNil())
-		})
-
-		It("returns nil users when users not configured", func() {
-			pdk.PDKMock.On("GetConfig", clientIDKey).Return("test-client-id", true)
-			host.ConfigMock.On("Keys", userKeyPrefix).Return([]string{})
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-
-			clientID, users, err := getConfig()
-			Expect(err).ToNot(HaveOccurred())
-			Expect(clientID).To(Equal("test-client-id"))
-			Expect(users).To(BeNil())
-		})
-	})
-
-	Describe("IsAuthorized", func() {
-		BeforeEach(func() {
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-		})
-
-		It("returns true for authorized user", func() {
-			pdk.PDKMock.On("GetConfig", clientIDKey).Return("test-client-id", true)
-			host.ConfigMock.On("Keys", userKeyPrefix).Return([]string{"user.testuser"})
-			host.ConfigMock.On("Get", "user.testuser").Return("token123", true)
-
-			authorized, err := plugin.IsAuthorized(scrobbler.IsAuthorizedRequest{
-				Username: "testuser",
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(authorized).To(BeTrue())
-		})
-
-		It("returns false for unauthorized user", func() {
-			pdk.PDKMock.On("GetConfig", clientIDKey).Return("test-client-id", true)
-			host.ConfigMock.On("Keys", userKeyPrefix).Return([]string{"user.otheruser"})
-			host.ConfigMock.On("Get", "user.otheruser").Return("token123", true)
-
-			authorized, err := plugin.IsAuthorized(scrobbler.IsAuthorizedRequest{
-				Username: "testuser",
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(authorized).To(BeFalse())
-		})
-	})
-
-	Describe("NowPlaying", func() {
-		BeforeEach(func() {
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-		})
-
-		It("returns not authorized error when user not in config", func() {
-			pdk.PDKMock.On("GetConfig", clientIDKey).Return("test-client-id", true)
-			host.ConfigMock.On("Keys", userKeyPrefix).Return([]string{"user.otheruser"})
-			host.ConfigMock.On("Get", "user.otheruser").Return("token", true)
-
-			err := plugin.NowPlaying(scrobbler.NowPlayingRequest{
-				Username: "testuser",
-				Track:    scrobbler.TrackInfo{Title: "Test Song"},
-			})
-			Expect(err).To(HaveOccurred())
-			Expect(errors.Is(err, scrobbler.ScrobblerErrorNotAuthorized)).To(BeTrue())
-		})
-
-		It("successfully sends now playing update", func() {
-			pdk.PDKMock.On("GetConfig", clientIDKey).Return("test-client-id", true)
-			host.ConfigMock.On("Keys", userKeyPrefix).Return([]string{"user.testuser"})
-			host.ConfigMock.On("Get", "user.testuser").Return("test-token", true)
-
-			// Connect mocks (isConnected check via heartbeat)
-			host.CacheMock.On("GetInt", "discord.seq.testuser").Return(int64(0), false, errors.New("not found"))
-
-			// Mock HTTP GET request for gateway discovery
-			gatewayResp := []byte(`{"url":"wss://gateway.discord.gg"}`)
-			gatewayReq := &pdk.HTTPRequest{}
-			pdk.PDKMock.On("NewHTTPRequest", pdk.MethodGet, "https://discord.com/api/gateway").Return(gatewayReq).Once()
-			pdk.PDKMock.On("Send", gatewayReq).Return(pdk.NewStubHTTPResponse(200, nil, gatewayResp)).Once()
-
-			// Mock WebSocket connection
-			host.WebSocketMock.On("Connect", mock.MatchedBy(func(url string) bool {
-				return strings.Contains(url, "gateway.discord.gg")
-			}), mock.Anything, "testuser").Return("testuser", nil)
-			host.WebSocketMock.On("SendText", "testuser", mock.Anything).Return(nil)
-			host.SchedulerMock.On("ScheduleRecurring", mock.Anything, payloadHeartbeat, "testuser").Return("testuser", nil)
-
-			// Cancel existing clear schedule (may or may not exist)
-			host.SchedulerMock.On("CancelSchedule", "testuser-clear").Return(nil)
-
-			// Image mocks - cache miss, will make HTTP request to Discord
-			host.CacheMock.On("GetString", mock.MatchedBy(func(key string) bool {
-				return strings.HasPrefix(key, "discord.image.")
-			})).Return("", false, nil)
-			host.CacheMock.On("SetString", mock.Anything, mock.Anything, mock.Anything).Return(nil)
-			host.ArtworkMock.On("GetTrackUrl", "track1", int32(300)).Return("https://example.com/art.jpg", nil)
-
-			// Mock HTTP request for Discord external assets API
-			assetsReq := &pdk.HTTPRequest{}
-			pdk.PDKMock.On("NewHTTPRequest", pdk.MethodPost, mock.MatchedBy(func(url string) bool {
-				return strings.Contains(url, "external-assets")
-			})).Return(assetsReq)
-			pdk.PDKMock.On("Send", assetsReq).Return(pdk.NewStubHTTPResponse(200, nil, []byte(`{"key":"test-key"}`)))
-
-			// Schedule clear activity callback
-			host.SchedulerMock.On("ScheduleOneTime", mock.Anything, payloadClearActivity, "testuser-clear").Return("testuser-clear", nil)
-
-			err := plugin.NowPlaying(scrobbler.NowPlayingRequest{
-				Username: "testuser",
-				Position: 10,
-				Track: scrobbler.TrackInfo{
-					ID:       "track1",
-					Title:    "Test Song",
-					Artist:   "Test Artist",
-					Album:    "Test Album",
-					Duration: 180,
-				},
-			})
-			Expect(err).ToNot(HaveOccurred())
-		})
-	})
-
-	Describe("Scrobble", func() {
-		It("does nothing (returns nil)", func() {
-			err := plugin.Scrobble(scrobbler.ScrobbleRequest{})
-			Expect(err).ToNot(HaveOccurred())
-		})
-	})
-
-	Describe("OnCallback", func() {
-		BeforeEach(func() {
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-		})
-
-		It("handles heartbeat callback", func() {
-			host.CacheMock.On("GetInt", "discord.seq.testuser").Return(int64(42), true, nil)
-			host.WebSocketMock.On("SendText", "testuser", mock.Anything).Return(nil)
-
-			err := plugin.OnCallback(scheduler.SchedulerCallbackRequest{
-				ScheduleID:  "testuser",
-				Payload:     payloadHeartbeat,
-				IsRecurring: true,
-			})
-			Expect(err).ToNot(HaveOccurred())
-		})
-
-		It("handles clearActivity callback", func() {
-			host.WebSocketMock.On("SendText", "testuser", mock.Anything).Return(nil)
-			host.SchedulerMock.On("CancelSchedule", "testuser").Return(nil)
-			host.WebSocketMock.On("CloseConnection", "testuser", int32(1000), "Navidrome disconnect").Return(nil)
-
-			err := plugin.OnCallback(scheduler.SchedulerCallbackRequest{
-				ScheduleID: "testuser-clear",
-				Payload:    payloadClearActivity,
-			})
-			Expect(err).ToNot(HaveOccurred())
-		})
-
-		It("logs warning for unknown payload", func() {
-			err := plugin.OnCallback(scheduler.SchedulerCallbackRequest{
-				ScheduleID: "testuser",
-				Payload:    "unknown",
-			})
-			Expect(err).ToNot(HaveOccurred())
-		})
-	})
-})

plugins/examples/discord-rich-presence/manifest.json

@@ -1,102 +0,0 @@
-{
-  "name": "Discord Rich Presence",
-  "author": "Navidrome Team",
-  "version": "1.0.0",
-  "description": "Discord Rich Presence integration for Navidrome",
-  "website": "https://github.com/navidrome/navidrome/tree/master/plugins/examples/discord-rich-presence",
-  "permissions": {
-    "users": {
-      "reason": "To process scrobbles on behalf of users"
-    },
-    "http": {
-      "reason": "To communicate with Discord API for gateway discovery and image uploads",
-      "requiredHosts": [
-        "discord.com"
-      ]
-    },
-    "websocket": {
-      "reason": "To maintain real-time connection with Discord gateway",
-      "requiredHosts": [
-        "gateway.discord.gg"
-      ]
-    },
-    "cache": {
-      "reason": "To store connection state and sequence numbers"
-    },
-    "scheduler": {
-      "reason": "To schedule heartbeat messages and activity clearing"
-    },
-    "artwork": {
-      "reason": "To get track artwork URLs for rich presence display"
-    }
-  },
-  "config": {
-    "schema": {
-      "type": "object",
-      "properties": {
-        "clientid": {
-          "type": "string",
-          "title": "Discord Application Client ID",
-          "description": "The Client ID from your Discord Developer Application. Create one at https://discord.com/developers/applications",
-          "minLength": 17,
-          "maxLength": 20,
-          "pattern": "^[0-9]+$"
-        },
-        "users": {
-          "type": "array",
-          "title": "User Tokens",
-          "description": "Discord tokens for each Navidrome user. WARNING: Store tokens securely!",
-          "minItems": 1,
-          "items": {
-            "type": "object",
-            "properties": {
-              "username": {
-                "type": "string",
-                "title": "Navidrome Username",
-                "description": "The Navidrome username to associate with this Discord token",
-                "minLength": 1
-              },
-              "token": {
-                "type": "string",
-                "title": "Discord Token",
-                "description": "The user's Discord token (keep this secret!)",
-                "minLength": 1
-              }
-            },
-            "required": ["username", "token"]
-          }
-        }
-      },
-      "required": ["clientid", "users"]
-    },
-    "uiSchema": {
-      "type": "VerticalLayout",
-      "elements": [
-        {
-          "type": "Control",
-          "scope": "#/properties/clientid"
-        },
-        {
-          "type": "Control",
-          "scope": "#/properties/users",
-          "options": {
-            "elementLabelProp": "username",
-            "detail": {
-              "type": "HorizontalLayout",
-              "elements": [
-                {
-                  "type": "Control",
-                  "scope": "#/properties/username"
-                },
-                {
-                  "type": "Control",
-                  "scope": "#/properties/token"
-                }
-              ]
-            }
-          }
-        }
-      ]
-    }
-  }
-}

plugins/examples/discord-rich-presence/rpc.go

@@ -1,400 +0,0 @@
-// Discord Rich Presence Plugin - RPC Communication
-//
-// This file handles all Discord gateway communication including WebSocket connections,
-// presence updates, and heartbeat management. The discordRPC struct implements WebSocket
-// callback interfaces and encapsulates all Discord communication logic.
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-
-	"github.com/navidrome/navidrome/plugins/pdk/go/host"
-	"github.com/navidrome/navidrome/plugins/pdk/go/pdk"
-	"github.com/navidrome/navidrome/plugins/pdk/go/websocket"
-)
-
-// Discord WebSocket Gateway constants
-const (
-	heartbeatOpCode = 1 // Heartbeat operation code
-	gateOpCode      = 2 // Identify operation code
-	presenceOpCode  = 3 // Presence update operation code
-)
-
-const (
-	heartbeatInterval = 41 // Heartbeat interval in seconds
-	defaultImage      = "https://i.imgur.com/hb3XPzA.png"
-)
-
-// Scheduler callback payloads for routing
-const (
-	payloadHeartbeat     = "heartbeat"
-	payloadClearActivity = "clear-activity"
-)
-
-// discordRPC handles Discord gateway communication and implements WebSocket callbacks.
-type discordRPC struct{}
-
-// ============================================================================
-// WebSocket Callback Implementation
-// ============================================================================
-
-// OnTextMessage handles incoming WebSocket text messages.
-func (r *discordRPC) OnTextMessage(input websocket.OnTextMessageRequest) error {
-	return r.handleWebSocketMessage(input.ConnectionID, input.Message)
-}
-
-// OnBinaryMessage handles incoming WebSocket binary messages.
-func (r *discordRPC) OnBinaryMessage(input websocket.OnBinaryMessageRequest) error {
-	pdk.Log(pdk.LogDebug, fmt.Sprintf("Received unexpected binary message for connection '%s'", input.ConnectionID))
-	return nil
-}
-
-// OnError handles WebSocket errors.
-func (r *discordRPC) OnError(input websocket.OnErrorRequest) error {
-	pdk.Log(pdk.LogWarn, fmt.Sprintf("WebSocket error for connection '%s': %s", input.ConnectionID, input.Error))
-	return nil
-}
-
-// OnClose handles WebSocket connection closure.
-func (r *discordRPC) OnClose(input websocket.OnCloseRequest) error {
-	pdk.Log(pdk.LogInfo, fmt.Sprintf("WebSocket connection '%s' closed with code %d: %s", input.ConnectionID, input.Code, input.Reason))
-	return nil
-}
-
-// activity represents a Discord activity.
-type activity struct {
-	Name        string             `json:"name"`
-	Type        int                `json:"type"`
-	Details     string             `json:"details"`
-	State       string             `json:"state"`
-	Application string             `json:"application_id"`
-	Timestamps  activityTimestamps `json:"timestamps"`
-	Assets      activityAssets     `json:"assets"`
-}
-
-type activityTimestamps struct {
-	Start int64 `json:"start"`
-	End   int64 `json:"end"`
-}
-
-type activityAssets struct {
-	LargeImage string `json:"large_image"`
-	LargeText  string `json:"large_text"`
-}
-
-// presencePayload represents a Discord presence update.
-type presencePayload struct {
-	Activities []activity `json:"activities"`
-	Since      int64      `json:"since"`
-	Status     string     `json:"status"`
-	Afk        bool       `json:"afk"`
-}
-
-// identifyPayload represents a Discord identify payload.
-type identifyPayload struct {
-	Token      string             `json:"token"`
-	Intents    int                `json:"intents"`
-	Properties identifyProperties `json:"properties"`
-}
-
-type identifyProperties struct {
-	OS      string `json:"os"`
-	Browser string `json:"browser"`
-	Device  string `json:"device"`
-}
-
-// ============================================================================
-// Image Processing
-// ============================================================================
-
-// processImage processes an image URL for Discord, with fallback to default image.
-func (r *discordRPC) processImage(imageURL, clientID, token string, isDefaultImage bool) (string, error) {
-	if imageURL == "" {
-		if isDefaultImage {
-			return "", fmt.Errorf("default image URL is empty")
-		}
-		return r.processImage(defaultImage, clientID, token, true)
-	}
-
-	if strings.HasPrefix(imageURL, "mp:") {
-		return imageURL, nil
-	}
-
-	// Check cache first
-	cacheKey := fmt.Sprintf("discord.image.%x", imageURL)
-	cachedValue, exists, err := host.CacheGetString(cacheKey)
-	if err == nil && exists {
-		pdk.Log(pdk.LogDebug, fmt.Sprintf("Cache hit for image URL: %s", imageURL))
-		return cachedValue, nil
-	}
-
-	// Process via Discord API
-	body := fmt.Sprintf(`{"urls":[%q]}`, imageURL)
-	req := pdk.NewHTTPRequest(pdk.MethodPost, fmt.Sprintf("https://discord.com/api/v9/applications/%s/external-assets", clientID))
-	req.SetHeader("Authorization", token)
-	req.SetHeader("Content-Type", "application/json")
-	req.SetBody([]byte(body))
-
-	resp := req.Send()
-	if resp.Status() >= 400 {
-		if isDefaultImage {
-			return "", fmt.Errorf("failed to process default image: HTTP %d", resp.Status())
-		}
-		return r.processImage(defaultImage, clientID, token, true)
-	}
-
-	var data []map[string]string
-	if err := json.Unmarshal(resp.Body(), &data); err != nil {
-		if isDefaultImage {
-			return "", fmt.Errorf("failed to unmarshal default image response: %w", err)
-		}
-		return r.processImage(defaultImage, clientID, token, true)
-	}
-
-	if len(data) == 0 {
-		if isDefaultImage {
-			return "", fmt.Errorf("no data returned for default image")
-		}
-		return r.processImage(defaultImage, clientID, token, true)
-	}
-
-	image := data[0]["external_asset_path"]
-	if image == "" {
-		if isDefaultImage {
-			return "", fmt.Errorf("empty external_asset_path for default image")
-		}
-		return r.processImage(defaultImage, clientID, token, true)
-	}
-
-	processedImage := fmt.Sprintf("mp:%s", image)
-
-	// Cache the processed image URL
-	var ttl int64 = 4 * 60 * 60 // 4 hours for regular images
-	if isDefaultImage {
-		ttl = 48 * 60 * 60 // 48 hours for default image
-	}
-
-	_ = host.CacheSetString(cacheKey, processedImage, ttl)
-	pdk.Log(pdk.LogDebug, fmt.Sprintf("Cached processed image URL for %s (TTL: %ds)", imageURL, ttl))
-
-	return processedImage, nil
-}
-
-// ============================================================================
-// Activity Management
-// ============================================================================
-
-// sendActivity sends an activity update to Discord.
-func (r *discordRPC) sendActivity(clientID, username, token string, data activity) error {
-	pdk.Log(pdk.LogInfo, fmt.Sprintf("Sending activity for user %s: %s - %s", username, data.Details, data.State))
-
-	processedImage, err := r.processImage(data.Assets.LargeImage, clientID, token, false)
-	if err != nil {
-		pdk.Log(pdk.LogWarn, fmt.Sprintf("Failed to process image for user %s, continuing without image: %v", username, err))
-		data.Assets.LargeImage = ""
-	} else {
-		data.Assets.LargeImage = processedImage
-	}
-
-	presence := presencePayload{
-		Activities: []activity{data},
-		Status:     "dnd",
-		Afk:        false,
-	}
-	return r.sendMessage(username, presenceOpCode, presence)
-}
-
-// clearActivity clears the Discord activity for a user.
-func (r *discordRPC) clearActivity(username string) error {
-	pdk.Log(pdk.LogInfo, fmt.Sprintf("Clearing activity for user %s", username))
-	return r.sendMessage(username, presenceOpCode, presencePayload{})
-}
-
-// ============================================================================
-// Low-level Communication
-// ============================================================================
-
-// sendMessage sends a message over the WebSocket connection.
-func (r *discordRPC) sendMessage(username string, opCode int, payload any) error {
-	message := map[string]any{
-		"op": opCode,
-		"d":  payload,
-	}
-	b, err := json.Marshal(message)
-	if err != nil {
-		return fmt.Errorf("failed to marshal message: %w", err)
-	}
-
-	err = host.WebSocketSendText(username, string(b))
-	if err != nil {
-		return fmt.Errorf("failed to send message: %w", err)
-	}
-	return nil
-}
-
-// getDiscordGateway retrieves the Discord gateway URL.
-func (r *discordRPC) getDiscordGateway() (string, error) {
-	req := pdk.NewHTTPRequest(pdk.MethodGet, "https://discord.com/api/gateway")
-	resp := req.Send()
-	if resp.Status() != 200 {
-		return "", fmt.Errorf("failed to get Discord gateway: HTTP %d", resp.Status())
-	}
-
-	var result map[string]string
-	if err := json.Unmarshal(resp.Body(), &result); err != nil {
-		return "", fmt.Errorf("failed to parse Discord gateway response: %w", err)
-	}
-	return result["url"], nil
-}
-
-// sendHeartbeat sends a heartbeat to Discord.
-func (r *discordRPC) sendHeartbeat(username string) error {
-	seqNum, _, err := host.CacheGetInt(fmt.Sprintf("discord.seq.%s", username))
-	if err != nil {
-		return fmt.Errorf("failed to get sequence number: %w", err)
-	}
-
-	pdk.Log(pdk.LogDebug, fmt.Sprintf("Sending heartbeat for user %s: %d", username, seqNum))
-	return r.sendMessage(username, heartbeatOpCode, seqNum)
-}
-
-// cleanupFailedConnection cleans up a failed Discord connection.
-func (r *discordRPC) cleanupFailedConnection(username string) {
-	pdk.Log(pdk.LogInfo, fmt.Sprintf("Cleaning up failed connection for user %s", username))
-
-	// Cancel the heartbeat schedule
-	if err := host.SchedulerCancelSchedule(username); err != nil {
-		pdk.Log(pdk.LogWarn, fmt.Sprintf("Failed to cancel heartbeat schedule for user %s: %v", username, err))
-	}
-
-	// Close the WebSocket connection
-	if err := host.WebSocketCloseConnection(username, 1000, "Connection lost"); err != nil {
-		pdk.Log(pdk.LogWarn, fmt.Sprintf("Failed to close WebSocket connection for user %s: %v", username, err))
-	}
-
-	// Clean up cache entries
-	_ = host.CacheRemove(fmt.Sprintf("discord.seq.%s", username))
-
-	pdk.Log(pdk.LogInfo, fmt.Sprintf("Cleaned up connection for user %s", username))
-}
-
-// isConnected checks if a user is connected to Discord by testing the heartbeat.
-func (r *discordRPC) isConnected(username string) bool {
-	err := r.sendHeartbeat(username)
-	if err != nil {
-		pdk.Log(pdk.LogDebug, fmt.Sprintf("Heartbeat test failed for user %s: %v", username, err))
-		return false
-	}
-	return true
-}
-
-// connect establishes a connection to Discord for a user.
-func (r *discordRPC) connect(username, token string) error {
-	if r.isConnected(username) {
-		pdk.Log(pdk.LogInfo, fmt.Sprintf("Reusing existing connection for user %s", username))
-		return nil
-	}
-	pdk.Log(pdk.LogInfo, fmt.Sprintf("Creating new connection for user %s", username))
-
-	// Get Discord Gateway URL
-	gateway, err := r.getDiscordGateway()
-	if err != nil {
-		return fmt.Errorf("failed to get Discord gateway: %w", err)
-	}
-	pdk.Log(pdk.LogDebug, fmt.Sprintf("Using gateway: %s", gateway))
-
-	// Connect to Discord Gateway
-	_, err = host.WebSocketConnect(gateway, nil, username)
-	if err != nil {
-		return fmt.Errorf("failed to connect to WebSocket: %w", err)
-	}
-
-	// Send identify payload
-	payload := identifyPayload{
-		Token:   token,
-		Intents: 0,
-		Properties: identifyProperties{
-			OS:      "Windows 10",
-			Browser: "Discord Client",
-			Device:  "Discord Client",
-		},
-	}
-	if err := r.sendMessage(username, gateOpCode, payload); err != nil {
-		return fmt.Errorf("failed to send identify payload: %w", err)
-	}
-
-	// Schedule heartbeats for this user/connection
-	cronExpr := fmt.Sprintf("@every %ds", heartbeatInterval)
-	scheduleID, err := host.SchedulerScheduleRecurring(cronExpr, payloadHeartbeat, username)
-	if err != nil {
-		return fmt.Errorf("failed to schedule heartbeat: %w", err)
-	}
-	pdk.Log(pdk.LogInfo, fmt.Sprintf("Scheduled heartbeat for user %s with ID %s", username, scheduleID))
-
-	pdk.Log(pdk.LogInfo, fmt.Sprintf("Successfully authenticated user %s", username))
-	return nil
-}
-
-// disconnect closes the Discord connection for a user.
-func (r *discordRPC) disconnect(username string) error {
-	if err := host.SchedulerCancelSchedule(username); err != nil {
-		return fmt.Errorf("failed to cancel schedule: %w", err)
-	}
-
-	if err := host.WebSocketCloseConnection(username, 1000, "Navidrome disconnect"); err != nil {
-		return fmt.Errorf("failed to close WebSocket connection: %w", err)
-	}
-	return nil
-}
-
-// handleWebSocketMessage processes incoming WebSocket messages from Discord.
-func (r *discordRPC) handleWebSocketMessage(connectionID, message string) error {
-	if len(message) < 1024 {
-		pdk.Log(pdk.LogTrace, fmt.Sprintf("Received WebSocket message for connection '%s': %s", connectionID, message))
-	} else {
-		pdk.Log(pdk.LogTrace, fmt.Sprintf("Received WebSocket message for connection '%s' (truncated): %s...", connectionID, message[:1021]))
-	}
-
-	// Parse the message
-	var msg map[string]any
-	if err := json.Unmarshal([]byte(message), &msg); err != nil {
-		return fmt.Errorf("failed to parse WebSocket message: %w", err)
-	}
-
-	// Store sequence number if present
-	if v := msg["s"]; v != nil {
-		seq := int64(v.(float64))
-		pdk.Log(pdk.LogTrace, fmt.Sprintf("Received sequence number for connection '%s': %d", connectionID, seq))
-		if err := host.CacheSetInt(fmt.Sprintf("discord.seq.%s", connectionID), seq, int64(heartbeatInterval*2)); err != nil {
-			return fmt.Errorf("failed to store sequence number for user %s: %w", connectionID, err)
-		}
-	}
-	return nil
-}
-
-// handleHeartbeatCallback processes heartbeat scheduler callbacks.
-func (r *discordRPC) handleHeartbeatCallback(username string) error {
-	if err := r.sendHeartbeat(username); err != nil {
-		// On first heartbeat failure, immediately clean up the connection
-		pdk.Log(pdk.LogWarn, fmt.Sprintf("Heartbeat failed for user %s, cleaning up connection: %v", username, err))
-		r.cleanupFailedConnection(username)
-		return fmt.Errorf("heartbeat failed, connection cleaned up: %w", err)
-	}
-	return nil
-}
-
-// handleClearActivityCallback processes clear activity scheduler callbacks.
-func (r *discordRPC) handleClearActivityCallback(username string) error {
-	pdk.Log(pdk.LogInfo, fmt.Sprintf("Removing presence for user %s", username))
-	if err := r.clearActivity(username); err != nil {
-		return fmt.Errorf("failed to clear activity: %w", err)
-	}
-
-	pdk.Log(pdk.LogInfo, fmt.Sprintf("Disconnecting user %s", username))
-	if err := r.disconnect(username); err != nil {
-		return fmt.Errorf("failed to disconnect from Discord: %w", err)
-	}
-	return nil
-}

plugins/examples/discord-rich-presence/rpc_test.go

@@ -1,279 +0,0 @@
-package main
-
-import (
-	"errors"
-	"strings"
-
-	"github.com/navidrome/navidrome/plugins/pdk/go/host"
-	"github.com/navidrome/navidrome/plugins/pdk/go/pdk"
-	"github.com/navidrome/navidrome/plugins/pdk/go/websocket"
-	"github.com/stretchr/testify/mock"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("discordRPC", func() {
-	var r *discordRPC
-
-	BeforeEach(func() {
-		r = &discordRPC{}
-		pdk.ResetMock()
-		host.CacheMock.ExpectedCalls = nil
-		host.CacheMock.Calls = nil
-		host.WebSocketMock.ExpectedCalls = nil
-		host.WebSocketMock.Calls = nil
-		host.SchedulerMock.ExpectedCalls = nil
-		host.SchedulerMock.Calls = nil
-	})
-
-	Describe("sendMessage", func() {
-		It("sends JSON message over WebSocket", func() {
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-			host.WebSocketMock.On("SendText", "testuser", mock.MatchedBy(func(msg string) bool {
-				return strings.Contains(msg, `"op":3`)
-			})).Return(nil)
-
-			err := r.sendMessage("testuser", presenceOpCode, map[string]string{"status": "online"})
-			Expect(err).ToNot(HaveOccurred())
-			host.WebSocketMock.AssertExpectations(GinkgoT())
-		})
-
-		It("returns error when WebSocket send fails", func() {
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-			host.WebSocketMock.On("SendText", mock.Anything, mock.Anything).
-				Return(errors.New("connection closed"))
-
-			err := r.sendMessage("testuser", presenceOpCode, map[string]string{})
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("connection closed"))
-		})
-	})
-
-	Describe("sendHeartbeat", func() {
-		It("retrieves sequence number from cache and sends heartbeat", func() {
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-			host.CacheMock.On("GetInt", "discord.seq.testuser").Return(int64(123), true, nil)
-			host.WebSocketMock.On("SendText", "testuser", mock.MatchedBy(func(msg string) bool {
-				return strings.Contains(msg, `"op":1`) && strings.Contains(msg, "123")
-			})).Return(nil)
-
-			err := r.sendHeartbeat("testuser")
-			Expect(err).ToNot(HaveOccurred())
-			host.CacheMock.AssertExpectations(GinkgoT())
-			host.WebSocketMock.AssertExpectations(GinkgoT())
-		})
-
-		It("returns error when cache get fails", func() {
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-			host.CacheMock.On("GetInt", "discord.seq.testuser").Return(int64(0), false, errors.New("cache error"))
-
-			err := r.sendHeartbeat("testuser")
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("cache error"))
-		})
-	})
-
-	Describe("connect", func() {
-		It("establishes WebSocket connection and sends identify payload", func() {
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-			host.CacheMock.On("GetInt", "discord.seq.testuser").Return(int64(0), false, errors.New("not found"))
-
-			// Mock HTTP GET request for gateway discovery
-			gatewayResp := []byte(`{"url":"wss://gateway.discord.gg"}`)
-			httpReq := &pdk.HTTPRequest{}
-			pdk.PDKMock.On("NewHTTPRequest", pdk.MethodGet, "https://discord.com/api/gateway").Return(httpReq)
-			pdk.PDKMock.On("Send", mock.Anything).Return(pdk.NewStubHTTPResponse(200, nil, gatewayResp))
-
-			// Mock WebSocket connection
-			host.WebSocketMock.On("Connect", mock.MatchedBy(func(url string) bool {
-				return strings.Contains(url, "gateway.discord.gg")
-			}), mock.Anything, "testuser").Return("testuser", nil)
-			host.WebSocketMock.On("SendText", "testuser", mock.MatchedBy(func(msg string) bool {
-				return strings.Contains(msg, `"op":2`) && strings.Contains(msg, "test-token")
-			})).Return(nil)
-			host.SchedulerMock.On("ScheduleRecurring", "@every 41s", payloadHeartbeat, "testuser").
-				Return("testuser", nil)
-
-			err := r.connect("testuser", "test-token")
-			Expect(err).ToNot(HaveOccurred())
-		})
-
-		It("reuses existing connection if connected", func() {
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-			host.CacheMock.On("GetInt", "discord.seq.testuser").Return(int64(42), true, nil)
-			host.WebSocketMock.On("SendText", "testuser", mock.Anything).Return(nil)
-
-			err := r.connect("testuser", "test-token")
-			Expect(err).ToNot(HaveOccurred())
-			host.WebSocketMock.AssertNotCalled(GinkgoT(), "Connect", mock.Anything, mock.Anything, mock.Anything)
-		})
-	})
-
-	Describe("disconnect", func() {
-		It("cancels schedule and closes WebSocket connection", func() {
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-			host.SchedulerMock.On("CancelSchedule", "testuser").Return(nil)
-			host.WebSocketMock.On("CloseConnection", "testuser", int32(1000), "Navidrome disconnect").Return(nil)
-
-			err := r.disconnect("testuser")
-			Expect(err).ToNot(HaveOccurred())
-			host.SchedulerMock.AssertExpectations(GinkgoT())
-			host.WebSocketMock.AssertExpectations(GinkgoT())
-		})
-	})
-
-	Describe("cleanupFailedConnection", func() {
-		It("cancels schedule, closes WebSocket, and clears cache", func() {
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-			host.SchedulerMock.On("CancelSchedule", "testuser").Return(nil)
-			host.WebSocketMock.On("CloseConnection", "testuser", int32(1000), "Connection lost").Return(nil)
-			host.CacheMock.On("Remove", "discord.seq.testuser").Return(nil)
-
-			r.cleanupFailedConnection("testuser")
-
-			host.SchedulerMock.AssertExpectations(GinkgoT())
-			host.WebSocketMock.AssertExpectations(GinkgoT())
-		})
-	})
-
-	Describe("handleHeartbeatCallback", func() {
-		It("sends heartbeat successfully", func() {
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-			host.CacheMock.On("GetInt", "discord.seq.testuser").Return(int64(42), true, nil)
-			host.WebSocketMock.On("SendText", "testuser", mock.Anything).Return(nil)
-
-			err := r.handleHeartbeatCallback("testuser")
-			Expect(err).ToNot(HaveOccurred())
-		})
-
-		It("cleans up connection on heartbeat failure", func() {
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-			host.CacheMock.On("GetInt", "discord.seq.testuser").Return(int64(0), false, errors.New("cache miss"))
-			host.SchedulerMock.On("CancelSchedule", "testuser").Return(nil)
-			host.WebSocketMock.On("CloseConnection", "testuser", int32(1000), "Connection lost").Return(nil)
-			host.CacheMock.On("Remove", "discord.seq.testuser").Return(nil)
-
-			err := r.handleHeartbeatCallback("testuser")
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("connection cleaned up"))
-		})
-	})
-
-	Describe("handleClearActivityCallback", func() {
-		It("clears activity and disconnects", func() {
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-			host.WebSocketMock.On("SendText", "testuser", mock.MatchedBy(func(msg string) bool {
-				return strings.Contains(msg, `"op":3`) && strings.Contains(msg, `"activities":null`)
-			})).Return(nil)
-			host.SchedulerMock.On("CancelSchedule", "testuser").Return(nil)
-			host.WebSocketMock.On("CloseConnection", "testuser", int32(1000), "Navidrome disconnect").Return(nil)
-
-			err := r.handleClearActivityCallback("testuser")
-			Expect(err).ToNot(HaveOccurred())
-		})
-	})
-
-	Describe("WebSocket callbacks", func() {
-		Describe("OnTextMessage", func() {
-			It("handles valid JSON message", func() {
-				pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-				host.CacheMock.On("SetInt", mock.Anything, mock.Anything, mock.Anything).Return(nil)
-
-				err := r.OnTextMessage(websocket.OnTextMessageRequest{
-					ConnectionID: "testuser",
-					Message:      `{"s":42}`,
-				})
-				Expect(err).ToNot(HaveOccurred())
-			})
-
-			It("returns error for invalid JSON", func() {
-				pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-				err := r.OnTextMessage(websocket.OnTextMessageRequest{
-					ConnectionID: "testuser",
-					Message:      `not json`,
-				})
-				Expect(err).To(HaveOccurred())
-			})
-		})
-
-		Describe("OnBinaryMessage", func() {
-			It("handles binary message without error", func() {
-				pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-				err := r.OnBinaryMessage(websocket.OnBinaryMessageRequest{
-					ConnectionID: "testuser",
-					Data:         "AQID", // base64 encoded [0x01, 0x02, 0x03]
-				})
-				Expect(err).ToNot(HaveOccurred())
-			})
-		})
-
-		Describe("OnError", func() {
-			It("handles error without returning error", func() {
-				pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-				err := r.OnError(websocket.OnErrorRequest{
-					ConnectionID: "testuser",
-					Error:        "test error",
-				})
-				Expect(err).ToNot(HaveOccurred())
-			})
-		})
-
-		Describe("OnClose", func() {
-			It("handles close without returning error", func() {
-				pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-				err := r.OnClose(websocket.OnCloseRequest{
-					ConnectionID: "testuser",
-					Code:         1000,
-					Reason:       "normal close",
-				})
-				Expect(err).ToNot(HaveOccurred())
-			})
-		})
-	})
-
-	Describe("sendActivity", func() {
-		BeforeEach(func() {
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-			host.CacheMock.On("GetString", mock.MatchedBy(func(key string) bool {
-				return strings.HasPrefix(key, "discord.image.")
-			})).Return("", false, nil)
-			host.CacheMock.On("SetString", mock.Anything, mock.Anything, mock.Anything).Return(nil)
-
-			// Mock HTTP request for Discord external assets API (image processing)
-			// When processImage is called, it makes an HTTP request
-			httpReq := &pdk.HTTPRequest{}
-			pdk.PDKMock.On("NewHTTPRequest", pdk.MethodPost, mock.Anything).Return(httpReq)
-			pdk.PDKMock.On("Send", mock.Anything).Return(pdk.NewStubHTTPResponse(200, nil, []byte(`{"key":"test-key"}`)))
-		})
-
-		It("sends activity update to Discord", func() {
-			host.WebSocketMock.On("SendText", "testuser", mock.MatchedBy(func(msg string) bool {
-				return strings.Contains(msg, `"op":3`) &&
-					strings.Contains(msg, `"name":"Test Song"`) &&
-					strings.Contains(msg, `"state":"Test Artist"`)
-			})).Return(nil)
-
-			err := r.sendActivity("client123", "testuser", "token123", activity{
-				Application: "client123",
-				Name:        "Test Song",
-				Type:        2,
-				State:       "Test Artist",
-				Details:     "Test Album",
-			})
-			Expect(err).ToNot(HaveOccurred())
-		})
-	})
-
-	Describe("clearActivity", func() {
-		It("sends presence update with nil activities", func() {
-			pdk.PDKMock.On("Log", mock.Anything, mock.Anything).Maybe()
-			host.WebSocketMock.On("SendText", "testuser", mock.MatchedBy(func(msg string) bool {
-				return strings.Contains(msg, `"op":3`) && strings.Contains(msg, `"activities":null`)
-			})).Return(nil)
-
-			err := r.clearActivity("testuser")
-			Expect(err).ToNot(HaveOccurred())
-		})
-	})
-})

plugins/host/subsonicapi.go

@@ -15,4 +15,10 @@ type SubsonicAPIService interface {
 	// e.g., "getAlbumList2?type=random&size=10". The response is returned as raw JSON.
 	//nd:hostfunc
 	Call(ctx context.Context, uri string) (responseJSON string, err error)
+
+	// CallRaw executes a Subsonic API request and returns the raw binary response.
+	// Optimized for binary endpoints like getCoverArt and stream that return
+	// non-JSON data. The response is returned as raw bytes without JSON encoding overhead.
+	//nd:hostfunc raw=true
+	CallRaw(ctx context.Context, uri string) (contentType string, data []byte, err error)
 }

plugins/host/subsonicapi_gen.go

@@ -4,6 +4,7 @@ package host
 
 import (
 	"context"
+	"encoding/binary"
 	"encoding/json"
 
 	extism "github.com/extism/go-sdk"
@@ -20,11 +21,17 @@ type SubsonicAPICallResponse struct {
 	Error        string `json:"error,omitempty"`
 }
 
+// SubsonicAPICallRawRequest is the request type for SubsonicAPI.CallRaw.
+type SubsonicAPICallRawRequest struct {
+	Uri string `json:"uri"`
+}
+
 // RegisterSubsonicAPIHostFunctions registers SubsonicAPI service host functions.
 // The returned host functions should be added to the plugin's configuration.
 func RegisterSubsonicAPIHostFunctions(service SubsonicAPIService) []extism.HostFunction {
 	return []extism.HostFunction{
 		newSubsonicAPICallHostFunction(service),
+		newSubsonicAPICallRawHostFunction(service),
 	}
 }
 
@@ -62,6 +69,50 @@ func newSubsonicAPICallHostFunction(service SubsonicAPIService) extism.HostFunct
 	)
 }
 
+func newSubsonicAPICallRawHostFunction(service SubsonicAPIService) extism.HostFunction {
+	return extism.NewHostFunctionWithStack(
+		"subsonicapi_callraw",
+		func(ctx context.Context, p *extism.CurrentPlugin, stack []uint64) {
+			// Read JSON request from plugin memory
+			reqBytes, err := p.ReadBytes(stack[0])
+			if err != nil {
+				subsonicapiWriteRawError(p, stack, err)
+				return
+			}
+			var req SubsonicAPICallRawRequest
+			if err := json.Unmarshal(reqBytes, &req); err != nil {
+				subsonicapiWriteRawError(p, stack, err)
+				return
+			}
+
+			// Call the service method
+			contenttype, data, svcErr := service.CallRaw(ctx, req.Uri)
+			if svcErr != nil {
+				subsonicapiWriteRawError(p, stack, svcErr)
+				return
+			}
+
+			// Write binary-framed response to plugin memory:
+			// [0x00][4-byte content-type length (big-endian)][content-type string][raw data]
+			ctBytes := []byte(contenttype)
+			frame := make([]byte, 1+4+len(ctBytes)+len(data))
+			frame[0] = 0x00 // success
+			binary.BigEndian.PutUint32(frame[1:5], uint32(len(ctBytes)))
+			copy(frame[5:5+len(ctBytes)], ctBytes)
+			copy(frame[5+len(ctBytes):], data)
+
+			respPtr, err := p.WriteBytes(frame)
+			if err != nil {
+				stack[0] = 0
+				return
+			}
+			stack[0] = respPtr
+		},
+		[]extism.ValueType{extism.ValueTypePTR},
+		[]extism.ValueType{extism.ValueTypePTR},
+	)
+}
+
 // subsonicapiWriteResponse writes a JSON response to plugin memory.
 func subsonicapiWriteResponse(p *extism.CurrentPlugin, stack []uint64, resp any) {
 	respBytes, err := json.Marshal(resp)
@@ -86,3 +137,14 @@ func subsonicapiWriteError(p *extism.CurrentPlugin, stack []uint64, err error) {
 	respPtr, _ := p.WriteBytes(respBytes)
 	stack[0] = respPtr
 }
+
+// subsonicapiWriteRawError writes a binary-framed error response to plugin memory.
+// Format: [0x01][UTF-8 error message]
+func subsonicapiWriteRawError(p *extism.CurrentPlugin, stack []uint64, err error) {
+	errMsg := []byte(err.Error())
+	frame := make([]byte, 1+len(errMsg))
+	frame[0] = 0x01 // error
+	copy(frame[1:], errMsg)
+	respPtr, _ := p.WriteBytes(frame)
+	stack[0] = respPtr
+}

plugins/host_subsonicapi.go

@@ -24,7 +24,7 @@ const subsonicAPIVersion = "1.16.1"
 //
 // Authentication: The plugin must provide a valid 'u' (username) parameter in the URL.
 // URL Format: Only the path and query parameters are used - host/protocol are ignored.
-// Automatic Parameters: The service adds 'c' (client), 'v' (version), 'f' (format).
+// Automatic Parameters: The service adds 'c' (client), 'v' (version), and optionally 'f' (format).
 type subsonicAPIServiceImpl struct {
 	pluginID       string
 	router         SubsonicRouter
@@ -50,15 +50,18 @@ func newSubsonicAPIService(pluginID string, router SubsonicRouter, ds model.Data
 	}
 }
 
-func (s *subsonicAPIServiceImpl) Call(ctx context.Context, uri string) (string, error) {
+// executeRequest handles URL parsing, validation, permission checks, HTTP request creation,
+// and router invocation. Shared between Call and CallRaw.
+// If setJSON is true, the 'f=json' query parameter is added.
+func (s *subsonicAPIServiceImpl) executeRequest(ctx context.Context, uri string, setJSON bool) (*httptest.ResponseRecorder, error) {
 	if s.router == nil {
-		return "", fmt.Errorf("SubsonicAPI router not available")
+		return nil, fmt.Errorf("SubsonicAPI router not available")
 	}
 
 	// Parse the input URL
 	parsedURL, err := url.Parse(uri)
 	if err != nil {
-		return "", fmt.Errorf("invalid URL format: %w", err)
+		return nil, fmt.Errorf("invalid URL format: %w", err)
 	}
 
 	// Extract query parameters
@@ -67,18 +70,20 @@ func (s *subsonicAPIServiceImpl) Call(ctx context.Context, uri string) (string,
 	// Validate that 'u' (username) parameter is present
 	username := query.Get("u")
 	if username == "" {
-		return "", fmt.Errorf("missing required parameter 'u' (username)")
+		return nil, fmt.Errorf("missing required parameter 'u' (username)")
 	}
 
 	if err := s.checkPermissions(ctx, username); err != nil {
 		log.Warn(ctx, "SubsonicAPI call blocked by permissions", "plugin", s.pluginID, "user", username, err)
-		return "", err
+		return nil, err
 	}
 
 	// Add required Subsonic API parameters
 	query.Set("c", s.pluginID)         // Client name (plugin ID)
-	query.Set("f", "json")             // Response format
 	query.Set("v", subsonicAPIVersion) // API version
+	if setJSON {
+		query.Set("f", "json") // Response format
+	}
 
 	// Extract the endpoint from the path
 	endpoint := path.Base(parsedURL.Path)
@@ -96,7 +101,7 @@ func (s *subsonicAPIServiceImpl) Call(ctx context.Context, uri string) (string,
 	// explicitly added in the next step via request.WithInternalAuth.
 	httpReq, err := http.NewRequest("GET", finalURL.String(), nil)
 	if err != nil {
-		return "", fmt.Errorf("failed to create HTTP request: %w", err)
+		return nil, fmt.Errorf("failed to create HTTP request: %w", err)
 	}
 
 	// Set internal authentication context using the username from the 'u' parameter
@@ -109,10 +114,26 @@ func (s *subsonicAPIServiceImpl) Call(ctx context.Context, uri string) (string,
 	// Call the subsonic router
 	s.router.ServeHTTP(recorder, httpReq)
 
-	// Return the response body as JSON
+	return recorder, nil
+}
+
+func (s *subsonicAPIServiceImpl) Call(ctx context.Context, uri string) (string, error) {
+	recorder, err := s.executeRequest(ctx, uri, true)
+	if err != nil {
+		return "", err
+	}
 	return recorder.Body.String(), nil
 }
 
+func (s *subsonicAPIServiceImpl) CallRaw(ctx context.Context, uri string) (string, []byte, error) {
+	recorder, err := s.executeRequest(ctx, uri, false)
+	if err != nil {
+		return "", nil, err
+	}
+	contentType := recorder.Header().Get("Content-Type")
+	return contentType, recorder.Body.Bytes(), nil
+}
+
 func (s *subsonicAPIServiceImpl) checkPermissions(ctx context.Context, username string) error {
 	// If allUsers is true, allow any user
 	if s.allUsers {

plugins/host_subsonicapi_test.go

@@ -8,6 +8,7 @@ import (
 	"encoding/json"
 	"net/http"
 	"os"
+	"path"
 	"path/filepath"
 
 	"github.com/navidrome/navidrome/conf"
@@ -177,6 +178,61 @@ var _ = Describe("SubsonicAPI Host Function", Ordered, func() {
 			Expect(err.Error()).To(ContainSubstring("missing required parameter"))
 		})
 	})
+
+	Describe("SubsonicAPI CallRaw", func() {
+		var plugin *plugin
+
+		BeforeEach(func() {
+			manager.mu.RLock()
+			plugin = manager.plugins["test-subsonicapi-plugin"]
+			manager.mu.RUnlock()
+			Expect(plugin).ToNot(BeNil())
+		})
+
+		It("successfully calls getCoverArt and returns binary data", func() {
+			instance, err := plugin.instance(GinkgoT().Context())
+			Expect(err).ToNot(HaveOccurred())
+			defer instance.Close(GinkgoT().Context())
+
+			exit, output, err := instance.Call("call_subsonic_api_raw", []byte("/getCoverArt?u=testuser&id=al-1"))
+			Expect(err).ToNot(HaveOccurred())
+			Expect(exit).To(Equal(uint32(0)))
+
+			// Parse the metadata response from the test plugin
+			var result map[string]any
+			err = json.Unmarshal(output, &result)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(result["contentType"]).To(Equal("image/png"))
+			Expect(result["size"]).To(BeNumerically("==", len(fakePNGHeader)))
+			Expect(result["firstByte"]).To(BeNumerically("==", 0x89)) // PNG magic byte
+		})
+
+		It("does NOT set f=json parameter for raw calls", func() {
+			instance, err := plugin.instance(GinkgoT().Context())
+			Expect(err).ToNot(HaveOccurred())
+			defer instance.Close(GinkgoT().Context())
+
+			_, _, err = instance.Call("call_subsonic_api_raw", []byte("/getCoverArt?u=testuser&id=al-1"))
+			Expect(err).ToNot(HaveOccurred())
+
+			Expect(router.lastRequest).ToNot(BeNil())
+			query := router.lastRequest.URL.Query()
+			Expect(query.Get("f")).To(BeEmpty())
+			Expect(query.Get("c")).To(Equal("test-subsonicapi-plugin"))
+			Expect(query.Get("v")).To(Equal("1.16.1"))
+		})
+
+		It("returns error when username is missing", func() {
+			instance, err := plugin.instance(GinkgoT().Context())
+			Expect(err).ToNot(HaveOccurred())
+			defer instance.Close(GinkgoT().Context())
+
+			exit, _, err := instance.Call("call_subsonic_api_raw", []byte("/getCoverArt"))
+			Expect(err).To(HaveOccurred())
+			Expect(exit).To(Equal(uint32(1)))
+			Expect(err.Error()).To(ContainSubstring("missing required parameter"))
+		})
+	})
 })
 
 var _ = Describe("SubsonicAPIService", func() {
@@ -323,6 +379,66 @@ var _ = Describe("SubsonicAPIService", func() {
 		})
 	})
 
+	Describe("CallRaw", func() {
+		It("returns binary data and content-type", func() {
+			service := newSubsonicAPIService("test-plugin", router, dataStore, nil, true)
+
+			ctx := GinkgoT().Context()
+			contentType, data, err := service.CallRaw(ctx, "/getCoverArt?u=testuser&id=al-1")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(contentType).To(Equal("image/png"))
+			Expect(data).To(Equal(fakePNGHeader))
+		})
+
+		It("does not set f=json parameter", func() {
+			service := newSubsonicAPIService("test-plugin", router, dataStore, nil, true)
+
+			ctx := GinkgoT().Context()
+			_, _, err := service.CallRaw(ctx, "/getCoverArt?u=testuser&id=al-1")
+			Expect(err).ToNot(HaveOccurred())
+
+			Expect(router.lastRequest).ToNot(BeNil())
+			query := router.lastRequest.URL.Query()
+			Expect(query.Get("f")).To(BeEmpty())
+		})
+
+		It("enforces permission checks", func() {
+			service := newSubsonicAPIService("test-plugin", router, dataStore, []string{"user2"}, false)
+
+			ctx := GinkgoT().Context()
+			_, _, err := service.CallRaw(ctx, "/getCoverArt?u=testuser&id=al-1")
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("not authorized"))
+		})
+
+		It("returns error when username is missing", func() {
+			service := newSubsonicAPIService("test-plugin", router, dataStore, nil, true)
+
+			ctx := GinkgoT().Context()
+			_, _, err := service.CallRaw(ctx, "/getCoverArt")
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("missing required parameter"))
+		})
+
+		It("returns error when router is nil", func() {
+			service := newSubsonicAPIService("test-plugin", nil, dataStore, nil, true)
+
+			ctx := GinkgoT().Context()
+			_, _, err := service.CallRaw(ctx, "/getCoverArt?u=testuser")
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("router not available"))
+		})
+
+		It("returns error for invalid URL", func() {
+			service := newSubsonicAPIService("test-plugin", router, dataStore, nil, true)
+
+			ctx := GinkgoT().Context()
+			_, _, err := service.CallRaw(ctx, "://invalid")
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid URL"))
+		})
+	})
+
 	Describe("Router Availability", func() {
 		It("returns error when router is nil", func() {
 			service := newSubsonicAPIService("test-plugin", nil, dataStore, nil, true)
@@ -335,6 +451,9 @@ var _ = Describe("SubsonicAPIService", func() {
 	})
 })
 
+// fakePNGHeader is a minimal PNG file header used in tests.
+var fakePNGHeader = []byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}
+
 // fakeSubsonicRouter is a mock Subsonic router that returns predictable responses.
 type fakeSubsonicRouter struct {
 	lastRequest *http.Request
@@ -343,13 +462,20 @@ type fakeSubsonicRouter struct {
 func (r *fakeSubsonicRouter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 	r.lastRequest = req
 
-	// Return a successful ping response
-	response := map[string]any{
-		"subsonic-response": map[string]any{
-			"status":  "ok",
-			"version": "1.16.1",
-		},
+	endpoint := path.Base(req.URL.Path)
+	switch endpoint {
+	case "getCoverArt":
+		w.Header().Set("Content-Type", "image/png")
+		_, _ = w.Write(fakePNGHeader)
+	default:
+		// Return a successful ping response
+		response := map[string]any{
+			"subsonic-response": map[string]any{
+				"status":  "ok",
+				"version": "1.16.1",
+			},
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(response)
 	}
-	w.Header().Set("Content-Type", "application/json")
-	_ = json.NewEncoder(w).Encode(response)
 }

plugins/manager_call.go

@@ -73,7 +73,8 @@ func callPluginFunction[I any, O any](ctx context.Context, plugin *plugin, funcN
 	if exit != 0 {
 		if exit == notImplementedCode {
 			log.Trace(ctx, "Plugin function not implemented", "plugin", plugin.name, "function", funcName, "pluginDuration", elapsed, "navidromeDuration", startCall.Sub(start))
-			plugin.metrics.RecordPluginRequest(ctx, plugin.name, funcName, true, elapsed.Milliseconds())
+			// TODO Should we record metrics for not implemented calls?
+			//plugin.metrics.RecordPluginRequest(ctx, plugin.name, funcName, true, elapsed.Milliseconds())
 			return result, fmt.Errorf("%w: %s", errNotImplemented, funcName)
 		}
 		plugin.metrics.RecordPluginRequest(ctx, plugin.name, funcName, false, elapsed.Milliseconds())

plugins/manager_call_test.go

@@ -106,7 +106,7 @@ var _ = Describe("callPluginFunction metrics", Ordered, func() {
 		Expect(calls[0].ok).To(BeFalse())
 	})
 
-	It("records metrics for not-implemented functions", func() {
+	It("does not record metrics for not-implemented functions", func() {
 		// Use partial metadata agent that doesn't implement GetArtistMBID
 		partialRecorder := &mockMetricsRecorder{}
 		partialManager, _ := createTestManagerWithPluginsAndMetrics(
@@ -123,9 +123,6 @@ var _ = Describe("callPluginFunction metrics", Ordered, func() {
 		Expect(err).To(MatchError(errNotImplemented))
 
 		calls := partialRecorder.getCalls()
-		Expect(calls).To(HaveLen(1))
-		Expect(calls[0].plugin).To(Equal("partial-metadata-agent"))
-		Expect(calls[0].method).To(Equal(FuncGetArtistMBID))
-		Expect(calls[0].ok).To(BeTrue())
+		Expect(calls).To(HaveLen(0))
 	})
 })

plugins/pdk/go/go.mod

@@ -6,10 +6,3 @@ require (
 	github.com/extism/go-pdk v1.1.3
 	github.com/stretchr/testify v1.11.1
 )
-
-require (
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/stretchr/objx v0.5.2 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-)

plugins/pdk/go/host/nd_host_subsonicapi.go

@@ -8,6 +8,7 @@
 package host
 
 import (
+	"encoding/binary"
 	"encoding/json"
 	"errors"
 
@@ -19,6 +20,11 @@ import (
 //go:wasmimport extism:host/user subsonicapi_call
 func subsonicapi_call(uint64) uint64
 
+// subsonicapi_callraw is the host function provided by Navidrome.
+//
+//go:wasmimport extism:host/user subsonicapi_callraw
+func subsonicapi_callraw(uint64) uint64
+
 type subsonicAPICallRequest struct {
 	Uri string `json:"uri"`
 }
@@ -28,6 +34,10 @@ type subsonicAPICallResponse struct {
 	Error        string `json:"error,omitempty"`
 }
 
+type subsonicAPICallRawRequest struct {
+	Uri string `json:"uri"`
+}
+
 // SubsonicAPICall calls the subsonicapi_call host function.
 // Call executes a Subsonic API request and returns the JSON response.
 //
@@ -65,3 +75,46 @@ func SubsonicAPICall(uri string) (string, error) {
 
 	return response.ResponseJSON, nil
 }
+
+// SubsonicAPICallRaw calls the subsonicapi_callraw host function.
+// CallRaw executes a Subsonic API request and returns the raw binary response.
+// Optimized for binary endpoints like getCoverArt and stream that return
+// non-JSON data. The response is returned as raw bytes without JSON encoding overhead.
+func SubsonicAPICallRaw(uri string) (string, []byte, error) {
+	// Marshal request to JSON
+	req := subsonicAPICallRawRequest{
+		Uri: uri,
+	}
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return "", nil, err
+	}
+	reqMem := pdk.AllocateBytes(reqBytes)
+	defer reqMem.Free()
+
+	// Call the host function
+	responsePtr := subsonicapi_callraw(reqMem.Offset())
+
+	// Read the response from memory
+	responseMem := pdk.FindMemory(responsePtr)
+	responseBytes := responseMem.ReadBytes()
+
+	// Parse binary-framed response
+	if len(responseBytes) == 0 {
+		return "", nil, errors.New("empty response from host")
+	}
+	if responseBytes[0] == 0x01 { // error
+		return "", nil, errors.New(string(responseBytes[1:]))
+	}
+	if responseBytes[0] != 0x00 {
+		return "", nil, errors.New("unknown response status")
+	}
+	if len(responseBytes) < 5 {
+		return "", nil, errors.New("malformed raw response: incomplete header")
+	}
+	ctLen := binary.BigEndian.Uint32(responseBytes[1:5])
+	if uint32(len(responseBytes)) < 5+ctLen {
+		return "", nil, errors.New("malformed raw response: content-type overflow")
+	}
+	return string(responseBytes[5 : 5+ctLen]), responseBytes[5+ctLen:], nil
+}

plugins/pdk/go/host/nd_host_subsonicapi_stub.go

@@ -33,3 +33,17 @@ func (m *mockSubsonicAPIService) Call(uri string) (string, error) {
 func SubsonicAPICall(uri string) (string, error) {
 	return SubsonicAPIMock.Call(uri)
 }
+
+// CallRaw is the mock method for SubsonicAPICallRaw.
+func (m *mockSubsonicAPIService) CallRaw(uri string) (string, []byte, error) {
+	args := m.Called(uri)
+	return args.String(0), args.Get(1).([]byte), args.Error(2)
+}
+
+// SubsonicAPICallRaw delegates to the mock instance.
+// CallRaw executes a Subsonic API request and returns the raw binary response.
+// Optimized for binary endpoints like getCoverArt and stream that return
+// non-JSON data. The response is returned as raw bytes without JSON encoding overhead.
+func SubsonicAPICallRaw(uri string) (string, []byte, error) {
+	return SubsonicAPIMock.CallRaw(uri)
+}

plugins/pdk/python/host/nd_host_subsonicapi.py

@@ -8,10 +8,11 @@
 # main __init__.py file. Copy the needed functions from this file into your plugin.
 
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Tuple
 
 import extism
 import json
+import struct
 
 
 class HostFunctionError(Exception):
@@ -25,6 +26,12 @@ def _subsonicapi_call(offset: int) -> int:
     ...
 
 
+@extism.import_fn("extism:host/user", "subsonicapi_callraw")
+def _subsonicapi_callraw(offset: int) -> int:
+    """Raw host function - do not call directly."""
+    ...
+
+
 def subsonicapi_call(uri: str) -> str:
     """Call executes a Subsonic API request and returns the JSON response.
 
@@ -53,3 +60,42 @@ e.g., "getAlbumList2?type=random&size=10". The response is returned as raw JSON.
         raise HostFunctionError(response["error"])
 
     return response.get("responseJson", "")
+
+
+def subsonicapi_call_raw(uri: str) -> Tuple[str, bytes]:
+    """CallRaw executes a Subsonic API request and returns the raw binary response.
+Optimized for binary endpoints like getCoverArt and stream that return
+non-JSON data. The response is returned as raw bytes without JSON encoding overhead.
+
+    Args:
+        uri: str parameter.
+
+    Returns:
+        Tuple of (content_type, data) with the raw binary response.
+
+    Raises:
+        HostFunctionError: If the host function returns an error.
+    """
+    request = {
+        "uri": uri,
+    }
+    request_bytes = json.dumps(request).encode("utf-8")
+    request_mem = extism.memory.alloc(request_bytes)
+    response_offset = _subsonicapi_callraw(request_mem.offset)
+    response_mem = extism.memory.find(response_offset)
+    response_bytes = response_mem.bytes()
+
+    if len(response_bytes) == 0:
+        raise HostFunctionError("empty response from host")
+    if response_bytes[0] == 0x01:
+        raise HostFunctionError(response_bytes[1:].decode("utf-8"))
+    if response_bytes[0] != 0x00:
+        raise HostFunctionError("unknown response status")
+    if len(response_bytes) < 5:
+        raise HostFunctionError("malformed raw response: incomplete header")
+    ct_len = struct.unpack(">I", response_bytes[1:5])[0]
+    if len(response_bytes) < 5 + ct_len:
+        raise HostFunctionError("malformed raw response: content-type overflow")
+    content_type = response_bytes[5:5 + ct_len].decode("utf-8")
+    data = response_bytes[5 + ct_len:]
+    return content_type, data

plugins/pdk/rust/nd-pdk-host/Cargo.lock

@@ -28,9 +28,9 @@ checksum = "1fbdf580320f38b612e485521afda1ee26d10cc9884efaaa750d383e13e3c5f4"
 
 [[package]]
 name = "bytes"
-version = "1.11.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
 [[package]]
 name = "either"
@@ -171,7 +171,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
 
 [[package]]
-name = "nd-host"
+name = "nd-pdk-host"
 version = "0.1.0"
 dependencies = [
  "extism-pdk",

plugins/pdk/rust/nd-pdk-host/src/nd_host_subsonicapi.rs

@@ -21,11 +21,22 @@ struct SubsonicAPICallResponse {
     error: Option<String>,
 }
 
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct SubsonicAPICallRawRequest {
+    uri: String,
+}
+
 #[host_fn]
 extern "ExtismHost" {
     fn subsonicapi_call(input: Json<SubsonicAPICallRequest>) -> Json<SubsonicAPICallResponse>;
 }
 
+#[link(wasm_import_module = "extism:host/user")]
+extern "C" {
+    fn subsonicapi_callraw(offset: u64) -> u64;
+}
+
 /// Call executes a Subsonic API request and returns the JSON response.
 /// 
 /// The uri parameter should be the Subsonic API path without the server prefix,
@@ -52,3 +63,56 @@ pub fn call(uri: &str) -> Result<String, Error> {
 
     Ok(response.0.response_json)
 }
+
+/// CallRaw executes a Subsonic API request and returns the raw binary response.
+/// Optimized for binary endpoints like getCoverArt and stream that return
+/// non-JSON data. The response is returned as raw bytes without JSON encoding overhead.
+///
+/// # Arguments
+/// * `uri` - String parameter.
+///
+/// # Returns
+/// A tuple of (content_type, data) with the raw binary response.
+///
+/// # Errors
+/// Returns an error if the host function call fails.
+pub fn call_raw(uri: &str) -> Result<(String, Vec<u8>), Error> {
+    let req = SubsonicAPICallRawRequest {
+        uri: uri.to_owned(),
+    };
+    let input_bytes = serde_json::to_vec(&req).map_err(|e| Error::msg(e.to_string()))?;
+    let input_mem = Memory::from_bytes(&input_bytes).map_err(|e| Error::msg(e.to_string()))?;
+
+    let response_offset = unsafe { subsonicapi_callraw(input_mem.offset()) };
+
+    let response_mem = Memory::find(response_offset)
+        .ok_or_else(|| Error::msg("empty response from host"))?;
+    let response_bytes = response_mem.to_vec();
+
+    if response_bytes.is_empty() {
+        return Err(Error::msg("empty response from host"));
+    }
+    if response_bytes[0] == 0x01 {
+        let msg = String::from_utf8_lossy(&response_bytes[1..]).to_string();
+        return Err(Error::msg(msg));
+    }
+    if response_bytes[0] != 0x00 {
+        return Err(Error::msg("unknown response status"));
+    }
+    if response_bytes.len() < 5 {
+        return Err(Error::msg("malformed raw response: incomplete header"));
+    }
+    let ct_len = u32::from_be_bytes([
+        response_bytes[1],
+        response_bytes[2],
+        response_bytes[3],
+        response_bytes[4],
+    ]) as usize;
+    if ct_len > response_bytes.len() - 5 {
+        return Err(Error::msg("malformed raw response: content-type overflow"));
+    }
+    let ct_end = 5 + ct_len;
+    let content_type = String::from_utf8_lossy(&response_bytes[5..ct_end]).to_string();
+    let data = response_bytes[ct_end..].to_vec();
+    Ok((content_type, data))
+}

plugins/testdata/test-subsonicapi-plugin/main.go

@@ -3,6 +3,8 @@
 package main
 
 import (
+	"fmt"
+
 	"github.com/navidrome/navidrome/plugins/pdk/go/host"
 	"github.com/navidrome/navidrome/plugins/pdk/go/pdk"
 )
@@ -28,4 +30,28 @@ func callSubsonicAPIExport() int32 {
 	return 0
 }
 
+// call_subsonic_api_raw is the exported function that tests the SubsonicAPI CallRaw host function.
+// Input: URI string (e.g., "/getCoverArt?u=testuser&id=al-1")
+// Output: JSON with contentType, size, and first bytes of the raw response
+//
+//go:wasmexport call_subsonic_api_raw
+func callSubsonicAPIRawExport() int32 {
+	uri := pdk.InputString()
+
+	contentType, data, err := host.SubsonicAPICallRaw(uri)
+	if err != nil {
+		pdk.SetErrorString("failed to call SubsonicAPI raw: " + err.Error())
+		return 1
+	}
+
+	// Return metadata about the raw response as JSON
+	firstByte := 0
+	if len(data) > 0 {
+		firstByte = int(data[0])
+	}
+	result := fmt.Sprintf(`{"contentType":%q,"size":%d,"firstByte":%d}`, contentType, len(data), firstByte)
+	pdk.OutputString(result)
+	return 0
+}
+
 func main() {}

resources/i18n/ca.json

@@ -95,11 +95,11 @@
       "lists": {
         "all": "Tot",
         "random": "Aleatori",
-        "recentlyAdded": "Afegit fa poc",
-        "recentlyPlayed": "Reproduït fa poc",
-        "mostPlayed": "Més reproduït",
+        "recentlyAdded": "Afegits recentment",
+        "recentlyPlayed": "Reproduïts recentment",
+        "mostPlayed": "Més reproduïts",
         "starred": "Preferits",
-        "topRated": "Més ben valorades"
+        "topRated": "Més ben valorats"
       }
     },
     "artist": {
@@ -119,7 +119,7 @@
         "albumartist": "Artista de l'Àlbum |||| Artistes de l'Àlbum",
         "artist": "Artista |||| Artistes",
         "composer": "Compositor |||| Compositors",
-        "conductor": "Conductor |||| Conductors",
+        "conductor": "Director |||| Directors",
         "lyricist": "Lletrista |||| Lletristes",
         "arranger": "Arranjador |||| Arranjadors",
         "producer": "Productor |||| Productors",
@@ -127,7 +127,7 @@
         "engineer": "Enginyer |||| Enginyers",
         "mixer": "Mesclador |||| Mescladors",
         "remixer": "Remesclador |||| Remescladors",
-        "djmixer": "DJ Mesclador |||| DJ Mescladors",
+        "djmixer": "Mesclador DJ |||| Mescladors DJ",
         "performer": "Intèrpret |||| Intèrprets",
         "maincredit": "Artista de l'àlbum or Artista |||| Artistes de l'àlbum or Artistes"
       },
@@ -654,7 +654,7 @@
     "links": {
       "homepage": "Inici",
       "source": "Codi font",
-      "featureRequests": "Sol·licitud de funcionalitats",
+      "featureRequests": "Sol·licita funcionalitats",
       "lastInsightsCollection": "Última recolecció d'informació",
       "insights": {
         "disabled": "Desactivada",

resources/i18n/de.json

@@ -48,7 +48,7 @@
         "playNext": "Als nächstes abspielen",
         "info": "Mehr Informationen",
         "showInPlaylist": "In Wiedergabeliste anzeigen",
-        "instantMix": ""
+        "instantMix": "Sofort-Mix"
       }
     },
     "album": {
@@ -588,7 +588,7 @@
     "remove_all_missing_content": "Möchtest du wirklich alle Fehlenden Dateien aus der Datenbank entfernen? Alle Referenzen zu den Dateien wie Anzahl Wiedergaben und Bewertungen werden permanent gelöscht.",
     "noSimilarSongsFound": "Keine ähnlichen Titel gefunden",
     "noTopSongsFound": "Keine beliebten Titel gefunden",
-    "startingInstantMix": ""
+    "startingInstantMix": "Lade Sofort-Mix..."
   },
   "menu": {
     "library": "Bibliothek",

resources/i18n/es.json

@@ -48,7 +48,7 @@
         "playNext": "Siguiente",
         "info": "Obtener información",
         "showInPlaylist": "Mostrar en la lista de reproducción",
-        "instantMix": ""
+        "instantMix": "Mezcla instantánea"
       }
     },
     "album": {
@@ -588,7 +588,7 @@
     "remove_all_missing_content": "¿Realmente desea eliminar todos los archivos faltantes de la base de datos? Esto eliminará permanentemente cualquier referencia a ellos, incluidas sus reproducciones y valoraciones.",
     "noSimilarSongsFound": "No se encontraron canciones similares",
     "noTopSongsFound": "No se encontraron canciones destacadas",
-    "startingInstantMix": ""
+    "startingInstantMix": "Cargando la mezcla instantánea..."
   },
   "menu": {
     "library": "Biblioteca",

resources/i18n/fr.json

@@ -48,7 +48,7 @@
         "playNext": "Jouer ensuite",
         "info": "Plus d'informations",
         "showInPlaylist": "Montrer dans la playlist",
-        "instantMix": ""
+        "instantMix": "Mix instantanné"
       }
     },
     "album": {
@@ -588,7 +588,7 @@
     "remove_all_missing_content": "Êtes-vous sûr(e) de vouloir supprimer tous les fichiers manquants de la base de données ? Cette action est permanente et supprimera leurs nombres d'écoutes,  leur notations et tout ce qui y fait référence.",
     "noSimilarSongsFound": "Aucun titre similaire n'a été trouvé",
     "noTopSongsFound": "Aucun meilleur titre n'a été trouvé",
-    "startingInstantMix": ""
+    "startingInstantMix": "Chargement du mix instantanné..."
   },
   "menu": {
     "library": "Bibliothèque",

resources/i18n/id.json

@@ -36,7 +36,8 @@
         "bitDepth": "Bit depth",
         "sampleRate": "Sample rate",
         "missing": "Hilang",
-        "libraryName": "Pustaka"
+        "libraryName": "Pustaka",
+        "composer": "Komposer"
       },
       "actions": {
         "addToQueue": "Tambah ke antrean",
@@ -46,7 +47,8 @@
         "download": "Unduh",
         "playNext": "Putar Berikutnya",
         "info": "Lihat Info",
-        "showInPlaylist": "Tampilkan di Playlist"
+        "showInPlaylist": "Tampilkan di Playlist",
+        "instantMix": "Mix Instan"
       }
     },
     "album": {
@@ -301,14 +303,19 @@
       "actions": {
         "scan": "Pindai Pustaka",
         "manageUsers": "Kelola Akses Pengguna",
-        "viewDetails": "Lihat Detail"
+        "viewDetails": "Lihat Detail",
+        "quickScan": "Pindai Cepat",
+        "fullScan": "Pindai Keseluruhan"
       },
       "notifications": {
         "created": "Pustaka berhasil dibuat",
         "updated": "Pustaka berhasil dibuat",
         "deleted": "Berhasil menghapus pustaka",
         "scanStarted": "Memindai pustaka dimulai",
-        "scanCompleted": "Memindai pustaka selesai"
+        "scanCompleted": "Memindai pustaka selesai",
+        "quickScanStarted": "Pemindaian cepat dimulai",
+        "fullScanStarted": "Pemindaian keseluruhan dimulai",
+        "scanError": "Kesalahan saat memulai pemindaian. Periksa log"
       },
       "validation": {
         "nameRequired": "Nama pustaka diperlukan",
@@ -323,6 +330,80 @@
         "scanInProgress": "Pemindaian sedang berlangsung...",
         "noLibrariesAssigned": "Tidak ada pustaka yang ditugaskan ke pengguna ini"
       }
+    },
+    "plugin": {
+      "name": "Plugin |||| Plugin",
+      "fields": {
+        "id": "ID",
+        "name": "Nama",
+        "description": "Deskripsi",
+        "version": "Versi",
+        "author": "Pembuat",
+        "website": "Situs Web",
+        "permissions": "Perizinan",
+        "enabled": "Diaktifkan",
+        "status": "Status",
+        "path": "Jalur",
+        "lastError": "Kesalahan",
+        "hasError": "Kesalahan",
+        "updatedAt": "Diperbarui",
+        "createdAt": "Terinstal",
+        "configKey": "Key",
+        "configValue": "Value",
+        "allUsers": "Izinkan semua pengguna",
+        "selectedUsers": "Pengguna yang dipilih",
+        "allLibraries": "Izinkan semua pustaka",
+        "selectedLibraries": "Pustaka dipilih"
+      },
+      "sections": {
+        "status": "Status",
+        "info": "Informasi plugin",
+        "configuration": "Konfigurasi",
+        "manifest": "Manifes",
+        "usersPermission": "Pengguna yang Diizinkan",
+        "libraryPermission": "Pustaka yang Diizinkan"
+      },
+      "status": {
+        "enabled": "Diaktifkan",
+        "disabled": "Dinonaktifkan"
+      },
+      "actions": {
+        "enable": "Aktifkan",
+        "disable": "Nonaktifkan",
+        "disabledDueToError": "Perbaiki kesalahan sebelum diaktifkan",
+        "disabledUsersRequired": "Pilih pengguna sebelum diaktifkan",
+        "disabledLibrariesRequired": "Pilih pustaka sebelum diaktifkan",
+        "addConfig": "Tambahkan Konfigurasi",
+        "rescan": "Pindai ulang"
+      },
+      "notifications": {
+        "enabled": "Plugin diaktifkan",
+        "disabled": "Plugin dinonaktifkan",
+        "updated": "Plugin diperbarui",
+        "error": "Kesalahan saat memperbarui plugin"
+      },
+      "validation": {
+        "invalidJson": "Konfigurasi harus berupa JSON yang valid"
+      },
+      "messages": {
+        "configHelp": "Konfigurasikan plugin menggunakan key-value pairs. Biarkan kosong jika plugin tidak membutuhkan konfigurasi.",
+        "clickPermissions": "Klik perizinan untuk detail",
+        "noConfig": "Konfigurasi tidak diatur",
+        "allUsersHelp": "Ketika diaktifkan, plugin akan mengakses untuk semua pengguna, termasuk  yang akan dibuat di masa depan.",
+        "noUsers": "Tidak ada pengguna yang dipilih",
+        "permissionReason": "Alasan",
+        "usersRequired": "Plugin ini membutuhkan akses ke informasi pengguna. Pilih pengguna yang bisa mengakses plugin, atau aktifkan 'Izinkan semua pengguna'.",
+        "allLibrariesHelp": "Ketika diaktifkan, plugin akan memiliki akses ke semua pustaka, termasuk yang dibuat di masa depan.",
+        "noLibraries": "Tidak ada pustaka yang dipilih",
+        "librariesRequired": "Plugin ini membutuhkan akses ke informasi pustaka. Pilih beberapa pustaka yang bisa diakses, atau aktifkan 'Izinkan semua pustaka'.",
+        "requiredHosts": "Hosts diperlukan",
+        "configValidationError": "Validasi konfigurasi gagal:",
+        "schemaRenderError": "Tidak dapat menampilkan form konfigurasi. Skema plugin mungkin tidak valid."
+      },
+      "placeholders": {
+        "configKey": "key",
+        "configValue": "value"
+      }
     }
   },
   "ra": {
@@ -506,7 +587,8 @@
     "remove_all_missing_title": "Hapus semua file yang hilang",
     "remove_all_missing_content": "Apa kamu yakin ingin menghapus semua file dari database? Ini akan menghapus permanen dan apapun referensi ke mereka, termasuk hitungan pemutaran dan rating mereka.",
     "noSimilarSongsFound": "Tidak ada lagu yang serupa ditemukan",
-    "noTopSongsFound": "Tidak ada lagu teratas ditemukan"
+    "noTopSongsFound": "Tidak ada lagu teratas ditemukan",
+    "startingInstantMix": "Memuat Mix Instan..."
   },
   "menu": {
     "library": "Pustaka",
@@ -604,7 +686,8 @@
     "serverDown": "LURING",
     "scanType": "Tipe",
     "status": "Kesalahan Memindai",
-    "elapsedTime": "Waktu Berakhir"
+    "elapsedTime": "Waktu Berakhir",
+    "selectiveScan": "Selektif"
   },
   "help": {
     "title": "Tombol Pintasan Navidrome",

resources/i18n/pl.json

@@ -48,7 +48,7 @@
         "playNext": "Odtwarzaj Następny",
         "info": "Zdobądź Informacje",
         "showInPlaylist": "Pokaż w Liście Odtwarzania",
-        "instantMix": ""
+        "instantMix": "Natychmiastowy Miks"
       }
     },
     "album": {
@@ -588,7 +588,7 @@
     "remove_all_missing_content": "Czy chcesz usunąć wszystkie brakujące pliki z bazy danych? Spowoduje to trwałe usunięcie wszelkich odniesień do tych plików, takich jak liczba odtworzeń, czy oceny.",
     "noSimilarSongsFound": "Brak podobnych utworów",
     "noTopSongsFound": "Brak najlepszych utworów",
-    "startingInstantMix": ""
+    "startingInstantMix": "Ładowanie Natychmiastowego Miksu..."
   },
   "menu": {
     "library": "Biblioteka",

resources/i18n/zh-Hant.json

@@ -10,6 +10,7 @@
         "playCount": "播放次數",
         "title": "標題",
         "artist": "藝人",
+        "composer": "作曲者",
         "album": "專輯",
         "path": "檔案路徑",
         "libraryName": "媒體庫",
@@ -46,7 +47,8 @@
         "shuffleAll": "全部隨機播放",
         "download": "下載",
         "playNext": "下一首播放",
-        "info": "取得資訊"
+        "info": "取得資訊",
+        "instantMix": "即時混音"
       }
     },
     "album": {
@@ -302,6 +304,8 @@
       },
       "actions": {
         "scan": "掃描媒體庫",
+        "quickScan": "快速掃描",
+        "fullScan": "完整掃描",
         "manageUsers": "管理使用者權限",
         "viewDetails": "查看詳細資料"
       },
@@ -310,6 +314,9 @@
         "updated": "成功更新媒體庫",
         "deleted": "成功刪除媒體庫",
         "scanStarted": "開始掃描媒體庫",
+        "quickScanStarted": "快速掃描已開始",
+        "fullScanStarted": "完整掃描已開始",
+        "scanError": "掃描啟動失敗，請檢查日誌",
         "scanCompleted": "媒體庫掃描完成"
       },
       "validation": {
@@ -325,6 +332,80 @@
         "scanInProgress": "正在掃描...",
         "noLibrariesAssigned": "沒有為該使用者指派任何媒體庫"
       }
+    },
+    "plugin": {
+      "name": "插件 |||| 插件",
+      "fields": {
+        "id": "ID",
+        "name": "名稱",
+        "description": "描述",
+        "version": "版本",
+        "author": "作者",
+        "website": "網站",
+        "permissions": "權限",
+        "enabled": "已啟用",
+        "status": "狀態",
+        "path": "路徑",
+        "lastError": "錯誤",
+        "hasError": "錯誤",
+        "updatedAt": "更新於",
+        "createdAt": "安裝於",
+        "configKey": "鍵",
+        "configValue": "值",
+        "allUsers": "允許所有使用者",
+        "selectedUsers": "選定的使用者",
+        "allLibraries": "允許所有媒體庫",
+        "selectedLibraries": "選定的媒體庫"
+      },
+      "sections": {
+        "status": "狀態",
+        "info": "插件資訊",
+        "configuration": "設定",
+        "manifest": "資訊清單",
+        "usersPermission": "使用者權限",
+        "libraryPermission": "媒體庫權限"
+      },
+      "status": {
+        "enabled": "已啟用",
+        "disabled": "已停用"
+      },
+      "actions": {
+        "enable": "啟用",
+        "disable": "停用",
+        "disabledDueToError": "修復錯誤後才能啟用",
+        "disabledUsersRequired": "啟用前請先選擇使用者",
+        "disabledLibrariesRequired": "啟用前請先選擇媒體庫",
+        "addConfig": "新增設定",
+        "rescan": "重新掃描"
+      },
+      "notifications": {
+        "enabled": "插件已啟用",
+        "disabled": "插件已停用",
+        "updated": "插件已更新",
+        "error": "更新插件時發生錯誤"
+      },
+      "validation": {
+        "invalidJson": "設定必須是有效的 JSON"
+      },
+      "messages": {
+        "configHelp": "使用鍵值對設定插件。若插件無需設定則留空。",
+        "configValidationError": "設定驗證失敗：",
+        "schemaRenderError": "無法顯示設定表單。插件的 schema 可能無效。",
+        "clickPermissions": "點擊權限以查看詳細資訊",
+        "noConfig": "無設定",
+        "allUsersHelp": "啟用後，插件將可存取所有使用者，包含未來建立的使用者。",
+        "noUsers": "未選擇使用者",
+        "permissionReason": "原因",
+        "usersRequired": "此插件需要存取使用者資訊。請選擇插件可存取的使用者，或啟用「允許所有使用者」。",
+        "allLibrariesHelp": "啟用後，插件將可存取所有媒體庫，包含未來建立的媒體庫。",
+        "noLibraries": "未選擇媒體庫",
+        "librariesRequired": "此插件需要存取媒體庫資訊。請選擇插件可存取的媒體庫，或啟用「允許所有媒體庫」。",
+        "requiredHosts": "必要的 Hosts"
+      },
+      "placeholders": {
+        "configKey": "鍵",
+        "configValue": "值"
+      }
     }
   },
   "ra": {
@@ -474,10 +555,11 @@
   },
   "message": {
     "note": "注意",
-    "transcodingDisabled": "出於安全原因，已停用了從 Web 介面更改參數。要更改（編輯或新增）轉碼選項，請在啟用 %{config} 選項的情況下重新啟動伺服器。",
+    "transcodingDisabled": "出於安全原因，已禁用了從 Web 介面更改參數。要更改（編輯或新增）轉碼選項，請在啟用 %{config} 設定選項的情況下重新啟動伺服器。",
     "transcodingEnabled": "Navidrome 目前與 %{config} 一起使用，因此可以透過 Web 介面從轉碼設定中執行系統命令。出於安全考慮，我們建議停用此功能，並僅在設定轉碼選項時啟用。",
     "songsAddedToPlaylist": "已加入一首歌到播放清單 |||| 已新增 %{smart_count} 首歌到播放清單",
     "noSimilarSongsFound": "找不到相似歌曲",
+    "startingInstantMix": "正在載入即時混音...",
     "noTopSongsFound": "找不到熱門歌曲",
     "noPlaylistsAvailable": "沒有可用的播放清單",
     "delete_user_title": "刪除使用者「%{name}」",
@@ -490,12 +572,12 @@
     "notifications_not_available": "此瀏覽器不支援桌面通知，或您並非透過 HTTPS 存取 Navidrome",
     "lastfmLinkSuccess": "已成功連接 Last.fm 並開啟音樂記錄",
     "lastfmLinkFailure": "無法連接 Last.fm",
-    "lastfmUnlinkSuccess": "已取消 Last.fm 的連接並停用音樂記錄",
-    "lastfmUnlinkFailure": "無法取消 Last.fm 的連接",
-    "listenBrainzLinkSuccess": "已成功以 %{user} 身份連接 ListenBrainz 並開啟音樂記錄",
+    "lastfmUnlinkSuccess": "已取消與 Last.fm 的連接並停用音樂記錄",
+    "lastfmUnlinkFailure": "無法取消與 Last.fm 的連接",
+    "listenBrainzLinkSuccess": "已成功以 %{user} 的身份連接 ListenBrainz 並開啟音樂記錄",
     "listenBrainzLinkFailure": "無法連接 ListenBrainz：%{error}",
-    "listenBrainzUnlinkSuccess": "已取消 ListenBrainz 的連接並停用音樂記錄",
-    "listenBrainzUnlinkFailure": "無法取消 ListenBrainz 的連接",
+    "listenBrainzUnlinkSuccess": "已取消與 ListenBrainz 的連接並停用音樂記錄",
+    "listenBrainzUnlinkFailure": "無法取消與 ListenBrainz 的連接",
     "openIn": {
       "lastfm": "在 Last.fm 中開啟",
       "musicbrainz": "在 MusicBrainz 中開啟"
@@ -556,7 +638,7 @@
     "previousTrackText": "上一首",
     "reloadText": "重新載入",
     "volumeText": "音量",
-    "toggleLyricText": "切換歌詞",
+    "toggleLyricText": "歌詞顯示",
     "toggleMiniModeText": "最小化",
     "destroyText": "關閉",
     "downloadText": "下載",
@@ -602,6 +684,7 @@
     "totalScanned": "已掃描的資料夾總數",
     "quickScan": "快速掃描",
     "fullScan": "完全掃描",
+    "selectiveScan": "選擇性掃描",
     "serverUptime": "伺服器運作時間",
     "serverDown": "伺服器已離線",
     "scanType": "掃描類型",

server/subsonic/album_lists_test.go

@@ -27,7 +27,7 @@ var _ = Describe("Album Lists", func() {
 		ds = &tests.MockDataStore{}
 		auth.Init(ds)
 		mockRepo = ds.Album(ctx).(*tests.MockAlbumRepo)
-		router = New(ds, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
+		router = New(ds, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
 		w = httptest.NewRecorder()
 	})
 

server/subsonic/api.go

@@ -31,40 +31,42 @@ type handlerRaw = func(http.ResponseWriter, *http.Request) (*responses.Subsonic,
 
 type Router struct {
 	http.Handler
-	ds        model.DataStore
-	artwork   artwork.Artwork
-	streamer  core.MediaStreamer
-	archiver  core.Archiver
-	players   core.Players
-	provider  external.Provider
-	playlists core.Playlists
-	scanner   model.Scanner
-	broker    events.Broker
-	scrobbler scrobbler.PlayTracker
-	share     core.Share
-	playback  playback.PlaybackServer
-	metrics   metrics.Metrics
+	ds                model.DataStore
+	artwork           artwork.Artwork
+	streamer          core.MediaStreamer
+	archiver          core.Archiver
+	players           core.Players
+	provider          external.Provider
+	playlists         core.Playlists
+	scanner           model.Scanner
+	broker            events.Broker
+	scrobbler         scrobbler.PlayTracker
+	share             core.Share
+	playback          playback.PlaybackServer
+	metrics           metrics.Metrics
+	transcodeDecision core.TranscodeDecision
 }
 
 func New(ds model.DataStore, artwork artwork.Artwork, streamer core.MediaStreamer, archiver core.Archiver,
 	players core.Players, provider external.Provider, scanner model.Scanner, broker events.Broker,
 	playlists core.Playlists, scrobbler scrobbler.PlayTracker, share core.Share, playback playback.PlaybackServer,
-	metrics metrics.Metrics,
+	metrics metrics.Metrics, transcodeDecision core.TranscodeDecision,
 ) *Router {
 	r := &Router{
-		ds:        ds,
-		artwork:   artwork,
-		streamer:  streamer,
-		archiver:  archiver,
-		players:   players,
-		provider:  provider,
-		playlists: playlists,
-		scanner:   scanner,
-		broker:    broker,
-		scrobbler: scrobbler,
-		share:     share,
-		playback:  playback,
-		metrics:   metrics,
+		ds:                ds,
+		artwork:           artwork,
+		streamer:          streamer,
+		archiver:          archiver,
+		players:           players,
+		provider:          provider,
+		playlists:         playlists,
+		scanner:           scanner,
+		broker:            broker,
+		scrobbler:         scrobbler,
+		share:             share,
+		playback:          playback,
+		metrics:           metrics,
+		transcodeDecision: transcodeDecision,
 	}
 	r.Handler = r.routes()
 	return r
@@ -169,6 +171,8 @@ func (api *Router) routes() http.Handler {
 			h(r, "getLyricsBySongId", api.GetLyricsBySongId)
 			hr(r, "stream", api.Stream)
 			hr(r, "download", api.Download)
+			hr(r, "getTranscodeDecision", api.GetTranscodeDecision)
+			hr(r, "getTranscodeStream", api.GetTranscodeStream)
 		})
 		r.Group(func(r chi.Router) {
 			// configure request throttling

server/subsonic/media_annotation_test.go

@@ -27,7 +27,7 @@ var _ = Describe("MediaAnnotationController", func() {
 		ds = &tests.MockDataStore{}
 		playTracker = &fakePlayTracker{}
 		eventBroker = &fakeEventBroker{}
-		router = New(ds, nil, nil, nil, nil, nil, nil, eventBroker, nil, playTracker, nil, nil, nil)
+		router = New(ds, nil, nil, nil, nil, nil, nil, eventBroker, nil, playTracker, nil, nil, nil, nil)
 	})
 
 	Describe("Scrobble", func() {

server/subsonic/media_retrieval_test.go

@@ -33,7 +33,7 @@ var _ = Describe("MediaRetrievalController", func() {
 			MockedMediaFile: mockRepo,
 		}
 		artwork = &fakeArtwork{data: "image data"}
-		router = New(ds, artwork, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
+		router = New(ds, artwork, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
 		w = httptest.NewRecorder()
 		DeferCleanup(configtest.SetupConfig())
 		conf.Server.LyricsPriority = "embedded,.lrc"

server/subsonic/opensubsonic.go

@@ -13,6 +13,7 @@ func (api *Router) GetOpenSubsonicExtensions(_ *http.Request) (*responses.Subson
 		{Name: "formPost", Versions: []int32{1}},
 		{Name: "songLyrics", Versions: []int32{1}},
 		{Name: "indexBasedQueue", Versions: []int32{1}},
+		{Name: "transcoding", Versions: []int32{1}},
 	}
 	return response, nil
 }

server/subsonic/opensubsonic_test.go

@@ -19,7 +19,7 @@ var _ = Describe("GetOpenSubsonicExtensions", func() {
 	)
 
 	BeforeEach(func() {
-		router = subsonic.New(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
+		router = subsonic.New(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
 		w = httptest.NewRecorder()
 		r = httptest.NewRequest("GET", "/getOpenSubsonicExtensions?f=json", nil)
 	})
@@ -35,11 +35,12 @@ var _ = Describe("GetOpenSubsonicExtensions", func() {
 		err := json.Unmarshal(w.Body.Bytes(), &response)
 		Expect(err).NotTo(HaveOccurred())
 		Expect(*response.Subsonic.OpenSubsonicExtensions).To(SatisfyAll(
-			HaveLen(4),
+			HaveLen(5),
 			ContainElement(responses.OpenSubsonicExtension{Name: "transcodeOffset", Versions: []int32{1}}),
 			ContainElement(responses.OpenSubsonicExtension{Name: "formPost", Versions: []int32{1}}),
 			ContainElement(responses.OpenSubsonicExtension{Name: "songLyrics", Versions: []int32{1}}),
 			ContainElement(responses.OpenSubsonicExtension{Name: "indexBasedQueue", Versions: []int32{1}}),
+			ContainElement(responses.OpenSubsonicExtension{Name: "transcoding", Versions: []int32{1}}),
 		))
 	})
 })

server/subsonic/playlists_test.go

@@ -23,7 +23,7 @@ var _ = Describe("buildPlaylist", func() {
 
 	BeforeEach(func() {
 		ds = &tests.MockDataStore{}
-		router = New(ds, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
+		router = New(ds, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
 		ctx = context.Background()
 
 		createdAt := time.Date(2023, 1, 15, 10, 30, 0, 0, time.UTC)
@@ -125,7 +125,7 @@ var _ = Describe("UpdatePlaylist", func() {
 	BeforeEach(func() {
 		ds = &tests.MockDataStore{}
 		playlists = &fakePlaylists{}
-		router = New(ds, nil, nil, nil, nil, nil, nil, nil, playlists, nil, nil, nil, nil)
+		router = New(ds, nil, nil, nil, nil, nil, nil, nil, playlists, nil, nil, nil, nil, nil)
 	})
 
 	It("clears the comment when parameter is empty", func() {

server/subsonic/responses/responses.go

@@ -61,6 +61,7 @@ type Subsonic struct {
 	OpenSubsonicExtensions *OpenSubsonicExtensions `xml:"openSubsonicExtensions,omitempty"  json:"openSubsonicExtensions,omitempty"`
 	LyricsList             *LyricsList             `xml:"lyricsList,omitempty"              json:"lyricsList,omitempty"`
 	PlayQueueByIndex       *PlayQueueByIndex       `xml:"playQueueByIndex,omitempty" json:"playQueueByIndex,omitempty"`
+	TranscodeDecision      *TranscodeDecision      `xml:"transcodeDecision,omitempty"       json:"transcodeDecision,omitempty"`
 }
 
 const (
@@ -611,3 +612,26 @@ func marshalJSONArray[T any](v []T) ([]byte, error) {
 	}
 	return json.Marshal(v)
 }
+
+// TranscodeDecision represents the response for getTranscodeDecision (OpenSubsonic transcoding extension)
+type TranscodeDecision struct {
+	CanDirectPlay    bool           `xml:"canDirectPlay,attr"               json:"canDirectPlay"`
+	CanTranscode     bool           `xml:"canTranscode,attr"                json:"canTranscode"`
+	TranscodeReasons []string       `xml:"transcodeReason,omitempty"        json:"transcodeReason,omitempty"`
+	ErrorReason      string         `xml:"errorReason,attr,omitempty"       json:"errorReason,omitempty"`
+	TranscodeParams  string         `xml:"transcodeParams,attr,omitempty"   json:"transcodeParams,omitempty"`
+	SourceStream     *StreamDetails `xml:"sourceStream,omitempty"           json:"sourceStream,omitempty"`
+	TranscodeStream  *StreamDetails `xml:"transcodeStream,omitempty"        json:"transcodeStream,omitempty"`
+}
+
+// StreamDetails describes audio stream properties for transcoding decisions
+type StreamDetails struct {
+	Protocol        string `xml:"protocol,attr,omitempty"        json:"protocol,omitempty"`
+	Container       string `xml:"container,attr,omitempty"       json:"container,omitempty"`
+	Codec           string `xml:"codec,attr,omitempty"           json:"codec,omitempty"`
+	AudioChannels   int32  `xml:"audioChannels,attr,omitempty"   json:"audioChannels,omitempty"`
+	AudioBitrate    int32  `xml:"audioBitrate,attr,omitempty"     json:"audioBitrate,omitempty"`
+	AudioProfile    string `xml:"audioProfile,attr,omitempty"    json:"audioProfile,omitempty"`
+	AudioSamplerate int32  `xml:"audioSamplerate,attr,omitempty" json:"audioSamplerate,omitempty"`
+	AudioBitdepth   int32  `xml:"audioBitdepth,attr,omitempty"   json:"audioBitdepth,omitempty"`
+}

server/subsonic/searching_test.go

@@ -21,7 +21,7 @@ var _ = Describe("Search", func() {
 		ds = &tests.MockDataStore{}
 		auth.Init(ds)
 
-		router = New(ds, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
+		router = New(ds, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
 
 		// Get references to the mock repositories so we can inspect their Options
 		mockAlbumRepo = ds.Album(nil).(*tests.MockAlbumRepo)

server/subsonic/transcode.go

@@ -0,0 +1,349 @@
+package subsonic
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"github.com/navidrome/navidrome/core"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/server/subsonic/responses"
+	"github.com/navidrome/navidrome/utils/req"
+)
+
+// API-layer request structs for JSON unmarshaling (decoupled from core structs)
+
+// clientInfoRequest represents client playback capabilities from the request body
+type clientInfoRequest struct {
+	Name                       string                  `json:"name,omitempty"`
+	Platform                   string                  `json:"platform,omitempty"`
+	MaxAudioBitrate            int                     `json:"maxAudioBitrate,omitempty"`
+	MaxTranscodingAudioBitrate int                     `json:"maxTranscodingAudioBitrate,omitempty"`
+	DirectPlayProfiles         []directPlayProfileReq  `json:"directPlayProfiles,omitempty"`
+	TranscodingProfiles        []transcodingProfileReq `json:"transcodingProfiles,omitempty"`
+	CodecProfiles              []codecProfileReq       `json:"codecProfiles,omitempty"`
+}
+
+// directPlayProfileReq describes a format the client can play directly
+type directPlayProfileReq struct {
+	Containers       []string `json:"containers,omitempty"`
+	AudioCodecs      []string `json:"audioCodecs,omitempty"`
+	Protocols        []string `json:"protocols,omitempty"`
+	MaxAudioChannels int      `json:"maxAudioChannels,omitempty"`
+}
+
+// transcodingProfileReq describes a transcoding target the client supports
+type transcodingProfileReq struct {
+	Container        string `json:"container,omitempty"`
+	AudioCodec       string `json:"audioCodec,omitempty"`
+	Protocol         string `json:"protocol,omitempty"`
+	MaxAudioChannels int    `json:"maxAudioChannels,omitempty"`
+}
+
+// codecProfileReq describes codec-specific limitations
+type codecProfileReq struct {
+	Type        string          `json:"type,omitempty"`
+	Name        string          `json:"name,omitempty"`
+	Limitations []limitationReq `json:"limitations,omitempty"`
+}
+
+// limitationReq describes a specific codec limitation
+type limitationReq struct {
+	Name       string   `json:"name,omitempty"`
+	Comparison string   `json:"comparison,omitempty"`
+	Values     []string `json:"values,omitempty"`
+	Required   bool     `json:"required,omitempty"`
+}
+
+// toCoreClientInfo converts the API request struct to the core.ClientInfo struct.
+// The OpenSubsonic spec uses bps for bitrate values; core uses kbps.
+func (r *clientInfoRequest) toCoreClientInfo() *core.ClientInfo {
+	ci := &core.ClientInfo{
+		Name:                       r.Name,
+		Platform:                   r.Platform,
+		MaxAudioBitrate:            bpsToKbps(r.MaxAudioBitrate),
+		MaxTranscodingAudioBitrate: bpsToKbps(r.MaxTranscodingAudioBitrate),
+	}
+
+	for _, dp := range r.DirectPlayProfiles {
+		ci.DirectPlayProfiles = append(ci.DirectPlayProfiles, core.DirectPlayProfile{
+			Containers:       dp.Containers,
+			AudioCodecs:      dp.AudioCodecs,
+			Protocols:        dp.Protocols,
+			MaxAudioChannels: dp.MaxAudioChannels,
+		})
+	}
+
+	for _, tp := range r.TranscodingProfiles {
+		ci.TranscodingProfiles = append(ci.TranscodingProfiles, core.TranscodingProfile{
+			Container:        tp.Container,
+			AudioCodec:       tp.AudioCodec,
+			Protocol:         tp.Protocol,
+			MaxAudioChannels: tp.MaxAudioChannels,
+		})
+	}
+
+	for _, cp := range r.CodecProfiles {
+		coreCP := core.CodecProfile{
+			Type: cp.Type,
+			Name: cp.Name,
+		}
+		for _, lim := range cp.Limitations {
+			coreLim := core.Limitation{
+				Name:       lim.Name,
+				Comparison: lim.Comparison,
+				Values:     lim.Values,
+				Required:   lim.Required,
+			}
+			// Convert audioBitrate limitation values from bps to kbps
+			if lim.Name == core.LimitationAudioBitrate {
+				coreLim.Values = convertBitrateValues(lim.Values)
+			}
+			coreCP.Limitations = append(coreCP.Limitations, coreLim)
+		}
+		ci.CodecProfiles = append(ci.CodecProfiles, coreCP)
+	}
+
+	return ci
+}
+
+// bpsToKbps converts bits per second to kilobits per second.
+func bpsToKbps(bps int) int {
+	return bps / 1000
+}
+
+// kbpsToBps converts kilobits per second to bits per second.
+func kbpsToBps(kbps int) int {
+	return kbps * 1000
+}
+
+// convertBitrateValues converts a slice of bps string values to kbps string values.
+func convertBitrateValues(bpsValues []string) []string {
+	result := make([]string, len(bpsValues))
+	for i, v := range bpsValues {
+		n, err := strconv.Atoi(v)
+		if err == nil {
+			result[i] = strconv.Itoa(n / 1000)
+		} else {
+			result[i] = v // preserve unparseable values as-is
+		}
+	}
+	return result
+}
+
+// validate checks that all enum fields in the request contain valid values per the OpenSubsonic spec.
+func (r *clientInfoRequest) validate() error {
+	for _, dp := range r.DirectPlayProfiles {
+		for _, p := range dp.Protocols {
+			if !isValidProtocol(p) {
+				return fmt.Errorf("invalid protocol: %s", p)
+			}
+		}
+	}
+	for _, tp := range r.TranscodingProfiles {
+		if tp.Protocol != "" && !isValidProtocol(tp.Protocol) {
+			return fmt.Errorf("invalid protocol: %s", tp.Protocol)
+		}
+	}
+	for _, cp := range r.CodecProfiles {
+		if !isValidCodecProfileType(cp.Type) {
+			return fmt.Errorf("invalid codec profile type: %s", cp.Type)
+		}
+		for _, lim := range cp.Limitations {
+			if !isValidLimitationName(lim.Name) {
+				return fmt.Errorf("invalid limitation name: %s", lim.Name)
+			}
+			if !isValidComparison(lim.Comparison) {
+				return fmt.Errorf("invalid comparison: %s", lim.Comparison)
+			}
+		}
+	}
+	return nil
+}
+
+func isValidProtocol(p string) bool {
+	return p == core.ProtocolHTTP || p == core.ProtocolHLS
+}
+
+func isValidCodecProfileType(t string) bool {
+	return t == core.CodecProfileTypeAudio
+}
+
+func isValidLimitationName(n string) bool {
+	return n == core.LimitationAudioChannels ||
+		n == core.LimitationAudioBitrate ||
+		n == core.LimitationAudioProfile ||
+		n == core.LimitationAudioSamplerate ||
+		n == core.LimitationAudioBitdepth
+}
+
+func isValidComparison(c string) bool {
+	return c == core.ComparisonEquals ||
+		c == core.ComparisonNotEquals ||
+		c == core.ComparisonLessThanEqual ||
+		c == core.ComparisonGreaterThanEqual
+}
+
+// GetTranscodeDecision handles the OpenSubsonic getTranscodeDecision endpoint.
+// It receives client capabilities and returns a decision on whether to direct play or transcode.
+func (api *Router) GetTranscodeDecision(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
+	if r.Method != http.MethodPost {
+		w.Header().Set("Allow", "POST")
+		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
+		return nil, nil
+	}
+
+	ctx := r.Context()
+	p := req.Params(r)
+
+	mediaID, err := p.String("mediaId")
+	if err != nil {
+		return nil, newError(responses.ErrorMissingParameter, "missing required parameter: mediaId")
+	}
+
+	mediaType, err := p.String("mediaType")
+	if err != nil {
+		return nil, newError(responses.ErrorMissingParameter, "missing required parameter: mediaType")
+	}
+
+	// Only support songs for now
+	if mediaType != "song" {
+		return nil, newError(responses.ErrorGeneric, "mediaType '%s' is not yet supported", mediaType)
+	}
+
+	// Parse and validate ClientInfo from request body (required per OpenSubsonic spec)
+	var clientInfoReq clientInfoRequest
+	if r.Body == nil {
+		return nil, newError(responses.ErrorMissingParameter, "missing required JSON request body")
+	}
+	if err := json.NewDecoder(r.Body).Decode(&clientInfoReq); err != nil {
+		return nil, newError(responses.ErrorGeneric, "invalid JSON request body")
+	}
+	if err := clientInfoReq.validate(); err != nil {
+		return nil, newError(responses.ErrorGeneric, "%v", err)
+	}
+	clientInfo := clientInfoReq.toCoreClientInfo()
+
+	// Get media file
+	mf, err := api.ds.MediaFile(ctx).Get(mediaID)
+	if err != nil {
+		return nil, newError(responses.ErrorDataNotFound, "media file not found: %s", mediaID)
+	}
+
+	// Make the decision
+	decision, err := api.transcodeDecision.MakeDecision(ctx, mf, clientInfo)
+	if err != nil {
+		return nil, newError(responses.ErrorGeneric, "failed to make transcode decision: %v", err)
+	}
+
+	// Create transcode params token
+	transcodeParams, err := api.transcodeDecision.CreateTranscodeParams(decision)
+	if err != nil {
+		return nil, newError(responses.ErrorGeneric, "failed to create transcode token: %v", err)
+	}
+
+	// Build response (convert kbps from core to bps for the API)
+	response := newResponse()
+	response.TranscodeDecision = &responses.TranscodeDecision{
+		CanDirectPlay:    decision.CanDirectPlay,
+		CanTranscode:     decision.CanTranscode,
+		TranscodeReasons: decision.TranscodeReasons,
+		ErrorReason:      decision.ErrorReason,
+		TranscodeParams:  transcodeParams,
+		SourceStream: &responses.StreamDetails{
+			Protocol:        "http",
+			Container:       decision.SourceStream.Container,
+			Codec:           decision.SourceStream.Codec,
+			AudioBitrate:    int32(kbpsToBps(decision.SourceStream.Bitrate)),
+			AudioProfile:    decision.SourceStream.Profile,
+			AudioSamplerate: int32(decision.SourceStream.SampleRate),
+			AudioBitdepth:   int32(decision.SourceStream.BitDepth),
+			AudioChannels:   int32(decision.SourceStream.Channels),
+		},
+	}
+
+	if decision.TranscodeStream != nil {
+		response.TranscodeDecision.TranscodeStream = &responses.StreamDetails{
+			Protocol:        "http",
+			Container:       decision.TranscodeStream.Container,
+			Codec:           decision.TranscodeStream.Codec,
+			AudioBitrate:    int32(kbpsToBps(decision.TranscodeStream.Bitrate)),
+			AudioProfile:    decision.TranscodeStream.Profile,
+			AudioSamplerate: int32(decision.TranscodeStream.SampleRate),
+			AudioBitdepth:   int32(decision.TranscodeStream.BitDepth),
+			AudioChannels:   int32(decision.TranscodeStream.Channels),
+		}
+	}
+
+	return response, nil
+}
+
+// GetTranscodeStream handles the OpenSubsonic getTranscodeStream endpoint.
+// It streams media using the decision encoded in the transcodeParams JWT token.
+func (api *Router) GetTranscodeStream(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
+	ctx := r.Context()
+	p := req.Params(r)
+
+	mediaID, err := p.String("mediaId")
+	if err != nil {
+		return nil, newError(responses.ErrorMissingParameter, "missing required parameter: mediaId")
+	}
+
+	mediaType, err := p.String("mediaType")
+	if err != nil {
+		return nil, newError(responses.ErrorMissingParameter, "missing required parameter: mediaType")
+	}
+
+	transcodeParams, err := p.String("transcodeParams")
+	if err != nil {
+		return nil, newError(responses.ErrorMissingParameter, "missing required parameter: transcodeParams")
+	}
+
+	// Only support songs for now
+	if mediaType != "song" {
+		return nil, newError(responses.ErrorGeneric, "mediaType '%s' is not yet supported", mediaType)
+	}
+
+	// Parse and validate the token
+	params, err := api.transcodeDecision.ParseTranscodeParams(transcodeParams)
+	if err != nil {
+		log.Warn(ctx, "Failed to parse transcode token", err)
+		return nil, newError(responses.ErrorDataNotFound, "invalid or expired transcodeParams token")
+	}
+
+	// Verify mediaId matches token
+	if params.MediaID != mediaID {
+		return nil, newError(responses.ErrorDataNotFound, "mediaId does not match token")
+	}
+
+	// Determine streaming parameters
+	format := ""
+	maxBitRate := 0
+	if !params.DirectPlay && params.TargetFormat != "" {
+		format = params.TargetFormat
+		maxBitRate = params.TargetBitrate // Already in kbps, matching the streamer
+	}
+
+	// Get offset parameter
+	offset := p.IntOr("offset", 0)
+
+	// Create stream
+	stream, err := api.streamer.NewStream(ctx, mediaID, format, maxBitRate, offset)
+	if err != nil {
+		return nil, err
+	}
+
+	// Make sure the stream will be closed at the end
+	defer func() {
+		if err := stream.Close(); err != nil && log.IsGreaterOrEqualTo(log.LevelDebug) {
+			log.Error("Error closing stream", "id", mediaID, "file", stream.Name(), err)
+		}
+	}()
+
+	w.Header().Set("X-Content-Type-Options", "nosniff")
+
+	api.serveStream(ctx, w, r, stream, mediaID)
+
+	return nil, nil
+}

server/subsonic/transcode_test.go

@@ -0,0 +1,268 @@
+package subsonic
+
+import (
+	"bytes"
+	"context"
+	"net/http"
+	"net/http/httptest"
+
+	"github.com/navidrome/navidrome/core"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Transcode endpoints", func() {
+	var (
+		router     *Router
+		ds         *tests.MockDataStore
+		mockTD     *mockTranscodeDecision
+		w          *httptest.ResponseRecorder
+		mockMFRepo *tests.MockMediaFileRepo
+	)
+
+	BeforeEach(func() {
+		mockMFRepo = &tests.MockMediaFileRepo{}
+		ds = &tests.MockDataStore{MockedMediaFile: mockMFRepo}
+		mockTD = &mockTranscodeDecision{}
+		router = New(ds, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, mockTD)
+		w = httptest.NewRecorder()
+	})
+
+	Describe("GetTranscodeDecision", func() {
+		It("returns 405 for non-POST requests", func() {
+			r := newGetRequest("mediaId=123", "mediaType=song")
+			resp, err := router.GetTranscodeDecision(w, r)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(resp).To(BeNil())
+			Expect(w.Code).To(Equal(http.StatusMethodNotAllowed))
+			Expect(w.Header().Get("Allow")).To(Equal("POST"))
+		})
+
+		It("returns error when mediaId is missing", func() {
+			r := newJSONPostRequest("mediaType=song", "{}")
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("returns error when mediaType is missing", func() {
+			r := newJSONPostRequest("mediaId=123", "{}")
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("returns error for unsupported mediaType", func() {
+			r := newJSONPostRequest("mediaId=123&mediaType=podcast", "{}")
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("not yet supported"))
+		})
+
+		It("returns error when media file not found", func() {
+			mockMFRepo.SetError(true)
+			r := newJSONPostRequest("mediaId=notfound&mediaType=song", "{}")
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("returns error when body is empty", func() {
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", "")
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("returns error when body contains invalid JSON", func() {
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", "not-json{{{")
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("returns error for invalid protocol in direct play profile", func() {
+			body := `{"directPlayProfiles":[{"containers":["mp3"],"audioCodecs":["mp3"],"protocols":["ftp"]}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid protocol"))
+		})
+
+		It("returns error for invalid comparison operator", func() {
+			body := `{"codecProfiles":[{"type":"AudioCodec","name":"mp3","limitations":[{"name":"audioBitrate","comparison":"InvalidOp","values":["320"]}]}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid comparison"))
+		})
+
+		It("returns error for invalid limitation name", func() {
+			body := `{"codecProfiles":[{"type":"AudioCodec","name":"mp3","limitations":[{"name":"unknownField","comparison":"Equals","values":["320"]}]}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid limitation name"))
+		})
+
+		It("returns error for invalid codec profile type", func() {
+			body := `{"codecProfiles":[{"type":"VideoCodec","name":"mp3"}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid codec profile type"))
+		})
+
+		It("rejects wrong-case protocol", func() {
+			body := `{"directPlayProfiles":[{"containers":["mp3"],"audioCodecs":["mp3"],"protocols":["HTTP"]}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid protocol"))
+		})
+
+		It("rejects wrong-case codec profile type", func() {
+			body := `{"codecProfiles":[{"type":"audiocodec","name":"mp3"}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid codec profile type"))
+		})
+
+		It("rejects wrong-case comparison operator", func() {
+			body := `{"codecProfiles":[{"type":"AudioCodec","name":"mp3","limitations":[{"name":"audioBitrate","comparison":"lessthanequal","values":["320"]}]}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid comparison"))
+		})
+
+		It("rejects wrong-case limitation name", func() {
+			body := `{"codecProfiles":[{"type":"AudioCodec","name":"mp3","limitations":[{"name":"AudioBitrate","comparison":"Equals","values":["320"]}]}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid limitation name"))
+		})
+
+		It("returns a valid decision response", func() {
+			mockMFRepo.SetData(model.MediaFiles{
+				{ID: "song-1", Suffix: "mp3", Codec: "MP3", BitRate: 320, Channels: 2, SampleRate: 44100},
+			})
+			mockTD.decision = &core.Decision{
+				MediaID:       "song-1",
+				CanDirectPlay: true,
+				SourceStream: core.StreamDetails{
+					Container: "mp3", Codec: "mp3", Bitrate: 320,
+					SampleRate: 44100, Channels: 2,
+				},
+			}
+			mockTD.token = "test-jwt-token"
+
+			body := `{"directPlayProfiles":[{"containers":["mp3"],"protocols":["http"]}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			resp, err := router.GetTranscodeDecision(w, r)
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(resp.TranscodeDecision).ToNot(BeNil())
+			Expect(resp.TranscodeDecision.CanDirectPlay).To(BeTrue())
+			Expect(resp.TranscodeDecision.TranscodeParams).To(Equal("test-jwt-token"))
+			Expect(resp.TranscodeDecision.SourceStream).ToNot(BeNil())
+			Expect(resp.TranscodeDecision.SourceStream.Protocol).To(Equal("http"))
+			Expect(resp.TranscodeDecision.SourceStream.Container).To(Equal("mp3"))
+			Expect(resp.TranscodeDecision.SourceStream.AudioBitrate).To(Equal(int32(320_000)))
+		})
+
+		It("includes transcode stream when transcoding", func() {
+			mockMFRepo.SetData(model.MediaFiles{
+				{ID: "song-2", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 96000, BitDepth: 24},
+			})
+			mockTD.decision = &core.Decision{
+				MediaID:          "song-2",
+				CanDirectPlay:    false,
+				CanTranscode:     true,
+				TargetFormat:     "mp3",
+				TargetBitrate:    256,
+				TranscodeReasons: []string{"container not supported"},
+				SourceStream: core.StreamDetails{
+					Container: "flac", Codec: "flac", Bitrate: 1000,
+					SampleRate: 96000, BitDepth: 24, Channels: 2,
+				},
+				TranscodeStream: &core.StreamDetails{
+					Container: "mp3", Codec: "mp3", Bitrate: 256,
+					SampleRate: 96000, Channels: 2,
+				},
+			}
+			mockTD.token = "transcode-token"
+
+			r := newJSONPostRequest("mediaId=song-2&mediaType=song", "{}")
+			resp, err := router.GetTranscodeDecision(w, r)
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(resp.TranscodeDecision.CanTranscode).To(BeTrue())
+			Expect(resp.TranscodeDecision.TranscodeReasons).To(ConsistOf("container not supported"))
+			Expect(resp.TranscodeDecision.TranscodeStream).ToNot(BeNil())
+			Expect(resp.TranscodeDecision.TranscodeStream.Container).To(Equal("mp3"))
+		})
+	})
+
+	Describe("GetTranscodeStream", func() {
+		It("returns error when mediaId is missing", func() {
+			r := newGetRequest("mediaType=song", "transcodeParams=abc")
+			_, err := router.GetTranscodeStream(w, r)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("returns error when transcodeParams is missing", func() {
+			r := newGetRequest("mediaId=123", "mediaType=song")
+			_, err := router.GetTranscodeStream(w, r)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("returns error for invalid token", func() {
+			mockTD.parseErr = model.ErrNotFound
+			r := newGetRequest("mediaId=123", "mediaType=song", "transcodeParams=bad-token")
+			_, err := router.GetTranscodeStream(w, r)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("returns error when mediaId doesn't match token", func() {
+			mockTD.params = &core.TranscodeParams{MediaID: "other-id", DirectPlay: true}
+			r := newGetRequest("mediaId=wrong-id", "mediaType=song", "transcodeParams=valid-token")
+			_, err := router.GetTranscodeStream(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("does not match"))
+		})
+	})
+})
+
+// newJSONPostRequest creates an HTTP POST request with JSON body and query params
+func newJSONPostRequest(queryParams string, jsonBody string) *http.Request {
+	r := httptest.NewRequest("POST", "/getTranscodeDecision?"+queryParams, bytes.NewBufferString(jsonBody))
+	r.Header.Set("Content-Type", "application/json")
+	return r
+}
+
+// mockTranscodeDecision is a test double for core.TranscodeDecision
+type mockTranscodeDecision struct {
+	decision *core.Decision
+	token    string
+	tokenErr error
+	params   *core.TranscodeParams
+	parseErr error
+}
+
+func (m *mockTranscodeDecision) MakeDecision(_ context.Context, _ *model.MediaFile, _ *core.ClientInfo) (*core.Decision, error) {
+	if m.decision != nil {
+		return m.decision, nil
+	}
+	return &core.Decision{}, nil
+}
+
+func (m *mockTranscodeDecision) CreateTranscodeParams(_ *core.Decision) (string, error) {
+	return m.token, m.tokenErr
+}
+
+func (m *mockTranscodeDecision) ParseTranscodeParams(_ string) (*core.TranscodeParams, error) {
+	if m.parseErr != nil {
+		return nil, m.parseErr
+	}
+	return m.params, nil
+}

ui/package-lock.json

@@ -18,6 +18,7 @@
         "clsx": "^2.1.1",
         "connected-react-router": "^6.9.3",
         "deepmerge": "^4.3.1",
+        "dompurify": "^3.3.1",
         "history": "^4.10.1",
         "inflection": "^3.0.2",
         "jwt-decode": "^4.0.0",
@@ -2394,9 +2395,9 @@
       }
     },
     "node_modules/@isaacs/brace-expansion": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/@isaacs/brace-expansion/-/brace-expansion-5.0.0.tgz",
-      "integrity": "sha512-ZT55BDLV0yv0RBm2czMiZ+SqCGO7AvmOM3G/w2xhVPH+te0aKgFjmBvGlL1dH+ql2tgGO3MVrbb3jCKyvpgnxA==",
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/@isaacs/brace-expansion/-/brace-expansion-5.0.1.tgz",
+      "integrity": "sha512-WMz71T1JS624nWj2n2fnYAuPovhv7EUhk69R6i9dsVyzxt5eM3bjwvgk9L+APE1TRscGysAVMANkB0jh0LQZrQ==",
       "license": "MIT",
       "dependencies": {
         "@isaacs/balanced-match": "^4.0.1"
@@ -5502,10 +5503,13 @@
       "license": "MIT"
     },
     "node_modules/dompurify": {
-      "version": "2.5.8",
-      "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-2.5.8.tgz",
-      "integrity": "sha512-o1vSNgrmYMQObbSSvF/1brBYEQPHhV1+gsmrusO7/GXtp1T9rCS8cXFqVxK/9crT1jA6Ccv+5MTSjBNqr7Sovw==",
-      "license": "(MPL-2.0 OR Apache-2.0)"
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.3.1.tgz",
+      "integrity": "sha512-qkdCKzLNtrgPFP1Vo+98FRzJnBRGe4ffyCea9IwHB1fyxPOeNTHpLKYGd4Uk9xvNoH0ZoOjwZxNptyMwqrId1Q==",
+      "license": "(MPL-2.0 OR Apache-2.0)",
+      "optionalDependencies": {
+        "@types/trusted-types": "^2.0.7"
+      }
     },
     "node_modules/dot-prop": {
       "version": "9.0.0",
@@ -8379,9 +8383,9 @@
       }
     },
     "node_modules/lodash": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
-      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
+      "version": "4.17.23",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.23.tgz",
+      "integrity": "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==",
       "license": "MIT"
     },
     "node_modules/lodash.debounce": {
@@ -9677,6 +9681,12 @@
       "integrity": "sha512-JR/iSQOSt+LQIWwrwEzJ9uk0xfN3mTVYMwt1Ir5mUcSN6pU+V4zQFFaJsclJbPuAUQH+yfWef6tm7l1quW3C8Q==",
       "license": "MIT"
     },
+    "node_modules/ra-ui-materialui/node_modules/dompurify": {
+      "version": "2.5.8",
+      "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-2.5.8.tgz",
+      "integrity": "sha512-o1vSNgrmYMQObbSSvF/1brBYEQPHhV1+gsmrusO7/GXtp1T9rCS8cXFqVxK/9crT1jA6Ccv+5MTSjBNqr7Sovw==",
+      "license": "(MPL-2.0 OR Apache-2.0)"
+    },
     "node_modules/ra-ui-materialui/node_modules/inflection": {
       "version": "1.13.4",
       "resolved": "https://registry.npmjs.org/inflection/-/inflection-1.13.4.tgz",

ui/package.json

@@ -27,6 +27,7 @@
     "clsx": "^2.1.1",
     "connected-react-router": "^6.9.3",
     "deepmerge": "^4.3.1",
+    "dompurify": "^3.3.1",
     "history": "^4.10.1",
     "inflection": "^3.0.2",
     "jwt-decode": "^4.0.0",

ui/src/album/AlbumDetails.jsx

@@ -33,6 +33,7 @@ import {
 import config from '../config'
 import { formatFullDate, intersperse } from '../utils'
 import AlbumExternalLinks from './AlbumExternalLinks'
+import { SafeHTML } from '../common/SafeHTML'
 
 const useStyles = makeStyles(
   (theme) => ({
@@ -225,8 +226,7 @@ const AlbumDetails = (props) => {
   const [imageLoading, setImageLoading] = useState(false)
   const [imageError, setImageError] = useState(false)
 
-  let notes =
-    albumInfo?.notes?.replace(new RegExp('<.*>', 'g'), '') || record.notes
+  let notes = albumInfo?.notes || record.notes
 
   if (notes) {
     notes += '..'
@@ -351,7 +351,9 @@ const AlbumDetails = (props) => {
                   variant={'body1'}
                   onClick={() => setExpanded(!expanded)}
                 >
-                  <span dangerouslySetInnerHTML={{ __html: notes }} />
+                  <span>
+                    <SafeHTML>{notes}</SafeHTML>
+                  </span>
                 </Typography>
               </Collapse>
             )}
@@ -371,7 +373,9 @@ const AlbumDetails = (props) => {
               variant={'body1'}
               onClick={() => setExpanded(!expanded)}
             >
-              <span dangerouslySetInnerHTML={{ __html: notes }} />
+              <span>
+                <SafeHTML>{notes}</SafeHTML>
+              </span>
             </Typography>
           </Collapse>
         </div>

ui/src/artist/ArtistExternalLink.jsx

@@ -4,7 +4,7 @@ import { IconButton, Tooltip, Link } from '@material-ui/core'
 
 import { ImLastfm2 } from 'react-icons/im'
 import MusicBrainz from '../icons/MusicBrainz'
-import { intersperse } from '../utils'
+import { intersperse, isLastFmURL } from '../utils'
 import config from '../config'
 import { makeStyles } from '@material-ui/core/styles'
 
@@ -38,13 +38,13 @@ const ArtistExternalLinks = ({ artistInfo, record }) => {
   }
 
   if (config.lastFMEnabled) {
-    if (lastFMlink) {
+    if (lastFMlink && isLastFmURL(lastFMlink[2])) {
       addLink(
         lastFMlink[2],
         'message.openIn.lastfm',
         <ImLastfm2 className="lastfm-icon" />,
       )
-    } else if (artistInfo?.lastFmUrl) {
+    } else if (isLastFmURL(artistInfo?.lastFmUrl)) {
       addLink(
         artistInfo?.lastFmUrl,
         'message.openIn.lastfm',

ui/src/artist/ArtistShow.jsx

@@ -1,4 +1,4 @@
-import React, { useState, createElement, useEffect } from 'react'
+import { useState, useEffect } from 'react'
 import { useMediaQuery, withWidth } from '@material-ui/core'
 import {
   useShowController,
@@ -53,9 +53,7 @@ const ArtistDetails = (props) => {
   const isDesktop = useMediaQuery((theme) => theme.breakpoints.up('sm'))
   const [artistInfo, setArtistInfo] = useState()
 
-  const biography =
-    artistInfo?.biography?.replace(new RegExp('<.*>', 'g'), '') ||
-    record.biography
+  const biography = artistInfo?.biography || record.biography
 
   useEffect(() => {
     subsonic
@@ -72,15 +70,9 @@ const ArtistDetails = (props) => {
       })
   }, [record.id])
 
-  const component = isDesktop ? DesktopArtistDetails : MobileArtistDetails
+  const Component = isDesktop ? DesktopArtistDetails : MobileArtistDetails
   return (
-    <>
-      {createElement(component, {
-        artistInfo,
-        record,
-        biography,
-      })}
-    </>
+    <Component artistInfo={artistInfo} record={record} biography={biography} />
   )
 }
 

ui/src/artist/DesktopArtistDetails.jsx

@@ -11,6 +11,7 @@ import Lightbox from 'react-image-lightbox'
 import ExpandInfoDialog from '../dialogs/ExpandInfoDialog'
 import AlbumInfo from '../album/AlbumInfo'
 import subsonic from '../subsonic'
+import { SafeHTML } from '../common/SafeHTML'
 
 const useStyles = makeStyles(
   (theme) => ({
@@ -172,7 +173,9 @@ const DesktopArtistDetails = ({ artistInfo, record, biography }) => {
                 variant={'body1'}
                 onClick={() => setExpanded(!expanded)}
               >
-                <span dangerouslySetInnerHTML={{ __html: biography }} />
+                <span>
+                  <SafeHTML>{biography}</SafeHTML>
+                </span>
               </Typography>
             </Collapse>
           </CardContent>

ui/src/artist/MobileArtistDetails.jsx

@@ -7,6 +7,7 @@ import config from '../config'
 import { LoveButton, RatingField } from '../common'
 import Lightbox from 'react-image-lightbox'
 import subsonic from '../subsonic'
+import { SafeHTML } from '../common/SafeHTML'
 
 const useStyles = makeStyles(
   (theme) => ({
@@ -168,7 +169,9 @@ const MobileArtistDetails = ({ artistInfo, biography, record }) => {
       <div className={classes.biography}>
         <Collapse collapsedHeight={'1.5em'} in={expanded} timeout={'auto'}>
           <Typography variant={'body1'} onClick={() => setExpanded(!expanded)}>
-            <span dangerouslySetInnerHTML={{ __html: biography }} />
+            <span>
+              <SafeHTML>{biography}</SafeHTML>
+            </span>
           </Typography>
         </Collapse>
       </div>

ui/src/common/Linkify.jsx

@@ -53,12 +53,7 @@ const Linkify = ({ text, ...rest }) => {
 
     // Push remaining text
     if (text.length > lastIndex) {
-      elements.push(
-        <span
-          key={'last-span-key'}
-          dangerouslySetInnerHTML={{ __html: text.substring(lastIndex) }}
-        />,
-      )
+      elements.push(text.substring(lastIndex))
     }
 
     return elements.length === 1 ? elements[0] : elements

ui/src/common/MultiLineTextField.jsx

@@ -28,19 +28,7 @@ export const MultiLineTextField = memo(
         component="span"
         {...sanitizeFieldRestProps(rest)}
       >
-        {lines.length === 0 && emptyText
-          ? emptyText
-          : lines.map((line, idx) =>
-              line === '' ? (
-                <br key={md5(line + idx)} />
-              ) : (
-                <div
-                  data-testid={`${source}.${idx}`}
-                  key={md5(line + idx)}
-                  dangerouslySetInnerHTML={{ __html: line }}
-                />
-              ),
-            )}
+        {lines.length === 0 && emptyText ? emptyText : lines}
       </Typography>
     )
   },

ui/src/common/MultiLineTextField.test.jsx

@@ -1,28 +0,0 @@
-import * as React from 'react'
-import { render, cleanup, screen } from '@testing-library/react'
-import { MultiLineTextField } from './MultiLineTextField'
-
-describe('<MultiLineTextField />', () => {
-  afterEach(cleanup)
-
-  it('should render each line in a separated div', () => {
-    const record = { comment: 'line1\nline2' }
-    render(<MultiLineTextField record={record} source={'comment'} />)
-    expect(screen.queryByTestId('comment.0').textContent).toBe('line1')
-    expect(screen.queryByTestId('comment.1').textContent).toBe('line2')
-  })
-
-  it.each([null, undefined])(
-    'should render the emptyText when value is %s',
-    (body) => {
-      render(
-        <MultiLineTextField
-          record={{ id: 123, body }}
-          emptyText="NA"
-          source="body"
-        />,
-      )
-      expect(screen.getByText('NA')).toBeInTheDocument()
-    },
-  )
-})

ui/src/common/SafeHTML.jsx

@@ -0,0 +1,27 @@
+import DOMPurify from 'dompurify'
+import { useMemo } from 'react'
+
+export const SafeHTML = ({ children }) => {
+  const purified = useMemo(() => {
+    const purify = DOMPurify()
+
+    purify.addHook('afterSanitizeElements', async (node) => {
+      if (node instanceof HTMLElement) {
+        // Set referrer-policy for elements with src
+        switch (node.tagName.toLowerCase()) {
+          case 'a':
+          case 'area':
+          case 'img':
+          case 'video':
+          case 'iframe':
+          case 'script':
+            node.setAttribute('referrer-policy', 'no-referrer')
+        }
+      }
+    })
+
+    return purify.sanitize(children, { ADD_ATTR: ['referrer-policy'] })
+  }, [children])
+
+  return <span dangerouslySetInnerHTML={{ __html: purified }} />
+}

ui/src/layout/Login.jsx

@@ -136,6 +136,8 @@ const FormLogin = ({ loading, handleSubmit, validate }) => {
               {config.welcomeMessage && (
                 <div
                   className={classes.welcome}
+                  // Use dangerouslySetInnerHTML to allow admins to configure
+                  // whatever content they want
                   dangerouslySetInnerHTML={{ __html: config.welcomeMessage }}
                 />
               )}

ui/src/themes/nautiline.js

@@ -8,6 +8,7 @@
 // ============================================
 
 const ACCENT_COLOR = '#009688' // Material teal
+const UNBOUNDED_FONT_PATH = 'fonts/Unbounded-Variable.woff2'
 
 // ============================================
 // DESIGN TOKENS
@@ -69,7 +70,7 @@ const tokens = {
         font-style: normal;
         font-weight: 300 800;
         font-display: swap;
-        src: url('/fonts/Unbounded-Variable.woff2') format('woff2');
+        src: url('${UNBOUNDED_FONT_PATH}') format('woff2');
       }
     `,
   },
@@ -275,7 +276,7 @@ const NautilineTheme = {
           fontStyle: 'normal',
           fontWeight: '300 800',
           fontDisplay: 'swap',
-          src: "url('/fonts/Unbounded-Variable.woff2') format('woff2')",
+          src: `url('${UNBOUNDED_FONT_PATH}') format('woff2')`,
         },
         body: {
           backgroundColor: colors.background.primary,
@@ -794,7 +795,7 @@ const NautilineTheme = {
         font-style: normal;
         font-weight: 300 800;
         font-display: swap;
-        src: url('/fonts/Unbounded-Variable.woff2') format('woff2');
+        src: url('${UNBOUNDED_FONT_PATH}') format('woff2');
       }
 
       .react-jinke-music-player-main {

ui/src/utils/urls.js

@@ -44,3 +44,16 @@ export const shareCoverUrl = (id, square) => {
 }
 
 export const docsUrl = (path) => `https://www.navidrome.org${path}`
+
+export const isLastFmURL = (url) => {
+  try {
+    const parsed = new URL(url)
+    return (
+      (parsed.protocol === 'http:' || parsed.protocol === 'https:') &&
+      (parsed.hostname === 'last.fm' || parsed.hostname.endsWith('.last.fm')) &&
+      parsed.pathname.startsWith('/music/')
+    )
+  } catch (e) {
+    return false
+  }
+}

ui/src/utils/urls.test.js

@@ -0,0 +1,25 @@
+import { isLastFmURL } from './urls'
+
+describe('isLastFmURL', () => {
+  it('returns true for valid Last.fm music URLs', () => {
+    expect(isLastFmURL('https://last.fm/music/The+Beatles')).toBe(true)
+    expect(isLastFmURL('http://last.fm/music/Radiohead')).toBe(true)
+    expect(isLastFmURL('https://www.last.fm/music/Daft+Punk')).toBe(true)
+  })
+
+  it('returns false for non-http(s) protocols (XSS prevention)', () => {
+    expect(isLastFmURL('javascript:alert(1)//last.fm/music/')).toBe(false)
+    expect(isLastFmURL('data:text/html,<script>//last.fm/music/')).toBe(false)
+  })
+
+  it('returns false for non-last.fm domains', () => {
+    expect(isLastFmURL('https://example.com/?q=last.fm/music/')).toBe(false)
+    expect(isLastFmURL('https://fake-last.fm/music/Artist')).toBe(false)
+  })
+
+  it('returns false for invalid paths or inputs', () => {
+    expect(isLastFmURL('https://last.fm/user/someone')).toBe(false)
+    expect(isLastFmURL(null)).toBe(false)
+    expect(isLastFmURL('not-a-url')).toBe(false)
+  })
+})