chore: install TagLib in devcontainer Dockerfile

Move TagLib installation from postCreateCommand script into the devcontainer Dockerfile to leverage Docker layer caching and simplify setup.\n\nChanges:\n- Install cross-taglib v2.1.1-1 directly in Dockerfile using TARGETARCH for multi-arch support (amd64/arm64).\n- Remove redundant libtag1-dev apt dependency; keep ffmpeg only.\n- Add CROSS_TAGLIB_VERSION as a build arg for consistency with CI/Makefile.\n- Remove postCreateCommand from devcontainer.json and delete install-taglib.sh script.\n\nWhy:\n- Avoid re-downloading TagLib on each container create; benefit from cached image layers.\n- Reduce redundancy and potential version mismatch between apt libtag and cross-taglib.\n- Keep devcontainer aligned with production build approach and CI settings.

.devcontainer/Dockerfile

@@ -23,7 +23,5 @@ RUN DOWNLOAD_ARCH="linux-${TARGETARCH}" \
     && rmdir /usr/include/taglib \
     && rm /tmp/cross-taglib.tar.gz /usr/provenance.json
 
-ENV CGO_CFLAGS_ALLOW="--define-prefix"
-
 # [Optional] Uncomment this line to install global node packages.
 # RUN su vscode -c "source /usr/local/share/nvm/nvm.sh && npm install -g <your-package-here>" 2>&1

.dockerignore

@@ -15,5 +15,4 @@ dist
 binaries
 cache
 music
-music.old
 !Dockerfile

.github/workflows/pipeline.yml

@@ -14,8 +14,7 @@ concurrency:
   cancel-in-progress: true
 
 env:
-  CROSS_TAGLIB_VERSION: "2.1.1-2"
-  CGO_CFLAGS_ALLOW: "--define-prefix"
+  CROSS_TAGLIB_VERSION: "2.1.1-1"
   IS_RELEASE: ${{ startsWith(github.ref, 'refs/tags/') && 'true' || 'false' }}
 
 jobs:
@@ -89,16 +88,6 @@ jobs:
             exit 1
           fi
 
-      - name: Run go generate
-        run: go generate ./...
-      - name: Verify no changes from go generate
-        run: |
-          git status --porcelain
-          if [ -n "$(git status --porcelain)" ]; then
-            echo 'Generated code is out of date. Run "make gen" and commit the changes'
-            exit 1
-          fi
-
   go:
     name: Test Go code
     runs-on: ubuntu-latest
@@ -119,13 +108,6 @@ jobs:
           pkg-config --define-prefix --cflags --libs taglib # for debugging
           go test -shuffle=on -tags netgo -race ./... -v
 
-      - name: Test ndpgen
-        run: |
-          cd plugins/cmd/ndpgen
-          go test -shuffle=on -v
-          go build -o ndpgen .
-          ./ndpgen --help
-
   js:
     name: Test JS code
     runs-on: ubuntu-latest
@@ -193,7 +175,7 @@ jobs:
     needs: [js, go, go-lint, i18n-lint, git-version, check-push-enabled]
     strategy:
       matrix:
-        platform: [ linux/amd64, linux/arm64, linux/arm/v5, linux/arm/v6, linux/arm/v7, linux/386, linux/riscv64, darwin/amd64, darwin/arm64, windows/amd64, windows/386 ]
+        platform: [ linux/amd64, linux/arm64, linux/arm/v5, linux/arm/v6, linux/arm/v7, linux/386, darwin/amd64, darwin/arm64, windows/amd64, windows/386 ]
     runs-on: ubuntu-latest
     env:
       IS_LINUX: ${{ startsWith(matrix.platform, 'linux/') && 'true' || 'false' }}
@@ -235,7 +217,7 @@ jobs:
             CROSS_TAGLIB_VERSION=${{ env.CROSS_TAGLIB_VERSION }}
 
       - name: Upload Binaries
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v5
         with:
           name: navidrome-${{ env.PLATFORM }}
           path: ./output
@@ -266,7 +248,7 @@ jobs:
           touch "/tmp/digests/${digest#sha256:}"          
 
       - name: Upload digest
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v5
         if: env.IS_LINUX == 'true' && env.IS_DOCKER_PUSH_CONFIGURED == 'true' && env.IS_ARMV5 == 'false'
         with:
           name: digests-${{ env.PLATFORM }}
@@ -274,11 +256,8 @@ jobs:
           if-no-files-found: error
           retention-days: 1
 
-  push-manifest-ghcr:
-    name: Push to GHCR
-    permissions:
-      contents: read
-      packages: write
+  push-manifest:
+    name: Push Docker manifest
     runs-on: ubuntu-latest
     needs: [build, check-push-enabled]
     if: needs.check-push-enabled.outputs.is_enabled == 'true'
@@ -288,41 +267,7 @@ jobs:
       - uses: actions/checkout@v6
 
       - name: Download digests
-        uses: actions/download-artifact@v7
-        with:
-          path: /tmp/digests
-          pattern: digests-*
-          merge-multiple: true
-
-      - name: Prepare Docker Buildx
-        uses: ./.github/actions/prepare-docker
-        id: docker
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Create manifest list and push to ghcr.io
-        working-directory: /tmp/digests
-        run: |
-          docker buildx imagetools create $(jq -cr '.tags | map(select(startswith("ghcr.io"))) | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-            $(printf '${{ env.REGISTRY_IMAGE }}@sha256:%s ' *)          
-
-      - name: Inspect image in ghcr.io
-        run: |
-          docker buildx imagetools inspect ${{ env.REGISTRY_IMAGE }}:${{ steps.docker.outputs.version }}
-
-  push-manifest-dockerhub:
-    name: Push to Docker Hub
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-    needs: [build, check-push-enabled]
-    if: needs.check-push-enabled.outputs.is_enabled == 'true' && vars.DOCKER_HUB_REPO != ''
-    continue-on-error: true
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Download digests
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v6
         with:
           path: /tmp/digests
           pattern: digests-*
@@ -337,27 +282,28 @@ jobs:
           hub_username: ${{ secrets.DOCKER_HUB_USERNAME }}
           hub_password: ${{ secrets.DOCKER_HUB_PASSWORD }}
 
+      - name: Create manifest list and push to ghcr.io
+        working-directory: /tmp/digests
+        run: |
+          docker buildx imagetools create $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
+            $(printf '${{ env.REGISTRY_IMAGE }}@sha256:%s ' *)          
+
       - name: Create manifest list and push to Docker Hub
-        uses: nick-fields/retry@v3
-        with:
-          timeout_minutes: 5
-          max_attempts: 3
-          retry_wait_seconds: 30
-          command: |
-            cd /tmp/digests
-            docker buildx imagetools create $(jq -cr '.tags | map(select(startswith("ghcr.io") | not)) | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-              $(printf 'ghcr.io/${{ github.repository }}@sha256:%s ' *)
+        working-directory: /tmp/digests
+        if: vars.DOCKER_HUB_REPO != ''
+        run: |
+          docker buildx imagetools create $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
+            $(printf '${{ vars.DOCKER_HUB_REPO }}@sha256:%s ' *)          
+
+      - name: Inspect image in ghcr.io
+        run: |
+          docker buildx imagetools inspect ${{ env.REGISTRY_IMAGE }}:${{ steps.docker.outputs.version }}
 
       - name: Inspect image in Docker Hub
+        if: vars.DOCKER_HUB_REPO != ''
         run: |
           docker buildx imagetools inspect ${{ vars.DOCKER_HUB_REPO }}:${{ steps.docker.outputs.version }}
 
-  cleanup-digests:
-    name: Cleanup digest artifacts
-    runs-on: ubuntu-latest
-    needs: [push-manifest-ghcr, push-manifest-dockerhub]
-    if: always() && needs.push-manifest-ghcr.result == 'success'
-    steps:
       - name: Delete unnecessary digest artifacts
         env:
           GH_TOKEN: ${{ github.token }}
@@ -374,7 +320,7 @@ jobs:
     steps:
       - uses: actions/checkout@v6
 
-      - uses: actions/download-artifact@v7
+      - uses: actions/download-artifact@v6
         with:
           path: ./binaries
           pattern: navidrome-windows*
@@ -393,7 +339,7 @@ jobs:
           du -h binaries/msi/*.msi
 
       - name: Upload MSI files
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v5
         with:
           name: navidrome-windows-installers
           path: binaries/msi/*.msi
@@ -411,7 +357,7 @@ jobs:
           fetch-depth: 0
           fetch-tags: true
 
-      - uses: actions/download-artifact@v7
+      - uses: actions/download-artifact@v6
         with:
           path: ./binaries
           pattern: navidrome-*
@@ -437,7 +383,7 @@ jobs:
           rm ./dist/*.tar.gz ./dist/*.zip
 
       - name: Upload all-packages artifact
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v5
         with:
           name: packages
           path: dist/navidrome_0*
@@ -460,13 +406,13 @@ jobs:
         item: ${{ fromJson(needs.release.outputs.package_list) }}
     steps:
       - name: Download all-packages artifact
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v6
         with:
           name: packages
           path: ./dist
 
       - name: Upload all-packages artifact
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v5
         with:
           name: navidrome_linux_${{ matrix.item }}
           path: dist/navidrome_0*_linux_${{ matrix.item }}

.github/workflows/stale.yml

@@ -12,7 +12,7 @@ jobs:
       pull-requests: write
     runs-on: ubuntu-latest
     steps:
-      - uses: dessant/lock-threads@v6
+      - uses: dessant/lock-threads@v5
         with:
           process-only: 'issues, prs'
           issue-inactive-days: 120

.github/workflows/update-translations.yml

@@ -24,7 +24,7 @@ jobs:
           git status --porcelain
           git diff
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v8
+        uses: peter-evans/create-pull-request@v7
         with:
           token: ${{ secrets.PAT }}
           author: "navidrome-bot <navidrome-bot@navidrome.org>"

.gitignore

@@ -17,24 +17,18 @@ master.zip
 testDB
 cache/*
 *.swp
-coverage.out
 dist
 music
-music.old
 *.db*
 .gitinfo
 docker-compose.yml
 !contrib/docker-compose.yml
 binaries
 navidrome-*
-/ndpgen
 AGENTS.md
 .github/prompts
 .github/instructions
 .github/git-commit-instructions.md
 *.exe
 *.test
-*.wasm
-*.ndp
-openspec/
-go.work*
+*.wasm

Dockerfile

@@ -2,10 +2,10 @@ FROM --platform=$BUILDPLATFORM ghcr.io/crazy-max/osxcross:14.5-debian AS osxcros
 
 ########################################################################################################################
 ### Build xx (original image: tonistiigi/xx)
-FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/alpine:3.20 AS xx-build
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/alpine:3.19 AS xx-build
 
-# v1.9.0
-ENV XX_VERSION=a5592eab7a57895e8d385394ff12241bc65ecd50
+# v1.5.0
+ENV XX_VERSION=b4e4c451c778822e6742bfc9d9a91d7c7d885c8a
 
 RUN apk add -U --no-cache git
 RUN git clone https://github.com/tonistiigi/xx && \
@@ -26,9 +26,9 @@ COPY --from=xx-build /out/ /usr/bin/
 
 ########################################################################################################################
 ### Get TagLib
-FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/alpine:3.20 AS taglib-build
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/alpine:3.19 AS taglib-build
 ARG TARGETPLATFORM
-ARG CROSS_TAGLIB_VERSION=2.1.1-2
+ARG CROSS_TAGLIB_VERSION=2.1.1-1
 ENV CROSS_TAGLIB_RELEASES_URL=https://github.com/navidrome/cross-taglib/releases/download/v${CROSS_TAGLIB_VERSION}/
 
 # wget in busybox can't follow redirects
@@ -63,7 +63,7 @@ COPY --from=ui /build /build
 
 ########################################################################################################################
 ### Build Navidrome binary
-FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.25-trixie AS base
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.25-bookworm AS base
 RUN apt-get update && apt-get install -y clang lld
 COPY --from=xx / /
 WORKDIR /workspace
@@ -94,7 +94,6 @@ RUN --mount=type=bind,source=. \
     # Setup CGO cross-compilation environment
     xx-go --wrap
     export CGO_ENABLED=1
-    export CGO_CFLAGS_ALLOW="--define-prefix"
     export PKG_CONFIG_PATH=/taglib/lib/pkgconfig
     cat $(go env GOENV)
 
@@ -123,7 +122,7 @@ COPY --from=build /out /
 
 ########################################################################################################################
 ### Build Final Image
-FROM public.ecr.aws/docker/library/alpine:3.20 AS final
+FROM public.ecr.aws/docker/library/alpine:3.19 AS final
 LABEL maintainer="deluan@navidrome.org"
 LABEL org.opencontainers.image.source="https://github.com/navidrome/navidrome"
 

Makefile

@@ -1,10 +1,6 @@
 GO_VERSION=$(shell grep "^go " go.mod | cut -f 2 -d ' ')
 NODE_VERSION=$(shell cat .nvmrc)
 
-# Set global environment variables, required for most targets
-export CGO_CFLAGS_ALLOW=--define-prefix
-export ND_ENABLEINSIGHTSCOLLECTOR=false
-
 ifneq ("$(wildcard .git/HEAD)","")
 GIT_SHA=$(shell git rev-parse --short HEAD)
 GIT_TAG=$(shell git describe --tags `git rev-list --tags --max-count=1`)-SNAPSHOT
@@ -13,14 +9,14 @@ GIT_SHA=source_archive
 GIT_TAG=$(patsubst navidrome-%,v%,$(notdir $(PWD)))-SNAPSHOT
 endif
 
-SUPPORTED_PLATFORMS ?= linux/amd64,linux/arm64,linux/arm/v5,linux/arm/v6,linux/arm/v7,linux/386,linux/riscv64,darwin/amd64,darwin/arm64,windows/amd64,windows/386
+SUPPORTED_PLATFORMS ?= linux/amd64,linux/arm64,linux/arm/v5,linux/arm/v6,linux/arm/v7,linux/386,darwin/amd64,darwin/arm64,windows/amd64,windows/386
 IMAGE_PLATFORMS ?= $(shell echo $(SUPPORTED_PLATFORMS) | tr ',' '\n' | grep "linux" | grep -v "arm/v5" | tr '\n' ',' | sed 's/,$$//')
 PLATFORMS ?= $(SUPPORTED_PLATFORMS)
 DOCKER_TAG ?= deluan/navidrome:develop
 
 # Taglib version to use in cross-compilation, from https://github.com/navidrome/cross-taglib
-CROSS_TAGLIB_VERSION ?= 2.1.1-2
-GOLANGCI_LINT_VERSION ?= v2.8.0
+CROSS_TAGLIB_VERSION ?= 2.1.1-1
+GOLANGCI_LINT_VERSION ?= v2.6.2
 
 UI_SRC_FILES := $(shell find ui -type f -not -path "ui/build/*" -not -path "ui/node_modules/*")
 
@@ -30,11 +26,11 @@ setup: check_env download-deps install-golangci-lint setup-git ##@1_Run_First In
 .PHONY: setup
 
 dev: check_env   ##@Development Start Navidrome in development mode, with hot-reload for both frontend and backend
-	npx foreman -j Procfile.dev -p 4533 start
+	ND_ENABLEINSIGHTSCOLLECTOR="false" npx foreman -j Procfile.dev -p 4533 start
 .PHONY: dev
 
 server: check_go_env buildjs ##@Development Start the backend in development mode
-	go tool reflex -d none -c reflex.conf
+	@ND_ENABLEINSIGHTSCOLLECTOR="false" go tool reflex -d none -c reflex.conf
 .PHONY: server
 
 stop: ##@Development Stop development servers (UI and backend)
@@ -54,11 +50,7 @@ test: ##@Development Run Go tests. Use PKG variable to specify packages to test,
 	go test -tags netgo $(PKG)
 .PHONY: test
 
-test-ndpgen: ##@Development Run tests for ndpgen plugin
-	cd plugins/cmd/ndpgen && go test ./......
-.PHONY: test-ndpgen
-
-testall: test test-ndpgen test-i18n test-js ##@Development Run Go and JS tests
+testall: test-race test-i18n test-js ##@Development Run Go and JS tests
 .PHONY: testall
 
 test-race: ##@Development Run Go tests with race detector
@@ -93,7 +85,7 @@ install-golangci-lint: ##@Development Install golangci-lint if not present
 .PHONY: install-golangci-lint
 
 lint: install-golangci-lint ##@Development Lint Go code
-	PATH=$$PATH:./bin golangci-lint run --timeout 5m
+	PATH=$$PATH:./bin golangci-lint run -v --timeout 5m
 .PHONY: lint
 
 lintall: lint ##@Development Lint Go and JS code
@@ -111,15 +103,6 @@ wire: check_go_env ##@Development Update Dependency Injection
 	go tool wire gen -tags=netgo ./...
 .PHONY: wire
 
-gen: check_go_env ##@Development Run go generate for code generation
-	go generate ./...
-	cd plugins/cmd/ndpgen && go run . -host-wrappers -input=../../host -package=host
-	cd plugins/cmd/ndpgen && go run . -input=../../host -output=../../pdk -go -python -rust
-	cd plugins/cmd/ndpgen && go run . -capability-only -input=../../capabilities -output=../../pdk -go -rust
-	cd plugins/cmd/ndpgen && go run . -schemas -input=../../capabilities
-	go mod tidy -C plugins/pdk/go
-.PHONY: gen
-
 snapshots: ##@Development Update (GoLang) Snapshot tests
 	UPDATE_SNAPSHOTS=true go tool ginkgo ./server/subsonic/responses/...
 .PHONY: snapshots
@@ -283,6 +266,24 @@ deprecated:
 	@echo "WARNING: This target is deprecated and will be removed in future releases. Use 'make build' instead."
 .PHONY: deprecated
 
+# Generate Go code from plugins/api/api.proto
+plugin-gen: check_go_env ##@Development Generate Go code from plugins protobuf files
+	go generate ./plugins/...
+.PHONY: plugin-gen
+
+plugin-examples: check_go_env ##@Development Build all example plugins
+	$(MAKE) -C plugins/examples clean all
+.PHONY: plugin-examples
+
+plugin-clean: check_go_env ##@Development Clean all plugins
+	$(MAKE) -C plugins/examples clean
+	$(MAKE) -C plugins/testdata clean
+.PHONY: plugin-clean
+
+plugin-tests: check_go_env ##@Development Build all test plugins
+	$(MAKE) -C plugins/testdata clean all
+.PHONY: plugin-tests
+
 .DEFAULT_GOAL := help
 
 HELP_FUN = \

adapters/deezer/deezer_test.go

@@ -1,171 +0,0 @@
-package deezer
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"time"
-
-	"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("deezerAgent", func() {
-	var ctx context.Context
-
-	BeforeEach(func() {
-		ctx = context.Background()
-		DeferCleanup(configtest.SetupConfig())
-		conf.Server.Deezer.Enabled = true
-	})
-
-	Describe("deezerConstructor", func() {
-		It("uses configured languages", func() {
-			conf.Server.Deezer.Languages = []string{"pt", "en"}
-			agent := deezerConstructor(&tests.MockDataStore{}).(*deezerAgent)
-			Expect(agent.languages).To(Equal([]string{"pt", "en"}))
-		})
-	})
-
-	Describe("GetArtistBiography - Language Fallback", func() {
-		var agent *deezerAgent
-		var httpClient *langAwareHttpClient
-
-		BeforeEach(func() {
-			httpClient = newLangAwareHttpClient()
-
-			// Mock search artist (returns Michael Jackson)
-			fSearch, _ := os.Open("tests/fixtures/deezer.search.artist.json")
-			httpClient.searchResponse = &http.Response{Body: fSearch, StatusCode: 200}
-
-			// Mock JWT token
-			testJWT := createTestJWT(5 * time.Minute)
-			httpClient.jwtResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(fmt.Sprintf(`{"jwt":"%s","refresh_token":""}`, testJWT))),
-			}
-		})
-
-		setupAgent := func(languages []string) {
-			conf.Server.Deezer.Languages = languages
-			agent = &deezerAgent{
-				dataStore: &tests.MockDataStore{},
-				client:    newClient(httpClient),
-				languages: languages,
-			}
-		}
-
-		It("returns content in first language when available (1 bio API call)", func() {
-			setupAgent([]string{"fr", "en"})
-
-			// French biography available
-			fFr, _ := os.Open("tests/fixtures/deezer.artist.bio.fr.json")
-			httpClient.bioResponses["fr"] = &http.Response{Body: fFr, StatusCode: 200}
-
-			bio, err := agent.GetArtistBiography(ctx, "", "Michael Jackson", "")
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(bio).To(ContainSubstring("Guy-Manuel de Homem Christo et Thomas Bangalter"))
-			Expect(httpClient.bioRequestCount).To(Equal(1))
-			Expect(httpClient.bioRequests[0].Header.Get("Accept-Language")).To(Equal("fr"))
-		})
-
-		It("falls back to second language when first returns empty (2 bio API calls)", func() {
-			setupAgent([]string{"ja", "en"})
-
-			// Japanese returns empty biography
-			fJa, _ := os.Open("tests/fixtures/deezer.artist.bio.empty.json")
-			httpClient.bioResponses["ja"] = &http.Response{Body: fJa, StatusCode: 200}
-			// English returns full biography
-			fEn, _ := os.Open("tests/fixtures/deezer.artist.bio.en.json")
-			httpClient.bioResponses["en"] = &http.Response{Body: fEn, StatusCode: 200}
-
-			bio, err := agent.GetArtistBiography(ctx, "", "Michael Jackson", "")
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(bio).To(ContainSubstring("Schoolmates Thomas and Guy-Manuel"))
-			Expect(httpClient.bioRequestCount).To(Equal(2))
-			Expect(httpClient.bioRequests[0].Header.Get("Accept-Language")).To(Equal("ja"))
-			Expect(httpClient.bioRequests[1].Header.Get("Accept-Language")).To(Equal("en"))
-		})
-
-		It("returns ErrNotFound when all languages return empty", func() {
-			setupAgent([]string{"ja", "xx"})
-
-			// Both languages return empty biography
-			fJa, _ := os.Open("tests/fixtures/deezer.artist.bio.empty.json")
-			httpClient.bioResponses["ja"] = &http.Response{Body: fJa, StatusCode: 200}
-			fXx, _ := os.Open("tests/fixtures/deezer.artist.bio.empty.json")
-			httpClient.bioResponses["xx"] = &http.Response{Body: fXx, StatusCode: 200}
-
-			_, err := agent.GetArtistBiography(ctx, "", "Michael Jackson", "")
-
-			Expect(err).To(MatchError(agents.ErrNotFound))
-			Expect(httpClient.bioRequestCount).To(Equal(2))
-		})
-	})
-})
-
-// langAwareHttpClient is a mock HTTP client that returns different responses based on the Accept-Language header
-type langAwareHttpClient struct {
-	searchResponse  *http.Response
-	jwtResponse     *http.Response
-	bioResponses    map[string]*http.Response
-	bioRequests     []*http.Request
-	bioRequestCount int
-}
-
-func newLangAwareHttpClient() *langAwareHttpClient {
-	return &langAwareHttpClient{
-		bioResponses: make(map[string]*http.Response),
-		bioRequests:  make([]*http.Request, 0),
-	}
-}
-
-func (c *langAwareHttpClient) Do(req *http.Request) (*http.Response, error) {
-	// Handle search artist request
-	if req.URL.Host == "api.deezer.com" && req.URL.Path == "/search/artist" {
-		if c.searchResponse != nil {
-			return c.searchResponse, nil
-		}
-		return &http.Response{
-			StatusCode: 200,
-			Body:       io.NopCloser(bytes.NewBufferString(`{"data":[],"total":0}`)),
-		}, nil
-	}
-
-	// Handle JWT token request
-	if req.URL.Host == "auth.deezer.com" && req.URL.Path == "/login/anonymous" {
-		if c.jwtResponse != nil {
-			return c.jwtResponse, nil
-		}
-		return &http.Response{
-			StatusCode: 500,
-			Body:       io.NopCloser(bytes.NewBufferString(`{"error":"no mock"}`)),
-		}, nil
-	}
-
-	// Handle bio request (GraphQL API)
-	if req.URL.Host == "pipe.deezer.com" && req.URL.Path == "/api" {
-		c.bioRequestCount++
-		c.bioRequests = append(c.bioRequests, req)
-		lang := req.Header.Get("Accept-Language")
-		if resp, ok := c.bioResponses[lang]; ok {
-			return resp, nil
-		}
-		// Return empty bio by default
-		return &http.Response{
-			StatusCode: 200,
-			Body:       io.NopCloser(bytes.NewBufferString(`{"data":{"artist":{"bio":{"full":""}}}}`)),
-		}, nil
-	}
-
-	panic("URL not mocked: " + req.URL.String())
-}

adapters/gotaglib/end_to_end_test.go

@@ -1,274 +0,0 @@
-package gotaglib
-
-import (
-	"io/fs"
-	"os"
-	"time"
-
-	"github.com/djherbis/times"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/model/metadata"
-	"github.com/navidrome/navidrome/utils/gg"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-type testFileInfo struct {
-	fs.FileInfo
-}
-
-func (t testFileInfo) BirthTime() time.Time {
-	if ts := times.Get(t.FileInfo); ts.HasBirthTime() {
-		return ts.BirthTime()
-	}
-	return t.FileInfo.ModTime()
-}
-
-var _ = Describe("Extractor", func() {
-	toP := func(name, sortName, mbid string) model.Participant {
-		return model.Participant{
-			Artist: model.Artist{Name: name, SortArtistName: sortName, MbzArtistID: mbid},
-		}
-	}
-
-	roles := []struct {
-		model.Role
-		model.ParticipantList
-	}{
-		{model.RoleComposer, model.ParticipantList{
-			toP("coma a", "a, coma", "bf13b584-f27c-43db-8f42-32898d33d4e2"),
-			toP("comb", "comb", "924039a2-09c6-4d29-9b4f-50cc54447d36"),
-		}},
-		{model.RoleLyricist, model.ParticipantList{
-			toP("la a", "a, la", "c84f648f-68a6-40a2-a0cb-d135b25da3c2"),
-			toP("lb", "lb", "0a7c582d-143a-4540-b4e9-77200835af65"),
-		}},
-		{model.RoleArranger, model.ParticipantList{
-			toP("aa", "", "4605a1d4-8d15-42a3-bd00-9c20e42f71e6"),
-			toP("ab", "", "002f0ff8-77bf-42cc-8216-61a9c43dc145"),
-		}},
-		{model.RoleConductor, model.ParticipantList{
-			toP("cona", "", "af86879b-2141-42af-bad2-389a4dc91489"),
-			toP("conb", "", "3dfa3c70-d7d3-4b97-b953-c298dd305e12"),
-		}},
-		{model.RoleDirector, model.ParticipantList{
-			toP("dia", "", "f943187f-73de-4794-be47-88c66f0fd0f4"),
-			toP("dib", "", "bceb75da-1853-4b3d-b399-b27f0cafc389"),
-		}},
-		{model.RoleEngineer, model.ParticipantList{
-			toP("ea", "", "f634bf6d-d66a-425d-888a-28ad39392759"),
-			toP("eb", "", "243d64ae-d514-44e1-901a-b918d692baee"),
-		}},
-		{model.RoleProducer, model.ParticipantList{
-			toP("pra", "", "d971c8d7-999c-4a5f-ac31-719721ab35d6"),
-			toP("prb", "", "f0a09070-9324-434f-a599-6d25ded87b69"),
-		}},
-		{model.RoleRemixer, model.ParticipantList{
-			toP("ra", "", "c7dc6095-9534-4c72-87cc-aea0103462cf"),
-			toP("rb", "", "8ebeef51-c08c-4736-992f-c37870becedd"),
-		}},
-		{model.RoleDJMixer, model.ParticipantList{
-			toP("dja", "", "d063f13b-7589-4efc-ab7f-c60e6db17247"),
-			toP("djb", "", "3636670c-385f-4212-89c8-0ff51d6bc456"),
-		}},
-		{model.RoleMixer, model.ParticipantList{
-			toP("ma", "", "53fb5a2d-7016-427e-a563-d91819a5f35a"),
-			toP("mb", "", "64c13e65-f0da-4ab9-a300-71ee53b0376a"),
-		}},
-	}
-
-	var e *extractor
-
-	parseTestFile := func(path string) *model.MediaFile {
-		mds, err := e.Parse(path)
-		Expect(err).ToNot(HaveOccurred())
-
-		info, ok := mds[path]
-		Expect(ok).To(BeTrue())
-
-		fileInfo, err := os.Stat(path)
-		Expect(err).ToNot(HaveOccurred())
-		info.FileInfo = testFileInfo{FileInfo: fileInfo}
-
-		metadata := metadata.New(path, info)
-		mf := metadata.ToMediaFile(1, "folderID")
-		return &mf
-	}
-
-	BeforeEach(func() {
-		e = &extractor{fs: os.DirFS(".")}
-	})
-
-	Describe("ReplayGain", func() {
-		DescribeTable("test replaygain end-to-end", func(file string, trackGain, trackPeak, albumGain, albumPeak *float64) {
-			mf := parseTestFile("tests/fixtures/" + file)
-
-			Expect(mf.RGTrackGain).To(Equal(trackGain))
-			Expect(mf.RGTrackPeak).To(Equal(trackPeak))
-			Expect(mf.RGAlbumGain).To(Equal(albumGain))
-			Expect(mf.RGAlbumPeak).To(Equal(albumPeak))
-		},
-			Entry("mp3 with no replaygain", "no_replaygain.mp3", nil, nil, nil, nil),
-			Entry("mp3 with no zero replaygain", "zero_replaygain.mp3", gg.P(0.0), gg.P(1.0), gg.P(0.0), gg.P(1.0)),
-		)
-	})
-
-	Describe("lyrics", func() {
-		makeLyrics := func(code, secondLine string) model.Lyrics {
-			return model.Lyrics{
-				DisplayArtist: "",
-				DisplayTitle:  "",
-				Lang:          code,
-				Line: []model.Line{
-					{Start: gg.P(int64(0)), Value: "This is"},
-					{Start: gg.P(int64(2500)), Value: secondLine},
-				},
-				Offset: nil,
-				Synced: true,
-			}
-		}
-
-		It("should fetch both synced and unsynced lyrics in mixed flac", func() {
-			mf := parseTestFile("tests/fixtures/mixed-lyrics.flac")
-
-			lyrics, err := mf.StructuredLyrics()
-			Expect(err).ToNot(HaveOccurred())
-			Expect(lyrics).To(HaveLen(2))
-
-			Expect(lyrics[0].Synced).To(BeTrue())
-			Expect(lyrics[1].Synced).To(BeFalse())
-		})
-
-		It("should handle mp3 with uslt and sylt", func() {
-			mf := parseTestFile("tests/fixtures/test.mp3")
-
-			lyrics, err := mf.StructuredLyrics()
-			Expect(err).ToNot(HaveOccurred())
-			Expect(lyrics).To(HaveLen(4))
-
-			engSylt := makeLyrics("eng", "English SYLT")
-			engUslt := makeLyrics("eng", "English")
-			unsSylt := makeLyrics("xxx", "unspecified SYLT")
-			unsUslt := makeLyrics("xxx", "unspecified")
-
-			Expect(lyrics).To(ConsistOf(engSylt, engUslt, unsSylt, unsUslt))
-		})
-
-		DescribeTable("format-specific lyrics", func(file string, isId3 bool) {
-			mf := parseTestFile("tests/fixtures/" + file)
-
-			lyrics, err := mf.StructuredLyrics()
-			Expect(err).To(Not(HaveOccurred()))
-			Expect(lyrics).To(HaveLen(2))
-
-			unspec := makeLyrics("xxx", "unspecified")
-			eng := makeLyrics("xxx", "English")
-
-			if isId3 {
-				eng.Lang = "eng"
-			}
-
-			Expect(lyrics).To(Or(
-				Equal(model.LyricList{unspec, eng}),
-				Equal(model.LyricList{eng, unspec})))
-		},
-			Entry("flac", "test.flac", false),
-			Entry("m4a", "test.m4a", false),
-			Entry("ogg", "test.ogg", false),
-			Entry("wma", "test.wma", false),
-			Entry("wv", "test.wv", false),
-			Entry("wav", "test.wav", true),
-			Entry("aiff", "test.aiff", true),
-		)
-	})
-
-	Describe("Participants", func() {
-		DescribeTable("test tags consistent across formats", func(format string) {
-			mf := parseTestFile("tests/fixtures/test." + format)
-
-			for _, data := range roles {
-				role := data.Role
-				artists := data.ParticipantList
-
-				actual := mf.Participants[role]
-				Expect(actual).To(HaveLen(len(artists)))
-
-				for i := range artists {
-					actualArtist := actual[i]
-					expectedArtist := artists[i]
-
-					Expect(actualArtist.Name).To(Equal(expectedArtist.Name))
-					Expect(actualArtist.SortArtistName).To(Equal(expectedArtist.SortArtistName))
-					Expect(actualArtist.MbzArtistID).To(Equal(expectedArtist.MbzArtistID))
-				}
-			}
-
-			if format != "m4a" {
-				performers := mf.Participants[model.RolePerformer]
-				Expect(performers).To(HaveLen(8))
-
-				rules := map[string][]string{
-					"pgaa": {"2fd0b311-9fa8-4ff9-be5d-f6f3d16b835e", "Guitar"},
-					"pgbb": {"223d030b-bf97-4c2a-ad26-b7f7bbe25c93", "Guitar", ""},
-					"pvaa": {"cb195f72-448f-41c8-b962-3f3c13d09d38", "Vocals"},
-					"pvbb": {"60a1f832-8ca2-49f6-8660-84d57f07b520", "Vocals", "Flute"},
-					"pfaa": {"51fb40c-0305-4bf9-a11b-2ee615277725", "", "Flute"},
-				}
-
-				for name, rule := range rules {
-					mbid := rule[0]
-					for i := 1; i < len(rule); i++ {
-						found := false
-
-						for _, mapped := range performers {
-							if mapped.Name == name && mapped.MbzArtistID == mbid && mapped.SubRole == rule[i] {
-								found = true
-								break
-							}
-						}
-
-						Expect(found).To(BeTrue(), "Could not find matching artist")
-					}
-				}
-			}
-		},
-			Entry("FLAC format", "flac"),
-			Entry("M4a format", "m4a"),
-			Entry("OGG format", "ogg"),
-			Entry("WV format", "wv"),
-
-			Entry("MP3 format", "mp3"),
-			Entry("WAV format", "wav"),
-			Entry("AIFF format", "aiff"),
-		)
-
-		It("should parse wma", func() {
-			mf := parseTestFile("tests/fixtures/test.wma")
-
-			for _, data := range roles {
-				role := data.Role
-				artists := data.ParticipantList
-				actual := mf.Participants[role]
-
-				// WMA has no Arranger role
-				if role == model.RoleArranger {
-					Expect(actual).To(HaveLen(0))
-					continue
-				}
-
-				Expect(actual).To(HaveLen(len(artists)), role.String())
-
-				// For some bizarre reason, the order is inverted. We also don't get
-				// sort names or MBIDs
-				for i := range artists {
-					idx := len(artists) - 1 - i
-
-					actualArtist := actual[i]
-					expectedArtist := artists[idx]
-
-					Expect(actualArtist.Name).To(Equal(expectedArtist.Name))
-				}
-			}
-		})
-	})
-})

adapters/gotaglib/gotaglib.go

@@ -1,277 +0,0 @@
-// Package gotaglib provides an alternative metadata extractor using go-taglib,
-// a pure Go (WASM-based) implementation of TagLib.
-//
-// This extractor aims for parity with the CGO-based taglib extractor. It uses
-// TagLib's PropertyMap interface for standard tags. The File handle API provides
-// 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 "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"
-)
-
-type extractor struct {
-	fs fs.FS
-}
-
-func (e extractor) Parse(files ...string) (map[string]metadata.Info, error) {
-	results := make(map[string]metadata.Info)
-	for _, path := range files {
-		props, err := e.extractMetadata(path)
-		if err != nil {
-			continue
-		}
-		results[path] = *props
-	}
-	return results, nil
-}
-
-func (e extractor) Version() string {
-	return "go-taglib (TagLib 2.1.1 WASM)"
-}
-
-func (e extractor) extractMetadata(filePath string) (*metadata.Info, error) {
-	f, close, err := e.openFile(filePath)
-	if err != nil {
-		log.Warn("gotaglib: Error reading metadata from file. Skipping", "filePath", filePath, err)
-		return nil, err
-	}
-	defer close()
-
-	// Get all tags and properties in one go
-	allTags := f.AllTags()
-	props := f.Properties()
-
-	// Map properties to AudioProperties
-	ap := metadata.AudioProperties{
-		Duration:   props.Length.Round(time.Millisecond * 10),
-		BitRate:    int(props.Bitrate),
-		Channels:   int(props.Channels),
-		SampleRate: int(props.SampleRate),
-		BitDepth:   int(props.BitsPerSample),
-	}
-
-	// Convert normalized tags to lowercase keys (go-taglib returns UPPERCASE keys)
-	normalizedTags := make(map[string][]string, len(allTags.Tags))
-	for key, values := range allTags.Tags {
-		lowerKey := strings.ToLower(key)
-		normalizedTags[lowerKey] = values
-	}
-
-	// Process format-specific raw tags
-	processRawTags(allTags, normalizedTags)
-
-	// Parse track/disc totals from "N/Total" format
-	parseTuple(normalizedTags, "track")
-	parseTuple(normalizedTags, "disc")
-
-	// Adjust some ID3 tags
-	parseLyrics(normalizedTags)
-	parseTIPL(normalizedTags)
-	delete(normalizedTags, "tmcl") // TMCL is already parsed by TagLib
-
-	// Determine if file has embedded picture
-	hasPicture := len(props.Images) > 0
-
-	return &metadata.Info{
-		Tags:            normalizedTags,
-		AudioProperties: ap,
-		HasPicture:      hasPicture,
-	}, nil
-}
-
-// 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) (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 {
-		return nil, nil, err
-	}
-	rs, isSeekable := file.(io.ReadSeeker)
-	if !isSeekable {
-		file.Close()
-		return nil, nil, errors.New("file is not seekable")
-	}
-	f, err = taglib.OpenStream(rs, taglib.WithReadStyle(taglib.ReadStyleFast))
-	if err != nil {
-		file.Close()
-		return nil, nil, err
-	}
-	closeFunc = func() {
-		f.Close()
-		file.Close()
-	}
-	return f, closeFunc, nil
-}
-
-// parseTuple parses track/disc numbers in "N/Total" format and separates them.
-// For example, tracknumber="2/10" becomes tracknumber="2" and tracktotal="10".
-func parseTuple(tags map[string][]string, prop string) {
-	tagName := prop + "number"
-	tagTotal := prop + "total"
-	if value, ok := tags[tagName]; ok && len(value) > 0 {
-		parts := strings.Split(value[0], "/")
-		tags[tagName] = []string{parts[0]}
-		if len(parts) == 2 {
-			tags[tagTotal] = []string{parts[1]}
-		}
-	}
-}
-
-// parseLyrics ensures lyrics tags have a language code.
-// If lyrics exist without a language code, they are moved to "lyrics:xxx".
-func parseLyrics(tags map[string][]string) {
-	lyrics := tags["lyrics"]
-	if len(lyrics) > 0 {
-		tags["lyrics:xxx"] = lyrics
-		delete(tags, "lyrics")
-	}
-}
-
-// processRawTags processes format-specific raw tags based on the detected file format.
-// This handles ID3v2 frames (MP3/WAV/AIFF), MP4 atoms, and ASF attributes.
-func processRawTags(allTags taglib.AllTags, normalizedTags map[string][]string) {
-	switch allTags.Format {
-	case taglib.FormatMPEG, taglib.FormatWAV, taglib.FormatAIFF:
-		parseID3v2Frames(allTags.Raw, normalizedTags)
-	case taglib.FormatMP4:
-		parseMP4Atoms(allTags.Raw, normalizedTags)
-	case taglib.FormatASF:
-		parseASFAttributes(allTags.Raw, normalizedTags)
-	}
-}
-
-// parseID3v2Frames processes ID3v2 raw frames to extract USLT/SYLT with language codes.
-// This extracts language-specific lyrics that the standard Tags() doesn't provide.
-func parseID3v2Frames(rawFrames map[string][]string, tags map[string][]string) {
-	// Process frames that have language-specific data
-	for key, values := range rawFrames {
-		lowerKey := strings.ToLower(key)
-
-		// Handle USLT:xxx and SYLT:xxx (lyrics with language codes)
-		if strings.HasPrefix(lowerKey, "uslt:") || strings.HasPrefix(lowerKey, "sylt:") {
-			parts := strings.SplitN(lowerKey, ":", 2)
-			if len(parts) == 2 && parts[1] != "" {
-				lang := parts[1]
-				lyricsKey := "lyrics:" + lang
-				tags[lyricsKey] = append(tags[lyricsKey], values...)
-			}
-		}
-	}
-
-	// If we found any language-specific lyrics from ID3v2 frames, remove the generic lyrics
-	for key := range tags {
-		if strings.HasPrefix(key, "lyrics:") && key != "lyrics" {
-			delete(tags, "lyrics")
-			break
-		}
-	}
-}
-
-const iTunesKeyPrefix = "----:com.apple.iTunes:"
-
-// parseMP4Atoms processes MP4 raw atoms to get iTunes-specific tags.
-func parseMP4Atoms(rawAtoms map[string][]string, tags map[string][]string) {
-	// Process all atoms and add them to tags
-	for key, values := range rawAtoms {
-		// Strip iTunes prefix and convert to lowercase
-		normalizedKey := strings.TrimPrefix(key, iTunesKeyPrefix)
-		normalizedKey = strings.ToLower(normalizedKey)
-
-		// Only add if the tag doesn't already exist (avoid duplication with PropertyMap)
-		if _, exists := tags[normalizedKey]; !exists {
-			tags[normalizedKey] = values
-		}
-	}
-}
-
-// parseASFAttributes processes ASF raw attributes to get WMA-specific tags.
-func parseASFAttributes(rawAttrs map[string][]string, tags map[string][]string) {
-	// Process all attributes and add them to tags
-	for key, values := range rawAttrs {
-		normalizedKey := strings.ToLower(key)
-
-		// Only add if the tag doesn't already exist (avoid duplication with PropertyMap)
-		if _, exists := tags[normalizedKey]; !exists {
-			tags[normalizedKey] = values
-		}
-	}
-}
-
-// These are the only roles we support, based on Picard's tag map:
-// https://picard-docs.musicbrainz.org/downloads/MusicBrainz_Picard_Tag_Map.html
-var tiplMapping = map[string]string{
-	"arranger": "arranger",
-	"engineer": "engineer",
-	"producer": "producer",
-	"mix":      "mixer",
-	"DJ-mix":   "djmixer",
-}
-
-// parseTIPL parses the ID3v2.4 TIPL frame string, which is received from TagLib in the format:
-//
-//	"arranger Andrew Powell engineer Chris Blair engineer Pat Stapley producer Eric Woolfson".
-//
-// and breaks it down into a map of roles and names, e.g.:
-//
-//	{"arranger": ["Andrew Powell"], "engineer": ["Chris Blair", "Pat Stapley"], "producer": ["Eric Woolfson"]}.
-func parseTIPL(tags map[string][]string) {
-	tipl := tags["tipl"]
-	if len(tipl) == 0 {
-		return
-	}
-	addRole := func(currentRole string, currentValue []string) {
-		if currentRole != "" && len(currentValue) > 0 {
-			role := tiplMapping[currentRole]
-			tags[role] = append(tags[role], strings.Join(currentValue, " "))
-		}
-	}
-	var currentRole string
-	var currentValue []string
-	for _, part := range strings.Split(tipl[0], " ") {
-		if _, ok := tiplMapping[part]; ok {
-			addRole(currentRole, currentValue)
-			currentRole = part
-			currentValue = nil
-			continue
-		}
-		currentValue = append(currentValue, part)
-	}
-	addRole(currentRole, currentValue)
-	delete(tags, "tipl")
-}
-
-var _ local.Extractor = (*extractor)(nil)
-
-func init() {
-	local.RegisterExtractor("taglib", func(fsys fs.FS, baseDir string) local.Extractor {
-		return &extractor{fsys}
-	})
-}

adapters/gotaglib/gotaglib_suite_test.go

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

adapters/gotaglib/gotaglib_test.go

@@ -1,302 +0,0 @@
-package gotaglib
-
-import (
-	"io/fs"
-	"os"
-	"strings"
-
-	"github.com/navidrome/navidrome/utils"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Extractor", func() {
-	var e *extractor
-
-	BeforeEach(func() {
-		e = &extractor{fs: os.DirFS(".")}
-	})
-
-	Describe("Parse", func() {
-		It("correctly parses metadata from all files in folder", func() {
-			mds, err := e.Parse(
-				"tests/fixtures/test.mp3",
-				"tests/fixtures/test.ogg",
-			)
-			Expect(err).NotTo(HaveOccurred())
-			Expect(mds).To(HaveLen(2))
-
-			// Test MP3
-			m := mds["tests/fixtures/test.mp3"]
-			Expect(m.Tags).To(HaveKeyWithValue("title", []string{"Song"}))
-			Expect(m.Tags).To(HaveKeyWithValue("album", []string{"Album"}))
-			Expect(m.Tags).To(HaveKeyWithValue("artist", []string{"Artist"}))
-			Expect(m.Tags).To(HaveKeyWithValue("albumartist", []string{"Album Artist"}))
-
-			Expect(m.HasPicture).To(BeTrue())
-			Expect(m.AudioProperties.Duration.String()).To(Equal("1.02s"))
-			Expect(m.AudioProperties.BitRate).To(Equal(192))
-			Expect(m.AudioProperties.Channels).To(Equal(2))
-			Expect(m.AudioProperties.SampleRate).To(Equal(44100))
-
-			Expect(m.Tags).To(Or(
-				HaveKeyWithValue("compilation", []string{"1"}),
-				HaveKeyWithValue("tcmp", []string{"1"})),
-			)
-			Expect(m.Tags).To(HaveKeyWithValue("genre", []string{"Rock"}))
-			Expect(m.Tags).To(HaveKeyWithValue("date", []string{"2014-05-21"}))
-			Expect(m.Tags).To(HaveKeyWithValue("originaldate", []string{"1996-11-21"}))
-			Expect(m.Tags).To(HaveKeyWithValue("releasedate", []string{"2020-12-31"}))
-			Expect(m.Tags).To(HaveKeyWithValue("discnumber", []string{"1"}))
-			Expect(m.Tags).To(HaveKeyWithValue("disctotal", []string{"2"}))
-			Expect(m.Tags).To(HaveKeyWithValue("comment", []string{"Comment1\nComment2"}))
-			Expect(m.Tags).To(HaveKeyWithValue("bpm", []string{"123"}))
-			Expect(m.Tags).To(HaveKeyWithValue("replaygain_album_gain", []string{"+3.21518 dB"}))
-			Expect(m.Tags).To(HaveKeyWithValue("replaygain_album_peak", []string{"0.9125"}))
-			Expect(m.Tags).To(HaveKeyWithValue("replaygain_track_gain", []string{"-1.48 dB"}))
-			Expect(m.Tags).To(HaveKeyWithValue("replaygain_track_peak", []string{"0.4512"}))
-
-			Expect(m.Tags).To(HaveKeyWithValue("tracknumber", []string{"2"}))
-			Expect(m.Tags).To(HaveKeyWithValue("tracktotal", []string{"10"}))
-
-			Expect(m.Tags).ToNot(HaveKey("lyrics"))
-			Expect(m.Tags).To(Or(HaveKeyWithValue("lyrics:eng", []string{
-				"[00:00.00]This is\n[00:02.50]English SYLT\n",
-				"[00:00.00]This is\n[00:02.50]English",
-			}), HaveKeyWithValue("lyrics:eng", []string{
-				"[00:00.00]This is\n[00:02.50]English",
-				"[00:00.00]This is\n[00:02.50]English SYLT\n",
-			})))
-			Expect(m.Tags).To(Or(HaveKeyWithValue("lyrics:xxx", []string{
-				"[00:00.00]This is\n[00:02.50]unspecified SYLT\n",
-				"[00:00.00]This is\n[00:02.50]unspecified",
-			}), HaveKeyWithValue("lyrics:xxx", []string{
-				"[00:00.00]This is\n[00:02.50]unspecified",
-				"[00:00.00]This is\n[00:02.50]unspecified SYLT\n",
-			})))
-
-			// Test OGG
-			m = mds["tests/fixtures/test.ogg"]
-			Expect(err).To(BeNil())
-			Expect(m.Tags).To(HaveKeyWithValue("fbpm", []string{"141.7"}))
-
-			// TagLib 1.12 returns 18, previous versions return 39.
-			// See https://github.com/taglib/taglib/commit/2f238921824741b2cfe6fbfbfc9701d9827ab06b
-			Expect(m.AudioProperties.BitRate).To(BeElementOf(18, 19, 39, 40, 43, 49))
-			Expect(m.AudioProperties.Channels).To(BeElementOf(2))
-			Expect(m.AudioProperties.SampleRate).To(BeElementOf(8000))
-			Expect(m.HasPicture).To(BeTrue())
-		})
-
-		DescribeTable("Format-Specific tests",
-			func(file, duration string, channels, samplerate, bitdepth int, albumGain, albumPeak, trackGain, trackPeak string, id3Lyrics bool, image bool) {
-				file = "tests/fixtures/" + file
-				mds, err := e.Parse(file)
-				Expect(err).NotTo(HaveOccurred())
-				Expect(mds).To(HaveLen(1))
-
-				m := mds[file]
-
-				Expect(m.HasPicture).To(Equal(image))
-				Expect(m.AudioProperties.Duration.String()).To(Equal(duration))
-				Expect(m.AudioProperties.Channels).To(Equal(channels))
-				Expect(m.AudioProperties.SampleRate).To(Equal(samplerate))
-				Expect(m.AudioProperties.BitDepth).To(Equal(bitdepth))
-
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("replaygain_album_gain", []string{albumGain}),
-					HaveKeyWithValue("----:com.apple.itunes:replaygain_album_gain", []string{albumGain}),
-				))
-
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("replaygain_album_peak", []string{albumPeak}),
-					HaveKeyWithValue("----:com.apple.itunes:replaygain_album_peak", []string{albumPeak}),
-				))
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("replaygain_track_gain", []string{trackGain}),
-					HaveKeyWithValue("----:com.apple.itunes:replaygain_track_gain", []string{trackGain}),
-				))
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("replaygain_track_peak", []string{trackPeak}),
-					HaveKeyWithValue("----:com.apple.itunes:replaygain_track_peak", []string{trackPeak}),
-				))
-
-				Expect(m.Tags).To(HaveKeyWithValue("title", []string{"Title"}))
-				Expect(m.Tags).To(HaveKeyWithValue("album", []string{"Album"}))
-				Expect(m.Tags).To(HaveKeyWithValue("artist", []string{"Artist"}))
-				Expect(m.Tags).To(HaveKeyWithValue("albumartist", []string{"Album Artist"}))
-				Expect(m.Tags).To(HaveKeyWithValue("genre", []string{"Rock"}))
-				Expect(m.Tags).To(HaveKeyWithValue("date", []string{"2014"}))
-
-				Expect(m.Tags).To(HaveKeyWithValue("bpm", []string{"123"}))
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("tracknumber", []string{"3"}),
-					HaveKeyWithValue("tracknumber", []string{"3/10"}),
-				))
-				if !strings.HasSuffix(file, "test.wma") {
-					// TODO Not sure why this is not working for WMA
-					Expect(m.Tags).To(HaveKeyWithValue("tracktotal", []string{"10"}))
-				}
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("discnumber", []string{"1"}),
-					HaveKeyWithValue("discnumber", []string{"1/2"}),
-				))
-				Expect(m.Tags).To(HaveKeyWithValue("disctotal", []string{"2"}))
-
-				// WMA does not have a "compilation" tag, but "wm/iscompilation"
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("compilation", []string{"1"}),
-					HaveKeyWithValue("wm/iscompilation", []string{"1"})),
-				)
-
-				if id3Lyrics {
-					Expect(m.Tags).To(HaveKeyWithValue("lyrics:eng", []string{
-						"[00:00.00]This is\n[00:02.50]English",
-					}))
-					Expect(m.Tags).To(HaveKeyWithValue("lyrics:xxx", []string{
-						"[00:00.00]This is\n[00:02.50]unspecified",
-					}))
-				} else {
-					Expect(m.Tags).To(HaveKeyWithValue("lyrics:xxx", []string{
-						"[00:00.00]This is\n[00:02.50]unspecified",
-						"[00:00.00]This is\n[00:02.50]English",
-					}))
-				}
-
-				Expect(m.Tags).To(HaveKeyWithValue("comment", []string{"Comment1\nComment2"}))
-			},
-
-			// ffmpeg -f lavfi -i "sine=frequency=1200:duration=1" test.flac
-			Entry("correctly parses flac tags", "test.flac", "1s", 1, 44100, 16, "+4.06 dB", "0.12496948", "+4.06 dB", "0.12496948", false, true),
-
-			Entry("correctly parses m4a (aac) gain tags", "01 Invisible (RED) Edit Version.m4a", "1.04s", 2, 44100, 16, "0.37", "0.48", "0.37", "0.48", false, true),
-			Entry("correctly parses m4a (aac) gain tags (uppercase)", "test.m4a", "1.04s", 2, 44100, 16, "0.37", "0.48", "0.37", "0.48", false, true),
-			Entry("correctly parses ogg (vorbis) tags", "test.ogg", "1.04s", 2, 8000, 0, "+7.64 dB", "0.11772506", "+7.64 dB", "0.11772506", false, true),
-
-			// ffmpeg -f lavfi -i "sine=frequency=900:duration=1" test.wma
-			// Weird note: for the tag parsing to work, the lyrics are actually stored in the reverse order
-			Entry("correctly parses wma/asf tags", "test.wma", "1.02s", 1, 44100, 16, "3.27 dB", "0.132914", "3.27 dB", "0.132914", false, true),
-
-			// ffmpeg -f lavfi -i "sine=frequency=800:duration=1" test.wv
-			Entry("correctly parses wv (wavpak) tags", "test.wv", "1s", 1, 44100, 16, "3.43 dB", "0.125061", "3.43 dB", "0.125061", false, true),
-
-			// ffmpeg -f lavfi -i "sine=frequency=1000:duration=1" test.wav
-			Entry("correctly parses wav tags", "test.wav", "1s", 1, 44100, 16, "3.06 dB", "0.125056", "3.06 dB", "0.125056", true, true),
-
-			// ffmpeg -f lavfi -i "sine=frequency=1400:duration=1" test.aiff
-			Entry("correctly parses aiff tags", "test.aiff", "1s", 1, 44100, 16, "2.00 dB", "0.124972", "2.00 dB", "0.124972", true, true),
-		)
-
-		// Skip these tests when running as root
-		Context("Access Forbidden", func() {
-			var accessForbiddenFile string
-			var RegularUserContext = XContext
-			var isRegularUser = os.Getuid() != 0
-			if isRegularUser {
-				RegularUserContext = Context
-			}
-
-			// Only run permission tests if we are not root
-			RegularUserContext("when run without root privileges", func() {
-				BeforeEach(func() {
-					// Use root fs for absolute paths in temp directory
-					e = &extractor{fs: os.DirFS("/")}
-					accessForbiddenFile = utils.TempFileName("access_forbidden-", ".mp3")
-
-					f, err := os.OpenFile(accessForbiddenFile, os.O_WRONLY|os.O_CREATE, 0222)
-					Expect(err).ToNot(HaveOccurred())
-
-					DeferCleanup(func() {
-						Expect(f.Close()).To(Succeed())
-						Expect(os.Remove(accessForbiddenFile)).To(Succeed())
-					})
-				})
-
-				It("correctly handle unreadable file due to insufficient read permission", func() {
-					// Strip leading slash for DirFS rooted at "/"
-					_, err := e.extractMetadata(accessForbiddenFile[1:])
-					Expect(err).To(MatchError(os.ErrPermission))
-				})
-
-				It("skips the file if it cannot be read", func() {
-					// Get current working directory to construct paths relative to root
-					cwd, err := os.Getwd()
-					Expect(err).ToNot(HaveOccurred())
-					// Strip leading slash for DirFS rooted at "/"
-					files := []string{
-						cwd[1:] + "/tests/fixtures/test.mp3",
-						cwd[1:] + "/tests/fixtures/test.ogg",
-						accessForbiddenFile[1:],
-					}
-					mds, err := e.Parse(files...)
-					Expect(err).NotTo(HaveOccurred())
-					Expect(mds).To(HaveLen(2))
-					Expect(mds).ToNot(HaveKey(accessForbiddenFile[1:]))
-				})
-			})
-		})
-
-	})
-
-	Describe("Error Checking", func() {
-		It("returns a generic ErrPath if file does not exist", func() {
-			testFilePath := "tests/fixtures/NON_EXISTENT.ogg"
-			_, err := e.extractMetadata(testFilePath)
-			Expect(err).To(MatchError(fs.ErrNotExist))
-		})
-		It("does not throw a SIGSEGV error when reading a file with an invalid frame", func() {
-			// File has an empty TDAT frame
-			md, err := e.extractMetadata("tests/fixtures/invalid-files/test-invalid-frame.mp3")
-			Expect(err).ToNot(HaveOccurred())
-			Expect(md.Tags).To(HaveKeyWithValue("albumartist", []string{"Elvis Presley"}))
-		})
-	})
-
-	Describe("parseTIPL", func() {
-		var tags map[string][]string
-
-		BeforeEach(func() {
-			tags = make(map[string][]string)
-		})
-
-		Context("when the TIPL string is populated", func() {
-			It("correctly parses roles and names", func() {
-				tags["tipl"] = []string{"arranger Andrew Powell DJ-mix François Kevorkian DJ-mix Jane Doe engineer Chris Blair"}
-				parseTIPL(tags)
-				Expect(tags["arranger"]).To(ConsistOf("Andrew Powell"))
-				Expect(tags["engineer"]).To(ConsistOf("Chris Blair"))
-				Expect(tags["djmixer"]).To(ConsistOf("François Kevorkian", "Jane Doe"))
-			})
-
-			It("handles multiple names for a single role", func() {
-				tags["tipl"] = []string{"engineer Pat Stapley producer Eric Woolfson engineer Chris Blair"}
-				parseTIPL(tags)
-				Expect(tags["producer"]).To(ConsistOf("Eric Woolfson"))
-				Expect(tags["engineer"]).To(ConsistOf("Pat Stapley", "Chris Blair"))
-			})
-
-			It("discards roles without names", func() {
-				tags["tipl"] = []string{"engineer Pat Stapley producer engineer Chris Blair"}
-				parseTIPL(tags)
-				Expect(tags).ToNot(HaveKey("producer"))
-				Expect(tags["engineer"]).To(ConsistOf("Pat Stapley", "Chris Blair"))
-			})
-		})
-
-		Context("when the TIPL string is empty", func() {
-			It("does nothing", func() {
-				tags["tipl"] = []string{""}
-				parseTIPL(tags)
-				Expect(tags).To(BeEmpty())
-			})
-		})
-
-		Context("when the TIPL is not present", func() {
-			It("does nothing", func() {
-				parseTIPL(tags)
-				Expect(tags).To(BeEmpty())
-			})
-		})
-	})
-
-})

adapters/listenbrainz/agent_test.go

@@ -1,443 +0,0 @@
-package listenbrainz
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"io"
-	"net/http"
-	"os"
-	"time"
-
-	"github.com/navidrome/navidrome/consts"
-	"github.com/navidrome/navidrome/core/agents"
-	"github.com/navidrome/navidrome/core/scrobbler"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gstruct"
-)
-
-var _ = Describe("listenBrainzAgent", func() {
-	var ds model.DataStore
-	var ctx context.Context
-	var agent *listenBrainzAgent
-	var httpClient *tests.FakeHttpClient
-	var track *model.MediaFile
-
-	BeforeEach(func() {
-		ds = &tests.MockDataStore{}
-		ctx = context.Background()
-		_ = ds.UserProps(ctx).Put("user-1", sessionKeyProperty, "SK-1")
-		httpClient = &tests.FakeHttpClient{}
-		agent = listenBrainzConstructor(ds)
-		agent.client = newClient("http://localhost:8080", httpClient)
-		track = &model.MediaFile{
-			ID:                "123",
-			Title:             "Track Title",
-			Album:             "Track Album",
-			Artist:            "Track Artist",
-			TrackNumber:       1,
-			MbzRecordingID:    "mbz-123",
-			MbzAlbumID:        "mbz-456",
-			MbzReleaseGroupID: "mbz-789",
-			Duration:          142.2,
-			Participants: map[model.Role]model.ParticipantList{
-				model.RoleArtist: []model.Participant{
-					{Artist: model.Artist{ID: "ar-1", Name: "Artist 1", MbzArtistID: "mbz-111"}},
-					{Artist: model.Artist{ID: "ar-2", Name: "Artist 2", MbzArtistID: "mbz-222"}},
-				},
-			},
-		}
-	})
-
-	Describe("formatListen", func() {
-		It("constructs the listenInfo properly", func() {
-			lr := agent.formatListen(track)
-			Expect(lr).To(MatchAllFields(Fields{
-				"ListenedAt": Equal(0),
-				"TrackMetadata": MatchAllFields(Fields{
-					"ArtistName":  Equal(track.Artist),
-					"TrackName":   Equal(track.Title),
-					"ReleaseName": Equal(track.Album),
-					"AdditionalInfo": MatchAllFields(Fields{
-						"SubmissionClient":        Equal(consts.AppName),
-						"SubmissionClientVersion": Equal(consts.Version),
-						"TrackNumber":             Equal(track.TrackNumber),
-						"RecordingMBID":           Equal(track.MbzRecordingID),
-						"ReleaseMBID":             Equal(track.MbzAlbumID),
-						"ReleaseGroupMBID":        Equal(track.MbzReleaseGroupID),
-						"ArtistNames":             ConsistOf("Artist 1", "Artist 2"),
-						"ArtistMBIDs":             ConsistOf("mbz-111", "mbz-222"),
-						"DurationMs":              Equal(142200),
-					}),
-				}),
-			}))
-		})
-	})
-
-	Describe("NowPlaying", func() {
-		It("updates NowPlaying successfully", func() {
-			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(`{"status": "ok"}`)), StatusCode: 200}
-
-			err := agent.NowPlaying(ctx, "user-1", track, 0)
-			Expect(err).ToNot(HaveOccurred())
-		})
-
-		It("returns ErrNotAuthorized if user is not linked", func() {
-			err := agent.NowPlaying(ctx, "user-2", track, 0)
-			Expect(err).To(MatchError(scrobbler.ErrNotAuthorized))
-		})
-	})
-
-	Describe("Scrobble", func() {
-		var sc scrobbler.Scrobble
-
-		BeforeEach(func() {
-			sc = scrobbler.Scrobble{MediaFile: *track, TimeStamp: time.Now()}
-		})
-
-		It("sends a Scrobble successfully", func() {
-			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(`{"status": "ok"}`)), StatusCode: 200}
-
-			err := agent.Scrobble(ctx, "user-1", sc)
-			Expect(err).ToNot(HaveOccurred())
-		})
-
-		It("sets the Timestamp properly", func() {
-			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(`{"status": "ok"}`)), StatusCode: 200}
-
-			err := agent.Scrobble(ctx, "user-1", sc)
-			Expect(err).ToNot(HaveOccurred())
-
-			decoder := json.NewDecoder(httpClient.SavedRequest.Body)
-			var lr listenBrainzRequestBody
-			err = decoder.Decode(&lr)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(lr.Payload[0].ListenedAt).To(Equal(int(sc.TimeStamp.Unix())))
-		})
-
-		It("returns ErrNotAuthorized if user is not linked", func() {
-			err := agent.Scrobble(ctx, "user-2", sc)
-			Expect(err).To(MatchError(scrobbler.ErrNotAuthorized))
-		})
-
-		It("returns ErrRetryLater on error 503", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"code": 503, "error": "Cannot submit listens to queue, please try again later."}`)),
-				StatusCode: 503,
-			}
-
-			err := agent.Scrobble(ctx, "user-1", sc)
-			Expect(err).To(MatchError(scrobbler.ErrRetryLater))
-		})
-
-		It("returns ErrRetryLater on error 500", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"code": 500, "error": "Something went wrong. Please try again."}`)),
-				StatusCode: 500,
-			}
-
-			err := agent.Scrobble(ctx, "user-1", sc)
-			Expect(err).To(MatchError(scrobbler.ErrRetryLater))
-		})
-
-		It("returns ErrRetryLater on http errors", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`Bad Gateway`)),
-				StatusCode: 500,
-			}
-
-			err := agent.Scrobble(ctx, "user-1", sc)
-			Expect(err).To(MatchError(scrobbler.ErrRetryLater))
-		})
-
-		It("returns ErrUnrecoverable on other errors", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"code": 400, "error": "BadRequest: Invalid JSON document submitted."}`)),
-				StatusCode: 400,
-			}
-
-			err := agent.Scrobble(ctx, "user-1", sc)
-			Expect(err).To(MatchError(scrobbler.ErrUnrecoverable))
-		})
-	})
-
-	Describe("GetArtistUrl", func() {
-		var agent *listenBrainzAgent
-		var httpClient *tests.FakeHttpClient
-		BeforeEach(func() {
-			httpClient = &tests.FakeHttpClient{}
-			client := newClient("BASE_URL", httpClient)
-			agent = listenBrainzConstructor(ds)
-			agent.client = client
-		})
-
-		It("returns artist url when MBID present", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.artist.metadata.homepage.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			Expect(agent.GetArtistURL(ctx, "", "", "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56")).To(Equal("http://projectmili.com/"))
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Query().Get("artist_mbids")).To(Equal("d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"))
-		})
-
-		It("returns error when url not present", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.artist.metadata.no_homepage.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			_, err := agent.GetArtistURL(ctx, "", "", "7c2cc610-f998-43ef-a08f-dae3344b8973")
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Query().Get("artist_mbids")).To(Equal("7c2cc610-f998-43ef-a08f-dae3344b8973"))
-		})
-
-		It("returns error when fetch calls fails", func() {
-			httpClient.Err = errors.New("error")
-			_, err := agent.GetArtistURL(ctx, "", "", "7c2cc610-f998-43ef-a08f-dae3344b8973")
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Query().Get("artist_mbids")).To(Equal("7c2cc610-f998-43ef-a08f-dae3344b8973"))
-		})
-
-		It("returns error when ListenBrainz returns an error", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"code": 400,"error": "artist mbid 1 is not valid."}`)),
-				StatusCode: 400,
-			}
-			_, err := agent.GetArtistURL(ctx, "", "", "7c2cc610-f998-43ef-a08f-dae3344b8973")
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Query().Get("artist_mbids")).To(Equal("7c2cc610-f998-43ef-a08f-dae3344b8973"))
-		})
-	})
-
-	Describe("GetTopSongs", func() {
-		var agent *listenBrainzAgent
-		var httpClient *tests.FakeHttpClient
-		BeforeEach(func() {
-			httpClient = &tests.FakeHttpClient{}
-			client := newClient("BASE_URL", httpClient)
-			agent = listenBrainzConstructor(ds)
-			agent.client = client
-		})
-
-		It("returns error when fetch calls", func() {
-			httpClient.Err = errors.New("error")
-			_, err := agent.GetArtistTopSongs(ctx, "", "", "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56", 1)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Path).To(Equal("/1/popularity/top-recordings-for-artist/d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"))
-		})
-
-		It("returns an error on listenbrainz error", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"code":400,"error":"artist_mbid: '1' is not a valid uuid"}`)),
-				StatusCode: 400,
-			}
-			_, err := agent.GetArtistTopSongs(ctx, "", "", "1", 1)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Path).To(Equal("/1/popularity/top-recordings-for-artist/1"))
-		})
-
-		It("returns all tracks when asked", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.popularity.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			data, err := agent.GetArtistTopSongs(ctx, "", "", "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56", 2)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(data).To(Equal([]agents.Song{
-				{
-					ID:         "",
-					Name:       "world.execute(me);",
-					MBID:       "9980309d-3480-4e7e-89ce-fce971a452be",
-					Artist:     "Mili",
-					ArtistMBID: "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56",
-					Album:      "Miracle Milk",
-					AlbumMBID:  "38a8f6e1-0e34-4418-a89d-78240a367408",
-					Duration:   211912,
-				},
-				{
-					ID:         "",
-					Name:       "String Theocracy",
-					MBID:       "afa2c83d-b17f-4029-b9da-790ea9250cf9",
-					Artist:     "Mili",
-					ArtistMBID: "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56",
-					Album:      "String Theocracy",
-					AlbumMBID:  "d79a38e3-7016-4f39-a31a-f495ce914b8e",
-					Duration:   174000,
-				},
-			}))
-		})
-
-		It("returns only one track when prompted", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.popularity.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			data, err := agent.GetArtistTopSongs(ctx, "", "", "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56", 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(data).To(Equal([]agents.Song{
-				{
-					ID:         "",
-					Name:       "world.execute(me);",
-					MBID:       "9980309d-3480-4e7e-89ce-fce971a452be",
-					Artist:     "Mili",
-					ArtistMBID: "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56",
-					Album:      "Miracle Milk",
-					AlbumMBID:  "38a8f6e1-0e34-4418-a89d-78240a367408",
-					Duration:   211912,
-				},
-			}))
-		})
-	})
-
-	Describe("GetSimilarArtists", func() {
-		var agent *listenBrainzAgent
-		var httpClient *tests.FakeHttpClient
-		baseUrl := "https://labs.api.listenbrainz.org/similar-artists/json?algorithm=session_based_days_9000_session_300_contribution_5_threshold_15_limit_50_skip_30&artist_mbids="
-		mbid := "db92a151-1ac2-438b-bc43-b82e149ddd50"
-
-		BeforeEach(func() {
-			httpClient = &tests.FakeHttpClient{}
-			client := newClient("BASE_URL", httpClient)
-			agent = listenBrainzConstructor(ds)
-			agent.client = client
-		})
-
-		It("returns error when fetch calls", func() {
-			httpClient.Err = errors.New("error")
-			_, err := agent.GetSimilarArtists(ctx, "", "", mbid, 1)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + mbid))
-		})
-
-		It("returns an error on listenbrainz error", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`Bad request`)),
-				StatusCode: 400,
-			}
-			_, err := agent.GetSimilarArtists(ctx, "", "", "1", 1)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "1"))
-		})
-
-		It("returns all data on call", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-artists.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-
-			resp, err := agent.GetSimilarArtists(ctx, "", "", "db92a151-1ac2-438b-bc43-b82e149ddd50", 2)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + mbid))
-			Expect(resp).To(Equal([]agents.Artist{
-				{MBID: "f27ec8db-af05-4f36-916e-3d57f91ecf5e", Name: "Michael Jackson"},
-				{MBID: "7364dea6-ca9a-48e3-be01-b44ad0d19897", Name: "a-ha"},
-			}))
-		})
-
-		It("returns subset of data on call", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-artists.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-
-			resp, err := agent.GetSimilarArtists(ctx, "", "", "db92a151-1ac2-438b-bc43-b82e149ddd50", 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + mbid))
-			Expect(resp).To(Equal([]agents.Artist{
-				{MBID: "f27ec8db-af05-4f36-916e-3d57f91ecf5e", Name: "Michael Jackson"},
-			}))
-		})
-	})
-
-	Describe("GetSimilarTracks", func() {
-		var agent *listenBrainzAgent
-		var httpClient *tests.FakeHttpClient
-		mbid := "8f3471b5-7e6a-48da-86a9-c1c07a0f47ae"
-		baseUrl := "https://labs.api.listenbrainz.org/similar-recordings/json?algorithm=session_based_days_9000_session_300_contribution_5_threshold_15_limit_50_skip_30&recording_mbids="
-
-		BeforeEach(func() {
-			httpClient = &tests.FakeHttpClient{}
-			client := newClient("BASE_URL", httpClient)
-			agent = listenBrainzConstructor(ds)
-			agent.client = client
-		})
-
-		It("returns error when fetch calls", func() {
-			httpClient.Err = errors.New("error")
-			_, err := agent.GetSimilarSongsByTrack(ctx, "", "", "", mbid, 1)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + mbid))
-		})
-
-		It("returns an error on listenbrainz error", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`Bad request`)),
-				StatusCode: 400,
-			}
-			_, err := agent.GetSimilarSongsByTrack(ctx, "", "", "", "1", 1)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "1"))
-		})
-
-		It("returns all data on call", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-recordings.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-
-			resp, err := agent.GetSimilarSongsByTrack(ctx, "", "", "", mbid, 2)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + mbid))
-			Expect(resp).To(Equal([]agents.Song{
-				{
-					ID:         "",
-					Name:       "Take On Me",
-					MBID:       "12f65dca-de8f-43fe-a65d-f12a02aaadf3",
-					ISRC:       "",
-					Artist:     "a‐ha",
-					ArtistMBID: "",
-					Album:      "Hunting High and Low",
-					AlbumMBID:  "4ec07fe8-e7c6-3106-a0aa-fdf92f13f7fc",
-					Duration:   0,
-				},
-				{
-					ID:         "",
-					Name:       "Wake Me Up Before You Go‐Go",
-					MBID:       "80033c72-aa19-4ba8-9227-afb075fec46e",
-					ISRC:       "",
-					Artist:     "Wham!",
-					ArtistMBID: "",
-					Album:      "Make It Big",
-					AlbumMBID:  "c143d542-48dc-446b-b523-1762da721638",
-					Duration:   0,
-				},
-			}))
-		})
-
-		It("returns subset of data on call", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-recordings.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-
-			resp, err := agent.GetSimilarSongsByTrack(ctx, "", "", "", mbid, 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + mbid))
-			Expect(resp).To(Equal([]agents.Song{
-				{
-					ID:         "",
-					Name:       "Take On Me",
-					MBID:       "12f65dca-de8f-43fe-a65d-f12a02aaadf3",
-					ISRC:       "",
-					Artist:     "a‐ha",
-					ArtistMBID: "",
-					Album:      "Hunting High and Low",
-					AlbumMBID:  "4ec07fe8-e7c6-3106-a0aa-fdf92f13f7fc",
-					Duration:   0,
-				},
-			}))
-		})
-	})
-})

adapters/listenbrainz/client.go

@@ -1,378 +0,0 @@
-package listenbrainz
-
-import (
-	"bytes"
-	"cmp"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/url"
-	"path"
-	"slices"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/log"
-)
-
-const (
-	lbzApiUrl = "https://api.listenbrainz.org/1/"
-	labsBase  = "https://labs.api.listenbrainz.org/"
-)
-
-var (
-	ErrorNotFound = errors.New("listenbrainz: not found")
-)
-
-type listenBrainzError struct {
-	Code    int
-	Message string
-}
-
-func (e *listenBrainzError) Error() string {
-	return fmt.Sprintf("ListenBrainz error(%d): %s", e.Code, e.Message)
-}
-
-type httpDoer interface {
-	Do(req *http.Request) (*http.Response, error)
-}
-
-func newClient(baseURL string, hc httpDoer) *client {
-	return &client{baseURL, hc}
-}
-
-type client struct {
-	baseURL string
-	hc      httpDoer
-}
-
-type listenBrainzResponse struct {
-	Code     int    `json:"code"`
-	Message  string `json:"message"`
-	Error    string `json:"error"`
-	Status   string `json:"status"`
-	Valid    bool   `json:"valid"`
-	UserName string `json:"user_name"`
-}
-
-type listenBrainzRequest struct {
-	ApiKey string
-	Body   listenBrainzRequestBody
-}
-
-type listenBrainzRequestBody struct {
-	ListenType listenType   `json:"listen_type,omitempty"`
-	Payload    []listenInfo `json:"payload,omitempty"`
-}
-
-type listenType string
-
-const (
-	Single     listenType = "single"
-	PlayingNow listenType = "playing_now"
-)
-
-type listenInfo struct {
-	ListenedAt    int           `json:"listened_at,omitempty"`
-	TrackMetadata trackMetadata `json:"track_metadata,omitempty"`
-}
-
-type trackMetadata struct {
-	ArtistName     string         `json:"artist_name,omitempty"`
-	TrackName      string         `json:"track_name,omitempty"`
-	ReleaseName    string         `json:"release_name,omitempty"`
-	AdditionalInfo additionalInfo `json:"additional_info,omitempty"`
-}
-
-type additionalInfo struct {
-	SubmissionClient        string   `json:"submission_client,omitempty"`
-	SubmissionClientVersion string   `json:"submission_client_version,omitempty"`
-	TrackNumber             int      `json:"tracknumber,omitempty"`
-	ArtistNames             []string `json:"artist_names,omitempty"`
-	ArtistMBIDs             []string `json:"artist_mbids,omitempty"`
-	RecordingMBID           string   `json:"recording_mbid,omitempty"`
-	ReleaseMBID             string   `json:"release_mbid,omitempty"`
-	ReleaseGroupMBID        string   `json:"release_group_mbid,omitempty"`
-	DurationMs              int      `json:"duration_ms,omitempty"`
-}
-
-func (c *client) validateToken(ctx context.Context, apiKey string) (*listenBrainzResponse, error) {
-	r := &listenBrainzRequest{
-		ApiKey: apiKey,
-	}
-	response, err := c.makeAuthenticatedRequest(ctx, http.MethodGet, "validate-token", r)
-	if err != nil {
-		return nil, err
-	}
-	return response, nil
-}
-
-func (c *client) updateNowPlaying(ctx context.Context, apiKey string, li listenInfo) error {
-	r := &listenBrainzRequest{
-		ApiKey: apiKey,
-		Body: listenBrainzRequestBody{
-			ListenType: PlayingNow,
-			Payload:    []listenInfo{li},
-		},
-	}
-
-	resp, err := c.makeAuthenticatedRequest(ctx, http.MethodPost, "submit-listens", r)
-	if err != nil {
-		return err
-	}
-	if resp.Status != "ok" {
-		log.Warn(ctx, "ListenBrainz: NowPlaying was not accepted", "status", resp.Status)
-	}
-	return nil
-}
-
-func (c *client) scrobble(ctx context.Context, apiKey string, li listenInfo) error {
-	r := &listenBrainzRequest{
-		ApiKey: apiKey,
-		Body: listenBrainzRequestBody{
-			ListenType: Single,
-			Payload:    []listenInfo{li},
-		},
-	}
-	resp, err := c.makeAuthenticatedRequest(ctx, http.MethodPost, "submit-listens", r)
-	if err != nil {
-		return err
-	}
-	if resp.Status != "ok" {
-		log.Warn(ctx, "ListenBrainz: Scrobble was not accepted", "status", resp.Status)
-	}
-	return nil
-}
-
-func (c *client) path(endpoint string) (string, error) {
-	u, err := url.Parse(c.baseURL)
-	if err != nil {
-		return "", err
-	}
-	u.Path = path.Join(u.Path, endpoint)
-	return u.String(), nil
-}
-
-func (c *client) makeAuthenticatedRequest(ctx context.Context, method string, endpoint string, r *listenBrainzRequest) (*listenBrainzResponse, error) {
-	b, _ := json.Marshal(r.Body)
-	uri, err := c.path(endpoint)
-	if err != nil {
-		return nil, err
-	}
-	req, _ := http.NewRequestWithContext(ctx, method, uri, bytes.NewBuffer(b))
-	req.Header.Add("Content-Type", "application/json; charset=UTF-8")
-
-	if r.ApiKey != "" {
-		req.Header.Add("Authorization", fmt.Sprintf("Token %s", r.ApiKey))
-	}
-
-	log.Trace(ctx, fmt.Sprintf("Sending ListenBrainz %s request", req.Method), "url", req.URL)
-	resp, err := c.hc.Do(req)
-	if err != nil {
-		return nil, err
-	}
-
-	defer resp.Body.Close()
-	decoder := json.NewDecoder(resp.Body)
-
-	var response listenBrainzResponse
-	jsonErr := decoder.Decode(&response)
-	if resp.StatusCode != 200 && jsonErr != nil {
-		return nil, fmt.Errorf("ListenBrainz: HTTP Error, Status: (%d)", resp.StatusCode)
-	}
-	if jsonErr != nil {
-		return nil, jsonErr
-	}
-	if response.Code != 0 && response.Code != 200 {
-		return &response, &listenBrainzError{Code: response.Code, Message: response.Error}
-	}
-
-	return &response, nil
-}
-
-type lbzHttpError struct {
-	Code  int    `json:"code"`
-	Error string `json:"error"`
-}
-
-func (c *client) makeGenericRequest(ctx context.Context, method string, endpoint string, params url.Values) (*http.Response, error) {
-	req, _ := http.NewRequestWithContext(ctx, method, lbzApiUrl+endpoint, nil)
-	req.Header.Add("Content-Type", "application/json; charset=UTF-8")
-	req.URL.RawQuery = params.Encode()
-
-	log.Trace(ctx, fmt.Sprintf("Sending ListenBrainz %s request", req.Method), "url", req.URL)
-	resp, err := c.hc.Do(req)
-
-	if err != nil {
-		return nil, err
-	}
-
-	// On a 200 code, there is no code. Decode using using error message if it exists
-	if resp.StatusCode != 200 {
-		defer resp.Body.Close()
-		decoder := json.NewDecoder(resp.Body)
-
-		var lbzError lbzHttpError
-		jsonErr := decoder.Decode(&lbzError)
-
-		if jsonErr != nil {
-			return nil, fmt.Errorf("ListenBrainz: HTTP Error, Status: (%d)", resp.StatusCode)
-		}
-
-		return nil, &listenBrainzError{Code: lbzError.Code, Message: lbzError.Error}
-	}
-
-	return resp, err
-}
-
-type artistMetadataResult struct {
-	Rels struct {
-		OfficialHomepage string `json:"official homepage,omitempty"`
-	} `json:"rels,omitzero"`
-}
-
-func (c *client) getArtistUrl(ctx context.Context, mbid string) (string, error) {
-	params := url.Values{}
-	params.Add("artist_mbids", mbid)
-	resp, err := c.makeGenericRequest(ctx, http.MethodGet, "metadata/artist", params)
-	if err != nil {
-		return "", err
-	}
-
-	defer resp.Body.Close()
-	decoder := json.NewDecoder(resp.Body)
-
-	var response []artistMetadataResult
-	jsonErr := decoder.Decode(&response)
-	if jsonErr != nil {
-		return "", fmt.Errorf("ListenBrainz: HTTP Error, Status: (%d)", resp.StatusCode)
-	}
-
-	if len(response) == 0 || response[0].Rels.OfficialHomepage == "" {
-		return "", ErrorNotFound
-	}
-
-	return response[0].Rels.OfficialHomepage, nil
-}
-
-type trackInfo struct {
-	ArtistName    string   `json:"artist_name"`
-	ArtistMBIDs   []string `json:"artist_mbids"`
-	DurationMs    uint32   `json:"length"`
-	RecordingName string   `json:"recording_name"`
-	RecordingMbid string   `json:"recording_mbid"`
-	ReleaseName   string   `json:"release_name"`
-	ReleaseMBID   string   `json:"release_mbid"`
-}
-
-func (c *client) getArtistTopSongs(ctx context.Context, mbid string, count int) ([]trackInfo, error) {
-	resp, err := c.makeGenericRequest(ctx, http.MethodGet, "popularity/top-recordings-for-artist/"+mbid, url.Values{})
-	if err != nil {
-		return nil, err
-	}
-
-	defer resp.Body.Close()
-	decoder := json.NewDecoder(resp.Body)
-
-	var response []trackInfo
-	jsonErr := decoder.Decode(&response)
-	if jsonErr != nil {
-		return nil, fmt.Errorf("ListenBrainz: HTTP Error, Status: (%d)", resp.StatusCode)
-	}
-
-	if len(response) > count {
-		return response[0:count], nil
-	}
-
-	return response, nil
-}
-
-type artist struct {
-	MBID  string `json:"artist_mbid"`
-	Name  string `json:"name"`
-	Score int    `json:"score"`
-}
-
-func (c *client) getSimilarArtists(ctx context.Context, mbid string, limit int) ([]artist, error) {
-	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, labsBase+"similar-artists/json", nil)
-	req.Header.Add("Content-Type", "application/json; charset=UTF-8")
-	req.URL.RawQuery = url.Values{
-		"artist_mbids": []string{mbid}, "algorithm": []string{conf.Server.ListenBrainz.ArtistAlgorithm},
-	}.Encode()
-
-	log.Trace(ctx, fmt.Sprintf("Sending ListenBrainz Labs %s request", req.Method), "url", req.URL)
-	resp, err := c.hc.Do(req)
-
-	if err != nil {
-		return nil, err
-	}
-
-	defer resp.Body.Close()
-	decoder := json.NewDecoder(resp.Body)
-
-	var artists []artist
-	jsonErr := decoder.Decode(&artists)
-	if jsonErr != nil {
-		return nil, fmt.Errorf("ListenBrainz: HTTP Error, Status: (%d)", resp.StatusCode)
-	}
-
-	if len(artists) > limit {
-		return artists[:limit], nil
-	}
-
-	return artists, nil
-}
-
-type recording struct {
-	MBID        string `json:"recording_mbid"`
-	Name        string `json:"recording_name"`
-	Artist      string `json:"artist_credit_name"`
-	ReleaseName string `json:"release_name"`
-	ReleaseMBID string `json:"release_mbid"`
-	Score       int    `json:"score"`
-}
-
-func (c *client) getSimilarRecordings(ctx context.Context, mbid string, limit int) ([]recording, error) {
-	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, labsBase+"similar-recordings/json", nil)
-	req.Header.Add("Content-Type", "application/json; charset=UTF-8")
-	req.URL.RawQuery = url.Values{
-		"recording_mbids": []string{mbid}, "algorithm": []string{conf.Server.ListenBrainz.TrackAlgorithm},
-	}.Encode()
-
-	log.Trace(ctx, fmt.Sprintf("Sending ListenBrainz Labs %s request", req.Method), "url", req.URL)
-	resp, err := c.hc.Do(req)
-
-	if err != nil {
-		return nil, err
-	}
-
-	defer resp.Body.Close()
-	decoder := json.NewDecoder(resp.Body)
-
-	var recordings []recording
-	jsonErr := decoder.Decode(&recordings)
-	if jsonErr != nil {
-		return nil, fmt.Errorf("ListenBrainz: HTTP Error, Status: (%d)", resp.StatusCode)
-	}
-
-	// For whatever reason, labs API isn't guaranteed to give results in the proper order
-	// and may also provide duplicates. See listenbrainz.labs.similar-recordings-real-out-of-order.json
-	// generated from https://labs.api.listenbrainz.org/similar-recordings/json?recording_mbids=8f3471b5-7e6a-48da-86a9-c1c07a0f47ae&algorithm=session_based_days_180_session_300_contribution_5_threshold_15_limit_50_skip_30
-	slices.SortFunc(recordings, func(a, b recording) int {
-		return cmp.Or(
-			cmp.Compare(b.Score, a.Score), // Sort by score descending
-			cmp.Compare(a.MBID, b.MBID),   // Then by MBID ascending to ensure deterministic order for duplicates
-		)
-	})
-
-	recordings = slices.CompactFunc(recordings, func(a, b recording) bool {
-		return a.MBID == b.MBID
-	})
-
-	if len(recordings) > limit {
-		return recordings[:limit], nil
-	}
-
-	return recordings, nil
-}

adapters/listenbrainz/client_test.go

@@ -1,464 +0,0 @@
-package listenbrainz
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/conf/configtest"
-	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("client", func() {
-	var httpClient *tests.FakeHttpClient
-	var client *client
-	BeforeEach(func() {
-		httpClient = &tests.FakeHttpClient{}
-		client = newClient("BASE_URL/", httpClient)
-	})
-
-	Describe("listenBrainzResponse", func() {
-		It("parses a response properly", func() {
-			var response listenBrainzResponse
-			err := json.Unmarshal([]byte(`{"code": 200, "message": "Message", "user_name": "UserName", "valid": true, "status": "ok", "error": "Error"}`), &response)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(response.Code).To(Equal(200))
-			Expect(response.Message).To(Equal("Message"))
-			Expect(response.UserName).To(Equal("UserName"))
-			Expect(response.Valid).To(BeTrue())
-			Expect(response.Status).To(Equal("ok"))
-			Expect(response.Error).To(Equal("Error"))
-		})
-	})
-
-	Describe("validateToken", func() {
-		BeforeEach(func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"code": 200, "message": "Token valid.", "user_name": "ListenBrainzUser", "valid": true}`)),
-				StatusCode: 200,
-			}
-		})
-
-		It("formats the request properly", func() {
-			_, err := client.validateToken(context.Background(), "LB-TOKEN")
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal("BASE_URL/validate-token"))
-			Expect(httpClient.SavedRequest.Header.Get("Authorization")).To(Equal("Token LB-TOKEN"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("parses and returns the response", func() {
-			res, err := client.validateToken(context.Background(), "LB-TOKEN")
-			Expect(err).ToNot(HaveOccurred())
-			Expect(res.Valid).To(Equal(true))
-			Expect(res.UserName).To(Equal("ListenBrainzUser"))
-		})
-	})
-
-	Context("with listenInfo", func() {
-		var li listenInfo
-		BeforeEach(func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"status": "ok"}`)),
-				StatusCode: 200,
-			}
-			li = listenInfo{
-				TrackMetadata: trackMetadata{
-					ArtistName:  "Track Artist",
-					TrackName:   "Track Title",
-					ReleaseName: "Track Album",
-					AdditionalInfo: additionalInfo{
-						TrackNumber:   1,
-						ArtistNames:   []string{"Artist 1", "Artist 2"},
-						ArtistMBIDs:   []string{"mbz-789", "mbz-012"},
-						RecordingMBID: "mbz-123",
-						ReleaseMBID:   "mbz-456",
-						DurationMs:    142200,
-					},
-				},
-			}
-		})
-
-		Describe("updateNowPlaying", func() {
-			It("formats the request properly", func() {
-				Expect(client.updateNowPlaying(context.Background(), "LB-TOKEN", li)).To(Succeed())
-				Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodPost))
-				Expect(httpClient.SavedRequest.URL.String()).To(Equal("BASE_URL/submit-listens"))
-				Expect(httpClient.SavedRequest.Header.Get("Authorization")).To(Equal("Token LB-TOKEN"))
-				Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-
-				body, _ := io.ReadAll(httpClient.SavedRequest.Body)
-				f, _ := os.ReadFile("tests/fixtures/listenbrainz.nowplaying.request.json")
-				Expect(body).To(MatchJSON(f))
-			})
-		})
-
-		Describe("scrobble", func() {
-			BeforeEach(func() {
-				li.ListenedAt = 1635000000
-			})
-
-			It("formats the request properly", func() {
-				Expect(client.scrobble(context.Background(), "LB-TOKEN", li)).To(Succeed())
-				Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodPost))
-				Expect(httpClient.SavedRequest.URL.String()).To(Equal("BASE_URL/submit-listens"))
-				Expect(httpClient.SavedRequest.Header.Get("Authorization")).To(Equal("Token LB-TOKEN"))
-				Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-
-				body, _ := io.ReadAll(httpClient.SavedRequest.Body)
-				f, _ := os.ReadFile("tests/fixtures/listenbrainz.scrobble.request.json")
-				Expect(body).To(MatchJSON(f))
-			})
-		})
-	})
-
-	Context("getArtistUrl", func() {
-		baseUrl := "https://api.listenbrainz.org/1/metadata/artist?"
-		It("handles a malformed request with status code", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"code": 400,"error": "artist mbid 1 is not valid."}`)),
-				StatusCode: 400,
-			}
-			_, err := client.getArtistUrl(context.Background(), "1")
-			Expect(err.Error()).To(Equal("ListenBrainz error(400): artist mbid 1 is not valid."))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "artist_mbids=1"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("handles a malformed request without meaningful body", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(``)),
-				StatusCode: 501,
-			}
-			_, err := client.getArtistUrl(context.Background(), "1")
-			Expect(err.Error()).To(Equal("ListenBrainz: HTTP Error, Status: (501)"))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "artist_mbids=1"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("It returns not found when the artist has no official homepage", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.artist.metadata.no_homepage.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			_, err := client.getArtistUrl(context.Background(), "7c2cc610-f998-43ef-a08f-dae3344b8973")
-			Expect(err.Error()).To(Equal("listenbrainz: not found"))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "artist_mbids=7c2cc610-f998-43ef-a08f-dae3344b8973"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("It returns data when the artist has a homepage", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.artist.metadata.homepage.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			url, err := client.getArtistUrl(context.Background(), "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56")
-			Expect(err).ToNot(HaveOccurred())
-			Expect(url).To(Equal("http://projectmili.com/"))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "artist_mbids=d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-	})
-
-	Context("getArtistTopSongs", func() {
-		baseUrl := "https://api.listenbrainz.org/1/popularity/top-recordings-for-artist/"
-
-		It("handles a malformed request with status code", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"code":400,"error":"artist_mbid: '1' is not a valid uuid"}`)),
-				StatusCode: 400,
-			}
-			_, err := client.getArtistTopSongs(context.Background(), "1", 50)
-			Expect(err.Error()).To(Equal("ListenBrainz error(400): artist_mbid: '1' is not a valid uuid"))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "1"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("handles a malformed request without standard body", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(``)),
-				StatusCode: 500,
-			}
-			_, err := client.getArtistTopSongs(context.Background(), "1", 1)
-			Expect(err.Error()).To(Equal("ListenBrainz: HTTP Error, Status: (500)"))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "1"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("It returns all tracks when given the opportunity", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.popularity.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			data, err := client.getArtistTopSongs(context.Background(), "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56", 5)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(data).To(Equal([]trackInfo{
-				{
-					ArtistName:    "Mili",
-					ArtistMBIDs:   []string{"d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"},
-					DurationMs:    211912,
-					RecordingName: "world.execute(me);",
-					RecordingMbid: "9980309d-3480-4e7e-89ce-fce971a452be",
-					ReleaseName:   "Miracle Milk",
-					ReleaseMBID:   "38a8f6e1-0e34-4418-a89d-78240a367408",
-				},
-				{
-					ArtistName:    "Mili",
-					ArtistMBIDs:   []string{"d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"},
-					DurationMs:    174000,
-					RecordingName: "String Theocracy",
-					RecordingMbid: "afa2c83d-b17f-4029-b9da-790ea9250cf9",
-					ReleaseName:   "String Theocracy",
-					ReleaseMBID:   "d79a38e3-7016-4f39-a31a-f495ce914b8e",
-				},
-			}))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("It returns a subset of tracks when allowed", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.popularity.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			data, err := client.getArtistTopSongs(context.Background(), "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56", 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(data).To(Equal([]trackInfo{
-				{
-					ArtistName:    "Mili",
-					ArtistMBIDs:   []string{"d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"},
-					DurationMs:    211912,
-					RecordingName: "world.execute(me);",
-					RecordingMbid: "9980309d-3480-4e7e-89ce-fce971a452be",
-					ReleaseName:   "Miracle Milk",
-					ReleaseMBID:   "38a8f6e1-0e34-4418-a89d-78240a367408",
-				},
-			}))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-	})
-
-	Context("getSimilarArtists", func() {
-		var algorithm string
-
-		BeforeEach(func() {
-			algorithm = "session_based_days_9000_session_300_contribution_5_threshold_15_limit_50_skip_30"
-			DeferCleanup(configtest.SetupConfig())
-		})
-
-		getUrl := func(mbid string) string {
-			return fmt.Sprintf("https://labs.api.listenbrainz.org/similar-artists/json?algorithm=%s&artist_mbids=%s", algorithm, mbid)
-		}
-
-		mbid := "db92a151-1ac2-438b-bc43-b82e149ddd50"
-
-		It("handles a malformed request with status code", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`Bad request`)),
-				StatusCode: 400,
-			}
-			_, err := client.getSimilarArtists(context.Background(), "1", 2)
-			Expect(err.Error()).To(Equal("ListenBrainz: HTTP Error, Status: (400)"))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl("1")))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("handles real data properly", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-artists.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			resp, err := client.getSimilarArtists(context.Background(), mbid, 2)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl(mbid)))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-			Expect(resp).To(Equal([]artist{
-				{MBID: "f27ec8db-af05-4f36-916e-3d57f91ecf5e", Name: "Michael Jackson", Score: 800},
-				{MBID: "7364dea6-ca9a-48e3-be01-b44ad0d19897", Name: "a-ha", Score: 792},
-			}))
-		})
-
-		It("truncates data when requested", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-artists.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			resp, err := client.getSimilarArtists(context.Background(), "db92a151-1ac2-438b-bc43-b82e149ddd50", 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl(mbid)))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-			Expect(resp).To(Equal([]artist{
-				{MBID: "f27ec8db-af05-4f36-916e-3d57f91ecf5e", Name: "Michael Jackson", Score: 800},
-			}))
-		})
-
-		It("fetches a different endpoint when algorithm changes", func() {
-			algorithm = "session_based_days_1825_session_300_contribution_3_threshold_10_limit_100_filter_True_skip_30"
-			conf.Server.ListenBrainz.ArtistAlgorithm = algorithm
-
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-artists.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			resp, err := client.getSimilarArtists(context.Background(), mbid, 2)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl(mbid)))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-			Expect(resp).To(Equal([]artist{
-				{MBID: "f27ec8db-af05-4f36-916e-3d57f91ecf5e", Name: "Michael Jackson", Score: 800},
-				{MBID: "7364dea6-ca9a-48e3-be01-b44ad0d19897", Name: "a-ha", Score: 792},
-			}))
-		})
-	})
-
-	Context("getSimilarRecordings", func() {
-		var algorithm string
-
-		BeforeEach(func() {
-			algorithm = "session_based_days_9000_session_300_contribution_5_threshold_15_limit_50_skip_30"
-			DeferCleanup(configtest.SetupConfig())
-		})
-
-		getUrl := func(mbid string) string {
-			return fmt.Sprintf("https://labs.api.listenbrainz.org/similar-recordings/json?algorithm=%s&recording_mbids=%s", algorithm, mbid)
-		}
-
-		mbid := "8f3471b5-7e6a-48da-86a9-c1c07a0f47ae"
-
-		It("handles a malformed request with status code", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`Bad request`)),
-				StatusCode: 400,
-			}
-			_, err := client.getSimilarRecordings(context.Background(), "1", 2)
-			Expect(err.Error()).To(Equal("ListenBrainz: HTTP Error, Status: (400)"))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl("1")))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("handles real data properly", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-recordings.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			resp, err := client.getSimilarRecordings(context.Background(), mbid, 2)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl(mbid)))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-			Expect(resp).To(Equal([]recording{
-				{
-					MBID:        "12f65dca-de8f-43fe-a65d-f12a02aaadf3",
-					Name:        "Take On Me",
-					Artist:      "a‐ha",
-					ReleaseName: "Hunting High and Low",
-					ReleaseMBID: "4ec07fe8-e7c6-3106-a0aa-fdf92f13f7fc",
-					Score:       124,
-				},
-				{
-					MBID:        "80033c72-aa19-4ba8-9227-afb075fec46e",
-					Name:        "Wake Me Up Before You Go‐Go",
-					Artist:      "Wham!",
-					ReleaseName: "Make It Big",
-					ReleaseMBID: "c143d542-48dc-446b-b523-1762da721638",
-					Score:       65,
-				},
-			}))
-		})
-
-		It("truncates data when requested", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-recordings.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			resp, err := client.getSimilarRecordings(context.Background(), mbid, 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl(mbid)))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-			Expect(resp).To(Equal([]recording{
-				{
-					MBID:        "12f65dca-de8f-43fe-a65d-f12a02aaadf3",
-					Name:        "Take On Me",
-					Artist:      "a‐ha",
-					ReleaseName: "Hunting High and Low",
-					ReleaseMBID: "4ec07fe8-e7c6-3106-a0aa-fdf92f13f7fc",
-					Score:       124,
-				},
-			}))
-		})
-
-		It("properly sorts by score and truncates duplicates", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-recordings-real-out-of-order.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			// There are actually 5 items. The dedup should happen FIRST
-			resp, err := client.getSimilarRecordings(context.Background(), mbid, 4)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl(mbid)))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-			Expect(resp).To(Equal([]recording{
-				{
-					MBID:        "12f65dca-de8f-43fe-a65d-f12a02aaadf3",
-					Name:        "Take On Me",
-					Artist:      "a‐ha",
-					ReleaseName: "Hunting High and Low",
-					ReleaseMBID: "4ec07fe8-e7c6-3106-a0aa-fdf92f13f7fc",
-					Score:       124,
-				},
-				{
-					MBID:        "e4b347be-ecb2-44ff-aaa8-3d4c517d7ea5",
-					Name:        "Everybody Wants to Rule the World",
-					Artist:      "Tears for Fears",
-					ReleaseName: "Songs From the Big Chair",
-					ReleaseMBID: "21f19b06-81f1-347a-add5-5d0c77696597",
-					Score:       68,
-				},
-				{
-					MBID:        "80033c72-aa19-4ba8-9227-afb075fec46e",
-					Name:        "Wake Me Up Before You Go‐Go",
-					Artist:      "Wham!",
-					ReleaseName: "Make It Big",
-					ReleaseMBID: "c143d542-48dc-446b-b523-1762da721638",
-					Score:       65,
-				},
-				{
-					MBID:        "ef4c6855-949e-4e22-b41e-8e0a2d372d5f",
-					Name:        "Tainted Love",
-					Artist:      "Soft Cell",
-					ReleaseName: "Non-Stop Erotic Cabaret",
-					ReleaseMBID: "1acaa870-6e0c-4b6e-9e91-fdec4e5ea4b1",
-					Score:       61,
-				},
-			}))
-		})
-
-		It("uses a different algorithm when configured", func() {
-			algorithm = "session_based_days_180_session_300_contribution_5_threshold_15_limit_50_skip_30"
-			conf.Server.ListenBrainz.TrackAlgorithm = algorithm
-
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-recordings.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			resp, err := client.getSimilarRecordings(context.Background(), mbid, 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl(mbid)))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-			Expect(resp).To(Equal([]recording{
-				{
-					MBID:        "12f65dca-de8f-43fe-a65d-f12a02aaadf3",
-					Name:        "Take On Me",
-					Artist:      "a‐ha",
-					ReleaseName: "Hunting High and Low",
-					ReleaseMBID: "4ec07fe8-e7c6-3106-a0aa-fdf92f13f7fc",
-					Score:       124,
-				},
-			}))
-		})
-	})
-})

adapters/taglib/end_to_end_test.go

@@ -151,7 +151,11 @@ var _ = Describe("Extractor", func() {
 			unsSylt := makeLyrics("xxx", "unspecified SYLT")
 			unsUslt := makeLyrics("xxx", "unspecified")
 
-			Expect(lyrics).To(ConsistOf(engSylt, engUslt, unsSylt, unsUslt))
+			// Why is the order inconsistent between runs? Nobody knows
+			Expect(lyrics).To(Or(
+				Equal(model.LyricList{engSylt, engUslt, unsSylt, unsUslt}),
+				Equal(model.LyricList{unsSylt, unsUslt, engSylt, engUslt}),
+			))
 		})
 
 		DescribeTable("format-specific lyrics", func(file string, isId3 bool) {

adapters/taglib/taglib.go

@@ -168,7 +168,7 @@ func parseTIPL(tags map[string][]string) {
 var _ local.Extractor = (*extractor)(nil)
 
 func init() {
-	local.RegisterExtractor("legacy-taglib", func(_ fs.FS, baseDir string) local.Extractor {
+	local.RegisterExtractor("taglib", func(_ fs.FS, baseDir string) local.Extractor {
 		// ignores fs, as taglib extractor only works with local files
 		return &extractor{baseDir}
 	})

adapters/taglib/taglib_test.go

@@ -80,11 +80,12 @@ var _ = Describe("Extractor", func() {
 			Expect(err).To(BeNil())
 			Expect(m.Tags).To(HaveKeyWithValue("fbpm", []string{"141.7"}))
 
-			// TagLib 1.12 returns 18, previous versions return 39.
+			// TabLib 1.12 returns 18, previous versions return 39.
 			// See https://github.com/taglib/taglib/commit/2f238921824741b2cfe6fbfbfc9701d9827ab06b
 			Expect(m.AudioProperties.BitRate).To(BeElementOf(18, 19, 39, 40, 43, 49))
 			Expect(m.AudioProperties.Channels).To(BeElementOf(2))
 			Expect(m.AudioProperties.SampleRate).To(BeElementOf(8000))
+			Expect(m.AudioProperties.SampleRate).To(BeElementOf(8000))
 			Expect(m.HasPicture).To(BeTrue())
 		})
 
@@ -105,7 +106,7 @@ var _ = Describe("Extractor", func() {
 
 				Expect(m.Tags).To(Or(
 					HaveKeyWithValue("replaygain_album_gain", []string{albumGain}),
-					HaveKeyWithValue("----:com.apple.itunes:replaygain_album_gain", []string{albumGain}),
+					HaveKeyWithValue("----:com.apple.itunes:replaygain_track_gain", []string{albumGain}),
 				))
 
 				Expect(m.Tags).To(Or(

cmd/pls.go

@@ -10,8 +10,11 @@ import (
 	"strconv"
 
 	"github.com/Masterminds/squirrel"
+	"github.com/navidrome/navidrome/core/auth"
+	"github.com/navidrome/navidrome/db"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/persistence"
 	"github.com/spf13/cobra"
 )
 
@@ -49,7 +52,7 @@ var (
 		Short: "Export playlists",
 		Long:  "Export Navidrome playlists to M3U files",
 		Run: func(cmd *cobra.Command, args []string) {
-			runExporter(cmd.Context())
+			runExporter()
 		},
 	}
 
@@ -57,13 +60,15 @@ var (
 		Use:   "list",
 		Short: "List playlists",
 		Run: func(cmd *cobra.Command, args []string) {
-			runList(cmd.Context())
+			runList()
 		},
 	}
 )
 
-func runExporter(ctx context.Context) {
-	ds, ctx := getAdminContext(ctx)
+func runExporter() {
+	sqlDB := db.Db()
+	ds := persistence.New(sqlDB)
+	ctx := auth.WithAdminUser(context.Background(), ds)
 	playlist, err := ds.Playlist(ctx).GetWithTracks(playlistID, true, false)
 	if err != nil && !errors.Is(err, model.ErrNotFound) {
 		log.Fatal("Error retrieving playlist", "name", playlistID, err)
@@ -95,19 +100,31 @@ func runExporter(ctx context.Context) {
 	}
 }
 
-func runList(ctx context.Context) {
+func runList() {
 	if outputFormat != "csv" && outputFormat != "json" {
 		log.Fatal("Invalid output format. Must be one of csv, json", "format", outputFormat)
 	}
 
-	ds, ctx := getAdminContext(ctx)
+	sqlDB := db.Db()
+	ds := persistence.New(sqlDB)
+	ctx := auth.WithAdminUser(context.Background(), ds)
+
 	options := model.QueryOptions{Sort: "owner_name"}
 
 	if userID != "" {
-		user, err := getUser(ctx, userID, ds)
-		if err != nil {
-			log.Fatal(ctx, "Error retrieving user", "username or id", userID)
+		user, err := ds.User(ctx).FindByUsername(userID)
+
+		if err != nil && !errors.Is(err, model.ErrNotFound) {
+			log.Fatal("Error retrieving user by name", "name", userID, err)
 		}
+
+		if errors.Is(err, model.ErrNotFound) {
+			user, err = ds.User(ctx).Get(userID)
+			if err != nil {
+				log.Fatal("Error retrieving user by id", "id", userID, err)
+			}
+		}
+
 		options.Filters = squirrel.Eq{"owner_id": user.ID}
 	}
 

cmd/plugin.go

@@ -0,0 +1,716 @@
+package cmd
+
+import (
+	"cmp"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"text/tabwriter"
+	"time"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/plugins"
+	"github.com/navidrome/navidrome/plugins/schema"
+	"github.com/navidrome/navidrome/utils"
+	"github.com/navidrome/navidrome/utils/slice"
+	"github.com/spf13/cobra"
+)
+
+const (
+	pluginPackageExtension = ".ndp"
+	pluginDirPermissions   = 0700
+	pluginFilePermissions  = 0600
+)
+
+func init() {
+	pluginCmd := &cobra.Command{
+		Use:   "plugin",
+		Short: "Manage Navidrome plugins",
+		Long:  "Commands for managing Navidrome plugins",
+	}
+
+	listCmd := &cobra.Command{
+		Use:   "list",
+		Short: "List installed plugins",
+		Long:  "List all installed plugins with their metadata",
+		Run:   pluginList,
+	}
+
+	infoCmd := &cobra.Command{
+		Use:   "info [pluginPackage|pluginName]",
+		Short: "Show details of a plugin",
+		Long:  "Show detailed information about a plugin package (.ndp file) or an installed plugin",
+		Args:  cobra.ExactArgs(1),
+		Run:   pluginInfo,
+	}
+
+	installCmd := &cobra.Command{
+		Use:   "install [pluginPackage]",
+		Short: "Install a plugin from a .ndp file",
+		Long:  "Install a Navidrome Plugin Package (.ndp) file",
+		Args:  cobra.ExactArgs(1),
+		Run:   pluginInstall,
+	}
+
+	removeCmd := &cobra.Command{
+		Use:   "remove [pluginName]",
+		Short: "Remove an installed plugin",
+		Long:  "Remove a plugin by name",
+		Args:  cobra.ExactArgs(1),
+		Run:   pluginRemove,
+	}
+
+	updateCmd := &cobra.Command{
+		Use:   "update [pluginPackage]",
+		Short: "Update an existing plugin",
+		Long:  "Update an installed plugin with a new version from a .ndp file",
+		Args:  cobra.ExactArgs(1),
+		Run:   pluginUpdate,
+	}
+
+	refreshCmd := &cobra.Command{
+		Use:   "refresh [pluginName]",
+		Short: "Reload a plugin without restarting Navidrome",
+		Long:  "Reload and recompile a plugin without needing to restart Navidrome",
+		Args:  cobra.ExactArgs(1),
+		Run:   pluginRefresh,
+	}
+
+	devCmd := &cobra.Command{
+		Use:   "dev [folder_path]",
+		Short: "Create symlink to development folder",
+		Long:  "Create a symlink from a plugin development folder to the plugins directory for easier development",
+		Args:  cobra.ExactArgs(1),
+		Run:   pluginDev,
+	}
+
+	pluginCmd.AddCommand(listCmd, infoCmd, installCmd, removeCmd, updateCmd, refreshCmd, devCmd)
+	rootCmd.AddCommand(pluginCmd)
+}
+
+// Validation helpers
+
+func validatePluginPackageFile(path string) error {
+	if !utils.FileExists(path) {
+		return fmt.Errorf("plugin package not found: %s", path)
+	}
+	if filepath.Ext(path) != pluginPackageExtension {
+		return fmt.Errorf("not a valid plugin package: %s (expected %s extension)", path, pluginPackageExtension)
+	}
+	return nil
+}
+
+func validatePluginDirectory(pluginsDir, pluginName string) (string, error) {
+	pluginDir := filepath.Join(pluginsDir, pluginName)
+	if !utils.FileExists(pluginDir) {
+		return "", fmt.Errorf("plugin not found: %s (path: %s)", pluginName, pluginDir)
+	}
+	return pluginDir, nil
+}
+
+func resolvePluginPath(pluginDir string) (resolvedPath string, isSymlink bool, err error) {
+	// Check if it's a directory or a symlink
+	lstat, err := os.Lstat(pluginDir)
+	if err != nil {
+		return "", false, fmt.Errorf("failed to stat plugin: %w", err)
+	}
+
+	isSymlink = lstat.Mode()&os.ModeSymlink != 0
+
+	if isSymlink {
+		// Resolve the symlink target
+		targetDir, err := os.Readlink(pluginDir)
+		if err != nil {
+			return "", true, fmt.Errorf("failed to resolve symlink: %w", err)
+		}
+
+		// If target is a relative path, make it absolute
+		if !filepath.IsAbs(targetDir) {
+			targetDir = filepath.Join(filepath.Dir(pluginDir), targetDir)
+		}
+
+		// Verify the target exists and is a directory
+		targetInfo, err := os.Stat(targetDir)
+		if err != nil {
+			return "", true, fmt.Errorf("failed to access symlink target %s: %w", targetDir, err)
+		}
+
+		if !targetInfo.IsDir() {
+			return "", true, fmt.Errorf("symlink target is not a directory: %s", targetDir)
+		}
+
+		return targetDir, true, nil
+	} else if !lstat.IsDir() {
+		return "", false, fmt.Errorf("not a valid plugin directory: %s", pluginDir)
+	}
+
+	return pluginDir, false, nil
+}
+
+// Package handling helpers
+
+func loadAndValidatePackage(ndpPath string) (*plugins.PluginPackage, error) {
+	if err := validatePluginPackageFile(ndpPath); err != nil {
+		return nil, err
+	}
+
+	pkg, err := plugins.LoadPackage(ndpPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load plugin package: %w", err)
+	}
+
+	return pkg, nil
+}
+
+func extractAndSetupPlugin(ndpPath, targetDir string) error {
+	if err := plugins.ExtractPackage(ndpPath, targetDir); err != nil {
+		return fmt.Errorf("failed to extract plugin package: %w", err)
+	}
+
+	ensurePluginDirPermissions(targetDir)
+	return nil
+}
+
+// Display helpers
+
+func displayPluginTableRow(w *tabwriter.Writer, discovery plugins.PluginDiscoveryEntry) {
+	if discovery.Error != nil {
+		// Handle global errors (like directory read failure)
+		if discovery.ID == "" {
+			log.Error("Failed to read plugins directory", "folder", conf.Server.Plugins.Folder, discovery.Error)
+			return
+		}
+		// Handle individual plugin errors - show them in the table
+		fmt.Fprintf(w, "%s\tERROR\tERROR\tERROR\tERROR\t%v\n", discovery.ID, discovery.Error)
+		return
+	}
+
+	// Mark symlinks with an indicator
+	nameDisplay := discovery.Manifest.Name
+	if discovery.IsSymlink {
+		nameDisplay = nameDisplay + " (dev)"
+	}
+
+	// Convert capabilities to strings
+	capabilities := slice.Map(discovery.Manifest.Capabilities, func(cap schema.PluginManifestCapabilitiesElem) string {
+		return string(cap)
+	})
+
+	fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\n",
+		discovery.ID,
+		nameDisplay,
+		cmp.Or(discovery.Manifest.Author, "-"),
+		cmp.Or(discovery.Manifest.Version, "-"),
+		strings.Join(capabilities, ", "),
+		cmp.Or(discovery.Manifest.Description, "-"))
+}
+
+func displayTypedPermissions(permissions schema.PluginManifestPermissions, indent string) {
+	if permissions.Http != nil {
+		fmt.Printf("%shttp:\n", indent)
+		fmt.Printf("%s  Reason: %s\n", indent, permissions.Http.Reason)
+		fmt.Printf("%s  Allow Local Network: %t\n", indent, permissions.Http.AllowLocalNetwork)
+		fmt.Printf("%s  Allowed URLs:\n", indent)
+		for urlPattern, methodEnums := range permissions.Http.AllowedUrls {
+			methods := make([]string, len(methodEnums))
+			for i, methodEnum := range methodEnums {
+				methods[i] = string(methodEnum)
+			}
+			fmt.Printf("%s    %s: [%s]\n", indent, urlPattern, strings.Join(methods, ", "))
+		}
+		fmt.Println()
+	}
+
+	if permissions.Config != nil {
+		fmt.Printf("%sconfig:\n", indent)
+		fmt.Printf("%s  Reason: %s\n", indent, permissions.Config.Reason)
+		fmt.Println()
+	}
+
+	if permissions.Scheduler != nil {
+		fmt.Printf("%sscheduler:\n", indent)
+		fmt.Printf("%s  Reason: %s\n", indent, permissions.Scheduler.Reason)
+		fmt.Println()
+	}
+
+	if permissions.Websocket != nil {
+		fmt.Printf("%swebsocket:\n", indent)
+		fmt.Printf("%s  Reason: %s\n", indent, permissions.Websocket.Reason)
+		fmt.Printf("%s  Allow Local Network: %t\n", indent, permissions.Websocket.AllowLocalNetwork)
+		fmt.Printf("%s  Allowed URLs: [%s]\n", indent, strings.Join(permissions.Websocket.AllowedUrls, ", "))
+		fmt.Println()
+	}
+
+	if permissions.Cache != nil {
+		fmt.Printf("%scache:\n", indent)
+		fmt.Printf("%s  Reason: %s\n", indent, permissions.Cache.Reason)
+		fmt.Println()
+	}
+
+	if permissions.Artwork != nil {
+		fmt.Printf("%sartwork:\n", indent)
+		fmt.Printf("%s  Reason: %s\n", indent, permissions.Artwork.Reason)
+		fmt.Println()
+	}
+
+	if permissions.Subsonicapi != nil {
+		allowedUsers := "All Users"
+		if len(permissions.Subsonicapi.AllowedUsernames) > 0 {
+			allowedUsers = strings.Join(permissions.Subsonicapi.AllowedUsernames, ", ")
+		}
+		fmt.Printf("%ssubsonicapi:\n", indent)
+		fmt.Printf("%s  Reason: %s\n", indent, permissions.Subsonicapi.Reason)
+		fmt.Printf("%s  Allow Admins: %t\n", indent, permissions.Subsonicapi.AllowAdmins)
+		fmt.Printf("%s  Allowed Usernames: [%s]\n", indent, allowedUsers)
+		fmt.Println()
+	}
+}
+
+func displayPluginDetails(manifest *schema.PluginManifest, fileInfo *pluginFileInfo, permInfo *pluginPermissionInfo) {
+	fmt.Println("\nPlugin Information:")
+	fmt.Printf("  Name:        %s\n", manifest.Name)
+	fmt.Printf("  Author:      %s\n", manifest.Author)
+	fmt.Printf("  Version:     %s\n", manifest.Version)
+	fmt.Printf("  Description: %s\n", manifest.Description)
+
+	fmt.Print("  Capabilities:    ")
+	capabilities := make([]string, len(manifest.Capabilities))
+	for i, cap := range manifest.Capabilities {
+		capabilities[i] = string(cap)
+	}
+	fmt.Print(strings.Join(capabilities, ", "))
+	fmt.Println()
+
+	// Display manifest permissions using the typed permissions
+	fmt.Println("  Required Permissions:")
+	displayTypedPermissions(manifest.Permissions, "    ")
+
+	// Print file information if available
+	if fileInfo != nil {
+		fmt.Println("Package Information:")
+		fmt.Printf("  File:        %s\n", fileInfo.path)
+		fmt.Printf("  Size:        %d bytes (%.2f KB)\n", fileInfo.size, float64(fileInfo.size)/1024)
+		fmt.Printf("  SHA-256:     %s\n", fileInfo.hash)
+		fmt.Printf("  Modified:    %s\n", fileInfo.modTime.Format(time.RFC3339))
+	}
+
+	// Print file permissions information if available
+	if permInfo != nil {
+		fmt.Println("File Permissions:")
+		fmt.Printf("  Plugin Directory: %s (%s)\n", permInfo.dirPath, permInfo.dirMode)
+		if permInfo.isSymlink {
+			fmt.Printf("  Symlink Target:   %s (%s)\n", permInfo.targetPath, permInfo.targetMode)
+		}
+		fmt.Printf("  Manifest File:    %s\n", permInfo.manifestMode)
+		if permInfo.wasmMode != "" {
+			fmt.Printf("  WASM File:        %s\n", permInfo.wasmMode)
+		}
+	}
+}
+
+type pluginFileInfo struct {
+	path    string
+	size    int64
+	hash    string
+	modTime time.Time
+}
+
+type pluginPermissionInfo struct {
+	dirPath      string
+	dirMode      string
+	isSymlink    bool
+	targetPath   string
+	targetMode   string
+	manifestMode string
+	wasmMode     string
+}
+
+func getFileInfo(path string) *pluginFileInfo {
+	fileInfo, err := os.Stat(path)
+	if err != nil {
+		log.Error("Failed to get file information", err)
+		return nil
+	}
+
+	return &pluginFileInfo{
+		path:    path,
+		size:    fileInfo.Size(),
+		hash:    calculateSHA256(path),
+		modTime: fileInfo.ModTime(),
+	}
+}
+
+func getPermissionInfo(pluginDir string) *pluginPermissionInfo {
+	// Get plugin directory permissions
+	dirInfo, err := os.Lstat(pluginDir)
+	if err != nil {
+		log.Error("Failed to get plugin directory permissions", err)
+		return nil
+	}
+
+	permInfo := &pluginPermissionInfo{
+		dirPath: pluginDir,
+		dirMode: dirInfo.Mode().String(),
+	}
+
+	// Check if it's a symlink
+	if dirInfo.Mode()&os.ModeSymlink != 0 {
+		permInfo.isSymlink = true
+
+		// Get target path and permissions
+		targetPath, err := os.Readlink(pluginDir)
+		if err == nil {
+			if !filepath.IsAbs(targetPath) {
+				targetPath = filepath.Join(filepath.Dir(pluginDir), targetPath)
+			}
+			permInfo.targetPath = targetPath
+
+			if targetInfo, err := os.Stat(targetPath); err == nil {
+				permInfo.targetMode = targetInfo.Mode().String()
+			}
+		}
+	}
+
+	// Get manifest file permissions
+	manifestPath := filepath.Join(pluginDir, "manifest.json")
+	if manifestInfo, err := os.Stat(manifestPath); err == nil {
+		permInfo.manifestMode = manifestInfo.Mode().String()
+	}
+
+	// Get WASM file permissions (look for .wasm files)
+	entries, err := os.ReadDir(pluginDir)
+	if err == nil {
+		for _, entry := range entries {
+			if filepath.Ext(entry.Name()) == ".wasm" {
+				wasmPath := filepath.Join(pluginDir, entry.Name())
+				if wasmInfo, err := os.Stat(wasmPath); err == nil {
+					permInfo.wasmMode = wasmInfo.Mode().String()
+					break // Just show the first WASM file found
+				}
+			}
+		}
+	}
+
+	return permInfo
+}
+
+// Command implementations
+
+func pluginList(cmd *cobra.Command, args []string) {
+	discoveries := plugins.DiscoverPlugins(conf.Server.Plugins.Folder)
+
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+	fmt.Fprintln(w, "ID\tNAME\tAUTHOR\tVERSION\tCAPABILITIES\tDESCRIPTION")
+
+	for _, discovery := range discoveries {
+		displayPluginTableRow(w, discovery)
+	}
+	w.Flush()
+}
+
+func pluginInfo(cmd *cobra.Command, args []string) {
+	path := args[0]
+	pluginsDir := conf.Server.Plugins.Folder
+
+	var manifest *schema.PluginManifest
+	var fileInfo *pluginFileInfo
+	var permInfo *pluginPermissionInfo
+
+	if filepath.Ext(path) == pluginPackageExtension {
+		// It's a package file
+		pkg, err := loadAndValidatePackage(path)
+		if err != nil {
+			log.Fatal("Failed to load plugin package", err)
+		}
+		manifest = pkg.Manifest
+		fileInfo = getFileInfo(path)
+		// No permission info for package files
+	} else {
+		// It's a plugin name
+		pluginDir, err := validatePluginDirectory(pluginsDir, path)
+		if err != nil {
+			log.Fatal("Plugin validation failed", err)
+		}
+
+		manifest, err = plugins.LoadManifest(pluginDir)
+		if err != nil {
+			log.Fatal("Failed to load plugin manifest", err)
+		}
+
+		// Get permission info for installed plugins
+		permInfo = getPermissionInfo(pluginDir)
+	}
+
+	displayPluginDetails(manifest, fileInfo, permInfo)
+}
+
+func pluginInstall(cmd *cobra.Command, args []string) {
+	ndpPath := args[0]
+	pluginsDir := conf.Server.Plugins.Folder
+
+	pkg, err := loadAndValidatePackage(ndpPath)
+	if err != nil {
+		log.Fatal("Package validation failed", err)
+	}
+
+	// Create target directory based on plugin name
+	targetDir := filepath.Join(pluginsDir, pkg.Manifest.Name)
+
+	// Check if plugin already exists
+	if utils.FileExists(targetDir) {
+		log.Fatal("Plugin already installed", "name", pkg.Manifest.Name, "path", targetDir,
+			"use", "navidrome plugin update")
+	}
+
+	if err := extractAndSetupPlugin(ndpPath, targetDir); err != nil {
+		log.Fatal("Plugin installation failed", err)
+	}
+
+	fmt.Printf("Plugin '%s' v%s installed successfully\n", pkg.Manifest.Name, pkg.Manifest.Version)
+}
+
+func pluginRemove(cmd *cobra.Command, args []string) {
+	pluginName := args[0]
+	pluginsDir := conf.Server.Plugins.Folder
+
+	pluginDir, err := validatePluginDirectory(pluginsDir, pluginName)
+	if err != nil {
+		log.Fatal("Plugin validation failed", err)
+	}
+
+	_, isSymlink, err := resolvePluginPath(pluginDir)
+	if err != nil {
+		log.Fatal("Failed to resolve plugin path", err)
+	}
+
+	if isSymlink {
+		// For symlinked plugins (dev mode), just remove the symlink
+		if err := os.Remove(pluginDir); err != nil {
+			log.Fatal("Failed to remove plugin symlink", "name", pluginName, err)
+		}
+		fmt.Printf("Development plugin symlink '%s' removed successfully (target directory preserved)\n", pluginName)
+	} else {
+		// For regular plugins, remove the entire directory
+		if err := os.RemoveAll(pluginDir); err != nil {
+			log.Fatal("Failed to remove plugin directory", "name", pluginName, err)
+		}
+		fmt.Printf("Plugin '%s' removed successfully\n", pluginName)
+	}
+}
+
+func pluginUpdate(cmd *cobra.Command, args []string) {
+	ndpPath := args[0]
+	pluginsDir := conf.Server.Plugins.Folder
+
+	pkg, err := loadAndValidatePackage(ndpPath)
+	if err != nil {
+		log.Fatal("Package validation failed", err)
+	}
+
+	// Check if plugin exists
+	targetDir := filepath.Join(pluginsDir, pkg.Manifest.Name)
+	if !utils.FileExists(targetDir) {
+		log.Fatal("Plugin not found", "name", pkg.Manifest.Name, "path", targetDir,
+			"use", "navidrome plugin install")
+	}
+
+	// Create a backup of the existing plugin
+	backupDir := targetDir + ".bak." + time.Now().Format("20060102150405")
+	if err := os.Rename(targetDir, backupDir); err != nil {
+		log.Fatal("Failed to backup existing plugin", err)
+	}
+
+	// Extract the new package
+	if err := extractAndSetupPlugin(ndpPath, targetDir); err != nil {
+		// Restore backup if extraction failed
+		os.RemoveAll(targetDir)
+		_ = os.Rename(backupDir, targetDir) // Ignore error as we're already in a fatal path
+		log.Fatal("Plugin update failed", err)
+	}
+
+	// Remove the backup
+	os.RemoveAll(backupDir)
+
+	fmt.Printf("Plugin '%s' updated to v%s successfully\n", pkg.Manifest.Name, pkg.Manifest.Version)
+}
+
+func pluginRefresh(cmd *cobra.Command, args []string) {
+	pluginName := args[0]
+	pluginsDir := conf.Server.Plugins.Folder
+
+	pluginDir, err := validatePluginDirectory(pluginsDir, pluginName)
+	if err != nil {
+		log.Fatal("Plugin validation failed", err)
+	}
+
+	resolvedPath, isSymlink, err := resolvePluginPath(pluginDir)
+	if err != nil {
+		log.Fatal("Failed to resolve plugin path", err)
+	}
+
+	if isSymlink {
+		log.Debug("Processing symlinked plugin", "name", pluginName, "link", pluginDir, "target", resolvedPath)
+	}
+
+	fmt.Printf("Refreshing plugin '%s'...\n", pluginName)
+
+	// Get the plugin manager and refresh
+	mgr := GetPluginManager(cmd.Context())
+	log.Debug("Scanning plugins directory", "path", pluginsDir)
+	mgr.ScanPlugins()
+
+	log.Info("Waiting for plugin compilation to complete", "name", pluginName)
+
+	// Wait for compilation to complete
+	if err := mgr.EnsureCompiled(pluginName); err != nil {
+		log.Fatal("Failed to compile refreshed plugin", "name", pluginName, err)
+	}
+
+	log.Info("Plugin compilation completed successfully", "name", pluginName)
+	fmt.Printf("Plugin '%s' refreshed successfully\n", pluginName)
+}
+
+func pluginDev(cmd *cobra.Command, args []string) {
+	sourcePath, err := filepath.Abs(args[0])
+	if err != nil {
+		log.Fatal("Invalid path", "path", args[0], err)
+	}
+	pluginsDir := conf.Server.Plugins.Folder
+
+	// Validate source directory and manifest
+	if err := validateDevSource(sourcePath); err != nil {
+		log.Fatal("Source validation failed", err)
+	}
+
+	// Load manifest to get plugin name
+	manifest, err := plugins.LoadManifest(sourcePath)
+	if err != nil {
+		log.Fatal("Failed to load plugin manifest", "path", filepath.Join(sourcePath, "manifest.json"), err)
+	}
+
+	pluginName := cmp.Or(manifest.Name, filepath.Base(sourcePath))
+	targetPath := filepath.Join(pluginsDir, pluginName)
+
+	// Handle existing target
+	if err := handleExistingTarget(targetPath, sourcePath); err != nil {
+		log.Fatal("Failed to handle existing target", err)
+	}
+
+	// Create target directory if needed
+	if err := os.MkdirAll(filepath.Dir(targetPath), 0755); err != nil {
+		log.Fatal("Failed to create plugins directory", "path", filepath.Dir(targetPath), err)
+	}
+
+	// Create the symlink
+	if err := os.Symlink(sourcePath, targetPath); err != nil {
+		log.Fatal("Failed to create symlink", "source", sourcePath, "target", targetPath, err)
+	}
+
+	fmt.Printf("Development symlink created: '%s' -> '%s'\n", targetPath, sourcePath)
+	fmt.Println("Plugin can be refreshed with: navidrome plugin refresh", pluginName)
+}
+
+// Utility functions
+
+func validateDevSource(sourcePath string) error {
+	sourceInfo, err := os.Stat(sourcePath)
+	if err != nil {
+		return fmt.Errorf("source folder not found: %s (%w)", sourcePath, err)
+	}
+	if !sourceInfo.IsDir() {
+		return fmt.Errorf("source path is not a directory: %s", sourcePath)
+	}
+
+	manifestPath := filepath.Join(sourcePath, "manifest.json")
+	if !utils.FileExists(manifestPath) {
+		return fmt.Errorf("source folder missing manifest.json: %s", sourcePath)
+	}
+
+	return nil
+}
+
+func handleExistingTarget(targetPath, sourcePath string) error {
+	if !utils.FileExists(targetPath) {
+		return nil // Nothing to handle
+	}
+
+	// Check if it's already a symlink to our source
+	existingLink, err := os.Readlink(targetPath)
+	if err == nil && existingLink == sourcePath {
+		fmt.Printf("Symlink already exists and points to the correct source\n")
+		return fmt.Errorf("symlink already exists") // This will cause early return in caller
+	}
+
+	// Handle case where target exists but is not a symlink to our source
+	fmt.Printf("Target path '%s' already exists.\n", targetPath)
+	fmt.Print("Do you want to replace it? (y/N): ")
+	var response string
+	_, err = fmt.Scanln(&response)
+	if err != nil || strings.ToLower(response) != "y" {
+		if err != nil {
+			log.Debug("Error reading input, assuming 'no'", err)
+		}
+		return fmt.Errorf("operation canceled")
+	}
+
+	// Remove existing target
+	if err := os.RemoveAll(targetPath); err != nil {
+		return fmt.Errorf("failed to remove existing target %s: %w", targetPath, err)
+	}
+
+	return nil
+}
+
+func ensurePluginDirPermissions(dir string) {
+	if err := os.Chmod(dir, pluginDirPermissions); err != nil {
+		log.Error("Failed to set plugin directory permissions", "dir", dir, err)
+	}
+
+	// Apply permissions to all files in the directory
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		log.Error("Failed to read plugin directory", "dir", dir, err)
+		return
+	}
+
+	for _, entry := range entries {
+		path := filepath.Join(dir, entry.Name())
+		info, err := os.Stat(path)
+		if err != nil {
+			log.Error("Failed to stat file", "path", path, err)
+			continue
+		}
+
+		mode := os.FileMode(pluginFilePermissions) // Files
+		if info.IsDir() {
+			mode = os.FileMode(pluginDirPermissions) // Directories
+			ensurePluginDirPermissions(path)         // Recursive
+		}
+
+		if err := os.Chmod(path, mode); err != nil {
+			log.Error("Failed to set file permissions", "path", path, err)
+		}
+	}
+}
+
+func calculateSHA256(filePath string) string {
+	file, err := os.Open(filePath)
+	if err != nil {
+		log.Error("Failed to open file for hashing", err)
+		return "N/A"
+	}
+	defer file.Close()
+
+	hasher := sha256.New()
+	if _, err := io.Copy(hasher, file); err != nil {
+		log.Error("Failed to calculate hash", err)
+		return "N/A"
+	}
+
+	return hex.EncodeToString(hasher.Sum(nil))
+}

cmd/plugin_test.go

@@ -0,0 +1,193 @@
+package cmd
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/conf/configtest"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/spf13/cobra"
+)
+
+var _ = Describe("Plugin CLI Commands", func() {
+	var tempDir string
+	var cmd *cobra.Command
+	var stdOut *os.File
+	var origStdout *os.File
+	var outReader *os.File
+
+	// Helper to create a test plugin with the given name and details
+	createTestPlugin := func(name, author, version string, capabilities []string) string {
+		pluginDir := filepath.Join(tempDir, name)
+		Expect(os.MkdirAll(pluginDir, 0755)).To(Succeed())
+
+		// Create a properly formatted capabilities JSON array
+		capabilitiesJSON := `"` + strings.Join(capabilities, `", "`) + `"`
+
+		manifest := `{
+			"name": "` + name + `",
+			"author": "` + author + `",
+			"version": "` + version + `",
+			"description": "Plugin for testing",
+			"website": "https://test.navidrome.org/` + name + `",
+			"capabilities": [` + capabilitiesJSON + `],
+			"permissions": {}
+		}`
+
+		Expect(os.WriteFile(filepath.Join(pluginDir, "manifest.json"), []byte(manifest), 0600)).To(Succeed())
+
+		// Create a dummy WASM file
+		wasmContent := []byte("dummy wasm content for testing")
+		Expect(os.WriteFile(filepath.Join(pluginDir, "plugin.wasm"), wasmContent, 0600)).To(Succeed())
+
+		return pluginDir
+	}
+
+	// Helper to execute a command and return captured output
+	captureOutput := func(reader io.Reader) string {
+		stdOut.Close()
+		outputBytes, err := io.ReadAll(reader)
+		Expect(err).NotTo(HaveOccurred())
+		return string(outputBytes)
+	}
+
+	BeforeEach(func() {
+		DeferCleanup(configtest.SetupConfig())
+		tempDir = GinkgoT().TempDir()
+
+		// Setup config
+		conf.Server.Plugins.Enabled = true
+		conf.Server.Plugins.Folder = tempDir
+
+		// Create a command for testing
+		cmd = &cobra.Command{Use: "test"}
+
+		// Setup stdout capture
+		origStdout = os.Stdout
+		var err error
+		outReader, stdOut, err = os.Pipe()
+		Expect(err).NotTo(HaveOccurred())
+		os.Stdout = stdOut
+
+		DeferCleanup(func() {
+			os.Stdout = origStdout
+		})
+	})
+
+	AfterEach(func() {
+		os.Stdout = origStdout
+		if stdOut != nil {
+			stdOut.Close()
+		}
+		if outReader != nil {
+			outReader.Close()
+		}
+	})
+
+	Describe("Plugin list command", func() {
+		It("should list installed plugins", func() {
+			// Create test plugins
+			createTestPlugin("plugin1", "Test Author", "1.0.0", []string{"MetadataAgent"})
+			createTestPlugin("plugin2", "Another Author", "2.1.0", []string{"Scrobbler"})
+
+			// Execute command
+			pluginList(cmd, []string{})
+
+			// Verify output
+			output := captureOutput(outReader)
+
+			Expect(output).To(ContainSubstring("plugin1"))
+			Expect(output).To(ContainSubstring("Test Author"))
+			Expect(output).To(ContainSubstring("1.0.0"))
+			Expect(output).To(ContainSubstring("MetadataAgent"))
+
+			Expect(output).To(ContainSubstring("plugin2"))
+			Expect(output).To(ContainSubstring("Another Author"))
+			Expect(output).To(ContainSubstring("2.1.0"))
+			Expect(output).To(ContainSubstring("Scrobbler"))
+		})
+	})
+
+	Describe("Plugin info command", func() {
+		It("should display information about an installed plugin", func() {
+			// Create test plugin with multiple capabilities
+			createTestPlugin("test-plugin", "Test Author", "1.0.0",
+				[]string{"MetadataAgent", "Scrobbler"})
+
+			// Execute command
+			pluginInfo(cmd, []string{"test-plugin"})
+
+			// Verify output
+			output := captureOutput(outReader)
+
+			Expect(output).To(ContainSubstring("Name:        test-plugin"))
+			Expect(output).To(ContainSubstring("Author:      Test Author"))
+			Expect(output).To(ContainSubstring("Version:     1.0.0"))
+			Expect(output).To(ContainSubstring("Description: Plugin for testing"))
+			Expect(output).To(ContainSubstring("Capabilities:    MetadataAgent, Scrobbler"))
+		})
+	})
+
+	Describe("Plugin remove command", func() {
+		It("should remove a regular plugin directory", func() {
+			// Create test plugin
+			pluginDir := createTestPlugin("regular-plugin", "Test Author", "1.0.0",
+				[]string{"MetadataAgent"})
+
+			// Execute command
+			pluginRemove(cmd, []string{"regular-plugin"})
+
+			// Verify output
+			output := captureOutput(outReader)
+			Expect(output).To(ContainSubstring("Plugin 'regular-plugin' removed successfully"))
+
+			// Verify directory is actually removed
+			_, err := os.Stat(pluginDir)
+			Expect(os.IsNotExist(err)).To(BeTrue())
+		})
+
+		It("should remove only the symlink for a development plugin", func() {
+			// Create a real source directory
+			sourceDir := filepath.Join(GinkgoT().TempDir(), "dev-plugin-source")
+			Expect(os.MkdirAll(sourceDir, 0755)).To(Succeed())
+
+			manifest := `{
+				"name": "dev-plugin",
+				"author": "Dev Author",
+				"version": "0.1.0",
+				"description": "Development plugin for testing",
+				"website": "https://test.navidrome.org/dev-plugin",
+				"capabilities": ["Scrobbler"],
+				"permissions": {}
+			}`
+			Expect(os.WriteFile(filepath.Join(sourceDir, "manifest.json"), []byte(manifest), 0600)).To(Succeed())
+
+			// Create a dummy WASM file
+			wasmContent := []byte("dummy wasm content for testing")
+			Expect(os.WriteFile(filepath.Join(sourceDir, "plugin.wasm"), wasmContent, 0600)).To(Succeed())
+
+			// Create a symlink in the plugins directory
+			symlinkPath := filepath.Join(tempDir, "dev-plugin")
+			Expect(os.Symlink(sourceDir, symlinkPath)).To(Succeed())
+
+			// Execute command
+			pluginRemove(cmd, []string{"dev-plugin"})
+
+			// Verify output
+			output := captureOutput(outReader)
+			Expect(output).To(ContainSubstring("Development plugin symlink 'dev-plugin' removed successfully"))
+			Expect(output).To(ContainSubstring("target directory preserved"))
+
+			// Verify the symlink is removed but source directory exists
+			_, err := os.Lstat(symlinkPath)
+			Expect(os.IsNotExist(err)).To(BeTrue())
+
+			_, err = os.Stat(sourceDir)
+			Expect(err).NotTo(HaveOccurred())
+		})
+	})
+})

cmd/root.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/go-chi/chi/v5/middleware"
+	_ "github.com/navidrome/navidrome/adapters/taglib"
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/db"
@@ -21,14 +22,6 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"golang.org/x/sync/errgroup"
-
-	// Import adapters to register them
-	_ "github.com/navidrome/navidrome/adapters/deezer"
-	_ "github.com/navidrome/navidrome/adapters/gotaglib"
-	_ "github.com/navidrome/navidrome/adapters/lastfm"
-	_ "github.com/navidrome/navidrome/adapters/listenbrainz"
-	_ "github.com/navidrome/navidrome/adapters/spotify"
-	_ "github.com/navidrome/navidrome/adapters/taglib"
 )
 
 var (
@@ -337,13 +330,16 @@ func startPlaybackServer(ctx context.Context) func() error {
 // startPluginManager starts the plugin manager, if configured.
 func startPluginManager(ctx context.Context) func() error {
 	return func() error {
-		manager := GetPluginManager(ctx)
 		if !conf.Server.Plugins.Enabled {
-			log.Debug("Plugin system is DISABLED")
+			log.Debug("Plugins are DISABLED")
 			return nil
 		}
 		log.Info(ctx, "Starting plugin manager")
-		return manager.Start(ctx)
+		// Get the manager instance and scan for plugins
+		manager := GetPluginManager(ctx)
+		manager.ScanPlugins()
+
+		return nil
 	}
 }
 
@@ -378,7 +374,6 @@ func init() {
 	rootCmd.Flags().Duration("scaninterval", viper.GetDuration("scaninterval"), "how frequently to scan for changes in your music library")
 	rootCmd.Flags().String("uiloginbackgroundurl", viper.GetString("uiloginbackgroundurl"), "URL to a backaground image used in the Login page")
 	rootCmd.Flags().Bool("enabletranscodingconfig", viper.GetBool("enabletranscodingconfig"), "enables transcoding configuration in the UI")
-	rootCmd.Flags().Bool("enabletranscodingcancellation", viper.GetBool("enabletranscodingcancellation"), "enables transcoding context cancellation")
 	rootCmd.Flags().String("transcodingcachesize", viper.GetString("transcodingcachesize"), "size of transcoding cache")
 	rootCmd.Flags().String("imagecachesize", viper.GetString("imagecachesize"), "size of image (art work) cache. set to 0 to disable cache")
 	rootCmd.Flags().String("albumplaycountmode", viper.GetString("albumplaycountmode"), "how to compute playcount for albums. absolute (default) or normalized")
@@ -402,7 +397,6 @@ func init() {
 	_ = viper.BindPFlag("prometheus.metricspath", rootCmd.Flags().Lookup("prometheus.metricspath"))
 
 	_ = viper.BindPFlag("enabletranscodingconfig", rootCmd.Flags().Lookup("enabletranscodingconfig"))
-	_ = viper.BindPFlag("enabletranscodingcancellation", rootCmd.Flags().Lookup("enabletranscodingcancellation"))
 	_ = viper.BindPFlag("transcodingcachesize", rootCmd.Flags().Lookup("transcodingcachesize"))
 	_ = viper.BindPFlag("imagecachesize", rootCmd.Flags().Lookup("imagecachesize"))
 }

cmd/scan.go

@@ -1,12 +1,9 @@
 package cmd
 
 import (
-	"bufio"
 	"context"
 	"encoding/gob"
-	"fmt"
 	"os"
-	"strings"
 
 	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/db"
@@ -22,14 +19,12 @@ var (
 	fullScan   bool
 	subprocess bool
 	targets    []string
-	targetFile string
 )
 
 func init() {
 	scanCmd.Flags().BoolVarP(&fullScan, "full", "f", false, "check all subfolders, ignoring timestamps")
 	scanCmd.Flags().BoolVarP(&subprocess, "subprocess", "", false, "run as subprocess (internal use)")
 	scanCmd.Flags().StringArrayVarP(&targets, "target", "t", []string{}, "list of libraryID:folderPath pairs, can be repeated (e.g., \"-t 1:Music/Rock -t 1:Music/Jazz -t 2:Classical\")")
-	scanCmd.Flags().StringVar(&targetFile, "target-file", "", "path to file containing targets (one libraryID:folderPath per line)")
 	rootCmd.AddCommand(scanCmd)
 }
 
@@ -76,17 +71,10 @@ func runScanner(ctx context.Context) {
 	ds := persistence.New(sqlDB)
 	pls := core.NewPlaylists(ds)
 
-	// Parse targets from command line or file
+	// Parse targets if provided
 	var scanTargets []model.ScanTarget
-	var err error
-
-	if targetFile != "" {
-		scanTargets, err = readTargetsFromFile(targetFile)
-		if err != nil {
-			log.Fatal(ctx, "Failed to read targets from file", err)
-		}
-		log.Info(ctx, "Scanning specific folders from file", "numTargets", len(scanTargets))
-	} else if len(targets) > 0 {
+	if len(targets) > 0 {
+		var err error
 		scanTargets, err = model.ParseTargets(targets)
 		if err != nil {
 			log.Fatal(ctx, "Failed to parse targets", err)
@@ -106,31 +94,3 @@ func runScanner(ctx context.Context) {
 		trackScanInteractively(ctx, progress)
 	}
 }
-
-// readTargetsFromFile reads scan targets from a file, one per line.
-// Each line should be in the format "libraryID:folderPath".
-// Empty lines and lines starting with # are ignored.
-func readTargetsFromFile(filePath string) ([]model.ScanTarget, error) {
-	file, err := os.Open(filePath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to open target file: %w", err)
-	}
-	defer file.Close()
-
-	var targetStrings []string
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		line := strings.TrimSpace(scanner.Text())
-		// Skip empty lines and comments
-		if line == "" {
-			continue
-		}
-		targetStrings = append(targetStrings, line)
-	}
-
-	if err := scanner.Err(); err != nil {
-		return nil, fmt.Errorf("failed to read target file: %w", err)
-	}
-
-	return model.ParseTargets(targetStrings)
-}

cmd/scan_test.go

@@ -1,89 +0,0 @@
-package cmd
-
-import (
-	"os"
-	"path/filepath"
-
-	"github.com/navidrome/navidrome/model"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("readTargetsFromFile", func() {
-	var tempDir string
-
-	BeforeEach(func() {
-		var err error
-		tempDir, err = os.MkdirTemp("", "navidrome-test-")
-		Expect(err).ToNot(HaveOccurred())
-	})
-
-	AfterEach(func() {
-		os.RemoveAll(tempDir)
-	})
-
-	It("reads valid targets from file", func() {
-		filePath := filepath.Join(tempDir, "targets.txt")
-		content := "1:Music/Rock\n2:Music/Jazz\n3:Classical\n"
-		err := os.WriteFile(filePath, []byte(content), 0600)
-		Expect(err).ToNot(HaveOccurred())
-
-		targets, err := readTargetsFromFile(filePath)
-		Expect(err).ToNot(HaveOccurred())
-		Expect(targets).To(HaveLen(3))
-		Expect(targets[0]).To(Equal(model.ScanTarget{LibraryID: 1, FolderPath: "Music/Rock"}))
-		Expect(targets[1]).To(Equal(model.ScanTarget{LibraryID: 2, FolderPath: "Music/Jazz"}))
-		Expect(targets[2]).To(Equal(model.ScanTarget{LibraryID: 3, FolderPath: "Classical"}))
-	})
-
-	It("skips empty lines", func() {
-		filePath := filepath.Join(tempDir, "targets.txt")
-		content := "1:Music/Rock\n\n2:Music/Jazz\n\n"
-		err := os.WriteFile(filePath, []byte(content), 0600)
-		Expect(err).ToNot(HaveOccurred())
-
-		targets, err := readTargetsFromFile(filePath)
-		Expect(err).ToNot(HaveOccurred())
-		Expect(targets).To(HaveLen(2))
-	})
-
-	It("trims whitespace", func() {
-		filePath := filepath.Join(tempDir, "targets.txt")
-		content := "  1:Music/Rock  \n\t2:Music/Jazz\t\n"
-		err := os.WriteFile(filePath, []byte(content), 0600)
-		Expect(err).ToNot(HaveOccurred())
-
-		targets, err := readTargetsFromFile(filePath)
-		Expect(err).ToNot(HaveOccurred())
-		Expect(targets).To(HaveLen(2))
-		Expect(targets[0].FolderPath).To(Equal("Music/Rock"))
-		Expect(targets[1].FolderPath).To(Equal("Music/Jazz"))
-	})
-
-	It("returns error for non-existent file", func() {
-		_, err := readTargetsFromFile("/nonexistent/file.txt")
-		Expect(err).To(HaveOccurred())
-		Expect(err.Error()).To(ContainSubstring("failed to open target file"))
-	})
-
-	It("returns error for invalid target format", func() {
-		filePath := filepath.Join(tempDir, "targets.txt")
-		content := "invalid-format\n"
-		err := os.WriteFile(filePath, []byte(content), 0600)
-		Expect(err).ToNot(HaveOccurred())
-
-		_, err = readTargetsFromFile(filePath)
-		Expect(err).To(HaveOccurred())
-	})
-
-	It("handles mixed valid and empty lines", func() {
-		filePath := filepath.Join(tempDir, "targets.txt")
-		content := "\n1:Music/Rock\n\n\n2:Music/Jazz\n\n"
-		err := os.WriteFile(filePath, []byte(content), 0600)
-		Expect(err).ToNot(HaveOccurred())
-
-		targets, err := readTargetsFromFile(filePath)
-		Expect(err).ToNot(HaveOccurred())
-		Expect(targets).To(HaveLen(2))
-	})
-})

cmd/user.go

@@ -1,477 +0,0 @@
-package cmd
-
-import (
-	"context"
-	"encoding/csv"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"strconv"
-	"strings"
-	"syscall"
-	"time"
-
-	"github.com/Masterminds/squirrel"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
-	"github.com/spf13/cobra"
-	"golang.org/x/term"
-)
-
-var (
-	email      string
-	libraryIds []int
-	name       string
-
-	removeEmail    bool
-	removeName     bool
-	setAdmin       bool
-	setPassword    bool
-	setRegularUser bool
-)
-
-func init() {
-	rootCmd.AddCommand(userRoot)
-
-	userCreateCommand.Flags().StringVarP(&userID, "username", "u", "", "username")
-
-	userCreateCommand.Flags().StringVarP(&email, "email", "e", "", "New user email")
-	userCreateCommand.Flags().IntSliceVarP(&libraryIds, "library-ids", "i", []int{}, "Comma-separated list of library IDs. Set the user's accessible libraries. If empty, the user can access all libraries. This is incompatible with admin, as admin can always access all libraries")
-
-	userCreateCommand.Flags().BoolVarP(&setAdmin, "admin", "a", false, "If set, make the user an admin. This user will have access to every library")
-	userCreateCommand.Flags().StringVar(&name, "name", "", "New user's name (this is separate from username used to log in)")
-
-	_ = userCreateCommand.MarkFlagRequired("username")
-
-	userRoot.AddCommand(userCreateCommand)
-
-	userDeleteCommand.Flags().StringVarP(&userID, "user", "u", "", "username or id")
-	_ = userDeleteCommand.MarkFlagRequired("user")
-	userRoot.AddCommand(userDeleteCommand)
-
-	userEditCommand.Flags().StringVarP(&userID, "user", "u", "", "username or id")
-
-	userEditCommand.Flags().BoolVar(&setAdmin, "set-admin", false, "If set, make the user an admin")
-	userEditCommand.Flags().BoolVar(&setRegularUser, "set-regular", false, "If set, make the user a non-admin")
-	userEditCommand.MarkFlagsMutuallyExclusive("set-admin", "set-regular")
-
-	userEditCommand.Flags().BoolVar(&removeEmail, "remove-email", false, "If set, clear the user's email")
-	userEditCommand.Flags().StringVarP(&email, "email", "e", "", "New user email")
-	userEditCommand.MarkFlagsMutuallyExclusive("email", "remove-email")
-
-	userEditCommand.Flags().BoolVar(&removeName, "remove-name", false, "If set, clear the user's name")
-	userEditCommand.Flags().StringVar(&name, "name", "", "New user name (this is separate from username used to log in)")
-	userEditCommand.MarkFlagsMutuallyExclusive("name", "remove-name")
-
-	userEditCommand.Flags().BoolVar(&setPassword, "set-password", false, "If set, the user's new password will be prompted on the CLI")
-
-	userEditCommand.Flags().IntSliceVarP(&libraryIds, "library-ids", "i", []int{}, "Comma-separated list of library IDs. Set the user's accessible libraries by id")
-
-	_ = userEditCommand.MarkFlagRequired("user")
-	userRoot.AddCommand(userEditCommand)
-
-	userListCommand.Flags().StringVarP(&outputFormat, "format", "f", "csv", "output format [supported values: csv, json]")
-	userRoot.AddCommand(userListCommand)
-}
-
-var (
-	userRoot = &cobra.Command{
-		Use:   "user",
-		Short: "Administer users",
-		Long:  "Create, delete, list, or update users",
-	}
-
-	userCreateCommand = &cobra.Command{
-		Use:     "create",
-		Aliases: []string{"c"},
-		Short:   "Create a new user",
-		Run: func(cmd *cobra.Command, args []string) {
-			runCreateUser(cmd.Context())
-		},
-	}
-
-	userDeleteCommand = &cobra.Command{
-		Use:     "delete",
-		Aliases: []string{"d"},
-		Short:   "Deletes an existing user",
-		Run: func(cmd *cobra.Command, args []string) {
-			runDeleteUser(cmd.Context())
-		},
-	}
-
-	userEditCommand = &cobra.Command{
-		Use:     "edit",
-		Aliases: []string{"e"},
-		Short:   "Edit a user",
-		Long:    "Edit the password, admin status, and/or library access",
-		Run: func(cmd *cobra.Command, args []string) {
-			runUserEdit(cmd.Context())
-		},
-	}
-
-	userListCommand = &cobra.Command{
-		Use:   "list",
-		Short: "List users",
-		Run: func(cmd *cobra.Command, args []string) {
-			runUserList(cmd.Context())
-		},
-	}
-)
-
-func promptPassword() string {
-	for {
-		fmt.Print("Enter new password (press enter with no password to cancel): ")
-		// This cast is necessary for some platforms
-		password, err := term.ReadPassword(int(syscall.Stdin)) //nolint:unconvert
-
-		if err != nil {
-			log.Fatal("Error getting password", err)
-		}
-
-		fmt.Print("\nConfirm new password (press enter with no password to cancel): ")
-		confirmation, err := term.ReadPassword(int(syscall.Stdin)) //nolint:unconvert
-
-		if err != nil {
-			log.Fatal("Error getting password confirmation", err)
-		}
-
-		// clear the line.
-		fmt.Println()
-
-		pass := string(password)
-		confirm := string(confirmation)
-
-		if pass == "" {
-			return ""
-		}
-
-		if pass == confirm {
-			return pass
-		}
-
-		fmt.Println("Password and password confirmation do not match")
-	}
-}
-
-func libraryError(libraries model.Libraries) error {
-	ids := make([]int, len(libraries))
-	for idx, library := range libraries {
-		ids[idx] = library.ID
-	}
-	return fmt.Errorf("not all available libraries found. Requested ids: %v, Found libraries: %v", libraryIds, ids)
-}
-
-func runCreateUser(ctx context.Context) {
-	password := promptPassword()
-	if password == "" {
-		log.Fatal("Empty password provided, user creation cancelled")
-	}
-
-	user := model.User{
-		UserName:    userID,
-		Email:       email,
-		Name:        name,
-		IsAdmin:     setAdmin,
-		NewPassword: password,
-	}
-
-	if user.Name == "" {
-		user.Name = userID
-	}
-
-	ds, ctx := getAdminContext(ctx)
-
-	err := ds.WithTx(func(tx model.DataStore) error {
-		existingUser, err := tx.User(ctx).FindByUsername(userID)
-		if existingUser != nil {
-			return fmt.Errorf("existing user '%s'", userID)
-		}
-
-		if err != nil && !errors.Is(err, model.ErrNotFound) {
-			return fmt.Errorf("failed to check existing username: %w", err)
-		}
-
-		if len(libraryIds) > 0 && !setAdmin {
-			user.Libraries, err = tx.Library(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"id": libraryIds}})
-			if err != nil {
-				return err
-			}
-
-			if len(user.Libraries) != len(libraryIds) {
-				return libraryError(user.Libraries)
-			}
-		} else {
-			user.Libraries, err = tx.Library(ctx).GetAll()
-			if err != nil {
-				return err
-			}
-		}
-
-		err = tx.User(ctx).Put(&user)
-		if err != nil {
-			return err
-		}
-
-		updatedIds := make([]int, len(user.Libraries))
-		for idx, lib := range user.Libraries {
-			updatedIds[idx] = lib.ID
-		}
-
-		err = tx.User(ctx).SetUserLibraries(user.ID, updatedIds)
-		return err
-	})
-
-	if err != nil {
-		log.Fatal(ctx, err)
-	}
-
-	log.Info(ctx, "Successfully created user", "id", user.ID, "username", user.UserName)
-}
-
-func runDeleteUser(ctx context.Context) {
-	ds, ctx := getAdminContext(ctx)
-
-	var err error
-	var user *model.User
-
-	err = ds.WithTx(func(tx model.DataStore) error {
-		count, err := tx.User(ctx).CountAll()
-		if err != nil {
-			return err
-		}
-
-		if count == 1 {
-			return errors.New("refusing to delete the last user")
-		}
-
-		user, err = getUser(ctx, userID, tx)
-		if err != nil {
-			return err
-		}
-
-		return tx.User(ctx).Delete(user.ID)
-	})
-
-	if err != nil {
-		log.Fatal(ctx, "Failed to delete user", err)
-	}
-
-	log.Info(ctx, "Deleted user", "username", user.UserName)
-}
-
-func runUserEdit(ctx context.Context) {
-	ds, ctx := getAdminContext(ctx)
-
-	var err error
-	var user *model.User
-	changes := []string{}
-
-	err = ds.WithTx(func(tx model.DataStore) error {
-		var newLibraries model.Libraries
-
-		user, err = getUser(ctx, userID, tx)
-		if err != nil {
-			return err
-		}
-
-		if len(libraryIds) > 0 && !setAdmin {
-			libraries, err := tx.Library(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"id": libraryIds}})
-
-			if err != nil {
-				return err
-			}
-
-			if len(libraries) != len(libraryIds) {
-				return libraryError(libraries)
-			}
-
-			newLibraries = libraries
-			changes = append(changes, "updated library ids")
-		}
-
-		if setAdmin && !user.IsAdmin {
-			libraries, err := tx.Library(ctx).GetAll()
-			if err != nil {
-				return err
-			}
-
-			user.IsAdmin = true
-			user.Libraries = libraries
-			changes = append(changes, "set admin")
-
-			newLibraries = libraries
-		}
-
-		if setRegularUser && user.IsAdmin {
-			user.IsAdmin = false
-			changes = append(changes, "set regular user")
-		}
-
-		if setPassword {
-			password := promptPassword()
-
-			if password != "" {
-				user.NewPassword = password
-				changes = append(changes, "updated password")
-			}
-		}
-
-		if email != "" && email != user.Email {
-			user.Email = email
-			changes = append(changes, "updated email")
-		} else if removeEmail && user.Email != "" {
-			user.Email = ""
-			changes = append(changes, "removed email")
-		}
-
-		if name != "" && name != user.Name {
-			user.Name = name
-			changes = append(changes, "updated name")
-		} else if removeName && user.Name != "" {
-			user.Name = ""
-			changes = append(changes, "removed name")
-		}
-
-		if len(changes) == 0 {
-			return nil
-		}
-
-		err := tx.User(ctx).Put(user)
-		if err != nil {
-			return err
-		}
-
-		if len(newLibraries) > 0 {
-			updatedIds := make([]int, len(newLibraries))
-			for idx, lib := range newLibraries {
-				updatedIds[idx] = lib.ID
-			}
-
-			err := tx.User(ctx).SetUserLibraries(user.ID, updatedIds)
-			if err != nil {
-				return err
-			}
-		}
-
-		return nil
-	})
-
-	if err != nil {
-		log.Fatal(ctx, "Failed to update user", err)
-	}
-
-	if len(changes) == 0 {
-		log.Info(ctx, "No changes for user", "user", user.UserName)
-	} else {
-		log.Info(ctx, "Updated user", "user", user.UserName, "changes", strings.Join(changes, ", "))
-	}
-}
-
-type displayLibrary struct {
-	ID   int    `json:"id"`
-	Path string `json:"path"`
-}
-
-type displayUser struct {
-	Id         string           `json:"id"`
-	Username   string           `json:"username"`
-	Name       string           `json:"name"`
-	Email      string           `json:"email"`
-	Admin      bool             `json:"admin"`
-	CreatedAt  time.Time        `json:"createdAt"`
-	UpdatedAt  time.Time        `json:"updatedAt"`
-	LastAccess *time.Time       `json:"lastAccess"`
-	LastLogin  *time.Time       `json:"lastLogin"`
-	Libraries  []displayLibrary `json:"libraries"`
-}
-
-func runUserList(ctx context.Context) {
-	if outputFormat != "csv" && outputFormat != "json" {
-		log.Fatal("Invalid output format. Must be one of csv, json", "format", outputFormat)
-	}
-
-	ds, ctx := getAdminContext(ctx)
-
-	users, err := ds.User(ctx).ReadAll()
-	if err != nil {
-		log.Fatal(ctx, "Failed to retrieve users", err)
-	}
-
-	userList := users.(model.Users)
-
-	if outputFormat == "csv" {
-		w := csv.NewWriter(os.Stdout)
-		_ = w.Write([]string{
-			"user id",
-			"username",
-			"user's name",
-			"user email",
-			"admin",
-			"created at",
-			"updated at",
-			"last access",
-			"last login",
-			"libraries",
-		})
-		for _, user := range userList {
-			paths := make([]string, len(user.Libraries))
-
-			for idx, library := range user.Libraries {
-				paths[idx] = fmt.Sprintf("%d:%s", library.ID, library.Path)
-			}
-
-			var lastAccess, lastLogin string
-
-			if user.LastAccessAt != nil {
-				lastAccess = user.LastAccessAt.Format(time.RFC3339Nano)
-			} else {
-				lastAccess = "never"
-			}
-
-			if user.LastLoginAt != nil {
-				lastLogin = user.LastLoginAt.Format(time.RFC3339Nano)
-			} else {
-				lastLogin = "never"
-			}
-
-			_ = w.Write([]string{
-				user.ID,
-				user.UserName,
-				user.Name,
-				user.Email,
-				strconv.FormatBool(user.IsAdmin),
-				user.CreatedAt.Format(time.RFC3339Nano),
-				user.UpdatedAt.Format(time.RFC3339Nano),
-				lastAccess,
-				lastLogin,
-				fmt.Sprintf("'%s'", strings.Join(paths, "|")),
-			})
-		}
-		w.Flush()
-	} else {
-		users := make([]displayUser, len(userList))
-		for idx, user := range userList {
-			paths := make([]displayLibrary, len(user.Libraries))
-
-			for idx, library := range user.Libraries {
-				paths[idx].ID = library.ID
-				paths[idx].Path = library.Path
-			}
-
-			users[idx].Id = user.ID
-			users[idx].Username = user.UserName
-			users[idx].Name = user.Name
-			users[idx].Email = user.Email
-			users[idx].Admin = user.IsAdmin
-			users[idx].CreatedAt = user.CreatedAt
-			users[idx].UpdatedAt = user.UpdatedAt
-			users[idx].LastAccess = user.LastAccessAt
-			users[idx].LastLogin = user.LastLoginAt
-			users[idx].Libraries = paths
-		}
-
-		j, _ := json.Marshal(users)
-		fmt.Printf("%s\n", j)
-	}
-}

cmd/utils.go

@@ -1,42 +0,0 @@
-package cmd
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/navidrome/navidrome/core/auth"
-	"github.com/navidrome/navidrome/db"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/model/request"
-	"github.com/navidrome/navidrome/persistence"
-)
-
-func getAdminContext(ctx context.Context) (model.DataStore, context.Context) {
-	sqlDB := db.Db()
-	ds := persistence.New(sqlDB)
-	ctx = auth.WithAdminUser(ctx, ds)
-	u, _ := request.UserFrom(ctx)
-	if !u.IsAdmin {
-		log.Fatal(ctx, "There must be at least one admin user to run this command.")
-	}
-	return ds, ctx
-}
-
-func getUser(ctx context.Context, id string, ds model.DataStore) (*model.User, error) {
-	user, err := ds.User(ctx).FindByUsername(id)
-
-	if err != nil && !errors.Is(err, model.ErrNotFound) {
-		return nil, fmt.Errorf("finding user by name: %w", err)
-	}
-
-	if errors.Is(err, model.ErrNotFound) {
-		user, err = ds.User(ctx).Get(id)
-		if err != nil {
-			return nil, fmt.Errorf("finding user by id: %w", err)
-		}
-	}
-
-	return user, nil
-}

cmd/wire_gen.go

@@ -9,10 +9,10 @@ package cmd
 import (
 	"context"
 	"github.com/google/wire"
-	"github.com/navidrome/navidrome/adapters/lastfm"
-	"github.com/navidrome/navidrome/adapters/listenbrainz"
 	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/core/agents/lastfm"
+	"github.com/navidrome/navidrome/core/agents/listenbrainz"
 	"github.com/navidrome/navidrome/core/artwork"
 	"github.com/navidrome/navidrome/core/external"
 	"github.com/navidrome/navidrome/core/ffmpeg"
@@ -32,11 +32,6 @@ import (
 )
 
 import (
-	_ "github.com/navidrome/navidrome/adapters/deezer"
-	_ "github.com/navidrome/navidrome/adapters/gotaglib"
-	_ "github.com/navidrome/navidrome/adapters/lastfm"
-	_ "github.com/navidrome/navidrome/adapters/listenbrainz"
-	_ "github.com/navidrome/navidrome/adapters/spotify"
 	_ "github.com/navidrome/navidrome/adapters/taglib"
 )
 
@@ -52,7 +47,9 @@ func CreateServer() *server.Server {
 	sqlDB := db.Db()
 	dataStore := persistence.New(sqlDB)
 	broker := events.GetBroker()
-	insights := metrics.GetInstance(dataStore)
+	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
+	manager := plugins.GetManager(dataStore, metricsMetrics)
+	insights := metrics.GetInstance(dataStore, manager)
 	serverServer := server.New(dataStore, broker, insights)
 	return serverServer
 }
@@ -62,22 +59,21 @@ func CreateNativeAPIRouter(ctx context.Context) *nativeapi.Router {
 	dataStore := persistence.New(sqlDB)
 	share := core.NewShare(dataStore)
 	playlists := core.NewPlaylists(dataStore)
-	insights := metrics.GetInstance(dataStore)
+	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
+	manager := plugins.GetManager(dataStore, metricsMetrics)
+	insights := metrics.GetInstance(dataStore, manager)
 	fileCache := artwork.GetImageCache()
 	fFmpeg := ffmpeg.New()
-	broker := events.GetBroker()
-	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
-	manager := plugins.GetManager(dataStore, broker, metricsMetrics)
 	agentsAgents := agents.GetAgents(dataStore, manager)
 	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
+	broker := events.GetBroker()
 	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
 	watcher := scanner.GetWatcher(dataStore, modelScanner)
-	library := core.NewLibrary(dataStore, modelScanner, watcher, broker, manager)
-	user := core.NewUser(dataStore, manager)
+	library := core.NewLibrary(dataStore, modelScanner, watcher, broker)
 	maintenance := core.NewMaintenance(dataStore)
-	router := nativeapi.New(dataStore, share, playlists, insights, library, user, maintenance, manager)
+	router := nativeapi.New(dataStore, share, playlists, insights, library, maintenance)
 	return router
 }
 
@@ -86,9 +82,8 @@ func CreateSubsonicAPIRouter(ctx context.Context) *subsonic.Router {
 	dataStore := persistence.New(sqlDB)
 	fileCache := artwork.GetImageCache()
 	fFmpeg := ffmpeg.New()
-	broker := events.GetBroker()
 	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
-	manager := plugins.GetManager(dataStore, broker, metricsMetrics)
+	manager := plugins.GetManager(dataStore, metricsMetrics)
 	agentsAgents := agents.GetAgents(dataStore, manager)
 	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
@@ -98,6 +93,7 @@ func CreateSubsonicAPIRouter(ctx context.Context) *subsonic.Router {
 	archiver := core.NewArchiver(mediaStreamer, dataStore, share)
 	players := core.NewPlayers(dataStore)
 	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
+	broker := events.GetBroker()
 	playlists := core.NewPlaylists(dataStore)
 	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
 	playTracker := scrobbler.GetPlayTracker(dataStore, broker, manager)
@@ -111,9 +107,8 @@ func CreatePublicRouter() *public.Router {
 	dataStore := persistence.New(sqlDB)
 	fileCache := artwork.GetImageCache()
 	fFmpeg := ffmpeg.New()
-	broker := events.GetBroker()
 	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
-	manager := plugins.GetManager(dataStore, broker, metricsMetrics)
+	manager := plugins.GetManager(dataStore, metricsMetrics)
 	agentsAgents := agents.GetAgents(dataStore, manager)
 	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
@@ -142,7 +137,9 @@ func CreateListenBrainzRouter() *listenbrainz.Router {
 func CreateInsights() metrics.Insights {
 	sqlDB := db.Db()
 	dataStore := persistence.New(sqlDB)
-	insights := metrics.GetInstance(dataStore)
+	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
+	manager := plugins.GetManager(dataStore, metricsMetrics)
+	insights := metrics.GetInstance(dataStore, manager)
 	return insights
 }
 
@@ -158,13 +155,13 @@ func CreateScanner(ctx context.Context) model.Scanner {
 	dataStore := persistence.New(sqlDB)
 	fileCache := artwork.GetImageCache()
 	fFmpeg := ffmpeg.New()
-	broker := events.GetBroker()
 	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
-	manager := plugins.GetManager(dataStore, broker, metricsMetrics)
+	manager := plugins.GetManager(dataStore, metricsMetrics)
 	agentsAgents := agents.GetAgents(dataStore, manager)
 	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
+	broker := events.GetBroker()
 	playlists := core.NewPlaylists(dataStore)
 	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
 	return modelScanner
@@ -175,13 +172,13 @@ func CreateScanWatcher(ctx context.Context) scanner.Watcher {
 	dataStore := persistence.New(sqlDB)
 	fileCache := artwork.GetImageCache()
 	fFmpeg := ffmpeg.New()
-	broker := events.GetBroker()
 	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
-	manager := plugins.GetManager(dataStore, broker, metricsMetrics)
+	manager := plugins.GetManager(dataStore, metricsMetrics)
 	agentsAgents := agents.GetAgents(dataStore, manager)
 	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
+	broker := events.GetBroker()
 	playlists := core.NewPlaylists(dataStore)
 	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
 	watcher := scanner.GetWatcher(dataStore, modelScanner)
@@ -195,20 +192,19 @@ func GetPlaybackServer() playback.PlaybackServer {
 	return playbackServer
 }
 
-func getPluginManager() *plugins.Manager {
+func getPluginManager() plugins.Manager {
 	sqlDB := db.Db()
 	dataStore := persistence.New(sqlDB)
-	broker := events.GetBroker()
 	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
-	manager := plugins.GetManager(dataStore, broker, metricsMetrics)
+	manager := plugins.GetManager(dataStore, metricsMetrics)
 	return manager
 }
 
 // wire_injectors.go:
 
-var allProviders = wire.NewSet(core.Set, artwork.Set, server.New, subsonic.New, nativeapi.New, public.New, persistence.New, lastfm.NewRouter, listenbrainz.NewRouter, events.GetBroker, scanner.New, scanner.GetWatcher, metrics.GetPrometheusInstance, db.Db, plugins.GetManager, wire.Bind(new(agents.PluginLoader), new(*plugins.Manager)), wire.Bind(new(scrobbler.PluginLoader), new(*plugins.Manager)), wire.Bind(new(nativeapi.PluginManager), new(*plugins.Manager)), wire.Bind(new(core.PluginUnloader), new(*plugins.Manager)), wire.Bind(new(plugins.PluginMetricsRecorder), new(metrics.Metrics)), wire.Bind(new(core.Watcher), new(scanner.Watcher)))
+var allProviders = wire.NewSet(core.Set, artwork.Set, server.New, subsonic.New, nativeapi.New, public.New, persistence.New, lastfm.NewRouter, listenbrainz.NewRouter, events.GetBroker, scanner.New, scanner.GetWatcher, plugins.GetManager, metrics.GetPrometheusInstance, db.Db, wire.Bind(new(agents.PluginLoader), new(plugins.Manager)), wire.Bind(new(scrobbler.PluginLoader), new(plugins.Manager)), wire.Bind(new(metrics.PluginLoader), new(plugins.Manager)), wire.Bind(new(core.Watcher), new(scanner.Watcher)))
 
-func GetPluginManager(ctx context.Context) *plugins.Manager {
+func GetPluginManager(ctx context.Context) plugins.Manager {
 	manager := getPluginManager()
 	manager.SetSubsonicRouter(CreateSubsonicAPIRouter(ctx))
 	return manager

cmd/wire_injectors.go

@@ -6,10 +6,10 @@ import (
 	"context"
 
 	"github.com/google/wire"
-	"github.com/navidrome/navidrome/adapters/lastfm"
-	"github.com/navidrome/navidrome/adapters/listenbrainz"
 	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/core/agents/lastfm"
+	"github.com/navidrome/navidrome/core/agents/listenbrainz"
 	"github.com/navidrome/navidrome/core/artwork"
 	"github.com/navidrome/navidrome/core/metrics"
 	"github.com/navidrome/navidrome/core/playback"
@@ -39,14 +39,12 @@ var allProviders = wire.NewSet(
 	events.GetBroker,
 	scanner.New,
 	scanner.GetWatcher,
+	plugins.GetManager,
 	metrics.GetPrometheusInstance,
 	db.Db,
-	plugins.GetManager,
-	wire.Bind(new(agents.PluginLoader), new(*plugins.Manager)),
-	wire.Bind(new(scrobbler.PluginLoader), new(*plugins.Manager)),
-	wire.Bind(new(nativeapi.PluginManager), new(*plugins.Manager)),
-	wire.Bind(new(core.PluginUnloader), new(*plugins.Manager)),
-	wire.Bind(new(plugins.PluginMetricsRecorder), new(metrics.Metrics)),
+	wire.Bind(new(agents.PluginLoader), new(plugins.Manager)),
+	wire.Bind(new(scrobbler.PluginLoader), new(plugins.Manager)),
+	wire.Bind(new(metrics.PluginLoader), new(plugins.Manager)),
 	wire.Bind(new(core.Watcher), new(scanner.Watcher)),
 )
 
@@ -122,13 +120,13 @@ func GetPlaybackServer() playback.PlaybackServer {
 	))
 }
 
-func getPluginManager() *plugins.Manager {
+func getPluginManager() plugins.Manager {
 	panic(wire.Build(
 		allProviders,
 	))
 }
 
-func GetPluginManager(ctx context.Context) *plugins.Manager {
+func GetPluginManager(ctx context.Context) plugins.Manager {
 	manager := getPluginManager()
 	manager.SetSubsonicRouter(CreateSubsonicAPIRouter(ctx))
 	return manager

conf/configuration.go

@@ -1,7 +1,6 @@
 package conf
 
 import (
-	"cmp"
 	"fmt"
 	"net/url"
 	"os"
@@ -42,7 +41,6 @@ type configOptions struct {
 	UIWelcomeMessage                string
 	MaxSidebarPlaylists             int
 	EnableTranscodingConfig         bool
-	EnableTranscodingCancellation   bool
 	EnableDownloads                 bool
 	EnableExternalServices          bool
 	EnableInsightsCollector         bool
@@ -58,7 +56,6 @@ type configOptions struct {
 	AutoTranscodeDownload           bool
 	DefaultDownsamplingFormat       string
 	SearchFullString                bool
-	SimilarSongsMatchThreshold      int
 	RecentlyAddedByModTime          bool
 	PreferSortTags                  bool
 	IgnoredArticles                 string
@@ -89,9 +86,11 @@ type configOptions struct {
 	AuthRequestLimit                int
 	AuthWindowLength                time.Duration
 	PasswordEncryptionKey           string
-	ExtAuth                         extAuthOptions
+	ReverseProxyUserHeader          string
+	ReverseProxyWhitelist           string
 	Plugins                         pluginsOptions
-	HTTPHeaders                     httpHeaderOptions   `json:",omitzero"`
+	PluginConfig                    map[string]map[string]string
+	HTTPSecurityHeaders             secureOptions       `json:",omitzero"`
 	Prometheus                      prometheusOptions   `json:",omitzero"`
 	Scanner                         scannerOptions      `json:",omitzero"`
 	Jukebox                         jukeboxOptions      `json:",omitzero"`
@@ -103,39 +102,36 @@ type configOptions struct {
 	Spotify                         spotifyOptions      `json:",omitzero"`
 	Deezer                          deezerOptions       `json:",omitzero"`
 	ListenBrainz                    listenBrainzOptions `json:",omitzero"`
-	EnableScrobbleHistory           bool
-	Tags                            map[string]TagConf `json:",omitempty"`
+	Tags                            map[string]TagConf  `json:",omitempty"`
 	Agents                          string
 
 	// DevFlags. These are used to enable/disable debugging and incomplete features
-	DevLogLevels                      map[string]string `json:",omitempty"`
-	DevLogSourceLine                  bool
-	DevEnableProfiler                 bool
-	DevAutoCreateAdminPassword        string
-	DevAutoLoginUsername              string
-	DevActivityPanel                  bool
-	DevActivityPanelUpdateRate        time.Duration
-	DevSidebarPlaylists               bool
-	DevShowArtistPage                 bool
-	DevUIShowConfig                   bool
-	DevNewEventStream                 bool
-	DevOffsetOptimize                 int
-	DevArtworkMaxRequests             int
-	DevArtworkThrottleBacklogLimit    int
-	DevArtworkThrottleBacklogTimeout  time.Duration
-	DevArtistInfoTimeToLive           time.Duration
-	DevAlbumInfoTimeToLive            time.Duration
-	DevExternalScanner                bool
-	DevScannerThreads                 uint
-	DevSelectiveWatcher               bool
-	DevLegacyEmbedImage               bool
-	DevInsightsInitialDelay           time.Duration
-	DevEnablePlayerInsights           bool
-	DevEnablePluginsInsights          bool
-	DevPluginCompilationTimeout       time.Duration
-	DevExternalArtistFetchMultiplier  float64
-	DevOptimizeDB                     bool
-	DevPreserveUnicodeInExternalCalls bool
+	DevLogLevels                     map[string]string `json:",omitempty"`
+	DevLogSourceLine                 bool
+	DevEnableProfiler                bool
+	DevAutoCreateAdminPassword       string
+	DevAutoLoginUsername             string
+	DevActivityPanel                 bool
+	DevActivityPanelUpdateRate       time.Duration
+	DevSidebarPlaylists              bool
+	DevShowArtistPage                bool
+	DevUIShowConfig                  bool
+	DevNewEventStream                bool
+	DevOffsetOptimize                int
+	DevArtworkMaxRequests            int
+	DevArtworkThrottleBacklogLimit   int
+	DevArtworkThrottleBacklogTimeout time.Duration
+	DevArtistInfoTimeToLive          time.Duration
+	DevAlbumInfoTimeToLive           time.Duration
+	DevExternalScanner               bool
+	DevScannerThreads                uint
+	DevSelectiveWatcher              bool
+	DevInsightsInitialDelay          time.Duration
+	DevEnablePlayerInsights          bool
+	DevEnablePluginsInsights         bool
+	DevPluginCompilationTimeout      time.Duration
+	DevExternalArtistFetchMultiplier float64
+	DevOptimizeDB                    bool
 }
 
 type scannerOptions struct {
@@ -155,9 +151,7 @@ type subsonicOptions struct {
 	AppendSubtitle        bool
 	ArtistParticipations  bool
 	DefaultReportRealPath bool
-	EnableAverageRating   bool
 	LegacyClients         string
-	MinimalClients        string
 }
 
 type TagConf struct {
@@ -175,9 +169,6 @@ type lastfmOptions struct {
 	Secret                  string
 	Language                string
 	ScrobbleFirstArtistOnly bool
-
-	// Computed values
-	Languages []string // Computed from Language, split by comma
 }
 
 type spotifyOptions struct {
@@ -188,20 +179,15 @@ type spotifyOptions struct {
 type deezerOptions struct {
 	Enabled  bool
 	Language string
-
-	// Computed values
-	Languages []string // Computed from Language, split by comma
 }
 
 type listenBrainzOptions struct {
-	Enabled         bool
-	BaseURL         string
-	ArtistAlgorithm string
-	TrackAlgorithm  string
+	Enabled bool
+	BaseURL string
 }
 
-type httpHeaderOptions struct {
-	FrameOptions string
+type secureOptions struct {
+	CustomFrameOptionsValue string
 }
 
 type prometheusOptions struct {
@@ -238,16 +224,9 @@ type inspectOptions struct {
 }
 
 type pluginsOptions struct {
-	Enabled    bool
-	Folder     string
-	CacheSize  string
-	AutoReload bool
-	LogLevel   string
-}
-
-type extAuthOptions struct {
-	TrustedSources string
-	UserHeader     string
+	Enabled   bool
+	Folder    string
+	CacheSize string
 }
 
 var (
@@ -268,11 +247,6 @@ func LoadFromFile(confFile string) {
 func Load(noConfigDump bool) {
 	parseIniFileConfiguration()
 
-	// Map deprecated options to their new names for backwards compatibility
-	mapDeprecatedOption("ReverseProxyWhitelist", "ExtAuth.TrustedSources")
-	mapDeprecatedOption("ReverseProxyUserHeader", "ExtAuth.UserHeader")
-	mapDeprecatedOption("HTTPSecurityHeaders.CustomFrameOptionsValue", "HTTPHeaders.FrameOptions")
-
 	err := viper.Unmarshal(&Server)
 	if err != nil {
 		_, _ = fmt.Fprintln(os.Stderr, "FATAL: Error parsing config:", err)
@@ -356,18 +330,9 @@ func Load(noConfigDump bool) {
 		Server.BaseScheme = u.Scheme
 	}
 
-	// Log configuration source
-	if Server.ConfigFile != "" {
-		log.Info("Loaded configuration", "file", Server.ConfigFile)
-	} else if hasNDEnvVars() {
-		log.Info("No configuration file found. Loaded configuration only from environment variables")
-	} else {
-		log.Warn("No configuration file found. Using default values. To specify a config file, use the --configfile flag or set the ND_CONFIGFILE environment variable.")
-	}
-
 	// Print current configuration if log level is Debug
 	if log.IsGreaterOrEqualTo(log.LevelDebug) && !noConfigDump {
-		prettyConf := pretty.Sprintf("Configuration: %# v", Server)
+		prettyConf := pretty.Sprintf("Loaded configuration from '%s': %# v", Server.ConfigFile, Server)
 		if Server.EnableLogRedacting {
 			prettyConf = log.Redact(prettyConf)
 		}
@@ -378,22 +343,13 @@ func Load(noConfigDump bool) {
 		disableExternalServices()
 	}
 
-	// Make sure we don't have empty PIDs
-	Server.PID.Album = cmp.Or(Server.PID.Album, consts.DefaultAlbumPID)
-	Server.PID.Track = cmp.Or(Server.PID.Track, consts.DefaultTrackPID)
-
-	// Parse LastFM.Language into Languages slice (comma-separated, with fallback to DefaultInfoLanguage)
-	Server.LastFM.Languages = parseLanguages(Server.LastFM.Language)
-
-	// Parse Deezer.Language into Languages slice (comma-separated, with fallback to DefaultInfoLanguage)
-	Server.Deezer.Languages = parseLanguages(Server.Deezer.Language)
-
-	logDeprecatedOptions("Scanner.GenreSeparators", "")
-	logDeprecatedOptions("Scanner.GroupAlbumReleases", "")
-	logDeprecatedOptions("DevEnableBufferedScrobble", "") // Deprecated: Buffered scrobbling is now always enabled and this option is ignored
-	logDeprecatedOptions("ReverseProxyWhitelist", "ExtAuth.TrustedSources")
-	logDeprecatedOptions("ReverseProxyUserHeader", "ExtAuth.UserHeader")
-	logDeprecatedOptions("HTTPSecurityHeaders.CustomFrameOptionsValue", "HTTPHeaders.FrameOptions")
+	if Server.Scanner.Extractor != consts.DefaultScannerExtractor {
+		log.Warn(fmt.Sprintf("Extractor '%s' is not implemented, using 'taglib'", Server.Scanner.Extractor))
+		Server.Scanner.Extractor = consts.DefaultScannerExtractor
+	}
+	logDeprecatedOptions("Scanner.GenreSeparators")
+	logDeprecatedOptions("Scanner.GroupAlbumReleases")
+	logDeprecatedOptions("DevEnableBufferedScrobble") // Deprecated: Buffered scrobbling is now always enabled and this option is ignored
 
 	// Call init hooks
 	for _, hook := range hooks {
@@ -401,29 +357,15 @@ func Load(noConfigDump bool) {
 	}
 }
 
-func logDeprecatedOptions(oldName, newName string) {
-	envVar := "ND_" + strings.ToUpper(strings.ReplaceAll(oldName, ".", "_"))
-	newEnvVar := "ND_" + strings.ToUpper(strings.ReplaceAll(newName, ".", "_"))
-	logWarning := func(oldName, newName string) {
-		if newName != "" {
-			log.Warn(fmt.Sprintf("Option '%s' is deprecated and will be ignored in a future release. Please use the new '%s'", oldName, newName))
-		} else {
-			log.Warn(fmt.Sprintf("Option '%s' is deprecated and will be ignored in a future release", oldName))
+func logDeprecatedOptions(options ...string) {
+	for _, option := range options {
+		envVar := "ND_" + strings.ToUpper(strings.ReplaceAll(option, ".", "_"))
+		if os.Getenv(envVar) != "" {
+			log.Warn(fmt.Sprintf("Option '%s' is deprecated and will be ignored in a future release", envVar))
+		}
+		if viper.InConfig(option) {
+			log.Warn(fmt.Sprintf("Option '%s' is deprecated and will be ignored in a future release", option))
 		}
-	}
-	if os.Getenv(envVar) != "" {
-		logWarning(envVar, newEnvVar)
-	}
-	if viper.InConfig(oldName) {
-		logWarning(oldName, newName)
-	}
-}
-
-// mapDeprecatedOption is used to provide backwards compatibility for deprecated options. It should be called after
-// the config has been read by viper, but before unmarshalling it into the Config struct.
-func mapDeprecatedOption(legacyName, newName string) {
-	if viper.IsSet(legacyName) {
-		viper.Set(newName, viper.Get(legacyName))
 	}
 }
 
@@ -476,22 +418,6 @@ func validatePlaylistsPath() error {
 	return nil
 }
 
-// parseLanguages parses a comma-separated language string into a slice.
-// It trims whitespace from each entry and ensures at least [DefaultInfoLanguage] is returned.
-func parseLanguages(lang string) []string {
-	var languages []string
-	for _, l := range strings.Split(lang, ",") {
-		l = strings.TrimSpace(l)
-		if l != "" {
-			languages = append(languages, l)
-		}
-	}
-	if len(languages) == 0 {
-		return []string{consts.DefaultInfoLanguage}
-	}
-	return languages
-}
-
 func validatePurgeMissingOption() error {
 	allowedValues := []string{consts.PurgeMissingNever, consts.PurgeMissingAlways, consts.PurgeMissingFull}
 	valid := false
@@ -549,16 +475,6 @@ func AddHook(hook func()) {
 	hooks = append(hooks, hook)
 }
 
-// hasNDEnvVars checks if any ND_ prefixed environment variables are set (excluding ND_CONFIGFILE)
-func hasNDEnvVars() bool {
-	for _, env := range os.Environ() {
-		if strings.HasPrefix(env, "ND_") && !strings.HasPrefix(env, "ND_CONFIGFILE=") {
-			return true
-		}
-	}
-	return false
-}
-
 func setViperDefaults() {
 	viper.SetDefault("musicfolder", filepath.Join(".", "music"))
 	viper.SetDefault("cachefolder", "")
@@ -576,7 +492,6 @@ func setViperDefaults() {
 	viper.SetDefault("uiwelcomemessage", "")
 	viper.SetDefault("maxsidebarplaylists", consts.DefaultMaxSidebarPlaylists)
 	viper.SetDefault("enabletranscodingconfig", false)
-	viper.SetDefault("enabletranscodingcancellation", false)
 	viper.SetDefault("transcodingcachesize", "100MB")
 	viper.SetDefault("imagecachesize", "100MB")
 	viper.SetDefault("albumplaycountmode", consts.AlbumPlayCountModeAbsolute)
@@ -591,7 +506,6 @@ func setViperDefaults() {
 	viper.SetDefault("autotranscodedownload", false)
 	viper.SetDefault("defaultdownsamplingformat", consts.DefaultDownsamplingFormat)
 	viper.SetDefault("searchfullstring", false)
-	viper.SetDefault("similarsongsmatchthreshold", 85)
 	viper.SetDefault("recentlyaddedbymodtime", false)
 	viper.SetDefault("prefersorttags", false)
 	viper.SetDefault("ignoredarticles", "The El La Los Las Le Les Os As O A")
@@ -622,8 +536,8 @@ func setViperDefaults() {
 	viper.SetDefault("authrequestlimit", 5)
 	viper.SetDefault("authwindowlength", 20*time.Second)
 	viper.SetDefault("passwordencryptionkey", "")
-	viper.SetDefault("extauth.userheader", "Remote-User")
-	viper.SetDefault("extauth.trustedsources", "")
+	viper.SetDefault("reverseproxyuserheader", "Remote-User")
+	viper.SetDefault("reverseproxywhitelist", "")
 	viper.SetDefault("prometheus.enabled", false)
 	viper.SetDefault("prometheus.metricspath", consts.PrometheusDefaultPath)
 	viper.SetDefault("prometheus.password", "")
@@ -644,25 +558,20 @@ func setViperDefaults() {
 	viper.SetDefault("subsonic.appendsubtitle", true)
 	viper.SetDefault("subsonic.artistparticipations", false)
 	viper.SetDefault("subsonic.defaultreportrealpath", false)
-	viper.SetDefault("subsonic.enableaveragerating", true)
 	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)
+	viper.SetDefault("lastfm.language", "en")
 	viper.SetDefault("lastfm.apikey", "")
 	viper.SetDefault("lastfm.secret", "")
 	viper.SetDefault("lastfm.scrobblefirstartistonly", false)
 	viper.SetDefault("spotify.id", "")
 	viper.SetDefault("spotify.secret", "")
 	viper.SetDefault("deezer.enabled", true)
-	viper.SetDefault("deezer.language", consts.DefaultInfoLanguage)
+	viper.SetDefault("deezer.language", "en")
 	viper.SetDefault("listenbrainz.enabled", true)
-	viper.SetDefault("listenbrainz.baseurl", consts.DefaultListenBrainzBaseURL)
-	viper.SetDefault("listenbrainz.artistalgorithm", consts.DefaultListenBrainzArtistAlgorithm)
-	viper.SetDefault("listenbrainz.trackalgorithm", consts.DefaultListenBrainzTrackAlgorithm)
-	viper.SetDefault("enablescrobblehistory", true)
-	viper.SetDefault("httpheaders.frameoptions", "DENY")
+	viper.SetDefault("listenbrainz.baseurl", "https://api.listenbrainz.org/1/")
+	viper.SetDefault("httpsecurityheaders.customframeoptionsvalue", "DENY")
 	viper.SetDefault("backup.path", "")
 	viper.SetDefault("backup.schedule", "")
 	viper.SetDefault("backup.count", 0)
@@ -673,9 +582,8 @@ func setViperDefaults() {
 	viper.SetDefault("inspect.backloglimit", consts.RequestThrottleBacklogLimit)
 	viper.SetDefault("inspect.backlogtimeout", consts.RequestThrottleBacklogTimeout)
 	viper.SetDefault("plugins.folder", "")
-	viper.SetDefault("plugins.enabled", true)
-	viper.SetDefault("plugins.cachesize", "200MB")
-	viper.SetDefault("plugins.autoreload", false)
+	viper.SetDefault("plugins.enabled", false)
+	viper.SetDefault("plugins.cachesize", "100MB")
 
 	// DevFlags. These are used to enable/disable debugging and incomplete features
 	viper.SetDefault("devlogsourceline", false)
@@ -703,7 +611,6 @@ func setViperDefaults() {
 	viper.SetDefault("devplugincompilationtimeout", time.Minute)
 	viper.SetDefault("devexternalartistfetchmultiplier", 1.5)
 	viper.SetDefault("devoptimizedb", true)
-	viper.SetDefault("devpreserveunicodeinexternalcalls", false)
 }
 
 func init() {

conf/configuration_test.go

@@ -26,32 +26,6 @@ var _ = Describe("Configuration", func() {
 		conf.ResetConf()
 	})
 
-	Describe("ParseLanguages", func() {
-		It("parses single language", func() {
-			Expect(conf.ParseLanguages("en")).To(Equal([]string{"en"}))
-		})
-
-		It("parses multiple comma-separated languages", func() {
-			Expect(conf.ParseLanguages("pt,en")).To(Equal([]string{"pt", "en"}))
-		})
-
-		It("trims whitespace from languages", func() {
-			Expect(conf.ParseLanguages(" pt , en ")).To(Equal([]string{"pt", "en"}))
-		})
-
-		It("returns default 'en' when empty", func() {
-			Expect(conf.ParseLanguages("")).To(Equal([]string{"en"}))
-		})
-
-		It("returns default 'en' when only whitespace", func() {
-			Expect(conf.ParseLanguages("   ")).To(Equal([]string{"en"}))
-		})
-
-		It("handles multiple languages with various spacing", func() {
-			Expect(conf.ParseLanguages("ja, pt, en")).To(Equal([]string{"ja", "pt", "en"}))
-		})
-	})
-
 	DescribeTable("should load configuration from",
 		func(format string) {
 			filename := filepath.Join("testdata", "cfg."+format)
@@ -67,9 +41,6 @@ var _ = Describe("Configuration", func() {
 			Expect(conf.Server.Tags["custom"].Aliases).To(Equal([]string{format, "test"}))
 			Expect(conf.Server.Tags["artist"].Split).To(Equal([]string{";"}))
 
-			// Check deprecated option mapping
-			Expect(conf.Server.ExtAuth.UserHeader).To(Equal("X-Auth-User"))
-
 			// The config file used should be the one we created
 			Expect(conf.Server.ConfigFile).To(Equal(filename))
 		},

conf/export_test.go

@@ -5,5 +5,3 @@ func ResetConf() {
 }
 
 var SetViperDefaults = setViperDefaults
-
-var ParseLanguages = parseLanguages

conf/testdata/cfg.ini

@@ -1,7 +1,6 @@
 [default]
 MusicFolder = /ini/music
 UIWelcomeMessage = 'Welcome ini' ; Just a comment to test the LoadOptions
-ReverseProxyUserHeader = 'X-Auth-User'
 
 [Tags]
 Custom.Aliases = ini,test

conf/testdata/cfg.json

@@ -1,7 +1,6 @@
 {
   "musicFolder": "/json/music",
   "uiWelcomeMessage": "Welcome json",
-  "reverseProxyUserHeader": "X-Auth-User",
   "Tags": {
     "artist": {
       "split": ";"

conf/testdata/cfg.toml

@@ -1,6 +1,5 @@
 musicFolder = "/toml/music"
 uiWelcomeMessage = "Welcome toml"
-ReverseProxyUserHeader = "X-Auth-User"
 
 Tags.artist.Split = ';'
 

conf/testdata/cfg.yaml

@@ -1,6 +1,5 @@
 musicFolder: "/yaml/music"
 uiWelcomeMessage: "Welcome yaml"
-reverseProxyUserHeader: "X-Auth-User"
 Tags:
   artist:
     split:  [";"]

consts/consts.go

@@ -56,8 +56,6 @@ const (
 
 	ServerReadHeaderTimeout = 3 * time.Second
 
-	DefaultInfoLanguage = "en"
-
 	ArtistInfoTimeToLive      = 24 * time.Hour
 	AlbumInfoTimeToLive       = 7 * 24 * time.Hour
 	UpdateLastAccessFrequency = time.Minute
@@ -74,10 +72,6 @@ const (
 
 	DefaultHttpClientTimeOut = 10 * time.Second
 
-	DefaultListenBrainzBaseURL         = "https://api.listenbrainz.org/1/"
-	DefaultListenBrainzArtistAlgorithm = "session_based_days_9000_session_300_contribution_5_threshold_15_limit_50_skip_30"
-	DefaultListenBrainzTrackAlgorithm  = "session_based_days_9000_session_300_contribution_5_threshold_15_limit_50_skip_30"
-
 	DefaultScannerExtractor = "taglib"
 	DefaultWatcherWait      = 5 * time.Second
 	Zwsp                    = string('\u200b')
@@ -156,8 +150,6 @@ var (
 	}
 )
 
-var HTTPUserAgent = "Navidrome" + "/" + Version
-
 var (
 	VariousArtists = "Various Artists"
 	// TODO This will be dynamic when using disambiguation

core/agents/agents.go

@@ -22,8 +22,6 @@ type PluginLoader interface {
 	LoadMediaAgent(name string) (Interface, bool)
 }
 
-// Agents is a meta-agent that aggregates multiple built-in and plugin agents. It tries each enabled agent in order
-// until one returns valid data.
 type Agents struct {
 	ds           model.DataStore
 	pluginLoader PluginLoader
@@ -66,7 +64,6 @@ func (a *Agents) getEnabledAgentNames() []enabledAgent {
 	if a.pluginLoader != nil {
 		availablePlugins = a.pluginLoader.PluginNames("MetadataAgent")
 	}
-	log.Trace("Available MetadataAgent plugins", "plugins", availablePlugins)
 
 	configuredAgents := strings.Split(conf.Server.Agents, ",")
 
@@ -131,14 +128,26 @@ func (a *Agents) GetArtistMBID(ctx context.Context, id string, name string) (str
 	case consts.VariousArtistsID:
 		return "", nil
 	}
-
-	return callAgentMethod(ctx, a, "GetArtistMBID", func(ag Interface) (string, error) {
+	start := time.Now()
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
+		if utils.IsCtxDone(ctx) {
+			break
+		}
 		retriever, ok := ag.(ArtistMBIDRetriever)
 		if !ok {
-			return "", ErrNotFound
+			continue
 		}
-		return retriever.GetArtistMBID(ctx, id, name)
-	})
+		mbid, err := retriever.GetArtistMBID(ctx, id, name)
+		if mbid != "" && err == nil {
+			log.Debug(ctx, "Got MBID", "agent", ag.AgentName(), "artist", name, "mbid", mbid, "elapsed", time.Since(start))
+			return mbid, nil
+		}
+	}
+	return "", ErrNotFound
 }
 
 func (a *Agents) GetArtistURL(ctx context.Context, id, name, mbid string) (string, error) {
@@ -148,14 +157,26 @@ func (a *Agents) GetArtistURL(ctx context.Context, id, name, mbid string) (strin
 	case consts.VariousArtistsID:
 		return "", nil
 	}
-
-	return callAgentMethod(ctx, a, "GetArtistURL", func(ag Interface) (string, error) {
+	start := time.Now()
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
+		if utils.IsCtxDone(ctx) {
+			break
+		}
 		retriever, ok := ag.(ArtistURLRetriever)
 		if !ok {
-			return "", ErrNotFound
+			continue
 		}
-		return retriever.GetArtistURL(ctx, id, name, mbid)
-	})
+		url, err := retriever.GetArtistURL(ctx, id, name, mbid)
+		if url != "" && err == nil {
+			log.Debug(ctx, "Got External Url", "agent", ag.AgentName(), "artist", name, "url", url, "elapsed", time.Since(start))
+			return url, nil
+		}
+	}
+	return "", ErrNotFound
 }
 
 func (a *Agents) GetArtistBiography(ctx context.Context, id, name, mbid string) (string, error) {
@@ -165,14 +186,26 @@ func (a *Agents) GetArtistBiography(ctx context.Context, id, name, mbid string)
 	case consts.VariousArtistsID:
 		return "", nil
 	}
-
-	return callAgentMethod(ctx, a, "GetArtistBiography", func(ag Interface) (string, error) {
+	start := time.Now()
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
+		if utils.IsCtxDone(ctx) {
+			break
+		}
 		retriever, ok := ag.(ArtistBiographyRetriever)
 		if !ok {
-			return "", ErrNotFound
+			continue
 		}
-		return retriever.GetArtistBiography(ctx, id, name, mbid)
-	})
+		bio, err := retriever.GetArtistBiography(ctx, id, name, mbid)
+		if err == nil {
+			log.Debug(ctx, "Got Biography", "agent", ag.AgentName(), "artist", name, "len", len(bio), "elapsed", time.Since(start))
+			return bio, nil
+		}
+	}
+	return "", ErrNotFound
 }
 
 // GetSimilarArtists returns similar artists by id, name, and/or mbid. Because some artists returned from an enabled
@@ -220,14 +253,26 @@ func (a *Agents) GetArtistImages(ctx context.Context, id, name, mbid string) ([]
 	case consts.VariousArtistsID:
 		return nil, nil
 	}
-
-	return callAgentSliceMethod(ctx, a, "GetArtistImages", func(ag Interface) ([]ExternalImage, error) {
+	start := time.Now()
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
+		if utils.IsCtxDone(ctx) {
+			break
+		}
 		retriever, ok := ag.(ArtistImageRetriever)
 		if !ok {
-			return nil, ErrNotFound
+			continue
 		}
-		return retriever.GetArtistImages(ctx, id, name, mbid)
-	})
+		images, err := retriever.GetArtistImages(ctx, id, name, mbid)
+		if len(images) > 0 && err == nil {
+			log.Debug(ctx, "Got Images", "agent", ag.AgentName(), "artist", name, "images", images, "elapsed", time.Since(start))
+			return images, nil
+		}
+	}
+	return nil, ErrNotFound
 }
 
 // GetArtistTopSongs returns top songs by id, name, and/or mbid. Because some songs returned from an enabled
@@ -242,127 +287,77 @@ func (a *Agents) GetArtistTopSongs(ctx context.Context, id, artistName, mbid str
 
 	overLimit := int(float64(count) * conf.Server.DevExternalArtistFetchMultiplier)
 
-	return callAgentSliceMethod(ctx, a, "GetArtistTopSongs", func(ag Interface) ([]Song, error) {
+	start := time.Now()
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
+		if utils.IsCtxDone(ctx) {
+			break
+		}
 		retriever, ok := ag.(ArtistTopSongsRetriever)
 		if !ok {
-			return nil, ErrNotFound
+			continue
 		}
-		return retriever.GetArtistTopSongs(ctx, id, artistName, mbid, overLimit)
-	})
+		songs, err := retriever.GetArtistTopSongs(ctx, id, artistName, mbid, overLimit)
+		if len(songs) > 0 && err == nil {
+			log.Debug(ctx, "Got Top Songs", "agent", ag.AgentName(), "artist", artistName, "songs", songs, "elapsed", time.Since(start))
+			return songs, nil
+		}
+	}
+	return nil, ErrNotFound
 }
 
 func (a *Agents) GetAlbumInfo(ctx context.Context, name, artist, mbid string) (*AlbumInfo, error) {
 	if name == consts.UnknownAlbum {
 		return nil, ErrNotFound
 	}
-
-	return callAgentMethod(ctx, a, "GetAlbumInfo", func(ag Interface) (*AlbumInfo, error) {
+	start := time.Now()
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
+		if utils.IsCtxDone(ctx) {
+			break
+		}
 		retriever, ok := ag.(AlbumInfoRetriever)
 		if !ok {
-			return nil, ErrNotFound
+			continue
 		}
-		return retriever.GetAlbumInfo(ctx, name, artist, mbid)
-	})
+		album, err := retriever.GetAlbumInfo(ctx, name, artist, mbid)
+		if err == nil {
+			log.Debug(ctx, "Got Album Info", "agent", ag.AgentName(), "album", name, "artist", artist,
+				"mbid", mbid, "elapsed", time.Since(start))
+			return album, nil
+		}
+	}
+	return nil, ErrNotFound
 }
 
 func (a *Agents) GetAlbumImages(ctx context.Context, name, artist, mbid string) ([]ExternalImage, error) {
 	if name == consts.UnknownAlbum {
 		return nil, ErrNotFound
 	}
-
-	return callAgentSliceMethod(ctx, a, "GetAlbumImages", func(ag Interface) ([]ExternalImage, error) {
+	start := time.Now()
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
+		if utils.IsCtxDone(ctx) {
+			break
+		}
 		retriever, ok := ag.(AlbumImageRetriever)
 		if !ok {
-			return nil, ErrNotFound
-		}
-		return retriever.GetAlbumImages(ctx, name, artist, mbid)
-	})
-}
-
-// GetSimilarSongsByTrack returns similar songs for a given track.
-func (a *Agents) GetSimilarSongsByTrack(ctx context.Context, id, name, artist, mbid string, count int) ([]Song, error) {
-	return callAgentSliceMethod(ctx, a, "GetSimilarSongsByTrack", func(ag Interface) ([]Song, error) {
-		retriever, ok := ag.(SimilarSongsByTrackRetriever)
-		if !ok {
-			return nil, ErrNotFound
-		}
-		return retriever.GetSimilarSongsByTrack(ctx, id, name, artist, mbid, count)
-	})
-}
-
-// GetSimilarSongsByAlbum returns similar songs for a given album.
-func (a *Agents) GetSimilarSongsByAlbum(ctx context.Context, id, name, artist, mbid string, count int) ([]Song, error) {
-	return callAgentSliceMethod(ctx, a, "GetSimilarSongsByAlbum", func(ag Interface) ([]Song, error) {
-		retriever, ok := ag.(SimilarSongsByAlbumRetriever)
-		if !ok {
-			return nil, ErrNotFound
-		}
-		return retriever.GetSimilarSongsByAlbum(ctx, id, name, artist, mbid, count)
-	})
-}
-
-// GetSimilarSongsByArtist returns similar songs for a given artist.
-func (a *Agents) GetSimilarSongsByArtist(ctx context.Context, id, name, mbid string, count int) ([]Song, error) {
-	switch id {
-	case consts.UnknownArtistID:
-		return nil, ErrNotFound
-	case consts.VariousArtistsID:
-		return nil, nil
-	}
-
-	return callAgentSliceMethod(ctx, a, "GetSimilarSongsByArtist", func(ag Interface) ([]Song, error) {
-		retriever, ok := ag.(SimilarSongsByArtistRetriever)
-		if !ok {
-			return nil, ErrNotFound
-		}
-		return retriever.GetSimilarSongsByArtist(ctx, id, name, mbid, count)
-	})
-}
-
-func callAgentMethod[T comparable](ctx context.Context, agents *Agents, methodName string, fn func(Interface) (T, error)) (T, error) {
-	var zero T
-	start := time.Now()
-	for _, enabledAgent := range agents.getEnabledAgentNames() {
-		ag := agents.getAgent(enabledAgent)
-		if ag == nil {
 			continue
 		}
-		if utils.IsCtxDone(ctx) {
-			break
-		}
-		result, err := fn(ag)
-		if err != nil {
-			log.Trace(ctx, "Agent method call error", "method", methodName, "agent", ag.AgentName(), "error", err)
-			continue
-		}
-
-		if result != zero {
-			log.Debug(ctx, "Got result", "method", methodName, "agent", ag.AgentName(), "elapsed", time.Since(start))
-			return result, nil
-		}
-	}
-	return zero, ErrNotFound
-}
-
-func callAgentSliceMethod[T any](ctx context.Context, agents *Agents, methodName string, fn func(Interface) ([]T, error)) ([]T, error) {
-	start := time.Now()
-	for _, enabledAgent := range agents.getEnabledAgentNames() {
-		ag := agents.getAgent(enabledAgent)
-		if ag == nil {
-			continue
-		}
-		if utils.IsCtxDone(ctx) {
-			break
-		}
-		results, err := fn(ag)
-		if err != nil {
-			log.Trace(ctx, "Agent method call error", "method", methodName, "agent", ag.AgentName(), "error", err)
-			continue
-		}
-
-		if len(results) > 0 {
-			log.Debug(ctx, "Got results", "method", methodName, "agent", ag.AgentName(), "count", len(results), "elapsed", time.Since(start))
-			return results, nil
+		images, err := retriever.GetAlbumImages(ctx, name, artist, mbid)
+		if len(images) > 0 && err == nil {
+			log.Debug(ctx, "Got Album Images", "agent", ag.AgentName(), "album", name, "artist", artist,
+				"mbid", mbid, "elapsed", time.Since(start))
+			return images, nil
 		}
 	}
 	return nil, ErrNotFound
@@ -377,6 +372,3 @@ var _ ArtistImageRetriever = (*Agents)(nil)
 var _ ArtistTopSongsRetriever = (*Agents)(nil)
 var _ AlbumInfoRetriever = (*Agents)(nil)
 var _ AlbumImageRetriever = (*Agents)(nil)
-var _ SimilarSongsByTrackRetriever = (*Agents)(nil)
-var _ SimilarSongsByAlbumRetriever = (*Agents)(nil)
-var _ SimilarSongsByArtistRetriever = (*Agents)(nil)

core/agents/agents_test.go

@@ -295,72 +295,6 @@ var _ = Describe("Agents", func() {
 				Expect(mock.Args).To(BeEmpty())
 			})
 		})
-
-		Describe("GetSimilarSongsByTrack", func() {
-			It("returns on first match", func() {
-				Expect(ag.GetSimilarSongsByTrack(ctx, "123", "test song", "test artist", "mb123", 2)).To(Equal([]Song{{
-					Name: "Similar Song",
-					MBID: "mbid555",
-				}}))
-				Expect(mock.Args).To(HaveExactElements("123", "test song", "test artist", "mb123", 2))
-			})
-			It("skips the agent if it returns an error", func() {
-				mock.Err = errors.New("error")
-				_, err := ag.GetSimilarSongsByTrack(ctx, "123", "test song", "test artist", "mb123", 2)
-				Expect(err).To(MatchError(ErrNotFound))
-				Expect(mock.Args).To(HaveExactElements("123", "test song", "test artist", "mb123", 2))
-			})
-			It("interrupts if the context is canceled", func() {
-				cancel()
-				_, err := ag.GetSimilarSongsByTrack(ctx, "123", "test song", "test artist", "mb123", 2)
-				Expect(err).To(MatchError(ErrNotFound))
-				Expect(mock.Args).To(BeEmpty())
-			})
-		})
-
-		Describe("GetSimilarSongsByAlbum", func() {
-			It("returns on first match", func() {
-				Expect(ag.GetSimilarSongsByAlbum(ctx, "123", "test album", "test artist", "mb123", 2)).To(Equal([]Song{{
-					Name: "Album Similar Song",
-					MBID: "mbid666",
-				}}))
-				Expect(mock.Args).To(HaveExactElements("123", "test album", "test artist", "mb123", 2))
-			})
-			It("skips the agent if it returns an error", func() {
-				mock.Err = errors.New("error")
-				_, err := ag.GetSimilarSongsByAlbum(ctx, "123", "test album", "test artist", "mb123", 2)
-				Expect(err).To(MatchError(ErrNotFound))
-				Expect(mock.Args).To(HaveExactElements("123", "test album", "test artist", "mb123", 2))
-			})
-			It("interrupts if the context is canceled", func() {
-				cancel()
-				_, err := ag.GetSimilarSongsByAlbum(ctx, "123", "test album", "test artist", "mb123", 2)
-				Expect(err).To(MatchError(ErrNotFound))
-				Expect(mock.Args).To(BeEmpty())
-			})
-		})
-
-		Describe("GetSimilarSongsByArtist", func() {
-			It("returns on first match", func() {
-				Expect(ag.GetSimilarSongsByArtist(ctx, "123", "test artist", "mb123", 2)).To(Equal([]Song{{
-					Name: "Artist Similar Song",
-					MBID: "mbid777",
-				}}))
-				Expect(mock.Args).To(HaveExactElements("123", "test artist", "mb123", 2))
-			})
-			It("skips the agent if it returns an error", func() {
-				mock.Err = errors.New("error")
-				_, err := ag.GetSimilarSongsByArtist(ctx, "123", "test artist", "mb123", 2)
-				Expect(err).To(MatchError(ErrNotFound))
-				Expect(mock.Args).To(HaveExactElements("123", "test artist", "mb123", 2))
-			})
-			It("interrupts if the context is canceled", func() {
-				cancel()
-				_, err := ag.GetSimilarSongsByArtist(ctx, "123", "test artist", "mb123", 2)
-				Expect(err).To(MatchError(ErrNotFound))
-				Expect(mock.Args).To(BeEmpty())
-			})
-		})
 	})
 })
 
@@ -443,39 +377,6 @@ func (a *mockAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid string)
 	}, nil
 }
 
-func (a *mockAgent) GetSimilarSongsByTrack(_ context.Context, id, name, artist, mbid string, count int) ([]Song, error) {
-	a.Args = []interface{}{id, name, artist, mbid, count}
-	if a.Err != nil {
-		return nil, a.Err
-	}
-	return []Song{{
-		Name: "Similar Song",
-		MBID: "mbid555",
-	}}, nil
-}
-
-func (a *mockAgent) GetSimilarSongsByAlbum(_ context.Context, id, name, artist, mbid string, count int) ([]Song, error) {
-	a.Args = []interface{}{id, name, artist, mbid, count}
-	if a.Err != nil {
-		return nil, a.Err
-	}
-	return []Song{{
-		Name: "Album Similar Song",
-		MBID: "mbid666",
-	}}, nil
-}
-
-func (a *mockAgent) GetSimilarSongsByArtist(_ context.Context, id, name, mbid string, count int) ([]Song, error) {
-	a.Args = []interface{}{id, name, mbid, count}
-	if a.Err != nil {
-		return nil, a.Err
-	}
-	return []Song{{
-		Name: "Artist Similar Song",
-		MBID: "mbid777",
-	}}, nil
-}
-
 type emptyAgent struct {
 	Interface
 }

core/agents/deezer/client.go

@@ -29,19 +29,20 @@ type httpDoer interface {
 
 type client struct {
 	httpDoer httpDoer
+	language string
 	jwt      jwtToken
 }
 
-func newClient(hc httpDoer) *client {
+func newClient(hc httpDoer, language string) *client {
 	return &client{
 		httpDoer: hc,
+		language: language,
 	}
 }
 
 func (c *client) searchArtists(ctx context.Context, name string, limit int) ([]Artist, error) {
 	params := url.Values{}
 	params.Add("q", name)
-	params.Add("order", "RANKING")
 	params.Add("limit", strconv.Itoa(limit))
 	req, err := http.NewRequestWithContext(ctx, "GET", apiBaseURL+"/search/artist", nil)
 	if err != nil {
@@ -127,7 +128,7 @@ const pipeAPIURL = "https://pipe.deezer.com/api"
 
 var strictPolicy = bluemonday.StrictPolicy()
 
-func (c *client) getArtistBio(ctx context.Context, artistID int, lang string) (string, error) {
+func (c *client) getArtistBio(ctx context.Context, artistID int) (string, error) {
 	jwt, err := c.getJWT(ctx)
 	if err != nil {
 		return "", fmt.Errorf("deezer: failed to get JWT: %w", err)
@@ -158,10 +159,10 @@ func (c *client) getArtistBio(ctx context.Context, artistID int, lang string) (s
 	}
 
 	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Accept-Language", lang)
+	req.Header.Set("Accept-Language", c.language)
 	req.Header.Set("Authorization", "Bearer "+jwt)
 
-	log.Trace(ctx, "Fetching Deezer artist biography via GraphQL", "artistId", artistID, "language", lang)
+	log.Trace(ctx, "Fetching Deezer artist biography via GraphQL", "artistId", artistID, "language", c.language)
 	resp, err := c.httpDoer.Do(req)
 	if err != nil {
 		return "", err

core/agents/deezer/client_auth_test.go

@@ -21,7 +21,7 @@ var _ = Describe("JWT Authentication", func() {
 
 	BeforeEach(func() {
 		httpClient = &fakeHttpClient{}
-		client = newClient(httpClient)
+		client = newClient(httpClient, "en")
 		ctx = context.Background()
 	})
 

core/agents/deezer/client_test.go

@@ -18,7 +18,7 @@ var _ = Describe("client", func() {
 
 	BeforeEach(func() {
 		httpClient = &fakeHttpClient{}
-		client = newClient(httpClient)
+		client = newClient(httpClient, "en")
 	})
 
 	Describe("ArtistImages", func() {
@@ -45,28 +45,6 @@ var _ = Describe("client", func() {
 		})
 	})
 
-	Describe("TopTracks", func() {
-		It("returns top tracks with artist and album info from a successful request", func() {
-			f, err := os.Open("tests/fixtures/deezer.artist.top.json")
-			Expect(err).To(BeNil())
-			httpClient.mock("https://api.deezer.com/artist/27/top", http.Response{Body: f, StatusCode: 200})
-
-			tracks, err := client.getTopTracks(GinkgoT().Context(), 27, 5)
-			Expect(err).To(BeNil())
-			Expect(tracks).To(HaveLen(5))
-
-			// Verify first track has all expected fields
-			Expect(tracks[0].Title).To(Equal("Instant Crush (feat. Julian Casablancas)"))
-			Expect(tracks[0].Artist.Name).To(Equal("Daft Punk"))
-			Expect(tracks[0].Album.Title).To(Equal("Random Access Memories"))
-
-			// Verify second track
-			Expect(tracks[1].Title).To(Equal("One More Time"))
-			Expect(tracks[1].Artist.Name).To(Equal("Daft Punk"))
-			Expect(tracks[1].Album.Title).To(Equal("Discovery"))
-		})
-	})
-
 	Describe("ArtistBio", func() {
 		BeforeEach(func() {
 			// Mock the JWT token endpoint with a valid JWT that expires in 5 minutes
@@ -78,33 +56,40 @@ var _ = Describe("client", func() {
 		})
 
 		It("returns artist bio from a successful request", func() {
-			f, err := os.Open("tests/fixtures/deezer.artist.bio.en.json")
+			f, err := os.Open("tests/fixtures/deezer.artist.bio.json")
 			Expect(err).To(BeNil())
 			httpClient.mock("https://pipe.deezer.com/api", http.Response{Body: f, StatusCode: 200})
 
-			bio, err := client.getArtistBio(GinkgoT().Context(), 27, "en")
+			bio, err := client.getArtistBio(GinkgoT().Context(), 27)
 			Expect(err).To(BeNil())
 			Expect(bio).To(ContainSubstring("Schoolmates Thomas and Guy-Manuel"))
 			Expect(bio).ToNot(ContainSubstring("<p>"))
 			Expect(bio).ToNot(ContainSubstring("</p>"))
 		})
 
-		It("uses the provided language", func() {
-			f, err := os.Open("tests/fixtures/deezer.artist.bio.fr.json")
+		It("uses the configured language", func() {
+			client = newClient(httpClient, "fr")
+			// Mock JWT token for the new client instance with a valid JWT
+			testJWT := createTestJWT(5 * time.Minute)
+			httpClient.mock("https://auth.deezer.com/login/anonymous", http.Response{
+				StatusCode: 200,
+				Body:       io.NopCloser(bytes.NewBufferString(fmt.Sprintf(`{"jwt":"%s","refresh_token":""}`, testJWT))),
+			})
+			f, err := os.Open("tests/fixtures/deezer.artist.bio.json")
 			Expect(err).To(BeNil())
 			httpClient.mock("https://pipe.deezer.com/api", http.Response{Body: f, StatusCode: 200})
 
-			_, err = client.getArtistBio(GinkgoT().Context(), 27, "fr")
+			_, err = client.getArtistBio(GinkgoT().Context(), 27)
 			Expect(err).To(BeNil())
 			Expect(httpClient.lastRequest.Header.Get("Accept-Language")).To(Equal("fr"))
 		})
 
 		It("includes the JWT token in the request", func() {
-			f, err := os.Open("tests/fixtures/deezer.artist.bio.en.json")
+			f, err := os.Open("tests/fixtures/deezer.artist.bio.json")
 			Expect(err).To(BeNil())
 			httpClient.mock("https://pipe.deezer.com/api", http.Response{Body: f, StatusCode: 200})
 
-			_, err = client.getArtistBio(GinkgoT().Context(), 27, "en")
+			_, err = client.getArtistBio(GinkgoT().Context(), 27)
 			Expect(err).To(BeNil())
 			// Verify that the Authorization header has the Bearer token format
 			authHeader := httpClient.lastRequest.Header.Get("Authorization")
@@ -135,7 +120,7 @@ var _ = Describe("client", func() {
 				Body:       io.NopCloser(bytes.NewBufferString(errorResponse)),
 			})
 
-			_, err := client.getArtistBio(GinkgoT().Context(), 999, "en")
+			_, err := client.getArtistBio(GinkgoT().Context(), 999)
 			Expect(err).To(HaveOccurred())
 			Expect(err.Error()).To(ContainSubstring("GraphQL error"))
 			Expect(err.Error()).To(ContainSubstring("Artist not found"))
@@ -157,7 +142,7 @@ var _ = Describe("client", func() {
 				Body:       io.NopCloser(bytes.NewBufferString(emptyBioResponse)),
 			})
 
-			_, err := client.getArtistBio(GinkgoT().Context(), 27, "en")
+			_, err := client.getArtistBio(GinkgoT().Context(), 27)
 			Expect(err).To(MatchError("deezer: biography not found"))
 		})
 
@@ -167,7 +152,7 @@ var _ = Describe("client", func() {
 				Body:       io.NopCloser(bytes.NewBufferString(`{"error":"Internal server error"}`)),
 			})
 
-			_, err := client.getArtistBio(GinkgoT().Context(), 27, "en")
+			_, err := client.getArtistBio(GinkgoT().Context(), 27)
 			Expect(err).To(HaveOccurred())
 			Expect(err.Error()).To(ContainSubstring("failed to get JWT"))
 		})
@@ -180,7 +165,7 @@ var _ = Describe("client", func() {
 				Body:       io.NopCloser(bytes.NewBufferString(fmt.Sprintf(`{"jwt":"%s","refresh_token":""}`, expiredJWT))),
 			})
 
-			_, err := client.getArtistBio(GinkgoT().Context(), 27, "en")
+			_, err := client.getArtistBio(GinkgoT().Context(), 27)
 			Expect(err).To(HaveOccurred())
 			Expect(err.Error()).To(ContainSubstring("JWT token already expired or expires too soon"))
 		})

core/agents/deezer/deezer.go

@@ -3,7 +3,6 @@ package deezer
 import (
 	"context"
 	"errors"
-	"fmt"
 	"net/http"
 	"strings"
 
@@ -26,19 +25,15 @@ const deezerArtistSearchLimit = 50
 type deezerAgent struct {
 	dataStore model.DataStore
 	client    *client
-	languages []string
 }
 
 func deezerConstructor(dataStore model.DataStore) agents.Interface {
-	agent := &deezerAgent{
-		dataStore: dataStore,
-		languages: conf.Server.Deezer.Languages,
-	}
+	agent := &deezerAgent{dataStore: dataStore}
 	httpClient := &http.Client{
 		Timeout: consts.DefaultHttpClientTimeOut,
 	}
 	cachedHttpClient := cache.NewHTTPClient(httpClient, consts.DefaultHttpClientTimeOut)
-	agent.client = newClient(cachedHttpClient)
+	agent.client = newClient(cachedHttpClient, conf.Server.Deezer.Language)
 	return agent
 }
 
@@ -87,20 +82,10 @@ func (s *deezerAgent) searchArtist(ctx context.Context, name string) (*Artist, e
 		return nil, err
 	}
 
-	log.Trace(ctx, "Artists found", "count", len(artists), "searched_name", name)
-	for i := range artists {
-		log.Trace(ctx, fmt.Sprintf("Artists found #%d", i), "name", artists[i].Name, "id", artists[i].ID, "link", artists[i].Link)
-		if i > 2 {
-			break
-		}
-	}
-
 	// If the first one has the same name, that's the one
 	if !strings.EqualFold(artists[0].Name, name) {
-		log.Trace(ctx, "Top artist do not match", "searched_name", name, "found_name", artists[0].Name)
 		return nil, agents.ErrNotFound
 	}
-	log.Trace(ctx, "Found artist", "name", artists[0].Name, "id", artists[0].ID, "link", artists[0].Link)
 	return &artists[0], err
 }
 
@@ -139,9 +124,7 @@ func (s *deezerAgent) GetArtistTopSongs(ctx context.Context, _, artistName, _ st
 
 	res := slice.Map(tracks, func(r Track) agents.Song {
 		return agents.Song{
-			Name:     r.Title,
-			Album:    r.Album.Title,
-			Duration: uint32(r.Duration * 1000), // Convert seconds to milliseconds
+			Name: r.Title,
 		}
 	})
 	return res, nil
@@ -153,14 +136,7 @@ func (s *deezerAgent) GetArtistBiography(ctx context.Context, _, name, _ string)
 		return "", err
 	}
 
-	for _, lang := range s.languages {
-		bio, err := s.client.getArtistBio(ctx, artist.ID, lang)
-		if err == nil && bio != "" {
-			return bio, nil
-		}
-		log.Debug(ctx, "Deezer/artist.bio returned empty/error, trying next language", "artist", name, "lang", lang, err)
-	}
-	return "", agents.ErrNotFound
+	return s.client.getArtistBio(ctx, artist.ID)
 }
 
 func init() {

core/agents/interfaces.go

@@ -22,7 +22,6 @@ type AlbumInfo struct {
 }
 
 type Artist struct {
-	ID   string
 	Name string
 	MBID string
 }
@@ -33,15 +32,8 @@ type ExternalImage struct {
 }
 
 type Song struct {
-	ID         string
-	Name       string
-	MBID       string
-	ISRC       string
-	Artist     string
-	ArtistMBID string
-	Album      string
-	AlbumMBID  string
-	Duration   uint32 // Duration in milliseconds, 0 means unknown
+	Name string
+	MBID string
 }
 
 var (
@@ -82,41 +74,6 @@ type ArtistTopSongsRetriever interface {
 	GetArtistTopSongs(ctx context.Context, id, artistName, mbid string, count int) ([]Song, error)
 }
 
-// SimilarSongsByTrackRetriever provides similar songs based on a specific track
-type SimilarSongsByTrackRetriever interface {
-	// GetSimilarSongsByTrack returns songs similar to the given track.
-	// Parameters:
-	//   - id: local mediafile ID
-	//   - name: track title
-	//   - artist: artist name
-	//   - mbid: MusicBrainz recording ID (may be empty)
-	//   - count: maximum number of results
-	GetSimilarSongsByTrack(ctx context.Context, id, name, artist, mbid string, count int) ([]Song, error)
-}
-
-// SimilarSongsByAlbumRetriever provides similar songs based on an album
-type SimilarSongsByAlbumRetriever interface {
-	// GetSimilarSongsByAlbum returns songs similar to tracks on the given album.
-	// Parameters:
-	//   - id: local album ID
-	//   - name: album name
-	//   - artist: album artist name
-	//   - mbid: MusicBrainz release ID (may be empty)
-	//   - count: maximum number of results
-	GetSimilarSongsByAlbum(ctx context.Context, id, name, artist, mbid string, count int) ([]Song, error)
-}
-
-// SimilarSongsByArtistRetriever provides similar songs based on an artist
-type SimilarSongsByArtistRetriever interface {
-	// GetSimilarSongsByArtist returns songs similar to the artist's catalog.
-	// Parameters:
-	//   - id: local artist ID
-	//   - name: artist name
-	//   - mbid: MusicBrainz artist ID (may be empty)
-	//   - count: maximum number of results
-	GetSimilarSongsByArtist(ctx context.Context, id, name, mbid string, count int) ([]Song, error)
-}
-
 var Map map[string]Constructor
 
 func Register(name string, init Constructor) {

core/agents/lastfm/agent.go

@@ -26,23 +26,17 @@ const (
 	sessionKeyProperty = "LastFMSessionKey"
 )
 
-var ignoredContent = []string{
-	// Empty Artist/Album
+var ignoredBiographies = []string{
+	// Unknown Artist
 	`<a href="https://www.last.fm/music/`,
 }
 
-var lastFMReadMoreRegex = regexp.MustCompile(`\s*<a href="https://www\.last\.fm/music/[^"]*">Read more on Last\.fm</a>\.?`)
-
-func cleanContent(content string) string {
-	return strings.TrimSpace(lastFMReadMoreRegex.ReplaceAllString(content, ""))
-}
-
 type lastfmAgent struct {
 	ds           model.DataStore
 	sessionKeys  *agents.SessionKeys
 	apiKey       string
 	secret       string
-	languages    []string
+	lang         string
 	client       *client
 	httpClient   httpDoer
 	getInfoMutex sync.Mutex
@@ -54,7 +48,7 @@ func lastFMConstructor(ds model.DataStore) *lastfmAgent {
 	}
 	l := &lastfmAgent{
 		ds:          ds,
-		languages:   conf.Server.LastFM.Languages,
+		lang:        conf.Server.LastFM.Language,
 		apiKey:      conf.Server.LastFM.ApiKey,
 		secret:      conf.Server.LastFM.Secret,
 		sessionKeys: &agents.SessionKeys{DataStore: ds, KeyName: sessionKeyProperty},
@@ -64,7 +58,7 @@ func lastFMConstructor(ds model.DataStore) *lastfmAgent {
 	}
 	chc := cache.NewHTTPClient(hc, consts.DefaultHttpClientTimeOut)
 	l.httpClient = chc
-	l.client = newClient(l.apiKey, l.secret, chc)
+	l.client = newClient(l.apiKey, l.secret, l.lang, chc)
 	return l
 }
 
@@ -74,47 +68,22 @@ func (l *lastfmAgent) AgentName() string {
 
 var imageRegex = regexp.MustCompile(`u\/(\d+)`)
 
-// isValidContent checks if content is non-empty and not in the ignored list
-func isValidContent(content string) bool {
-	content = strings.TrimSpace(content)
-	if content == "" {
-		return false
-	}
-	for _, ign := range ignoredContent {
-		if strings.HasPrefix(content, ign) {
-			return false
-		}
-	}
-	return true
-}
-
 func (l *lastfmAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid string) (*agents.AlbumInfo, error) {
-	var a *Album
-	var resp agents.AlbumInfo
-	for _, lang := range l.languages {
-		var err error
-		a, err = l.callAlbumGetInfo(ctx, name, artist, mbid, lang)
-		if err != nil {
-			return nil, err
-		}
-		resp.Name = a.Name
-		resp.MBID = a.MBID
-		resp.URL = a.URL
-		if isValidContent(a.Description.Summary) {
-			resp.Description = cleanContent(a.Description.Summary)
-			return &resp, nil
-		}
-		log.Debug(ctx, "LastFM/album.getInfo returned empty/ignored description, trying next language", "album", name, "artist", artist, "lang", lang)
+	a, err := l.callAlbumGetInfo(ctx, name, artist, mbid)
+	if err != nil {
+		return nil, err
 	}
-	// This condition should not be hit (languages default to ["en"]), but just in case
-	if a == nil {
-		return nil, agents.ErrNotFound
-	}
-	return &resp, nil
+
+	return &agents.AlbumInfo{
+		Name:        a.Name,
+		MBID:        a.MBID,
+		Description: a.Description.Summary,
+		URL:         a.URL,
+	}, nil
 }
 
 func (l *lastfmAgent) GetAlbumImages(ctx context.Context, name, artist, mbid string) ([]agents.ExternalImage, error) {
-	a, err := l.callAlbumGetInfo(ctx, name, artist, mbid, l.languages[0])
+	a, err := l.callAlbumGetInfo(ctx, name, artist, mbid)
 	if err != nil {
 		return nil, err
 	}
@@ -149,7 +118,7 @@ func (l *lastfmAgent) GetAlbumImages(ctx context.Context, name, artist, mbid str
 }
 
 func (l *lastfmAgent) GetArtistMBID(ctx context.Context, id string, name string) (string, error) {
-	a, err := l.callArtistGetInfo(ctx, name, l.languages[0])
+	a, err := l.callArtistGetInfo(ctx, name)
 	if err != nil {
 		return "", err
 	}
@@ -160,7 +129,7 @@ func (l *lastfmAgent) GetArtistMBID(ctx context.Context, id string, name string)
 }
 
 func (l *lastfmAgent) GetArtistURL(ctx context.Context, id, name, mbid string) (string, error) {
-	a, err := l.callArtistGetInfo(ctx, name, l.languages[0])
+	a, err := l.callArtistGetInfo(ctx, name)
 	if err != nil {
 		return "", err
 	}
@@ -171,17 +140,20 @@ func (l *lastfmAgent) GetArtistURL(ctx context.Context, id, name, mbid string) (
 }
 
 func (l *lastfmAgent) GetArtistBiography(ctx context.Context, id, name, mbid string) (string, error) {
-	for _, lang := range l.languages {
-		a, err := l.callArtistGetInfo(ctx, name, lang)
-		if err != nil {
-			return "", err
-		}
-		if isValidContent(a.Bio.Summary) {
-			return cleanContent(a.Bio.Summary), nil
-		}
-		log.Debug(ctx, "LastFM/artist.getInfo returned empty/ignored biography, trying next language", "artist", name, "lang", lang)
+	a, err := l.callArtistGetInfo(ctx, name)
+	if err != nil {
+		return "", err
 	}
-	return "", agents.ErrNotFound
+	a.Bio.Summary = strings.TrimSpace(a.Bio.Summary)
+	if a.Bio.Summary == "" {
+		return "", agents.ErrNotFound
+	}
+	for _, ign := range ignoredBiographies {
+		if strings.HasPrefix(a.Bio.Summary, ign) {
+			return "", nil
+		}
+	}
+	return a.Bio.Summary, nil
 }
 
 func (l *lastfmAgent) GetSimilarArtists(ctx context.Context, id, name, mbid string, limit int) ([]agents.Artist, error) {
@@ -220,26 +192,6 @@ func (l *lastfmAgent) GetArtistTopSongs(ctx context.Context, id, artistName, mbi
 	return res, nil
 }
 
-func (l *lastfmAgent) GetSimilarSongsByTrack(ctx context.Context, id, name, artist, mbid string, count int) ([]agents.Song, error) {
-	resp, err := l.callTrackGetSimilar(ctx, name, artist, count)
-	if err != nil {
-		return nil, err
-	}
-	if len(resp) == 0 {
-		return nil, agents.ErrNotFound
-	}
-	res := make([]agents.Song, 0, len(resp))
-	for _, t := range resp {
-		res = append(res, agents.Song{
-			Name:       t.Name,
-			MBID:       t.MBID,
-			Artist:     t.Artist.Name,
-			ArtistMBID: t.Artist.MBID,
-		})
-	}
-	return res, nil
-}
-
 var (
 	artistOpenGraphQuery = cascadia.MustCompile(`html > head > meta[property="og:image"]`)
 	artistIgnoredImage   = "2a96cbd8b46e442fc41c2b86b821562f" // Last.fm artist placeholder image name
@@ -247,7 +199,7 @@ var (
 
 func (l *lastfmAgent) GetArtistImages(ctx context.Context, _, name, mbid string) ([]agents.ExternalImage, error) {
 	log.Debug(ctx, "Getting artist images from Last.fm", "name", name)
-	a, err := l.callArtistGetInfo(ctx, name, l.languages[0])
+	a, err := l.callArtistGetInfo(ctx, name)
 	if err != nil {
 		return nil, fmt.Errorf("get artist info: %w", err)
 	}
@@ -287,14 +239,14 @@ func (l *lastfmAgent) GetArtistImages(ctx context.Context, _, name, mbid string)
 	return res, nil
 }
 
-func (l *lastfmAgent) callAlbumGetInfo(ctx context.Context, name, artist, mbid string, lang string) (*Album, error) {
-	a, err := l.client.albumGetInfo(ctx, name, artist, mbid, lang)
+func (l *lastfmAgent) callAlbumGetInfo(ctx context.Context, name, artist, mbid string) (*Album, error) {
+	a, err := l.client.albumGetInfo(ctx, name, artist, mbid)
 	var lfErr *lastFMError
 	isLastFMError := errors.As(err, &lfErr)
 
 	if mbid != "" && (isLastFMError && lfErr.Code == 6) {
 		log.Debug(ctx, "LastFM/album.getInfo could not find album by mbid, trying again", "album", name, "mbid", mbid)
-		return l.callAlbumGetInfo(ctx, name, artist, "", lang)
+		return l.callAlbumGetInfo(ctx, name, artist, "")
 	}
 
 	if err != nil {
@@ -308,11 +260,11 @@ func (l *lastfmAgent) callAlbumGetInfo(ctx context.Context, name, artist, mbid s
 	return a, nil
 }
 
-func (l *lastfmAgent) callArtistGetInfo(ctx context.Context, name string, lang string) (*Artist, error) {
+func (l *lastfmAgent) callArtistGetInfo(ctx context.Context, name string) (*Artist, error) {
 	l.getInfoMutex.Lock()
 	defer l.getInfoMutex.Unlock()
 
-	a, err := l.client.artistGetInfo(ctx, name, lang)
+	a, err := l.client.artistGetInfo(ctx, name)
 	if err != nil {
 		log.Error(ctx, "Error calling LastFM/artist.getInfo", "artist", name, err)
 		return nil, err
@@ -338,20 +290,11 @@ func (l *lastfmAgent) callArtistGetTopTracks(ctx context.Context, artistName str
 	return t.Track, nil
 }
 
-func (l *lastfmAgent) callTrackGetSimilar(ctx context.Context, name, artist string, count int) ([]SimilarTrack, error) {
-	s, err := l.client.trackGetSimilar(ctx, name, artist, count)
-	if err != nil {
-		log.Error(ctx, "Error calling LastFM/track.getSimilar", "track", name, "artist", artist, err)
-		return nil, err
+func (l *lastfmAgent) getArtistForScrobble(track *model.MediaFile) string {
+	if conf.Server.LastFM.ScrobbleFirstArtistOnly && len(track.Participants[model.RoleArtist]) > 0 {
+		return track.Participants[model.RoleArtist][0].Name
 	}
-	return s.Track, nil
-}
-
-func (l *lastfmAgent) getArtistForScrobble(track *model.MediaFile, role model.Role, displayName string) string {
-	if conf.Server.LastFM.ScrobbleFirstArtistOnly && len(track.Participants[role]) > 0 {
-		return track.Participants[role][0].Name
-	}
-	return displayName
+	return track.Artist
 }
 
 func (l *lastfmAgent) NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) error {
@@ -361,13 +304,13 @@ func (l *lastfmAgent) NowPlaying(ctx context.Context, userId string, track *mode
 	}
 
 	err = l.client.updateNowPlaying(ctx, sk, ScrobbleInfo{
-		artist:      l.getArtistForScrobble(track, model.RoleArtist, track.Artist),
+		artist:      l.getArtistForScrobble(track),
 		track:       track.Title,
 		album:       track.Album,
 		trackNumber: track.TrackNumber,
 		mbid:        track.MbzRecordingID,
 		duration:    int(track.Duration),
-		albumArtist: l.getArtistForScrobble(track, model.RoleAlbumArtist, track.AlbumArtist),
+		albumArtist: track.AlbumArtist,
 	})
 	if err != nil {
 		log.Warn(ctx, "Last.fm client.updateNowPlaying returned error", "track", track.Title, err)
@@ -387,13 +330,13 @@ func (l *lastfmAgent) Scrobble(ctx context.Context, userId string, s scrobbler.S
 		return nil
 	}
 	err = l.client.scrobble(ctx, sk, ScrobbleInfo{
-		artist:      l.getArtistForScrobble(&s.MediaFile, model.RoleArtist, s.Artist),
+		artist:      l.getArtistForScrobble(&s.MediaFile),
 		track:       s.Title,
 		album:       s.Album,
 		trackNumber: s.TrackNumber,
 		mbid:        s.MbzRecordingID,
 		duration:    int(s.Duration),
-		albumArtist: l.getArtistForScrobble(&s.MediaFile, model.RoleAlbumArtist, s.AlbumArtist),
+		albumArtist: s.AlbumArtist,
 		timestamp:   s.TimeStamp,
 	})
 	if err == nil {

core/agents/lastfm/agent_test.go

@@ -6,7 +6,6 @@ import (
 	"errors"
 	"io"
 	"net/http"
-	"net/url"
 	"os"
 	"strconv"
 	"time"
@@ -39,12 +38,12 @@ var _ = Describe("lastfmAgent", func() {
 	})
 	Describe("lastFMConstructor", func() {
 		When("Agent is properly configured", func() {
-			It("uses configured api key and languages", func() {
-				conf.Server.LastFM.Languages = []string{"pt", "en"}
+			It("uses configured api key and language", func() {
+				conf.Server.LastFM.Language = "pt"
 				agent := lastFMConstructor(ds)
 				Expect(agent.apiKey).To(Equal("123"))
 				Expect(agent.secret).To(Equal("secret"))
-				Expect(agent.languages).To(Equal([]string{"pt", "en"}))
+				Expect(agent.lang).To(Equal("pt"))
 			})
 		})
 		When("Agent is disabled", func() {
@@ -72,7 +71,7 @@ var _ = Describe("lastfmAgent", func() {
 		var httpClient *tests.FakeHttpClient
 		BeforeEach(func() {
 			httpClient = &tests.FakeHttpClient{}
-			client := newClient("API_KEY", "SECRET", httpClient)
+			client := newClient("API_KEY", "SECRET", "pt", httpClient)
 			agent = lastFMConstructor(ds)
 			agent.client = client
 		})
@@ -80,7 +79,7 @@ var _ = Describe("lastfmAgent", func() {
 		It("returns the biography", func() {
 			f, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
 			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			Expect(agent.GetArtistBiography(ctx, "123", "U2", "")).To(Equal("U2 é uma das mais importantes bandas de rock de todos os tempos. Formada em 1976 em Dublin, composta por Bono (vocalista  e guitarrista), The Edge (guitarrista, pianista e backing vocal), Adam Clayton (baixista), Larry Mullen, Jr. (baterista e percussionista).\n\nDesde a década de 80, U2 é uma das bandas mais populares no mundo. Seus shows são únicos e um verdadeiro festival de efeitos especiais, além de serem um dos que mais arrecadam anualmente."))
+			Expect(agent.GetArtistBiography(ctx, "123", "U2", "")).To(Equal("U2 é uma das mais importantes bandas de rock de todos os tempos. Formada em 1976 em Dublin, composta por Bono (vocalista  e guitarrista), The Edge (guitarrista, pianista e backing vocal), Adam Clayton (baixista), Larry Mullen, Jr. (baterista e percussionista).\n\nDesde a década de 80, U2 é uma das bandas mais populares no mundo. Seus shows são únicos e um verdadeiro festival de efeitos especiais, além de serem um dos que mais arrecadam anualmente. <a href=\"https://www.last.fm/music/U2\">Read more on Last.fm</a>"))
 			Expect(httpClient.RequestCount).To(Equal(1))
 			Expect(httpClient.SavedRequest.URL.Query().Get("artist")).To(Equal("U2"))
 		})
@@ -102,129 +101,12 @@ var _ = Describe("lastfmAgent", func() {
 		})
 	})
 
-	Describe("Language Fallback", func() {
-		Describe("GetArtistBiography", func() {
-			var agent *lastfmAgent
-			var httpClient *langAwareHttpClient
-
-			BeforeEach(func() {
-				httpClient = newLangAwareHttpClient()
-			})
-
-			It("returns content in first language when available (1 API call)", func() {
-				conf.Server.LastFM.Languages = []string{"pt", "en"}
-				agent = lastFMConstructor(ds)
-				agent.client = newClient("API_KEY", "SECRET", httpClient)
-
-				// Portuguese biography available
-				f, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
-				httpClient.responses["pt"] = http.Response{Body: f, StatusCode: 200}
-
-				bio, err := agent.GetArtistBiography(ctx, "123", "U2", "")
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(bio).To(ContainSubstring("U2 é uma das mais importantes bandas de rock"))
-				Expect(httpClient.requestCount).To(Equal(1))
-				Expect(httpClient.requests[0].URL.Query().Get("lang")).To(Equal("pt"))
-			})
-
-			It("falls back to second language when first returns empty (2 API calls)", func() {
-				conf.Server.LastFM.Languages = []string{"ja", "en"}
-				agent = lastFMConstructor(ds)
-				agent.client = newClient("API_KEY", "SECRET", httpClient)
-
-				// Japanese returns empty/ignored biography (actual Last.fm response with just "Read more" link)
-				fJa, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.empty.json")
-				httpClient.responses["ja"] = http.Response{Body: fJa, StatusCode: 200}
-				// English returns full biography
-				fEn, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.en.json")
-				httpClient.responses["en"] = http.Response{Body: fEn, StatusCode: 200}
-
-				bio, err := agent.GetArtistBiography(ctx, "123", "Legião Urbana", "")
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(bio).To(ContainSubstring("Legião Urbana was a Brazilian post-punk band"))
-				Expect(httpClient.requestCount).To(Equal(2))
-				Expect(httpClient.requests[0].URL.Query().Get("lang")).To(Equal("ja"))
-				Expect(httpClient.requests[1].URL.Query().Get("lang")).To(Equal("en"))
-			})
-
-			It("returns ErrNotFound when all languages return empty", func() {
-				conf.Server.LastFM.Languages = []string{"ja", "xx"}
-				agent = lastFMConstructor(ds)
-				agent.client = newClient("API_KEY", "SECRET", httpClient)
-
-				// Both languages return empty/ignored biography (using actual Last.fm response format)
-				fJa, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.empty.json")
-				httpClient.responses["ja"] = http.Response{Body: fJa, StatusCode: 200}
-				// Second language also returns empty
-				fXx, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.empty.json")
-				httpClient.responses["xx"] = http.Response{Body: fXx, StatusCode: 200}
-
-				_, err := agent.GetArtistBiography(ctx, "123", "Legião Urbana", "")
-
-				Expect(err).To(MatchError(agents.ErrNotFound))
-				Expect(httpClient.requestCount).To(Equal(2))
-			})
-		})
-
-		Describe("GetAlbumInfo", func() {
-			var agent *lastfmAgent
-			var httpClient *langAwareHttpClient
-
-			BeforeEach(func() {
-				httpClient = newLangAwareHttpClient()
-			})
-
-			It("falls back to second language when first returns empty description (2 API calls)", func() {
-				conf.Server.LastFM.Languages = []string{"ja", "en"}
-				agent = lastFMConstructor(ds)
-				agent.client = newClient("API_KEY", "SECRET", httpClient)
-
-				// Japanese returns album without wiki/description (actual Last.fm response)
-				fJa, _ := os.Open("tests/fixtures/lastfm.album.getinfo.empty.json")
-				httpClient.responses["ja"] = http.Response{Body: fJa, StatusCode: 200}
-				// English returns album with description
-				fEn, _ := os.Open("tests/fixtures/lastfm.album.getinfo.en.json")
-				httpClient.responses["en"] = http.Response{Body: fEn, StatusCode: 200}
-
-				albumInfo, err := agent.GetAlbumInfo(ctx, "Dois", "Legião Urbana", "")
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(albumInfo.Name).To(Equal("Dois"))
-				Expect(albumInfo.Description).To(ContainSubstring("segundo álbum de estúdio"))
-				Expect(httpClient.requestCount).To(Equal(2))
-				Expect(httpClient.requests[0].URL.Query().Get("lang")).To(Equal("ja"))
-				Expect(httpClient.requests[1].URL.Query().Get("lang")).To(Equal("en"))
-			})
-
-			It("returns album without description when all languages return empty", func() {
-				conf.Server.LastFM.Languages = []string{"ja", "xx"}
-				agent = lastFMConstructor(ds)
-				agent.client = newClient("API_KEY", "SECRET", httpClient)
-
-				// Both languages return album without description
-				fJa, _ := os.Open("tests/fixtures/lastfm.album.getinfo.empty.json")
-				httpClient.responses["ja"] = http.Response{Body: fJa, StatusCode: 200}
-				fXx, _ := os.Open("tests/fixtures/lastfm.album.getinfo.empty.json")
-				httpClient.responses["xx"] = http.Response{Body: fXx, StatusCode: 200}
-
-				albumInfo, err := agent.GetAlbumInfo(ctx, "Dois", "Legião Urbana", "")
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(albumInfo.Name).To(Equal("Dois"))
-				Expect(albumInfo.Description).To(BeEmpty())
-				Expect(httpClient.requestCount).To(Equal(2))
-			})
-		})
-	})
-
 	Describe("GetSimilarArtists", func() {
 		var agent *lastfmAgent
 		var httpClient *tests.FakeHttpClient
 		BeforeEach(func() {
 			httpClient = &tests.FakeHttpClient{}
-			client := newClient("API_KEY", "SECRET", httpClient)
+			client := newClient("API_KEY", "SECRET", "pt", httpClient)
 			agent = lastFMConstructor(ds)
 			agent.client = client
 		})
@@ -262,7 +144,7 @@ var _ = Describe("lastfmAgent", func() {
 		var httpClient *tests.FakeHttpClient
 		BeforeEach(func() {
 			httpClient = &tests.FakeHttpClient{}
-			client := newClient("API_KEY", "SECRET", httpClient)
+			client := newClient("API_KEY", "SECRET", "pt", httpClient)
 			agent = lastFMConstructor(ds)
 			agent.client = client
 		})
@@ -295,54 +177,6 @@ var _ = Describe("lastfmAgent", func() {
 		})
 	})
 
-	Describe("GetSimilarSongsByTrack", func() {
-		var agent *lastfmAgent
-		var httpClient *tests.FakeHttpClient
-		BeforeEach(func() {
-			httpClient = &tests.FakeHttpClient{}
-			client := newClient("API_KEY", "SECRET", httpClient)
-			agent = lastFMConstructor(ds)
-			agent.client = client
-		})
-
-		It("returns similar songs", func() {
-			f, _ := os.Open("tests/fixtures/lastfm.track.getsimilar.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			Expect(agent.GetSimilarSongsByTrack(ctx, "123", "Just Can't Get Enough", "Depeche Mode", "", 5)).To(Equal([]agents.Song{
-				{Name: "Dreaming of Me", MBID: "027b553e-7c74-3ed4-a95e-1d4fea51f174", Artist: "Depeche Mode", ArtistMBID: "8538e728-ca0b-4321-b7e5-cff6565dd4c0"},
-				{Name: "Everything Counts", MBID: "5a5a3ca4-bdb8-4641-a674-9b54b9b319a6", Artist: "Depeche Mode", ArtistMBID: "8538e728-ca0b-4321-b7e5-cff6565dd4c0"},
-				{Name: "Don't You Want Me", MBID: "", Artist: "The Human League", ArtistMBID: "7adaabfb-acfb-47bc-8c7c-59471c2f0db8"},
-				{Name: "Tainted Love", MBID: "", Artist: "Soft Cell", ArtistMBID: "7fb50287-029d-47cc-825a-235ca28024b2"},
-				{Name: "Blue Monday", MBID: "727e84c6-1b56-31dd-a958-a5f46305cec0", Artist: "New Order", ArtistMBID: "f1106b17-dcbb-45f6-b938-199ccfab50cc"},
-			}))
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Query().Get("track")).To(Equal("Just Can't Get Enough"))
-			Expect(httpClient.SavedRequest.URL.Query().Get("artist")).To(Equal("Depeche Mode"))
-		})
-
-		It("returns ErrNotFound when no similar songs found", func() {
-			f, _ := os.Open("tests/fixtures/lastfm.track.getsimilar.unknown.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			_, err := agent.GetSimilarSongsByTrack(ctx, "123", "UnknownTrack", "UnknownArtist", "", 3)
-			Expect(err).To(MatchError(agents.ErrNotFound))
-			Expect(httpClient.RequestCount).To(Equal(1))
-		})
-
-		It("returns an error if Last.fm call fails", func() {
-			httpClient.Err = errors.New("error")
-			_, err := agent.GetSimilarSongsByTrack(ctx, "123", "Believe", "Cher", "", 3)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-		})
-
-		It("returns an error if Last.fm call returns an error", func() {
-			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError3)), StatusCode: 200}
-			_, err := agent.GetSimilarSongsByTrack(ctx, "123", "Believe", "Cher", "", 3)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-		})
-	})
-
 	Describe("Scrobbling", func() {
 		var agent *lastfmAgent
 		var httpClient *tests.FakeHttpClient
@@ -350,7 +184,7 @@ var _ = Describe("lastfmAgent", func() {
 		BeforeEach(func() {
 			_ = ds.UserProps(ctx).Put("user-1", sessionKeyProperty, "SK-1")
 			httpClient = &tests.FakeHttpClient{}
-			client := newClient("API_KEY", "SECRET", httpClient)
+			client := newClient("API_KEY", "SECRET", "en", httpClient)
 			agent = lastFMConstructor(ds)
 			agent.client = client
 			track = &model.MediaFile{
@@ -367,10 +201,6 @@ var _ = Describe("lastfmAgent", func() {
 						{Artist: model.Artist{ID: "ar-1", Name: "First Artist"}},
 						{Artist: model.Artist{ID: "ar-2", Name: "Second Artist"}},
 					},
-					model.RoleAlbumArtist: []model.Participant{
-						{Artist: model.Artist{ID: "ar-1", Name: "First Album Artist"}},
-						{Artist: model.Artist{ID: "ar-2", Name: "Second Album Artist"}},
-					},
 				},
 			}
 		})
@@ -383,8 +213,7 @@ var _ = Describe("lastfmAgent", func() {
 
 				Expect(err).ToNot(HaveOccurred())
 				Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodPost))
-				body, _ := io.ReadAll(httpClient.SavedRequest.Body)
-				sentParams, _ := url.ParseQuery(string(body))
+				sentParams := httpClient.SavedRequest.URL.Query()
 				Expect(sentParams.Get("method")).To(Equal("track.updateNowPlaying"))
 				Expect(sentParams.Get("sk")).To(Equal("SK-1"))
 				Expect(sentParams.Get("track")).To(Equal(track.Title))
@@ -400,24 +229,6 @@ var _ = Describe("lastfmAgent", func() {
 				err := agent.NowPlaying(ctx, "user-2", track, 0)
 				Expect(err).To(MatchError(scrobbler.ErrNotAuthorized))
 			})
-
-			When("ScrobbleFirstArtistOnly is true", func() {
-				BeforeEach(func() {
-					conf.Server.LastFM.ScrobbleFirstArtistOnly = true
-				})
-
-				It("uses only the first artist", func() {
-					httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString("{}")), StatusCode: 200}
-
-					err := agent.NowPlaying(ctx, "user-1", track, 0)
-
-					Expect(err).ToNot(HaveOccurred())
-					body, _ := io.ReadAll(httpClient.SavedRequest.Body)
-					sentParams, _ := url.ParseQuery(string(body))
-					Expect(sentParams.Get("artist")).To(Equal("First Artist"))
-					Expect(sentParams.Get("albumArtist")).To(Equal("First Album Artist"))
-				})
-			})
 		})
 
 		Describe("scrobble", func() {
@@ -429,8 +240,7 @@ var _ = Describe("lastfmAgent", func() {
 
 				Expect(err).ToNot(HaveOccurred())
 				Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodPost))
-				body, _ := io.ReadAll(httpClient.SavedRequest.Body)
-				sentParams, _ := url.ParseQuery(string(body))
+				sentParams := httpClient.SavedRequest.URL.Query()
 				Expect(sentParams.Get("method")).To(Equal("track.scrobble"))
 				Expect(sentParams.Get("sk")).To(Equal("SK-1"))
 				Expect(sentParams.Get("track")).To(Equal(track.Title))
@@ -455,10 +265,8 @@ var _ = Describe("lastfmAgent", func() {
 					err := agent.Scrobble(ctx, "user-1", scrobbler.Scrobble{MediaFile: *track, TimeStamp: ts})
 
 					Expect(err).ToNot(HaveOccurred())
-					body, _ := io.ReadAll(httpClient.SavedRequest.Body)
-					sentParams, _ := url.ParseQuery(string(body))
+					sentParams := httpClient.SavedRequest.URL.Query()
 					Expect(sentParams.Get("artist")).To(Equal("First Artist"))
-					Expect(sentParams.Get("albumArtist")).To(Equal("First Album Artist"))
 				})
 			})
 
@@ -524,7 +332,7 @@ var _ = Describe("lastfmAgent", func() {
 		var httpClient *tests.FakeHttpClient
 		BeforeEach(func() {
 			httpClient = &tests.FakeHttpClient{}
-			client := newClient("API_KEY", "SECRET", httpClient)
+			client := newClient("API_KEY", "SECRET", "pt", httpClient)
 			agent = lastFMConstructor(ds)
 			agent.client = client
 		})
@@ -535,7 +343,7 @@ var _ = Describe("lastfmAgent", func() {
 			Expect(agent.GetAlbumInfo(ctx, "Believe", "Cher", "03c91c40-49a6-44a7-90e7-a700edf97a62")).To(Equal(&agents.AlbumInfo{
 				Name:        "Believe",
 				MBID:        "03c91c40-49a6-44a7-90e7-a700edf97a62",
-				Description: "Believe is the twenty-third studio album by American singer-actress Cher, released on November 10, 1998 by Warner Bros. Records. The RIAA certified it Quadruple Platinum on December 23, 1999, recognizing four million shipments in the United States; Worldwide, the album has sold more than 20 million copies, making it the biggest-selling album of her career. In 1999 the album received three Grammy Awards nominations including \"Record of the Year\", \"Best Pop Album\" and winning \"Best Dance Recording\" for the single \"Believe\". It was released by Warner Bros. Records at the end of 1998. The album was executive produced by Rob",
+				Description: "Believe is the twenty-third studio album by American singer-actress Cher, released on November 10, 1998 by Warner Bros. Records. The RIAA certified it Quadruple Platinum on December 23, 1999, recognizing four million shipments in the United States; Worldwide, the album has sold more than 20 million copies, making it the biggest-selling album of her career. In 1999 the album received three Grammy Awards nominations including \"Record of the Year\", \"Best Pop Album\" and winning \"Best Dance Recording\" for the single \"Believe\". It was released by Warner Bros. Records at the end of 1998. The album was executive produced by Rob <a href=\"https://www.last.fm/music/Cher/Believe\">Read more on Last.fm</a>.",
 				URL:         "https://www.last.fm/music/Cher/Believe",
 			}))
 			Expect(httpClient.RequestCount).To(Equal(1))
@@ -594,7 +402,7 @@ var _ = Describe("lastfmAgent", func() {
 		BeforeEach(func() {
 			apiClient = &tests.FakeHttpClient{}
 			httpClient = &tests.FakeHttpClient{}
-			client := newClient("API_KEY", "SECRET", apiClient)
+			client := newClient("API_KEY", "SECRET", "pt", apiClient)
 			agent = lastFMConstructor(ds)
 			agent.client = client
 			agent.httpClient = httpClient
@@ -655,31 +463,3 @@ var _ = Describe("lastfmAgent", func() {
 		})
 	})
 })
-
-// langAwareHttpClient is a mock HTTP client that returns different responses based on the lang parameter
-type langAwareHttpClient struct {
-	responses    map[string]http.Response
-	requests     []*http.Request
-	requestCount int
-}
-
-func newLangAwareHttpClient() *langAwareHttpClient {
-	return &langAwareHttpClient{
-		responses: make(map[string]http.Response),
-		requests:  make([]*http.Request, 0),
-	}
-}
-
-func (c *langAwareHttpClient) Do(req *http.Request) (*http.Response, error) {
-	c.requestCount++
-	c.requests = append(c.requests, req)
-	lang := req.URL.Query().Get("lang")
-	if resp, ok := c.responses[lang]; ok {
-		return &resp, nil
-	}
-	// Return default empty response if no specific response is configured
-	return &http.Response{
-		StatusCode: 200,
-		Body:       io.NopCloser(bytes.NewBufferString(`{}`)),
-	}, nil
-}

core/agents/lastfm/auth_router.go

@@ -44,7 +44,7 @@ func NewRouter(ds model.DataStore) *Router {
 	hc := &http.Client{
 		Timeout: consts.DefaultHttpClientTimeOut,
 	}
-	r.client = newClient(r.apiKey, r.secret, hc)
+	r.client = newClient(r.apiKey, r.secret, "en", hc)
 	return r
 }
 

core/agents/lastfm/client.go

@@ -34,23 +34,24 @@ type httpDoer interface {
 	Do(req *http.Request) (*http.Response, error)
 }
 
-func newClient(apiKey string, secret string, hc httpDoer) *client {
-	return &client{apiKey, secret, hc}
+func newClient(apiKey string, secret string, lang string, hc httpDoer) *client {
+	return &client{apiKey, secret, lang, hc}
 }
 
 type client struct {
 	apiKey string
 	secret string
+	lang   string
 	hc     httpDoer
 }
 
-func (c *client) albumGetInfo(ctx context.Context, name string, artist string, mbid string, lang string) (*Album, error) {
+func (c *client) albumGetInfo(ctx context.Context, name string, artist string, mbid string) (*Album, error) {
 	params := url.Values{}
 	params.Add("method", "album.getInfo")
 	params.Add("album", name)
 	params.Add("artist", artist)
 	params.Add("mbid", mbid)
-	params.Add("lang", lang)
+	params.Add("lang", c.lang)
 	response, err := c.makeRequest(ctx, http.MethodGet, params, false)
 	if err != nil {
 		return nil, err
@@ -58,11 +59,11 @@ func (c *client) albumGetInfo(ctx context.Context, name string, artist string, m
 	return &response.Album, nil
 }
 
-func (c *client) artistGetInfo(ctx context.Context, name string, lang string) (*Artist, error) {
+func (c *client) artistGetInfo(ctx context.Context, name string) (*Artist, error) {
 	params := url.Values{}
 	params.Add("method", "artist.getInfo")
 	params.Add("artist", name)
-	params.Add("lang", lang)
+	params.Add("lang", c.lang)
 	response, err := c.makeRequest(ctx, http.MethodGet, params, false)
 	if err != nil {
 		return nil, err
@@ -94,19 +95,6 @@ func (c *client) artistGetTopTracks(ctx context.Context, name string, limit int)
 	return &response.TopTracks, nil
 }
 
-func (c *client) trackGetSimilar(ctx context.Context, name, artist string, limit int) (*SimilarTracks, error) {
-	params := url.Values{}
-	params.Add("method", "track.getSimilar")
-	params.Add("track", name)
-	params.Add("artist", artist)
-	params.Add("limit", strconv.Itoa(limit))
-	response, err := c.makeRequest(ctx, http.MethodGet, params, false)
-	if err != nil {
-		return nil, err
-	}
-	return &response.SimilarTracks, nil
-}
-
 func (c *client) GetToken(ctx context.Context) (string, error) {
 	params := url.Values{}
 	params.Add("method", "auth.getToken")
@@ -197,15 +185,8 @@ func (c *client) makeRequest(ctx context.Context, method string, params url.Valu
 		c.sign(params)
 	}
 
-	var req *http.Request
-	if method == http.MethodPost {
-		body := strings.NewReader(params.Encode())
-		req, _ = http.NewRequestWithContext(ctx, method, apiBaseUrl, body)
-		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	} else {
-		req, _ = http.NewRequestWithContext(ctx, method, apiBaseUrl, nil)
-		req.URL.RawQuery = params.Encode()
-	}
+	req, _ := http.NewRequestWithContext(ctx, method, apiBaseUrl, nil)
+	req.URL.RawQuery = params.Encode()
 
 	log.Trace(ctx, fmt.Sprintf("Sending Last.fm %s request", req.Method), "url", req.URL)
 	resp, err := c.hc.Do(req)

core/agents/lastfm/client_test.go

@@ -22,7 +22,7 @@ var _ = Describe("client", func() {
 
 	BeforeEach(func() {
 		httpClient = &tests.FakeHttpClient{}
-		client = newClient("API_KEY", "SECRET", httpClient)
+		client = newClient("API_KEY", "SECRET", "pt", httpClient)
 	})
 
 	Describe("albumGetInfo", func() {
@@ -30,7 +30,7 @@ var _ = Describe("client", func() {
 			f, _ := os.Open("tests/fixtures/lastfm.album.getinfo.json")
 			httpClient.Res = http.Response{Body: f, StatusCode: 200}
 
-			album, err := client.albumGetInfo(context.Background(), "Believe", "U2", "mbid-1234", "pt")
+			album, err := client.albumGetInfo(context.Background(), "Believe", "U2", "mbid-1234")
 			Expect(err).To(BeNil())
 			Expect(album.Name).To(Equal("Believe"))
 			Expect(httpClient.SavedRequest.URL.String()).To(Equal(apiBaseUrl + "?album=Believe&api_key=API_KEY&artist=U2&format=json&lang=pt&mbid=mbid-1234&method=album.getInfo"))
@@ -42,7 +42,7 @@ var _ = Describe("client", func() {
 			f, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
 			httpClient.Res = http.Response{Body: f, StatusCode: 200}
 
-			artist, err := client.artistGetInfo(context.Background(), "U2", "pt")
+			artist, err := client.artistGetInfo(context.Background(), "U2")
 			Expect(err).To(BeNil())
 			Expect(artist.Name).To(Equal("U2"))
 			Expect(httpClient.SavedRequest.URL.String()).To(Equal(apiBaseUrl + "?api_key=API_KEY&artist=U2&format=json&lang=pt&method=artist.getInfo"))
@@ -54,7 +54,7 @@ var _ = Describe("client", func() {
 				StatusCode: 500,
 			}
 
-			_, err := client.artistGetInfo(context.Background(), "U2", "pt")
+			_, err := client.artistGetInfo(context.Background(), "U2")
 			Expect(err).To(MatchError("last.fm http status: (500)"))
 		})
 
@@ -64,7 +64,7 @@ var _ = Describe("client", func() {
 				StatusCode: 400,
 			}
 
-			_, err := client.artistGetInfo(context.Background(), "U2", "pt")
+			_, err := client.artistGetInfo(context.Background(), "U2")
 			Expect(err).To(MatchError(&lastFMError{Code: 3, Message: "Invalid Method - No method with that name in this package"}))
 		})
 
@@ -74,14 +74,14 @@ var _ = Describe("client", func() {
 				StatusCode: 200,
 			}
 
-			_, err := client.artistGetInfo(context.Background(), "U2", "pt")
+			_, err := client.artistGetInfo(context.Background(), "U2")
 			Expect(err).To(MatchError(&lastFMError{Code: 6, Message: "The artist you supplied could not be found"}))
 		})
 
 		It("fails if HttpClient.Do() returns error", func() {
 			httpClient.Err = errors.New("generic error")
 
-			_, err := client.artistGetInfo(context.Background(), "U2", "pt")
+			_, err := client.artistGetInfo(context.Background(), "U2")
 			Expect(err).To(MatchError("generic error"))
 		})
 
@@ -91,7 +91,7 @@ var _ = Describe("client", func() {
 				StatusCode: 200,
 			}
 
-			_, err := client.artistGetInfo(context.Background(), "U2", "pt")
+			_, err := client.artistGetInfo(context.Background(), "U2")
 			Expect(err).To(MatchError("invalid character '<' looking for beginning of value"))
 		})
 
@@ -121,30 +121,6 @@ var _ = Describe("client", func() {
 		})
 	})
 
-	Describe("trackGetSimilar", func() {
-		It("returns similar tracks for a successful response", func() {
-			f, _ := os.Open("tests/fixtures/lastfm.track.getsimilar.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-
-			similar, err := client.trackGetSimilar(context.Background(), "Just Can't Get Enough", "Depeche Mode", 5)
-			Expect(err).To(BeNil())
-			Expect(len(similar.Track)).To(Equal(5))
-			Expect(similar.Track[0].Name).To(Equal("Dreaming of Me"))
-			Expect(similar.Track[0].Artist.Name).To(Equal("Depeche Mode"))
-			Expect(similar.Track[0].Match).To(Equal(1.0))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(apiBaseUrl + "?api_key=API_KEY&artist=Depeche+Mode&format=json&limit=5&method=track.getSimilar&track=Just+Can%27t+Get+Enough"))
-		})
-
-		It("returns empty list when no similar tracks found", func() {
-			f, _ := os.Open("tests/fixtures/lastfm.track.getsimilar.unknown.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-
-			similar, err := client.trackGetSimilar(context.Background(), "UnknownTrack", "UnknownArtist", 3)
-			Expect(err).To(BeNil())
-			Expect(similar.Track).To(BeEmpty())
-		})
-	})
-
 	Describe("GetToken", func() {
 		It("returns a token when the request is successful", func() {
 			httpClient.Res = http.Response{
@@ -178,74 +154,6 @@ var _ = Describe("client", func() {
 		})
 	})
 
-	Describe("scrobble", func() {
-		It("sends parameters in request body for POST", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"scrobbles":{"scrobble":{"ignoredMessage":{"code":"0"}},"@attr":{"accepted":1}}}`)),
-				StatusCode: 200,
-			}
-
-			info := ScrobbleInfo{
-				artist:      "U2",
-				track:       "One",
-				album:       "Achtung Baby",
-				trackNumber: 1,
-				duration:    276,
-				albumArtist: "U2",
-			}
-			err := client.scrobble(context.Background(), "SESSION_KEY", info)
-			Expect(err).To(BeNil())
-
-			req := httpClient.SavedRequest
-			Expect(req.Method).To(Equal(http.MethodPost))
-			Expect(req.Header.Get("Content-Type")).To(Equal("application/x-www-form-urlencoded"))
-			Expect(req.URL.RawQuery).To(BeEmpty())
-
-			body, _ := io.ReadAll(req.Body)
-			bodyParams, _ := url.ParseQuery(string(body))
-			Expect(bodyParams.Get("method")).To(Equal("track.scrobble"))
-			Expect(bodyParams.Get("artist")).To(Equal("U2"))
-			Expect(bodyParams.Get("track")).To(Equal("One"))
-			Expect(bodyParams.Get("sk")).To(Equal("SESSION_KEY"))
-			Expect(bodyParams.Get("api_key")).To(Equal("API_KEY"))
-			Expect(bodyParams.Get("api_sig")).ToNot(BeEmpty())
-		})
-	})
-
-	Describe("updateNowPlaying", func() {
-		It("sends parameters in request body for POST", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"nowplaying":{"ignoredMessage":{"code":"0"}}}`)),
-				StatusCode: 200,
-			}
-
-			info := ScrobbleInfo{
-				artist:      "U2",
-				track:       "One",
-				album:       "Achtung Baby",
-				trackNumber: 1,
-				duration:    276,
-				albumArtist: "U2",
-			}
-			err := client.updateNowPlaying(context.Background(), "SESSION_KEY", info)
-			Expect(err).To(BeNil())
-
-			req := httpClient.SavedRequest
-			Expect(req.Method).To(Equal(http.MethodPost))
-			Expect(req.Header.Get("Content-Type")).To(Equal("application/x-www-form-urlencoded"))
-			Expect(req.URL.RawQuery).To(BeEmpty())
-
-			body, _ := io.ReadAll(req.Body)
-			bodyParams, _ := url.ParseQuery(string(body))
-			Expect(bodyParams.Get("method")).To(Equal("track.updateNowPlaying"))
-			Expect(bodyParams.Get("artist")).To(Equal("U2"))
-			Expect(bodyParams.Get("track")).To(Equal("One"))
-			Expect(bodyParams.Get("sk")).To(Equal("SESSION_KEY"))
-			Expect(bodyParams.Get("api_key")).To(Equal("API_KEY"))
-			Expect(bodyParams.Get("api_sig")).ToNot(BeEmpty())
-		})
-	})
-
 	Describe("sign", func() {
 		It("adds an api_sig param with the signature", func() {
 			params := url.Values{}

core/agents/lastfm/responses.go

@@ -5,7 +5,6 @@ type Response struct {
 	SimilarArtists SimilarArtists `json:"similarartists"`
 	TopTracks      TopTracks      `json:"toptracks"`
 	Album          Album          `json:"album"`
-	SimilarTracks  SimilarTracks  `json:"similartracks"`
 	Error          int            `json:"error"`
 	Message        string         `json:"message"`
 	Token          string         `json:"token"`
@@ -60,28 +59,6 @@ type TopTracks struct {
 	Attr  Attr    `json:"@attr"`
 }
 
-type SimilarTracks struct {
-	Track []SimilarTrack `json:"track"`
-	Attr  SimilarAttr    `json:"@attr"`
-}
-
-type SimilarTrack struct {
-	Name   string             `json:"name"`
-	MBID   string             `json:"mbid"`
-	Match  float64            `json:"match"`
-	Artist SimilarTrackArtist `json:"artist"`
-}
-
-type SimilarTrackArtist struct {
-	Name string `json:"name"`
-	MBID string `json:"mbid"`
-}
-
-type SimilarAttr struct {
-	Artist string `json:"artist"`
-	Track  string `json:"track"`
-}
-
 type Session struct {
 	Name       string `json:"name"`
 	Key        string `json:"key"`

core/agents/listenbrainz/agent.go

@@ -118,129 +118,12 @@ func (l *listenBrainzAgent) IsAuthorized(ctx context.Context, userId string) boo
 	return err == nil && sk != ""
 }
 
-func (l *listenBrainzAgent) GetArtistURL(ctx context.Context, id, name, mbid string) (string, error) {
-	if mbid == "" {
-		return "", agents.ErrNotFound
-	}
-
-	url, err := l.client.getArtistUrl(ctx, mbid)
-	if err != nil {
-		return "", err
-	}
-	return url, nil
-}
-
-func (l *listenBrainzAgent) GetArtistTopSongs(ctx context.Context, id, artistName, mbid string, count int) ([]agents.Song, error) {
-	resp, err := l.client.getArtistTopSongs(ctx, mbid, count)
-	if err != nil {
-		return nil, err
-	}
-	if len(resp) == 0 {
-		return nil, agents.ErrNotFound
-	}
-
-	res := make([]agents.Song, len(resp))
-	for i, t := range resp {
-		mbid := ""
-		if len(t.ArtistMBIDs) > 0 {
-			mbid = t.ArtistMBIDs[0]
-		}
-
-		res[i] = agents.Song{
-			Album:      t.ReleaseName,
-			AlbumMBID:  t.ReleaseMBID,
-			Artist:     t.ArtistName,
-			ArtistMBID: mbid,
-			Duration:   t.DurationMs,
-			Name:       t.RecordingName,
-			MBID:       t.RecordingMbid,
-		}
-	}
-	return res, nil
-}
-
-func (l *listenBrainzAgent) GetSimilarArtists(ctx context.Context, id string, name string, mbid string, limit int) ([]agents.Artist, error) {
-	if mbid == "" {
-		return nil, agents.ErrNotFound
-	}
-
-	resp, err := l.client.getSimilarArtists(ctx, mbid, limit)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(resp) == 0 {
-		return nil, agents.ErrNotFound
-	}
-
-	artists := make([]agents.Artist, len(resp))
-	for i, artist := range resp {
-		artists[i] = agents.Artist{
-			MBID: artist.MBID,
-			Name: artist.Name,
-		}
-	}
-
-	return artists, nil
-}
-
-func (l *listenBrainzAgent) GetSimilarSongsByTrack(ctx context.Context, id string, name string, artist string, mbid string, limit int) ([]agents.Song, error) {
-	if mbid == "" {
-		return nil, agents.ErrNotFound
-	}
-
-	resp, err := l.client.getSimilarRecordings(ctx, mbid, limit)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(resp) == 0 {
-		return nil, agents.ErrNotFound
-	}
-
-	songs := make([]agents.Song, len(resp))
-	for i, song := range resp {
-		songs[i] = agents.Song{
-			Album:     song.ReleaseName,
-			AlbumMBID: song.ReleaseMBID,
-			Artist:    song.Artist,
-			MBID:      song.MBID,
-			Name:      song.Name,
-		}
-	}
-
-	return songs, nil
-}
-
 func init() {
 	conf.AddHook(func() {
 		if conf.Server.ListenBrainz.Enabled {
 			scrobbler.Register(listenBrainzAgentName, func(ds model.DataStore) scrobbler.Scrobbler {
-				// This is a workaround for the fact that a (Interface)(nil) is not the same as a (*listenBrainzAgent)(nil)
-				// See https://go.dev/doc/faq#nil_error
-				a := listenBrainzConstructor(ds)
-				if a != nil {
-					return a
-				}
-				return nil
-			})
-
-			agents.Register(listenBrainzAgentName, func(ds model.DataStore) agents.Interface {
-				// This is a workaround for the fact that a (Interface)(nil) is not the same as a (*listenBrainzAgent)(nil)
-				// See https://go.dev/doc/faq#nil_error
-				a := listenBrainzConstructor(ds)
-				if a != nil {
-					return a
-				}
-				return nil
+				return listenBrainzConstructor(ds)
 			})
 		}
 	})
 }
-
-var (
-	_ agents.ArtistTopSongsRetriever      = (*listenBrainzAgent)(nil)
-	_ agents.ArtistURLRetriever           = (*listenBrainzAgent)(nil)
-	_ agents.ArtistSimilarRetriever       = (*listenBrainzAgent)(nil)
-	_ agents.SimilarSongsByTrackRetriever = (*listenBrainzAgent)(nil)
-)

core/agents/listenbrainz/agent_test.go

@@ -0,0 +1,165 @@
+package listenbrainz
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"time"
+
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/core/scrobbler"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/gstruct"
+)
+
+var _ = Describe("listenBrainzAgent", func() {
+	var ds model.DataStore
+	var ctx context.Context
+	var agent *listenBrainzAgent
+	var httpClient *tests.FakeHttpClient
+	var track *model.MediaFile
+
+	BeforeEach(func() {
+		ds = &tests.MockDataStore{}
+		ctx = context.Background()
+		_ = ds.UserProps(ctx).Put("user-1", sessionKeyProperty, "SK-1")
+		httpClient = &tests.FakeHttpClient{}
+		agent = listenBrainzConstructor(ds)
+		agent.client = newClient("http://localhost:8080", httpClient)
+		track = &model.MediaFile{
+			ID:                "123",
+			Title:             "Track Title",
+			Album:             "Track Album",
+			Artist:            "Track Artist",
+			TrackNumber:       1,
+			MbzRecordingID:    "mbz-123",
+			MbzAlbumID:        "mbz-456",
+			MbzReleaseGroupID: "mbz-789",
+			Duration:          142.2,
+			Participants: map[model.Role]model.ParticipantList{
+				model.RoleArtist: []model.Participant{
+					{Artist: model.Artist{ID: "ar-1", Name: "Artist 1", MbzArtistID: "mbz-111"}},
+					{Artist: model.Artist{ID: "ar-2", Name: "Artist 2", MbzArtistID: "mbz-222"}},
+				},
+			},
+		}
+	})
+
+	Describe("formatListen", func() {
+		It("constructs the listenInfo properly", func() {
+			lr := agent.formatListen(track)
+			Expect(lr).To(MatchAllFields(Fields{
+				"ListenedAt": Equal(0),
+				"TrackMetadata": MatchAllFields(Fields{
+					"ArtistName":  Equal(track.Artist),
+					"TrackName":   Equal(track.Title),
+					"ReleaseName": Equal(track.Album),
+					"AdditionalInfo": MatchAllFields(Fields{
+						"SubmissionClient":        Equal(consts.AppName),
+						"SubmissionClientVersion": Equal(consts.Version),
+						"TrackNumber":             Equal(track.TrackNumber),
+						"RecordingMBID":           Equal(track.MbzRecordingID),
+						"ReleaseMBID":             Equal(track.MbzAlbumID),
+						"ReleaseGroupMBID":        Equal(track.MbzReleaseGroupID),
+						"ArtistNames":             ConsistOf("Artist 1", "Artist 2"),
+						"ArtistMBIDs":             ConsistOf("mbz-111", "mbz-222"),
+						"DurationMs":              Equal(142200),
+					}),
+				}),
+			}))
+		})
+	})
+
+	Describe("NowPlaying", func() {
+		It("updates NowPlaying successfully", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(`{"status": "ok"}`)), StatusCode: 200}
+
+			err := agent.NowPlaying(ctx, "user-1", track, 0)
+			Expect(err).ToNot(HaveOccurred())
+		})
+
+		It("returns ErrNotAuthorized if user is not linked", func() {
+			err := agent.NowPlaying(ctx, "user-2", track, 0)
+			Expect(err).To(MatchError(scrobbler.ErrNotAuthorized))
+		})
+	})
+
+	Describe("Scrobble", func() {
+		var sc scrobbler.Scrobble
+
+		BeforeEach(func() {
+			sc = scrobbler.Scrobble{MediaFile: *track, TimeStamp: time.Now()}
+		})
+
+		It("sends a Scrobble successfully", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(`{"status": "ok"}`)), StatusCode: 200}
+
+			err := agent.Scrobble(ctx, "user-1", sc)
+			Expect(err).ToNot(HaveOccurred())
+		})
+
+		It("sets the Timestamp properly", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(`{"status": "ok"}`)), StatusCode: 200}
+
+			err := agent.Scrobble(ctx, "user-1", sc)
+			Expect(err).ToNot(HaveOccurred())
+
+			decoder := json.NewDecoder(httpClient.SavedRequest.Body)
+			var lr listenBrainzRequestBody
+			err = decoder.Decode(&lr)
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(lr.Payload[0].ListenedAt).To(Equal(int(sc.TimeStamp.Unix())))
+		})
+
+		It("returns ErrNotAuthorized if user is not linked", func() {
+			err := agent.Scrobble(ctx, "user-2", sc)
+			Expect(err).To(MatchError(scrobbler.ErrNotAuthorized))
+		})
+
+		It("returns ErrRetryLater on error 503", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`{"code": 503, "error": "Cannot submit listens to queue, please try again later."}`)),
+				StatusCode: 503,
+			}
+
+			err := agent.Scrobble(ctx, "user-1", sc)
+			Expect(err).To(MatchError(scrobbler.ErrRetryLater))
+		})
+
+		It("returns ErrRetryLater on error 500", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`{"code": 500, "error": "Something went wrong. Please try again."}`)),
+				StatusCode: 500,
+			}
+
+			err := agent.Scrobble(ctx, "user-1", sc)
+			Expect(err).To(MatchError(scrobbler.ErrRetryLater))
+		})
+
+		It("returns ErrRetryLater on http errors", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`Bad Gateway`)),
+				StatusCode: 500,
+			}
+
+			err := agent.Scrobble(ctx, "user-1", sc)
+			Expect(err).To(MatchError(scrobbler.ErrRetryLater))
+		})
+
+		It("returns ErrUnrecoverable on other errors", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`{"code": 400, "error": "BadRequest: Invalid JSON document submitted."}`)),
+				StatusCode: 400,
+			}
+
+			err := agent.Scrobble(ctx, "user-1", sc)
+			Expect(err).To(MatchError(scrobbler.ErrUnrecoverable))
+		})
+	})
+})

core/agents/listenbrainz/client.go

@@ -0,0 +1,179 @@
+package listenbrainz
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"path"
+
+	"github.com/navidrome/navidrome/log"
+)
+
+type listenBrainzError struct {
+	Code    int
+	Message string
+}
+
+func (e *listenBrainzError) Error() string {
+	return fmt.Sprintf("ListenBrainz error(%d): %s", e.Code, e.Message)
+}
+
+type httpDoer interface {
+	Do(req *http.Request) (*http.Response, error)
+}
+
+func newClient(baseURL string, hc httpDoer) *client {
+	return &client{baseURL, hc}
+}
+
+type client struct {
+	baseURL string
+	hc      httpDoer
+}
+
+type listenBrainzResponse struct {
+	Code     int    `json:"code"`
+	Message  string `json:"message"`
+	Error    string `json:"error"`
+	Status   string `json:"status"`
+	Valid    bool   `json:"valid"`
+	UserName string `json:"user_name"`
+}
+
+type listenBrainzRequest struct {
+	ApiKey string
+	Body   listenBrainzRequestBody
+}
+
+type listenBrainzRequestBody struct {
+	ListenType listenType   `json:"listen_type,omitempty"`
+	Payload    []listenInfo `json:"payload,omitempty"`
+}
+
+type listenType string
+
+const (
+	Single     listenType = "single"
+	PlayingNow listenType = "playing_now"
+)
+
+type listenInfo struct {
+	ListenedAt    int           `json:"listened_at,omitempty"`
+	TrackMetadata trackMetadata `json:"track_metadata,omitempty"`
+}
+
+type trackMetadata struct {
+	ArtistName     string         `json:"artist_name,omitempty"`
+	TrackName      string         `json:"track_name,omitempty"`
+	ReleaseName    string         `json:"release_name,omitempty"`
+	AdditionalInfo additionalInfo `json:"additional_info,omitempty"`
+}
+
+type additionalInfo struct {
+	SubmissionClient        string   `json:"submission_client,omitempty"`
+	SubmissionClientVersion string   `json:"submission_client_version,omitempty"`
+	TrackNumber             int      `json:"tracknumber,omitempty"`
+	ArtistNames             []string `json:"artist_names,omitempty"`
+	ArtistMBIDs             []string `json:"artist_mbids,omitempty"`
+	RecordingMBID           string   `json:"recording_mbid,omitempty"`
+	ReleaseMBID             string   `json:"release_mbid,omitempty"`
+	ReleaseGroupMBID        string   `json:"release_group_mbid,omitempty"`
+	DurationMs              int      `json:"duration_ms,omitempty"`
+}
+
+func (c *client) validateToken(ctx context.Context, apiKey string) (*listenBrainzResponse, error) {
+	r := &listenBrainzRequest{
+		ApiKey: apiKey,
+	}
+	response, err := c.makeRequest(ctx, http.MethodGet, "validate-token", r)
+	if err != nil {
+		return nil, err
+	}
+	return response, nil
+}
+
+func (c *client) updateNowPlaying(ctx context.Context, apiKey string, li listenInfo) error {
+	r := &listenBrainzRequest{
+		ApiKey: apiKey,
+		Body: listenBrainzRequestBody{
+			ListenType: PlayingNow,
+			Payload:    []listenInfo{li},
+		},
+	}
+
+	resp, err := c.makeRequest(ctx, http.MethodPost, "submit-listens", r)
+	if err != nil {
+		return err
+	}
+	if resp.Status != "ok" {
+		log.Warn(ctx, "ListenBrainz: NowPlaying was not accepted", "status", resp.Status)
+	}
+	return nil
+}
+
+func (c *client) scrobble(ctx context.Context, apiKey string, li listenInfo) error {
+	r := &listenBrainzRequest{
+		ApiKey: apiKey,
+		Body: listenBrainzRequestBody{
+			ListenType: Single,
+			Payload:    []listenInfo{li},
+		},
+	}
+	resp, err := c.makeRequest(ctx, http.MethodPost, "submit-listens", r)
+	if err != nil {
+		return err
+	}
+	if resp.Status != "ok" {
+		log.Warn(ctx, "ListenBrainz: Scrobble was not accepted", "status", resp.Status)
+	}
+	return nil
+}
+
+func (c *client) path(endpoint string) (string, error) {
+	u, err := url.Parse(c.baseURL)
+	if err != nil {
+		return "", err
+	}
+	u.Path = path.Join(u.Path, endpoint)
+	return u.String(), nil
+}
+
+func (c *client) makeRequest(ctx context.Context, method string, endpoint string, r *listenBrainzRequest) (*listenBrainzResponse, error) {
+	b, _ := json.Marshal(r.Body)
+	uri, err := c.path(endpoint)
+	if err != nil {
+		return nil, err
+	}
+	req, _ := http.NewRequestWithContext(ctx, method, uri, bytes.NewBuffer(b))
+	req.Header.Add("Content-Type", "application/json; charset=UTF-8")
+
+	if r.ApiKey != "" {
+		req.Header.Add("Authorization", fmt.Sprintf("Token %s", r.ApiKey))
+	}
+
+	log.Trace(ctx, fmt.Sprintf("Sending ListenBrainz %s request", req.Method), "url", req.URL)
+	resp, err := c.hc.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	defer resp.Body.Close()
+	decoder := json.NewDecoder(resp.Body)
+
+	var response listenBrainzResponse
+	jsonErr := decoder.Decode(&response)
+	if resp.StatusCode != 200 && jsonErr != nil {
+		return nil, fmt.Errorf("ListenBrainz: HTTP Error, Status: (%d)", resp.StatusCode)
+	}
+	if jsonErr != nil {
+		return nil, jsonErr
+	}
+	if response.Code != 0 && response.Code != 200 {
+		return &response, &listenBrainzError{Code: response.Code, Message: response.Error}
+	}
+
+	return &response, nil
+}

core/agents/listenbrainz/client_test.go

@@ -0,0 +1,120 @@
+package listenbrainz
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"os"
+
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("client", func() {
+	var httpClient *tests.FakeHttpClient
+	var client *client
+	BeforeEach(func() {
+		httpClient = &tests.FakeHttpClient{}
+		client = newClient("BASE_URL/", httpClient)
+	})
+
+	Describe("listenBrainzResponse", func() {
+		It("parses a response properly", func() {
+			var response listenBrainzResponse
+			err := json.Unmarshal([]byte(`{"code": 200, "message": "Message", "user_name": "UserName", "valid": true, "status": "ok", "error": "Error"}`), &response)
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(response.Code).To(Equal(200))
+			Expect(response.Message).To(Equal("Message"))
+			Expect(response.UserName).To(Equal("UserName"))
+			Expect(response.Valid).To(BeTrue())
+			Expect(response.Status).To(Equal("ok"))
+			Expect(response.Error).To(Equal("Error"))
+		})
+	})
+
+	Describe("validateToken", func() {
+		BeforeEach(func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`{"code": 200, "message": "Token valid.", "user_name": "ListenBrainzUser", "valid": true}`)),
+				StatusCode: 200,
+			}
+		})
+
+		It("formats the request properly", func() {
+			_, err := client.validateToken(context.Background(), "LB-TOKEN")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
+			Expect(httpClient.SavedRequest.URL.String()).To(Equal("BASE_URL/validate-token"))
+			Expect(httpClient.SavedRequest.Header.Get("Authorization")).To(Equal("Token LB-TOKEN"))
+			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
+		})
+
+		It("parses and returns the response", func() {
+			res, err := client.validateToken(context.Background(), "LB-TOKEN")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Valid).To(Equal(true))
+			Expect(res.UserName).To(Equal("ListenBrainzUser"))
+		})
+	})
+
+	Context("with listenInfo", func() {
+		var li listenInfo
+		BeforeEach(func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`{"status": "ok"}`)),
+				StatusCode: 200,
+			}
+			li = listenInfo{
+				TrackMetadata: trackMetadata{
+					ArtistName:  "Track Artist",
+					TrackName:   "Track Title",
+					ReleaseName: "Track Album",
+					AdditionalInfo: additionalInfo{
+						TrackNumber:   1,
+						ArtistNames:   []string{"Artist 1", "Artist 2"},
+						ArtistMBIDs:   []string{"mbz-789", "mbz-012"},
+						RecordingMBID: "mbz-123",
+						ReleaseMBID:   "mbz-456",
+						DurationMs:    142200,
+					},
+				},
+			}
+		})
+
+		Describe("updateNowPlaying", func() {
+			It("formats the request properly", func() {
+				Expect(client.updateNowPlaying(context.Background(), "LB-TOKEN", li)).To(Succeed())
+				Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodPost))
+				Expect(httpClient.SavedRequest.URL.String()).To(Equal("BASE_URL/submit-listens"))
+				Expect(httpClient.SavedRequest.Header.Get("Authorization")).To(Equal("Token LB-TOKEN"))
+				Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
+
+				body, _ := io.ReadAll(httpClient.SavedRequest.Body)
+				f, _ := os.ReadFile("tests/fixtures/listenbrainz.nowplaying.request.json")
+				Expect(body).To(MatchJSON(f))
+			})
+		})
+
+		Describe("scrobble", func() {
+			BeforeEach(func() {
+				li.ListenedAt = 1635000000
+			})
+
+			It("formats the request properly", func() {
+				Expect(client.scrobble(context.Background(), "LB-TOKEN", li)).To(Succeed())
+				Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodPost))
+				Expect(httpClient.SavedRequest.URL.String()).To(Equal("BASE_URL/submit-listens"))
+				Expect(httpClient.SavedRequest.Header.Get("Authorization")).To(Equal("Token LB-TOKEN"))
+				Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
+
+				body, _ := io.ReadAll(httpClient.SavedRequest.Body)
+				f, _ := os.ReadFile("tests/fixtures/listenbrainz.scrobble.request.json")
+				Expect(body).To(MatchJSON(f))
+			})
+		})
+	})
+})

core/artwork/artwork_internal_test.go

@@ -302,33 +302,6 @@ var _ = Describe("Artwork", func() {
 				Entry("landscape jpg image", "jpg", true, 200),
 			)
 		})
-		When("Requested size is larger than original", func() {
-			It("clamps size to original dimensions", func() {
-				conf.Server.CoverArtPriority = "front.png"
-				// front.png is 16x16, requesting 99999 should return at original size
-				r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 99999, false)
-				Expect(err).ToNot(HaveOccurred())
-
-				img, _, err := image.Decode(r)
-				Expect(err).ToNot(HaveOccurred())
-				// Should be clamped to original size (16), not 99999
-				Expect(img.Bounds().Size().X).To(Equal(16))
-				Expect(img.Bounds().Size().Y).To(Equal(16))
-			})
-
-			It("clamps square size to original dimensions", func() {
-				conf.Server.CoverArtPriority = "front.png"
-				// front.png is 16x16, requesting 99999 with square should return 16x16 square
-				r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 99999, true)
-				Expect(err).ToNot(HaveOccurred())
-
-				img, _, err := image.Decode(r)
-				Expect(err).ToNot(HaveOccurred())
-				// Should be clamped to original size (16), not 99999
-				Expect(img.Bounds().Size().X).To(Equal(16))
-				Expect(img.Bounds().Size().Y).To(Equal(16))
-			})
-		})
 	})
 })
 

core/artwork/reader_resized.go

@@ -87,11 +87,6 @@ func resizeImage(reader io.Reader, size int, square bool) (io.Reader, int, error
 	bounds := original.Bounds()
 	originalSize := max(bounds.Max.X, bounds.Max.Y)
 
-	// Clamp size to original dimensions - upscaling wastes resources and adds no information
-	if size > originalSize {
-		size = originalSize
-	}
-
 	if originalSize <= size && !square {
 		return nil, originalSize, nil
 	}

core/artwork/sources.go

@@ -16,14 +16,12 @@ import (
 	"time"
 
 	"github.com/dhowden/tag"
-	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/core/external"
 	"github.com/navidrome/navidrome/core/ffmpeg"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/resources"
-	"go.senan.xyz/taglib"
 )
 
 func selectImageReader(ctx context.Context, artID model.ArtworkID, extractFuncs ...sourceFunc) (io.ReadCloser, string, error) {
@@ -86,13 +84,6 @@ var picTypeRegexes = []*regexp.Regexp{
 }
 
 func fromTag(ctx context.Context, path string) sourceFunc {
-	if conf.Server.DevLegacyEmbedImage {
-		return fromTagLegacy(ctx, path)
-	}
-	return fromTagGoTaglib(ctx, path)
-}
-
-func fromTagLegacy(ctx context.Context, path string) sourceFunc {
 	return func() (io.ReadCloser, string, error) {
 		if path == "" {
 			return nil, "", nil
@@ -137,44 +128,6 @@ func fromTagLegacy(ctx context.Context, path string) sourceFunc {
 	}
 }
 
-func fromTagGoTaglib(ctx context.Context, path string) sourceFunc {
-	return func() (io.ReadCloser, string, error) {
-		if path == "" {
-			return nil, "", nil
-		}
-		f, err := taglib.OpenReadOnly(path, taglib.WithReadStyle(taglib.ReadStyleFast))
-		if err != nil {
-			return nil, "", err
-		}
-		defer f.Close()
-
-		images := f.Properties().Images
-		if len(images) == 0 {
-			return nil, "", fmt.Errorf("no embedded image found in %s", path)
-		}
-
-		imageIndex := findBestImageIndex(ctx, images, path)
-		data, err := f.Image(imageIndex)
-		if err != nil || len(data) == 0 {
-			return nil, "", fmt.Errorf("could not load embedded image from %s", path)
-		}
-		return io.NopCloser(bytes.NewReader(data)), path, nil
-	}
-}
-
-func findBestImageIndex(ctx context.Context, images []taglib.ImageDesc, path string) int {
-	for _, regex := range picTypeRegexes {
-		for i, img := range images {
-			if regex.MatchString(img.Type) {
-				log.Trace(ctx, "Found embedded image", "type", img.Type, "path", path)
-				return i
-			}
-		}
-	}
-	log.Trace(ctx, "Could not find a front image. Getting the first one", "type", images[0].Type, "path", path)
-	return 0
-}
-
 func fromFFmpegTag(ctx context.Context, ffmpeg ffmpeg.FFmpeg, path string) sourceFunc {
 	return func() (io.ReadCloser, string, error) {
 		if path == "" {
@@ -229,7 +182,6 @@ func fromAlbumExternalSource(ctx context.Context, al model.Album, provider exter
 func fromURL(ctx context.Context, imageUrl *url.URL) (io.ReadCloser, string, error) {
 	hc := http.Client{Timeout: 5 * time.Second}
 	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, imageUrl.String(), nil)
-	req.Header.Set("User-Agent", consts.HTTPUserAgent)
 	resp, err := hc.Do(req)
 	if err != nil {
 		return nil, "", err

core/external/extdata_helper_test.go

@@ -92,11 +92,6 @@ func (m *mockMediaFileRepo) Get(id string) (*model.MediaFile, error) {
 	return args.Get(0).(*model.MediaFile), args.Error(1)
 }
 
-// GetAllByTags implements model.MediaFileRepository.
-func (m *mockMediaFileRepo) GetAllByTags(_ model.TagName, _ []string, options ...model.QueryOptions) (model.MediaFiles, error) {
-	return m.GetAll(options...)
-}
-
 // GetAll implements model.MediaFileRepository.
 func (m *mockMediaFileRepo) GetAll(options ...model.QueryOptions) (model.MediaFiles, error) {
 	argsSlice := make([]interface{}, len(options))
@@ -287,27 +282,3 @@ func (m *mockAgents) GetAlbumImages(ctx context.Context, name, artist, mbid stri
 	}
 	return nil, args.Error(1)
 }
-
-func (m *mockAgents) GetSimilarSongsByTrack(ctx context.Context, id, name, artist, mbid string, count int) ([]agents.Song, error) {
-	args := m.Called(ctx, id, name, artist, mbid, count)
-	if args.Get(0) != nil {
-		return args.Get(0).([]agents.Song), args.Error(1)
-	}
-	return nil, args.Error(1)
-}
-
-func (m *mockAgents) GetSimilarSongsByAlbum(ctx context.Context, id, name, artist, mbid string, count int) ([]agents.Song, error) {
-	args := m.Called(ctx, id, name, artist, mbid, count)
-	if args.Get(0) != nil {
-		return args.Get(0).([]agents.Song), args.Error(1)
-	}
-	return nil, args.Error(1)
-}
-
-func (m *mockAgents) GetSimilarSongsByArtist(ctx context.Context, id, name, mbid string, count int) ([]agents.Song, error) {
-	args := m.Called(ctx, id, name, mbid, count)
-	if args.Get(0) != nil {
-		return args.Get(0).([]agents.Song), args.Error(1)
-	}
-	return nil, args.Error(1)
-}

core/external/provider.go

@@ -12,6 +12,10 @@ import (
 	"github.com/Masterminds/squirrel"
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/core/agents"
+	_ "github.com/navidrome/navidrome/core/agents/deezer"
+	_ "github.com/navidrome/navidrome/core/agents/lastfm"
+	_ "github.com/navidrome/navidrome/core/agents/listenbrainz"
+	_ "github.com/navidrome/navidrome/core/agents/spotify"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/utils"
@@ -32,7 +36,7 @@ const (
 type Provider interface {
 	UpdateAlbumInfo(ctx context.Context, id string) (*model.Album, error)
 	UpdateArtistInfo(ctx context.Context, id string, count int, includeNotPresent bool) (*model.Artist, error)
-	SimilarSongs(ctx context.Context, id string, count int) (model.MediaFiles, error)
+	ArtistRadio(ctx context.Context, id string, count int) (model.MediaFiles, error)
 	TopSongs(ctx context.Context, artist string, count int) (model.MediaFiles, error)
 	ArtistImage(ctx context.Context, id string) (*url.URL, error)
 	AlbumImage(ctx context.Context, id string) (*url.URL, error)
@@ -47,28 +51,12 @@ type provider struct {
 
 type auxAlbum struct {
 	model.Album
-}
-
-// Name returns the appropriate album name for external API calls
-// based on the DevPreserveUnicodeInExternalCalls configuration option
-func (a *auxAlbum) Name() string {
-	if conf.Server.DevPreserveUnicodeInExternalCalls {
-		return a.Album.Name
-	}
-	return str.Clear(a.Album.Name)
+	Name string
 }
 
 type auxArtist struct {
 	model.Artist
-}
-
-// Name returns the appropriate artist name for external API calls
-// based on the DevPreserveUnicodeInExternalCalls configuration option
-func (a *auxArtist) Name() string {
-	if conf.Server.DevPreserveUnicodeInExternalCalls {
-		return a.Artist.Name
-	}
-	return str.Clear(a.Artist.Name)
+	Name string
 }
 
 type Agents interface {
@@ -80,9 +68,6 @@ type Agents interface {
 	agents.ArtistSimilarRetriever
 	agents.ArtistTopSongsRetriever
 	agents.ArtistURLRetriever
-	agents.SimilarSongsByTrackRetriever
-	agents.SimilarSongsByAlbumRetriever
-	agents.SimilarSongsByArtistRetriever
 }
 
 func NewProvider(ds model.DataStore, agents Agents) Provider {
@@ -103,6 +88,7 @@ func (e *provider) getAlbum(ctx context.Context, id string) (auxAlbum, error) {
 	switch v := entity.(type) {
 	case *model.Album:
 		album.Album = *v
+		album.Name = str.Clear(v.Name)
 	case *model.MediaFile:
 		return e.getAlbum(ctx, v.AlbumID)
 	default:
@@ -120,9 +106,8 @@ func (e *provider) UpdateAlbumInfo(ctx context.Context, id string) (*model.Album
 	}
 
 	updatedAt := V(album.ExternalInfoUpdatedAt)
-	albumName := album.Name()
 	if updatedAt.IsZero() {
-		log.Debug(ctx, "AlbumInfo not cached. Retrieving it now", "updatedAt", updatedAt, "id", id, "name", albumName)
+		log.Debug(ctx, "AlbumInfo not cached. Retrieving it now", "updatedAt", updatedAt, "id", id, "name", album.Name)
 		album, err = e.populateAlbumInfo(ctx, album)
 		if err != nil {
 			return nil, err
@@ -131,7 +116,7 @@ func (e *provider) UpdateAlbumInfo(ctx context.Context, id string) (*model.Album
 
 	// If info is expired, trigger a populateAlbumInfo in the background
 	if time.Since(updatedAt) > conf.Server.DevAlbumInfoTimeToLive {
-		log.Debug("Found expired cached AlbumInfo, refreshing in the background", "updatedAt", album.ExternalInfoUpdatedAt, "name", albumName)
+		log.Debug("Found expired cached AlbumInfo, refreshing in the background", "updatedAt", album.ExternalInfoUpdatedAt, "name", album.Name)
 		e.albumQueue.enqueue(&album)
 	}
 
@@ -140,13 +125,12 @@ func (e *provider) UpdateAlbumInfo(ctx context.Context, id string) (*model.Album
 
 func (e *provider) populateAlbumInfo(ctx context.Context, album auxAlbum) (auxAlbum, error) {
 	start := time.Now()
-	albumName := album.Name()
-	info, err := e.ag.GetAlbumInfo(ctx, albumName, album.AlbumArtist, album.MbzAlbumID)
+	info, err := e.ag.GetAlbumInfo(ctx, album.Name, album.AlbumArtist, album.MbzAlbumID)
 	if errors.Is(err, agents.ErrNotFound) {
 		return album, nil
 	}
 	if err != nil {
-		log.Error("Error refreshing AlbumInfo", "id", album.ID, "name", albumName, "artist", album.AlbumArtist,
+		log.Error("Error refreshing AlbumInfo", "id", album.ID, "name", album.Name, "artist", album.AlbumArtist,
 			"elapsed", time.Since(start), err)
 		return album, err
 	}
@@ -158,7 +142,7 @@ func (e *provider) populateAlbumInfo(ctx context.Context, album auxAlbum) (auxAl
 		album.Description = info.Description
 	}
 
-	images, err := e.ag.GetAlbumImages(ctx, albumName, album.AlbumArtist, album.MbzAlbumID)
+	images, err := e.ag.GetAlbumImages(ctx, album.Name, album.AlbumArtist, album.MbzAlbumID)
 	if err == nil && len(images) > 0 {
 		sort.Slice(images, func(i, j int) bool {
 			return images[i].Size > images[j].Size
@@ -177,7 +161,7 @@ func (e *provider) populateAlbumInfo(ctx context.Context, album auxAlbum) (auxAl
 
 	err = e.ds.Album(ctx).UpdateExternalInfo(&album.Album)
 	if err != nil {
-		log.Error(ctx, "Error trying to update album external information", "id", album.ID, "name", albumName,
+		log.Error(ctx, "Error trying to update album external information", "id", album.ID, "name", album.Name,
 			"elapsed", time.Since(start), err)
 	} else {
 		log.Trace(ctx, "AlbumInfo collected", "album", album, "elapsed", time.Since(start))
@@ -197,6 +181,7 @@ func (e *provider) getArtist(ctx context.Context, id string) (auxArtist, error)
 	switch v := entity.(type) {
 	case *model.Artist:
 		artist.Artist = *v
+		artist.Name = str.Clear(v.Name)
 	case *model.MediaFile:
 		return e.getArtist(ctx, v.ArtistID)
 	case *model.Album:
@@ -225,9 +210,8 @@ func (e *provider) refreshArtistInfo(ctx context.Context, id string) (auxArtist,
 
 	// If we don't have any info, retrieves it now
 	updatedAt := V(artist.ExternalInfoUpdatedAt)
-	artistName := artist.Name()
 	if updatedAt.IsZero() {
-		log.Debug(ctx, "ArtistInfo not cached. Retrieving it now", "updatedAt", updatedAt, "id", id, "name", artistName)
+		log.Debug(ctx, "ArtistInfo not cached. Retrieving it now", "updatedAt", updatedAt, "id", id, "name", artist.Name)
 		artist, err = e.populateArtistInfo(ctx, artist)
 		if err != nil {
 			return auxArtist{}, err
@@ -236,7 +220,7 @@ func (e *provider) refreshArtistInfo(ctx context.Context, id string) (auxArtist,
 
 	// If info is expired, trigger a populateArtistInfo in the background
 	if time.Since(updatedAt) > conf.Server.DevArtistInfoTimeToLive {
-		log.Debug("Found expired cached ArtistInfo, refreshing in the background", "updatedAt", updatedAt, "name", artistName)
+		log.Debug("Found expired cached ArtistInfo, refreshing in the background", "updatedAt", updatedAt, "name", artist.Name)
 		e.artistQueue.enqueue(&artist)
 	}
 	return artist, nil
@@ -245,9 +229,8 @@ func (e *provider) refreshArtistInfo(ctx context.Context, id string) (auxArtist,
 func (e *provider) populateArtistInfo(ctx context.Context, artist auxArtist) (auxArtist, error) {
 	start := time.Now()
 	// Get MBID first, if it is not yet available
-	artistName := artist.Name()
 	if artist.MbzArtistID == "" {
-		mbid, err := e.ag.GetArtistMBID(ctx, artist.ID, artistName)
+		mbid, err := e.ag.GetArtistMBID(ctx, artist.ID, artist.Name)
 		if mbid != "" && err == nil {
 			artist.MbzArtistID = mbid
 		}
@@ -259,18 +242,18 @@ func (e *provider) populateArtistInfo(ctx context.Context, artist auxArtist) (au
 	g.Go(func() error { e.callGetImage(ctx, e.ag, &artist); return nil })
 	g.Go(func() error { e.callGetBiography(ctx, e.ag, &artist); return nil })
 	g.Go(func() error { e.callGetURL(ctx, e.ag, &artist); return nil })
-	g.Go(func() error { e.callGetSimilarArtists(ctx, e.ag, &artist, maxSimilarArtists, true); return nil })
+	g.Go(func() error { e.callGetSimilar(ctx, e.ag, &artist, maxSimilarArtists, true); return nil })
 	_ = g.Wait()
 
 	if utils.IsCtxDone(ctx) {
-		log.Warn(ctx, "ArtistInfo update canceled", "id", artist.ID, "name", artistName, "elapsed", time.Since(start), ctx.Err())
+		log.Warn(ctx, "ArtistInfo update canceled", "elapsed", "id", artist.ID, "name", artist.Name, time.Since(start), ctx.Err())
 		return artist, ctx.Err()
 	}
 
 	artist.ExternalInfoUpdatedAt = P(time.Now())
 	err := e.ds.Artist(ctx).UpdateExternalInfo(&artist.Artist)
 	if err != nil {
-		log.Error(ctx, "Error trying to update artist external information", "id", artist.ID, "name", artistName,
+		log.Error(ctx, "Error trying to update artist external information", "id", artist.ID, "name", artist.Name,
 			"elapsed", time.Since(start), err)
 	} else {
 		log.Trace(ctx, "ArtistInfo collected", "artist", artist, "elapsed", time.Since(start))
@@ -278,59 +261,27 @@ func (e *provider) populateArtistInfo(ctx context.Context, artist auxArtist) (au
 	return artist, nil
 }
 
-func (e *provider) SimilarSongs(ctx context.Context, id string, count int) (model.MediaFiles, error) {
-	entity, err := model.GetEntityByID(ctx, e.ds, id)
-	if err != nil {
-		return nil, err
-	}
-
-	var songs []agents.Song
-
-	// Try entity-specific similarity first
-	switch v := entity.(type) {
-	case *model.MediaFile:
-		songs, err = e.ag.GetSimilarSongsByTrack(ctx, v.ID, v.Title, v.Artist, v.MbzRecordingID, count)
-	case *model.Album:
-		songs, err = e.ag.GetSimilarSongsByAlbum(ctx, v.ID, v.Name, v.AlbumArtist, v.MbzAlbumID, count)
-	case *model.Artist:
-		songs, err = e.ag.GetSimilarSongsByArtist(ctx, v.ID, v.Name, v.MbzArtistID, count)
-	default:
-		log.Warn(ctx, "Unknown entity type", "id", id, "type", fmt.Sprintf("%T", entity))
-		return nil, model.ErrNotFound
-	}
-
-	if err == nil && len(songs) > 0 {
-		return e.matchSongsToLibrary(ctx, songs, count)
-	}
-
-	// Fallback to existing similar artists + top songs algorithm
-	return e.similarSongsFallback(ctx, id, count)
-}
-
-// similarSongsFallback uses the original similar artists + top songs algorithm. The idea is to
-// get the artist of the given entity, retrieve similar artists, get their top songs, and pick
-// a weighted random selection of songs to return as similar songs.
-func (e *provider) similarSongsFallback(ctx context.Context, id string, count int) (model.MediaFiles, error) {
+func (e *provider) ArtistRadio(ctx context.Context, id string, count int) (model.MediaFiles, error) {
 	artist, err := e.getArtist(ctx, id)
 	if err != nil {
 		return nil, err
 	}
 
-	e.callGetSimilarArtists(ctx, e.ag, &artist, 15, false)
+	e.callGetSimilar(ctx, e.ag, &artist, 15, false)
 	if utils.IsCtxDone(ctx) {
-		log.Warn(ctx, "SimilarSongs call canceled", ctx.Err())
+		log.Warn(ctx, "ArtistRadio call canceled", ctx.Err())
 		return nil, ctx.Err()
 	}
 
 	weightedSongs := random.NewWeightedChooser[model.MediaFile]()
 	addArtist := func(a model.Artist, weightedSongs *random.WeightedChooser[model.MediaFile], count, artistWeight int) error {
 		if utils.IsCtxDone(ctx) {
-			log.Warn(ctx, "SimilarSongs call canceled", ctx.Err())
+			log.Warn(ctx, "ArtistRadio call canceled", ctx.Err())
 			return ctx.Err()
 		}
 
 		topCount := max(count, 20)
-		topSongs, err := e.getMatchingTopSongs(ctx, e.ag, &auxArtist{Artist: a}, topCount)
+		topSongs, err := e.getMatchingTopSongs(ctx, e.ag, &auxArtist{Name: a.Name, Artist: a}, topCount)
 		if err != nil {
 			log.Warn(ctx, "Error getting artist's top songs", "artist", a.Name, err)
 			return nil
@@ -393,23 +344,22 @@ func (e *provider) AlbumImage(ctx context.Context, id string) (*url.URL, error)
 		return nil, err
 	}
 
-	albumName := album.Name()
-	images, err := e.ag.GetAlbumImages(ctx, albumName, album.AlbumArtist, album.MbzAlbumID)
+	images, err := e.ag.GetAlbumImages(ctx, album.Name, album.AlbumArtist, album.MbzAlbumID)
 	if err != nil {
 		switch {
 		case errors.Is(err, agents.ErrNotFound):
-			log.Trace(ctx, "Album not found in agent", "albumID", id, "name", albumName, "artist", album.AlbumArtist)
+			log.Trace(ctx, "Album not found in agent", "albumID", id, "name", album.Name, "artist", album.AlbumArtist)
 			return nil, model.ErrNotFound
 		case errors.Is(err, context.Canceled):
 			log.Debug(ctx, "GetAlbumImages call canceled", err)
 		default:
-			log.Warn(ctx, "Error getting album images from agent", "albumID", id, "name", albumName, "artist", album.AlbumArtist, err)
+			log.Warn(ctx, "Error getting album images from agent", "albumID", id, "name", album.Name, "artist", album.AlbumArtist, err)
 		}
 		return nil, err
 	}
 
 	if len(images) == 0 {
-		log.Warn(ctx, "Agent returned no images without error", "albumID", id, "name", albumName, "artist", album.AlbumArtist)
+		log.Warn(ctx, "Agent returned no images without error", "albumID", id, "name", album.Name, "artist", album.AlbumArtist)
 		return nil, model.ErrNotFound
 	}
 
@@ -451,38 +401,124 @@ func (e *provider) TopSongs(ctx context.Context, artistName string, count int) (
 }
 
 func (e *provider) getMatchingTopSongs(ctx context.Context, agent agents.ArtistTopSongsRetriever, artist *auxArtist, count int) (model.MediaFiles, error) {
-	artistName := artist.Name()
-	songs, err := agent.GetArtistTopSongs(ctx, artist.ID, artistName, artist.MbzArtistID, count)
+	songs, err := agent.GetArtistTopSongs(ctx, artist.ID, artist.Name, artist.MbzArtistID, count)
 	if err != nil {
-		return nil, fmt.Errorf("failed to get top songs for artist %s: %w", artistName, err)
+		return nil, fmt.Errorf("failed to get top songs for artist %s: %w", artist.Name, err)
 	}
 
-	// Enrich songs with artist info if not already present (for top songs, we know the artist)
-	for i := range songs {
-		if songs[i].Artist == "" {
-			songs[i].Artist = artistName
-		}
-		if songs[i].ArtistMBID == "" {
-			songs[i].ArtistMBID = artist.MbzArtistID
-		}
+	mbidMatches, err := e.loadTracksByMBID(ctx, songs)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load tracks by MBID: %w", err)
+	}
+	titleMatches, err := e.loadTracksByTitle(ctx, songs, artist, mbidMatches)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load tracks by title: %w", err)
 	}
 
-	mfs, err := e.matchSongsToLibrary(ctx, songs, count)
-	if err != nil {
-		return nil, err
-	}
+	log.Trace(ctx, "Top Songs loaded", "name", artist.Name, "numSongs", len(songs), "numMBIDMatches", len(mbidMatches), "numTitleMatches", len(titleMatches))
+	mfs := e.selectTopSongs(songs, mbidMatches, titleMatches, count)
 
 	if len(mfs) == 0 {
-		log.Debug(ctx, "No matching top songs found", "name", artistName)
+		log.Debug(ctx, "No matching top songs found", "name", artist.Name)
 	} else {
-		log.Debug(ctx, "Found matching top songs", "name", artistName, "numSongs", len(mfs))
+		log.Debug(ctx, "Found matching top songs", "name", artist.Name, "numSongs", len(mfs))
 	}
 
 	return mfs, nil
 }
 
+func (e *provider) loadTracksByMBID(ctx context.Context, songs []agents.Song) (map[string]model.MediaFile, error) {
+	var mbids []string
+	for _, s := range songs {
+		if s.MBID != "" {
+			mbids = append(mbids, s.MBID)
+		}
+	}
+	matches := map[string]model.MediaFile{}
+	if len(mbids) == 0 {
+		return matches, nil
+	}
+	res, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+		Filters: squirrel.And{
+			squirrel.Eq{"mbz_recording_id": mbids},
+			squirrel.Eq{"missing": false},
+		},
+	})
+	if err != nil {
+		return matches, err
+	}
+	for _, mf := range res {
+		if id := mf.MbzRecordingID; id != "" {
+			if _, ok := matches[id]; !ok {
+				matches[id] = mf
+			}
+		}
+	}
+	return matches, nil
+}
+
+func (e *provider) loadTracksByTitle(ctx context.Context, songs []agents.Song, artist *auxArtist, mbidMatches map[string]model.MediaFile) (map[string]model.MediaFile, error) {
+	titleMap := map[string]string{}
+	for _, s := range songs {
+		if s.MBID != "" && mbidMatches[s.MBID].ID != "" {
+			continue
+		}
+		sanitized := str.SanitizeFieldForSorting(s.Name)
+		titleMap[sanitized] = s.Name
+	}
+	matches := map[string]model.MediaFile{}
+	if len(titleMap) == 0 {
+		return matches, nil
+	}
+	titleFilters := squirrel.Or{}
+	for sanitized := range titleMap {
+		titleFilters = append(titleFilters, squirrel.Like{"order_title": sanitized})
+	}
+
+	res, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+		Filters: squirrel.And{
+			squirrel.Or{
+				squirrel.Eq{"artist_id": artist.ID},
+				squirrel.Eq{"album_artist_id": artist.ID},
+			},
+			titleFilters,
+			squirrel.Eq{"missing": false},
+		},
+		Sort: "starred desc, rating desc, year asc, compilation asc ",
+	})
+	if err != nil {
+		return matches, err
+	}
+	for _, mf := range res {
+		sanitized := str.SanitizeFieldForSorting(mf.Title)
+		if _, ok := matches[sanitized]; !ok {
+			matches[sanitized] = mf
+		}
+	}
+	return matches, nil
+}
+
+func (e *provider) selectTopSongs(songs []agents.Song, byMBID, byTitle map[string]model.MediaFile, count int) model.MediaFiles {
+	var mfs model.MediaFiles
+	for _, t := range songs {
+		if len(mfs) == count {
+			break
+		}
+		if t.MBID != "" {
+			if mf, ok := byMBID[t.MBID]; ok {
+				mfs = append(mfs, mf)
+				continue
+			}
+		}
+		if mf, ok := byTitle[str.SanitizeFieldForSorting(t.Name)]; ok {
+			mfs = append(mfs, mf)
+		}
+	}
+	return mfs
+}
+
 func (e *provider) callGetURL(ctx context.Context, agent agents.ArtistURLRetriever, artist *auxArtist) {
-	artisURL, err := agent.GetArtistURL(ctx, artist.ID, artist.Name(), artist.MbzArtistID)
+	artisURL, err := agent.GetArtistURL(ctx, artist.ID, artist.Name, artist.MbzArtistID)
 	if err != nil {
 		return
 	}
@@ -490,7 +526,7 @@ func (e *provider) callGetURL(ctx context.Context, agent agents.ArtistURLRetriev
 }
 
 func (e *provider) callGetBiography(ctx context.Context, agent agents.ArtistBiographyRetriever, artist *auxArtist) {
-	bio, err := agent.GetArtistBiography(ctx, artist.ID, artist.Name(), artist.MbzArtistID)
+	bio, err := agent.GetArtistBiography(ctx, artist.ID, str.Clear(artist.Name), artist.MbzArtistID)
 	if err != nil {
 		return
 	}
@@ -500,7 +536,7 @@ func (e *provider) callGetBiography(ctx context.Context, agent agents.ArtistBiog
 }
 
 func (e *provider) callGetImage(ctx context.Context, agent agents.ArtistImageRetriever, artist *auxArtist) {
-	images, err := agent.GetArtistImages(ctx, artist.ID, artist.Name(), artist.MbzArtistID)
+	images, err := agent.GetArtistImages(ctx, artist.ID, artist.Name, artist.MbzArtistID)
 	if err != nil {
 		return
 	}
@@ -517,16 +553,15 @@ func (e *provider) callGetImage(ctx context.Context, agent agents.ArtistImageRet
 	}
 }
 
-func (e *provider) callGetSimilarArtists(ctx context.Context, agent agents.ArtistSimilarRetriever, artist *auxArtist,
+func (e *provider) callGetSimilar(ctx context.Context, agent agents.ArtistSimilarRetriever, artist *auxArtist,
 	limit int, includeNotPresent bool) {
-	artistName := artist.Name()
-	similar, err := agent.GetSimilarArtists(ctx, artist.ID, artistName, artist.MbzArtistID, limit)
+	similar, err := agent.GetSimilarArtists(ctx, artist.ID, artist.Name, artist.MbzArtistID, limit)
 	if len(similar) == 0 || err != nil {
 		return
 	}
 	start := time.Now()
 	sa, err := e.mapSimilarArtists(ctx, similar, limit, includeNotPresent)
-	log.Debug(ctx, "Mapped Similar Artists", "artist", artistName, "numSimilar", len(sa), "elapsed", time.Since(start))
+	log.Debug(ctx, "Mapped Similar Artists", "artist", artist.Name, "numSimilar", len(sa), "elapsed", time.Since(start))
 	if err != nil {
 		return
 	}
@@ -537,51 +572,36 @@ func (e *provider) mapSimilarArtists(ctx context.Context, similar []agents.Artis
 	var result model.Artists
 	var notPresent []string
 
-	// Load artists by ID (highest priority)
-	idMatches, err := e.loadArtistsByID(ctx, similar)
+	artistNames := slice.Map(similar, func(artist agents.Artist) string { return artist.Name })
+
+	// Query all artists at once
+	clauses := slice.Map(artistNames, func(name string) squirrel.Sqlizer {
+		return squirrel.Like{"artist.name": name}
+	})
+	artists, err := e.ds.Artist(ctx).GetAll(model.QueryOptions{
+		Filters: squirrel.Or(clauses),
+	})
 	if err != nil {
 		return nil, err
 	}
 
-	// Load artists by MBID (second priority)
-	mbidMatches, err := e.loadArtistsByMBID(ctx, similar, idMatches)
-	if err != nil {
-		return nil, err
-	}
-
-	// Load artists by name (lowest priority, fallback)
-	nameMatches, err := e.loadArtistsByName(ctx, similar, idMatches, mbidMatches)
-	if err != nil {
-		return nil, err
+	// Create a map for quick lookup
+	artistMap := make(map[string]model.Artist)
+	for _, artist := range artists {
+		artistMap[artist.Name] = artist
 	}
 
 	count := 0
 
-	// Process the similar artists using priority: ID → MBID → Name
+	// Process the similar artists
 	for _, s := range similar {
-		if count >= limit {
-			break
-		}
-		// Try ID match first
-		if s.ID != "" {
-			if artist, found := idMatches[s.ID]; found {
-				result = append(result, artist)
-				count++
-				continue
-			}
-		}
-		// Try MBID match second
-		if s.MBID != "" {
-			if artist, found := mbidMatches[s.MBID]; found {
-				result = append(result, artist)
-				count++
-				continue
-			}
-		}
-		// Fall back to name match
-		if artist, found := nameMatches[s.Name]; found {
+		if artist, found := artistMap[s.Name]; found {
 			result = append(result, artist)
 			count++
+
+			if count >= limit {
+				break
+			}
 		} else {
 			notPresent = append(notPresent, s.Name)
 		}
@@ -604,95 +624,6 @@ func (e *provider) mapSimilarArtists(ctx context.Context, similar []agents.Artis
 	return result, nil
 }
 
-func (e *provider) loadArtistsByID(ctx context.Context, similar []agents.Artist) (map[string]model.Artist, error) {
-	var ids []string
-	for _, s := range similar {
-		if s.ID != "" {
-			ids = append(ids, s.ID)
-		}
-	}
-	matches := map[string]model.Artist{}
-	if len(ids) == 0 {
-		return matches, nil
-	}
-	res, err := e.ds.Artist(ctx).GetAll(model.QueryOptions{
-		Filters: squirrel.Eq{"artist.id": ids},
-	})
-	if err != nil {
-		return matches, err
-	}
-	for _, a := range res {
-		if _, ok := matches[a.ID]; !ok {
-			matches[a.ID] = a
-		}
-	}
-	return matches, nil
-}
-
-func (e *provider) loadArtistsByMBID(ctx context.Context, similar []agents.Artist, idMatches map[string]model.Artist) (map[string]model.Artist, error) {
-	var mbids []string
-	for _, s := range similar {
-		// Skip if already matched by ID
-		if s.ID != "" && idMatches[s.ID].ID != "" {
-			continue
-		}
-		if s.MBID != "" {
-			mbids = append(mbids, s.MBID)
-		}
-	}
-	matches := map[string]model.Artist{}
-	if len(mbids) == 0 {
-		return matches, nil
-	}
-	res, err := e.ds.Artist(ctx).GetAll(model.QueryOptions{
-		Filters: squirrel.Eq{"mbz_artist_id": mbids},
-	})
-	if err != nil {
-		return matches, err
-	}
-	for _, a := range res {
-		if id := a.MbzArtistID; id != "" {
-			if _, ok := matches[id]; !ok {
-				matches[id] = a
-			}
-		}
-	}
-	return matches, nil
-}
-
-func (e *provider) loadArtistsByName(ctx context.Context, similar []agents.Artist, idMatches map[string]model.Artist, mbidMatches map[string]model.Artist) (map[string]model.Artist, error) {
-	var names []string
-	for _, s := range similar {
-		// Skip if already matched by ID or MBID
-		if s.ID != "" && idMatches[s.ID].ID != "" {
-			continue
-		}
-		if s.MBID != "" && mbidMatches[s.MBID].ID != "" {
-			continue
-		}
-		names = append(names, s.Name)
-	}
-	matches := map[string]model.Artist{}
-	if len(names) == 0 {
-		return matches, nil
-	}
-	clauses := slice.Map(names, func(name string) squirrel.Sqlizer {
-		return squirrel.Like{"artist.name": name}
-	})
-	res, err := e.ds.Artist(ctx).GetAll(model.QueryOptions{
-		Filters: squirrel.Or(clauses),
-	})
-	if err != nil {
-		return matches, err
-	}
-	for _, a := range res {
-		if _, ok := matches[a.Name]; !ok {
-			matches[a.Name] = a
-		}
-	}
-	return matches, nil
-}
-
 func (e *provider) findArtistByName(ctx context.Context, artistName string) (*auxArtist, error) {
 	artists, err := e.ds.Artist(ctx).GetAll(model.QueryOptions{
 		Filters: squirrel.Like{"artist.name": artistName},
@@ -704,7 +635,11 @@ func (e *provider) findArtistByName(ctx context.Context, artistName string) (*au
 	if len(artists) == 0 {
 		return nil, model.ErrNotFound
 	}
-	return &auxArtist{Artist: artists[0]}, nil
+	artist := &auxArtist{
+		Artist: artists[0],
+		Name:   str.Clear(artists[0].Name),
+	}
+	return artist, nil
 }
 
 func (e *provider) loadSimilar(ctx context.Context, artist *auxArtist, count int, includeNotPresent bool) error {
@@ -720,7 +655,7 @@ func (e *provider) loadSimilar(ctx context.Context, artist *auxArtist, count int
 		Filters: squirrel.Eq{"artist.id": ids},
 	})
 	if err != nil {
-		log.Error("Error loading similar artists", "id", artist.ID, "name", artist.Name(), err)
+		log.Error("Error loading similar artists", "id", artist.ID, "name", artist.Name, err)
 		return err
 	}
 

core/external/provider_albumimage_test.go

@@ -260,69 +260,6 @@ var _ = Describe("Provider - AlbumImage", func() {
 		mockMediaFileRepo.AssertCalled(GinkgoT(), "Get", "not-found")
 		mockAlbumAgent.AssertNotCalled(GinkgoT(), "GetAlbumImages", mock.Anything, mock.Anything, mock.Anything)
 	})
-
-	Context("Unicode handling in album names", func() {
-		var albumWithEnDash *model.Album
-		var expectedURL *url.URL
-
-		const (
-			originalAlbumName   = "Raising Hell–Deluxe" // Album name with en dash
-			normalizedAlbumName = "Raising Hell-Deluxe" // Normalized version with hyphen
-		)
-
-		BeforeEach(func() {
-			// Test with en dash (–) in album name
-			albumWithEnDash = &model.Album{ID: "album-endash", Name: originalAlbumName, AlbumArtistID: "artist-1"}
-			mockArtistRepo.Mock = mock.Mock{} // Reset default expectations
-			mockAlbumRepo.Mock = mock.Mock{}  // Reset default expectations
-			mockArtistRepo.On("Get", "album-endash").Return(nil, model.ErrNotFound).Once()
-			mockAlbumRepo.On("Get", "album-endash").Return(albumWithEnDash, nil).Once()
-
-			expectedURL, _ = url.Parse("http://example.com/album.jpg")
-
-			// Mock the album agent to return an image for the album
-			mockAlbumAgent.On("GetAlbumImages", ctx, mock.AnythingOfType("string"), "", "").
-				Return([]agents.ExternalImage{
-					{URL: "http://example.com/album.jpg", Size: 1000},
-				}, nil).Once()
-		})
-
-		When("DevPreserveUnicodeInExternalCalls is true", func() {
-			BeforeEach(func() {
-				conf.Server.DevPreserveUnicodeInExternalCalls = true
-			})
-
-			It("preserves Unicode characters in album names", func() {
-				// Act
-				imgURL, err := provider.AlbumImage(ctx, "album-endash")
-
-				// Assert
-				Expect(err).ToNot(HaveOccurred())
-				Expect(imgURL).To(Equal(expectedURL))
-				mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-endash")
-				// This is the key assertion: ensure the original Unicode name is used
-				mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, originalAlbumName, "", "")
-			})
-		})
-
-		When("DevPreserveUnicodeInExternalCalls is false", func() {
-			BeforeEach(func() {
-				conf.Server.DevPreserveUnicodeInExternalCalls = false
-			})
-
-			It("normalizes Unicode characters", func() {
-				// Act
-				imgURL, err := provider.AlbumImage(ctx, "album-endash")
-
-				// Assert
-				Expect(err).ToNot(HaveOccurred())
-				Expect(imgURL).To(Equal(expectedURL))
-				mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-endash")
-				// This assertion ensures the normalized name is used (en dash → hyphen)
-				mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, normalizedAlbumName, "", "")
-			})
-		})
-	})
 })
 
 // mockAlbumInfoAgent implementation

core/external/provider_artistimage_test.go

@@ -265,67 +265,6 @@ var _ = Describe("Provider - ArtistImage", func() {
 		mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1")
 		mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")
 	})
-
-	Context("Unicode handling in artist names", func() {
-		var artistWithEnDash *model.Artist
-		var expectedURL *url.URL
-
-		const (
-			originalArtistName   = "Run–D.M.C." // Artist name with en dash
-			normalizedArtistName = "Run-D.M.C." // Normalized version with hyphen
-		)
-
-		BeforeEach(func() {
-			// Test with en dash (–) in artist name like "Run–D.M.C."
-			artistWithEnDash = &model.Artist{ID: "artist-endash", Name: originalArtistName}
-			mockArtistRepo.Mock = mock.Mock{} // Reset default expectations
-			mockArtistRepo.On("Get", "artist-endash").Return(artistWithEnDash, nil).Once()
-
-			expectedURL, _ = url.Parse("http://example.com/rundmc.jpg")
-
-			// Mock the image agent to return an image for the artist
-			mockImageAgent.On("GetArtistImages", ctx, "artist-endash", mock.AnythingOfType("string"), "").
-				Return([]agents.ExternalImage{
-					{URL: "http://example.com/rundmc.jpg", Size: 1000},
-				}, nil).Once()
-
-		})
-
-		When("DevPreserveUnicodeInExternalCalls is true", func() {
-			BeforeEach(func() {
-				conf.Server.DevPreserveUnicodeInExternalCalls = true
-			})
-			It("preserves Unicode characters in artist names", func() {
-				// Act
-				imgURL, err := provider.ArtistImage(ctx, "artist-endash")
-
-				// Assert
-				Expect(err).ToNot(HaveOccurred())
-				Expect(imgURL).To(Equal(expectedURL))
-				mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-endash")
-				// This is the key assertion: ensure the original Unicode name is used
-				mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-endash", originalArtistName, "")
-			})
-		})
-
-		When("DevPreserveUnicodeInExternalCalls is false", func() {
-			BeforeEach(func() {
-				conf.Server.DevPreserveUnicodeInExternalCalls = false
-			})
-
-			It("normalizes Unicode characters", func() {
-				// Act
-				imgURL, err := provider.ArtistImage(ctx, "artist-endash")
-
-				// Assert
-				Expect(err).ToNot(HaveOccurred())
-				Expect(imgURL).To(Equal(expectedURL))
-				mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-endash")
-				// This assertion ensures the normalized name is used (en dash → hyphen)
-				mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-endash", normalizedArtistName, "")
-			})
-		})
-	})
 })
 
 // mockArtistImageAgent implementation using testify/mock

core/external/provider_artistradio_test.go

@@ -0,0 +1,196 @@
+package external_test
+
+import (
+	"context"
+	"errors"
+
+	"github.com/navidrome/navidrome/core/agents"
+	. "github.com/navidrome/navidrome/core/external"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/stretchr/testify/mock"
+)
+
+var _ = Describe("Provider - ArtistRadio", func() {
+	var ds model.DataStore
+	var provider Provider
+	var mockAgent *mockSimilarArtistAgent
+	var mockTopAgent agents.ArtistTopSongsRetriever
+	var mockSimilarAgent agents.ArtistSimilarRetriever
+	var agentsCombined Agents
+	var artistRepo *mockArtistRepo
+	var mediaFileRepo *mockMediaFileRepo
+	var ctx context.Context
+
+	BeforeEach(func() {
+		ctx = GinkgoT().Context()
+
+		artistRepo = newMockArtistRepo()
+		mediaFileRepo = newMockMediaFileRepo()
+
+		ds = &tests.MockDataStore{
+			MockedArtist:    artistRepo,
+			MockedMediaFile: mediaFileRepo,
+		}
+
+		mockAgent = &mockSimilarArtistAgent{}
+		mockTopAgent = mockAgent
+		mockSimilarAgent = mockAgent
+
+		agentsCombined = &mockAgents{
+			topSongsAgent: mockTopAgent,
+			similarAgent:  mockSimilarAgent,
+		}
+
+		provider = NewProvider(ds, agentsCombined)
+	})
+
+	It("returns similar songs from main artist and similar artists", func() {
+		artist1 := model.Artist{ID: "artist-1", Name: "Artist One"}
+		similarArtist := model.Artist{ID: "artist-3", Name: "Similar Artist"}
+		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-1"}
+		song2 := model.MediaFile{ID: "song-2", Title: "Song Two", ArtistID: "artist-1", MbzRecordingID: "mbid-2"}
+		song3 := model.MediaFile{ID: "song-3", Title: "Song Three", ArtistID: "artist-3", MbzRecordingID: "mbid-3"}
+
+		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
+		artistRepo.On("Get", "artist-3").Return(&similarArtist, nil).Maybe()
+
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 1 && opt.Filters != nil
+		})).Return(model.Artists{artist1}, nil).Once()
+
+		similarAgentsResp := []agents.Artist{
+			{Name: "Similar Artist", MBID: "similar-mbid"},
+		}
+		mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist One", "", 15).
+			Return(similarAgentsResp, nil).Once()
+
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 0 && opt.Filters != nil
+		})).Return(model.Artists{similarArtist}, nil).Once()
+
+		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
+			Return([]agents.Song{
+				{Name: "Song One", MBID: "mbid-1"},
+				{Name: "Song Two", MBID: "mbid-2"},
+			}, nil).Once()
+
+		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-3", "Similar Artist", "", mock.Anything).
+			Return([]agents.Song{
+				{Name: "Song Three", MBID: "mbid-3"},
+			}, nil).Once()
+
+		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1, song2}, nil).Once()
+		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song3}, nil).Once()
+
+		songs, err := provider.ArtistRadio(ctx, "artist-1", 3)
+
+		Expect(err).ToNot(HaveOccurred())
+		Expect(songs).To(HaveLen(3))
+		for _, song := range songs {
+			Expect(song.ID).To(BeElementOf("song-1", "song-2", "song-3"))
+		}
+	})
+
+	It("returns ErrNotFound when artist is not found", func() {
+		artistRepo.On("Get", "artist-unknown-artist").Return(nil, model.ErrNotFound)
+		mediaFileRepo.On("Get", "artist-unknown-artist").Return(nil, model.ErrNotFound)
+
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 1 && opt.Filters != nil
+		})).Return(model.Artists{}, nil).Maybe()
+
+		songs, err := provider.ArtistRadio(ctx, "artist-unknown-artist", 5)
+
+		Expect(err).To(Equal(model.ErrNotFound))
+		Expect(songs).To(BeNil())
+	})
+
+	It("returns songs from main artist when GetSimilarArtists returns error", func() {
+		artist1 := model.Artist{ID: "artist-1", Name: "Artist One"}
+		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-1"}
+
+		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 1 && opt.Filters != nil
+		})).Return(model.Artists{artist1}, nil).Maybe()
+
+		mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist One", "", 15).
+			Return(nil, errors.New("error getting similar artists")).Once()
+
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 0 && opt.Filters != nil
+		})).Return(model.Artists{}, nil).Once()
+
+		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
+			Return([]agents.Song{
+				{Name: "Song One", MBID: "mbid-1"},
+			}, nil).Once()
+
+		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1}, nil).Once()
+
+		songs, err := provider.ArtistRadio(ctx, "artist-1", 5)
+
+		Expect(err).ToNot(HaveOccurred())
+		Expect(songs).To(HaveLen(1))
+		Expect(songs[0].ID).To(Equal("song-1"))
+	})
+
+	It("returns empty list when GetArtistTopSongs returns error", func() {
+		artist1 := model.Artist{ID: "artist-1", Name: "Artist One"}
+
+		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 1 && opt.Filters != nil
+		})).Return(model.Artists{artist1}, nil).Maybe()
+
+		mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist One", "", 15).
+			Return([]agents.Artist{}, nil).Once()
+
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 0 && opt.Filters != nil
+		})).Return(model.Artists{}, nil).Once()
+
+		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
+			Return(nil, errors.New("error getting top songs")).Once()
+
+		songs, err := provider.ArtistRadio(ctx, "artist-1", 5)
+
+		Expect(err).ToNot(HaveOccurred())
+		Expect(songs).To(BeEmpty())
+	})
+
+	It("respects count parameter", func() {
+		artist1 := model.Artist{ID: "artist-1", Name: "Artist One"}
+		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-1"}
+		song2 := model.MediaFile{ID: "song-2", Title: "Song Two", ArtistID: "artist-1", MbzRecordingID: "mbid-2"}
+
+		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 1 && opt.Filters != nil
+		})).Return(model.Artists{artist1}, nil).Maybe()
+
+		mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist One", "", 15).
+			Return([]agents.Artist{}, nil).Once()
+
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 0 && opt.Filters != nil
+		})).Return(model.Artists{}, nil).Once()
+
+		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
+			Return([]agents.Song{
+				{Name: "Song One", MBID: "mbid-1"},
+				{Name: "Song Two", MBID: "mbid-2"},
+			}, nil).Once()
+
+		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1, song2}, nil).Once()
+
+		songs, err := provider.ArtistRadio(ctx, "artist-1", 1)
+
+		Expect(err).ToNot(HaveOccurred())
+		Expect(songs).To(HaveLen(1))
+		Expect(songs[0].ID).To(BeElementOf("song-1", "song-2"))
+	})
+})

core/external/provider_matching.go

@@ -1,504 +0,0 @@
-package external
-
-import (
-	"context"
-	"fmt"
-	"math"
-
-	"github.com/Masterminds/squirrel"
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/core/agents"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/utils/str"
-	"github.com/xrash/smetrics"
-)
-
-// matchSongsToLibrary matches agent song results to local library tracks using a multi-phase
-// matching algorithm that prioritizes accuracy over recall.
-//
-// # Algorithm Overview
-//
-// The algorithm matches songs from external agents (Last.fm, Deezer, etc.) to tracks in the
-// local music library using four matching strategies in priority order:
-//
-//  1. Direct ID match: Songs with an ID field are matched directly to MediaFiles by ID
-//  2. MusicBrainz Recording ID (MBID) match: Songs with MBID are matched to tracks with
-//     matching mbz_recording_id
-//  3. ISRC match: Songs with ISRC are matched to tracks with matching ISRC tag
-//  4. Title+Artist fuzzy match: Remaining songs are matched using fuzzy string comparison
-//     with metadata specificity scoring
-//
-// # Matching Priority
-//
-// When selecting the final result, matches are prioritized in order: ID > MBID > ISRC > Title+Artist.
-// This ensures that more reliable identifiers take precedence over fuzzy text matching.
-//
-// # Fuzzy Matching Details
-//
-// For title+artist matching, the algorithm uses Jaro-Winkler similarity (threshold configurable
-// via SimilarSongsMatchThreshold, default 85%). Matches are ranked by:
-//
-//  1. Title similarity (Jaro-Winkler score, 0.0-1.0)
-//  2. Duration proximity (closer duration = higher score, 1.0 if unknown)
-//  3. Specificity level (0-5, based on metadata precision):
-//     - Level 5: Title + Artist MBID + Album MBID (most specific)
-//     - Level 4: Title + Artist MBID + Album name (fuzzy)
-//     - Level 3: Title + Artist name + Album name (fuzzy)
-//     - Level 2: Title + Artist MBID
-//     - Level 1: Title + Artist name
-//     - Level 0: Title only
-//  4. Album similarity (Jaro-Winkler, as final tiebreaker)
-//
-// # Examples
-//
-// Example 1 - MBID Priority:
-//
-//	Agent returns: {Name: "Paranoid Android", MBID: "abc-123", Artist: "Radiohead"}
-//	Library has: [
-//	  {ID: "t1", Title: "Paranoid Android", MbzRecordingID: "abc-123"},
-//	  {ID: "t2", Title: "Paranoid Android", Artist: "Radiohead"},
-//	]
-//	Result: t1 (MBID match takes priority over title+artist)
-//
-// Example 2 - ISRC Priority:
-//
-//	Agent returns: {Name: "Paranoid Android", ISRC: "GBAYE0000351", Artist: "Radiohead"}
-//	Library has: [
-//	  {ID: "t1", Title: "Paranoid Android", Tags: {isrc: ["GBAYE0000351"]}},
-//	  {ID: "t2", Title: "Paranoid Android", Artist: "Radiohead"},
-//	]
-//	Result: t1 (ISRC match takes priority over title+artist)
-//
-// Example 3 - Specificity Ranking:
-//
-//	Agent returns: {Name: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"}
-//	Library has: [
-//	  {ID: "t1", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "101"},           // Level 1
-//	  {ID: "t2", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"},      // Level 3
-//	]
-//	Result: t2 (Level 3 beats Level 1 due to album match)
-//
-// Example 4 - Fuzzy Title Matching:
-//
-//	Agent returns: {Name: "Bohemian Rhapsody", Artist: "Queen"}
-//	Library has: {ID: "t1", Title: "Bohemian Rhapsody - Remastered", Artist: "Queen"}
-//	With threshold=85%: Match succeeds (similarity ~0.87)
-//	With threshold=100%: No match (not exact)
-//
-// # Parameters
-//
-//   - ctx: Context for database operations
-//   - songs: Slice of agent.Song results from external providers
-//   - count: Maximum number of matches to return
-//
-// # Returns
-//
-// Returns up to 'count' MediaFiles from the library that best match the input songs,
-// preserving the original order from the agent. Songs that cannot be matched are skipped.
-func (e *provider) matchSongsToLibrary(ctx context.Context, songs []agents.Song, count int) (model.MediaFiles, error) {
-	idMatches, err := e.loadTracksByID(ctx, songs)
-	if err != nil {
-		return nil, fmt.Errorf("failed to load tracks by ID: %w", err)
-	}
-	mbidMatches, err := e.loadTracksByMBID(ctx, songs, idMatches)
-	if err != nil {
-		return nil, fmt.Errorf("failed to load tracks by MBID: %w", err)
-	}
-	isrcMatches, err := e.loadTracksByISRC(ctx, songs, idMatches, mbidMatches)
-	if err != nil {
-		return nil, fmt.Errorf("failed to load tracks by ISRC: %w", err)
-	}
-	titleMatches, err := e.loadTracksByTitleAndArtist(ctx, songs, idMatches, mbidMatches, isrcMatches)
-	if err != nil {
-		return nil, fmt.Errorf("failed to load tracks by title: %w", err)
-	}
-
-	return e.selectBestMatchingSongs(songs, idMatches, mbidMatches, isrcMatches, titleMatches, count), nil
-}
-
-// songMatchedIn checks if a song has already been matched in any of the provided match maps.
-// It checks the song's ID, MBID, and ISRC fields against the corresponding map keys.
-func songMatchedIn(s agents.Song, priorMatches ...map[string]model.MediaFile) bool {
-	_, found := lookupByIdentifiers(s, priorMatches...)
-	return found
-}
-
-// lookupByIdentifiers searches for a song's identifiers (ID, MBID, ISRC) in the provided maps.
-// Returns the first matching MediaFile found and true, or an empty MediaFile and false if no match.
-func lookupByIdentifiers(s agents.Song, maps ...map[string]model.MediaFile) (model.MediaFile, bool) {
-	keys := []string{s.ID, s.MBID, s.ISRC}
-	for _, m := range maps {
-		for _, key := range keys {
-			if key != "" {
-				if mf, ok := m[key]; ok && mf.ID != "" {
-					return mf, true
-				}
-			}
-		}
-	}
-	return model.MediaFile{}, false
-}
-
-// loadTracksByID fetches MediaFiles from the library using direct ID matching.
-// It extracts all non-empty ID fields from the input songs and performs a single
-// batch query to the database. Returns a map keyed by MediaFile ID for O(1) lookup.
-// Only non-missing files are returned.
-func (e *provider) loadTracksByID(ctx context.Context, songs []agents.Song) (map[string]model.MediaFile, error) {
-	var ids []string
-	for _, s := range songs {
-		if s.ID != "" {
-			ids = append(ids, s.ID)
-		}
-	}
-	matches := map[string]model.MediaFile{}
-	if len(ids) == 0 {
-		return matches, nil
-	}
-	res, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
-		Filters: squirrel.And{
-			squirrel.Eq{"media_file.id": ids},
-			squirrel.Eq{"missing": false},
-		},
-	})
-	if err != nil {
-		return matches, err
-	}
-	for _, mf := range res {
-		if _, ok := matches[mf.ID]; !ok {
-			matches[mf.ID] = mf
-		}
-	}
-	return matches, nil
-}
-
-// loadTracksByMBID fetches MediaFiles from the library using MusicBrainz Recording IDs.
-// It extracts all non-empty MBID fields from the input songs and performs a single
-// batch query against the mbz_recording_id column. Returns a map keyed by MBID for
-// O(1) lookup. Only non-missing files are returned.
-func (e *provider) loadTracksByMBID(ctx context.Context, songs []agents.Song, priorMatches ...map[string]model.MediaFile) (map[string]model.MediaFile, error) {
-	var mbids []string
-	for _, s := range songs {
-		if s.MBID != "" && !songMatchedIn(s, priorMatches...) {
-			mbids = append(mbids, s.MBID)
-		}
-	}
-	matches := map[string]model.MediaFile{}
-	if len(mbids) == 0 {
-		return matches, nil
-	}
-	res, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
-		Filters: squirrel.And{
-			squirrel.Eq{"mbz_recording_id": mbids},
-			squirrel.Eq{"missing": false},
-		},
-	})
-	if err != nil {
-		return matches, err
-	}
-	for _, mf := range res {
-		if id := mf.MbzRecordingID; id != "" {
-			if _, ok := matches[id]; !ok {
-				matches[id] = mf
-			}
-		}
-	}
-	return matches, nil
-}
-
-// loadTracksByISRC fetches MediaFiles from the library using ISRC (International Standard
-// Recording Code) matching. It extracts all non-empty ISRC fields from the input songs and
-// queries the tags JSON column for matching ISRC values. Returns a map keyed by ISRC for
-// O(1) lookup. Only non-missing files are returned.
-func (e *provider) loadTracksByISRC(ctx context.Context, songs []agents.Song, priorMatches ...map[string]model.MediaFile) (map[string]model.MediaFile, error) {
-	var isrcs []string
-	for _, s := range songs {
-		if s.ISRC != "" && !songMatchedIn(s, priorMatches...) {
-			isrcs = append(isrcs, s.ISRC)
-		}
-	}
-	matches := map[string]model.MediaFile{}
-	if len(isrcs) == 0 {
-		return matches, nil
-	}
-	res, err := e.ds.MediaFile(ctx).GetAllByTags(model.TagISRC, isrcs, model.QueryOptions{
-		Filters: squirrel.Eq{"missing": false},
-	})
-	if err != nil {
-		return matches, err
-	}
-	for _, mf := range res {
-		for _, isrc := range mf.Tags.Values(model.TagISRC) {
-			if _, ok := matches[isrc]; !ok {
-				matches[isrc] = mf
-			}
-		}
-	}
-	return matches, nil
-}
-
-// songQuery represents a normalized query for matching a song to library tracks.
-// All string fields are sanitized (lowercased, diacritics removed) for comparison.
-// This struct is used internally by loadTracksByTitleAndArtist to group queries by artist.
-type songQuery struct {
-	title      string // Sanitized song title
-	artist     string // Sanitized artist name (without articles like "The")
-	artistMBID string // MusicBrainz Artist ID (optional, for higher specificity matching)
-	album      string // Sanitized album name (optional, for specificity scoring)
-	albumMBID  string // MusicBrainz Album ID (optional, for highest specificity matching)
-	durationMs uint32 // Duration in milliseconds (0 means unknown, skip duration filtering)
-}
-
-// matchScore combines title/album similarity with metadata specificity for ranking matches
-type matchScore struct {
-	titleSimilarity   float64 // 0.0-1.0 (Jaro-Winkler)
-	durationProximity float64 // 0.0-1.0 (closer duration = higher, 1.0 if unknown)
-	albumSimilarity   float64 // 0.0-1.0 (Jaro-Winkler), used as tiebreaker
-	specificityLevel  int     // 0-5 (higher = more specific metadata match)
-}
-
-// betterThan returns true if this score beats another.
-// Comparison order: title similarity > duration proximity > specificity level > album similarity
-func (s matchScore) betterThan(other matchScore) bool {
-	if s.titleSimilarity != other.titleSimilarity {
-		return s.titleSimilarity > other.titleSimilarity
-	}
-	if s.durationProximity != other.durationProximity {
-		return s.durationProximity > other.durationProximity
-	}
-	if s.specificityLevel != other.specificityLevel {
-		return s.specificityLevel > other.specificityLevel
-	}
-	return s.albumSimilarity > other.albumSimilarity
-}
-
-// computeSpecificityLevel determines how well query metadata matches a track (0-5).
-// Higher values indicate more specific matches (MBIDs > names > title only).
-// Uses fuzzy matching for album names with the same threshold as title matching.
-func computeSpecificityLevel(q songQuery, mf model.MediaFile, albumThreshold float64) int {
-	title := str.SanitizeFieldForSorting(mf.Title)
-	artist := str.SanitizeFieldForSortingNoArticle(mf.Artist)
-	album := str.SanitizeFieldForSorting(mf.Album)
-
-	// Level 5: Title + Artist MBID + Album MBID (most specific)
-	if q.artistMBID != "" && q.albumMBID != "" &&
-		mf.MbzArtistID == q.artistMBID && mf.MbzAlbumID == q.albumMBID {
-		return 5
-	}
-	// Level 4: Title + Artist MBID + Album name (fuzzy)
-	if q.artistMBID != "" && q.album != "" &&
-		mf.MbzArtistID == q.artistMBID && similarityRatio(album, q.album) >= albumThreshold {
-		return 4
-	}
-	// Level 3: Title + Artist name + Album name (fuzzy)
-	if q.artist != "" && q.album != "" &&
-		artist == q.artist && similarityRatio(album, q.album) >= albumThreshold {
-		return 3
-	}
-	// Level 2: Title + Artist MBID
-	if q.artistMBID != "" && mf.MbzArtistID == q.artistMBID {
-		return 2
-	}
-	// Level 1: Title + Artist name
-	if q.artist != "" && artist == q.artist {
-		return 1
-	}
-	// Level 0: Title only match (but for fuzzy, title matched via similarity)
-	// Check if at least the title matches exactly
-	if title == q.title {
-		return 0
-	}
-	return -1 // No exact title match, but could still be a fuzzy match
-}
-
-// loadTracksByTitleAndArtist loads tracks matching by title with optional artist/album filtering.
-// Uses a unified scoring approach that combines title similarity (Jaro-Winkler) with
-// metadata specificity (MBIDs, album names) for both exact and fuzzy matches.
-// Returns a map keyed by "title|artist" for compatibility with selectBestMatchingSongs.
-func (e *provider) loadTracksByTitleAndArtist(ctx context.Context, songs []agents.Song, priorMatches ...map[string]model.MediaFile) (map[string]model.MediaFile, error) {
-	queries := e.buildTitleQueries(songs, priorMatches...)
-	if len(queries) == 0 {
-		return map[string]model.MediaFile{}, nil
-	}
-
-	threshold := float64(conf.Server.SimilarSongsMatchThreshold) / 100.0
-
-	// Group queries by artist for efficient DB access
-	byArtist := map[string][]songQuery{}
-	for _, q := range queries {
-		if q.artist != "" {
-			byArtist[q.artist] = append(byArtist[q.artist], q)
-		}
-	}
-
-	matches := map[string]model.MediaFile{}
-	for artist, artistQueries := range byArtist {
-		// Single DB query per artist - get all their tracks
-		tracks, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
-			Filters: squirrel.And{
-				squirrel.Eq{"order_artist_name": artist},
-				squirrel.Eq{"missing": false},
-			},
-			Sort: "starred desc, rating desc, year asc, compilation asc",
-		})
-		if err != nil {
-			continue
-		}
-
-		// Find best match for each query using unified scoring
-		for _, q := range artistQueries {
-			if mf, found := e.findBestMatch(q, tracks, threshold); found {
-				key := q.title + "|" + q.artist
-				if _, exists := matches[key]; !exists {
-					matches[key] = mf
-				}
-			}
-		}
-	}
-	return matches, nil
-}
-
-// durationProximity returns a score from 0.0 to 1.0 indicating how close
-// the track's duration is to the target. A perfect match returns 1.0, and the
-// score decreases as the difference grows (using 1 / (1 + diff)). Returns 1.0
-// if durationMs is 0 (unknown), so duration does not influence scoring.
-func durationProximity(durationMs uint32, mediaFileDurationSec float32) float64 {
-	if durationMs <= 0 {
-		return 1.0 // Unknown duration — don't penalise
-	}
-	durationSec := float64(durationMs) / 1000.0
-	diff := math.Abs(durationSec - float64(mediaFileDurationSec))
-	return 1.0 / (1.0 + diff)
-}
-
-// findBestMatch finds the best matching track using combined title/album similarity and specificity scoring.
-// A track must meet the threshold for title similarity, then the best match is chosen by:
-// 1. Highest title similarity
-// 2. Duration proximity (closer duration = higher score, 1.0 if unknown)
-// 3. Highest specificity level
-// 4. Highest album similarity (as final tiebreaker)
-func (e *provider) findBestMatch(q songQuery, tracks model.MediaFiles, threshold float64) (model.MediaFile, bool) {
-	var bestMatch model.MediaFile
-	bestScore := matchScore{titleSimilarity: -1}
-	found := false
-
-	for _, mf := range tracks {
-		trackTitle := str.SanitizeFieldForSorting(mf.Title)
-		titleSim := similarityRatio(q.title, trackTitle)
-
-		if titleSim < threshold {
-			continue
-		}
-
-		// Compute album similarity for tiebreaking (0.0 if no album in query)
-		var albumSim float64
-		if q.album != "" {
-			trackAlbum := str.SanitizeFieldForSorting(mf.Album)
-			albumSim = similarityRatio(q.album, trackAlbum)
-		}
-
-		score := matchScore{
-			titleSimilarity:   titleSim,
-			durationProximity: durationProximity(q.durationMs, mf.Duration),
-			albumSimilarity:   albumSim,
-			specificityLevel:  computeSpecificityLevel(q, mf, threshold),
-		}
-
-		if score.betterThan(bestScore) {
-			bestScore = score
-			bestMatch = mf
-			found = true
-		}
-	}
-	return bestMatch, found
-}
-
-// buildTitleQueries converts agent songs into normalized songQuery structs for title+artist matching.
-// It skips songs that have already been matched in prior phases (by ID, MBID, or ISRC) and sanitizes
-// all string fields for consistent comparison (lowercase, diacritics removed, articles stripped from artist names).
-func (e *provider) buildTitleQueries(songs []agents.Song, priorMatches ...map[string]model.MediaFile) []songQuery {
-	var queries []songQuery
-	for _, s := range songs {
-		if songMatchedIn(s, priorMatches...) {
-			continue
-		}
-		queries = append(queries, songQuery{
-			title:      str.SanitizeFieldForSorting(s.Name),
-			artist:     str.SanitizeFieldForSortingNoArticle(s.Artist),
-			artistMBID: s.ArtistMBID,
-			album:      str.SanitizeFieldForSorting(s.Album),
-			albumMBID:  s.AlbumMBID,
-			durationMs: s.Duration,
-		})
-	}
-	return queries
-}
-
-// selectBestMatchingSongs assembles the final result by mapping input songs to their best matching
-// library tracks. It iterates through the input songs in order and selects the first available match
-// using priority order: ID > MBID > ISRC > title+artist.
-//
-// The function also handles deduplication: when multiple different input songs would match the same
-// library track (e.g., "Song (Live)" and "Song (Remastered)" both matching "Song (Live)" in the library),
-// only the first match is kept. However, if the same input song appears multiple times (intentional
-// repetition), duplicates are preserved in the output.
-//
-// Returns up to 'count' MediaFiles, preserving the input order. Songs that cannot be matched are skipped.
-func (e *provider) selectBestMatchingSongs(songs []agents.Song, byID, byMBID, byISRC, byTitleArtist map[string]model.MediaFile, count int) model.MediaFiles {
-	mfs := make(model.MediaFiles, 0, len(songs))
-	// Track MediaFile.ID -> input song that added it, for deduplication
-	addedBy := make(map[string]agents.Song, len(songs))
-
-	for _, t := range songs {
-		if len(mfs) == count {
-			break
-		}
-
-		mf, found := findMatchingTrack(t, byID, byMBID, byISRC, byTitleArtist)
-		if !found {
-			continue
-		}
-
-		// Check for duplicate library track
-		if prevSong, alreadyAdded := addedBy[mf.ID]; alreadyAdded {
-			// Only add duplicate if input songs are identical
-			if t != prevSong {
-				continue // Different input songs → skip mismatch-induced duplicate
-			}
-		} else {
-			addedBy[mf.ID] = t
-		}
-
-		mfs = append(mfs, mf)
-	}
-	return mfs
-}
-
-// findMatchingTrack looks up a song in the match maps using priority order: ID > MBID > ISRC > title+artist.
-// Returns the matched MediaFile and true if found, or an empty MediaFile and false if no match exists.
-func findMatchingTrack(t agents.Song, byID, byMBID, byISRC, byTitleArtist map[string]model.MediaFile) (model.MediaFile, bool) {
-	// Try identifier-based matches first (ID, MBID, ISRC)
-	if mf, found := lookupByIdentifiers(t, byID, byMBID, byISRC); found {
-		return mf, true
-	}
-	// Fall back to title+artist fuzzy match
-	key := str.SanitizeFieldForSorting(t.Name) + "|" + str.SanitizeFieldForSortingNoArticle(t.Artist)
-	if mf, ok := byTitleArtist[key]; ok {
-		return mf, true
-	}
-	return model.MediaFile{}, false
-}
-
-// similarityRatio calculates the similarity between two strings using Jaro-Winkler algorithm.
-// Returns a value between 0.0 (completely different) and 1.0 (identical).
-// Jaro-Winkler is well-suited for matching song titles because it gives higher scores
-// when strings share a common prefix (e.g., "Song Title" vs "Song Title - Remastered").
-func similarityRatio(a, b string) float64 {
-	if a == b {
-		return 1.0
-	}
-	if len(a) == 0 || len(b) == 0 {
-		return 0.0
-	}
-	// JaroWinkler params: boostThreshold=0.7, prefixSize=4
-	return smetrics.JaroWinkler(a, b, 0.7, 4)
-}

core/external/provider_matching_internal_test.go

@@ -1,57 +0,0 @@
-package external
-
-import (
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("similarityRatio", func() {
-	It("returns 1.0 for identical strings", func() {
-		Expect(similarityRatio("hello", "hello")).To(BeNumerically("==", 1.0))
-	})
-
-	It("returns 0.0 for empty strings", func() {
-		Expect(similarityRatio("", "test")).To(BeNumerically("==", 0.0))
-		Expect(similarityRatio("test", "")).To(BeNumerically("==", 0.0))
-	})
-
-	It("returns high similarity for remastered suffix", func() {
-		// Jaro-Winkler gives ~0.92 for this case
-		ratio := similarityRatio("paranoid android", "paranoid android remastered")
-		Expect(ratio).To(BeNumerically(">=", 0.85))
-	})
-
-	It("returns high similarity for suffix additions like (Live)", func() {
-		// Jaro-Winkler gives ~0.96 for this case
-		ratio := similarityRatio("bohemian rhapsody", "bohemian rhapsody live")
-		Expect(ratio).To(BeNumerically(">=", 0.90))
-	})
-
-	It("returns high similarity for 'yesterday' variants (common prefix)", func() {
-		// Jaro-Winkler gives ~0.90 because of common prefix
-		ratio := similarityRatio("yesterday", "yesterday once more")
-		Expect(ratio).To(BeNumerically(">=", 0.85))
-	})
-
-	It("returns low similarity for same suffix", func() {
-		// Jaro-Winkler gives ~0.70 for this case
-		ratio := similarityRatio("postman (live)", "taxman (live)")
-		Expect(ratio).To(BeNumerically("<", 0.85))
-	})
-
-	It("handles unicode characters", func() {
-		ratio := similarityRatio("dont stop believin", "don't stop believin'")
-		Expect(ratio).To(BeNumerically(">=", 0.85))
-	})
-
-	It("returns low similarity for completely different strings", func() {
-		ratio := similarityRatio("abc", "xyz")
-		Expect(ratio).To(BeNumerically("<", 0.5))
-	})
-
-	It("is symmetric", func() {
-		ratio1 := similarityRatio("hello world", "hello")
-		ratio2 := similarityRatio("hello", "hello world")
-		Expect(ratio1).To(Equal(ratio2))
-	})
-})

core/external/provider_matching_test.go

@@ -1,762 +0,0 @@
-package external_test
-
-import (
-	"context"
-
-	"github.com/Masterminds/squirrel"
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/conf/configtest"
-	"github.com/navidrome/navidrome/core/agents"
-	. "github.com/navidrome/navidrome/core/external"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-	"github.com/stretchr/testify/mock"
-)
-
-var _ = Describe("Provider - Song Matching", func() {
-	var ds model.DataStore
-	var provider Provider
-	var agentsCombined *mockAgents
-	var artistRepo *mockArtistRepo
-	var mediaFileRepo *mockMediaFileRepo
-	var albumRepo *mockAlbumRepo
-	var ctx context.Context
-
-	BeforeEach(func() {
-		ctx = GinkgoT().Context()
-
-		artistRepo = newMockArtistRepo()
-		mediaFileRepo = newMockMediaFileRepo()
-		albumRepo = newMockAlbumRepo()
-
-		ds = &tests.MockDataStore{
-			MockedArtist:    artistRepo,
-			MockedMediaFile: mediaFileRepo,
-			MockedAlbum:     albumRepo,
-		}
-
-		agentsCombined = &mockAgents{}
-		provider = NewProvider(ds, agentsCombined)
-	})
-
-	// Shared helper for tests that only need artist track queries (no ID/MBID matching)
-	setupSimilarSongsExpectations := func(returnedSongs []agents.Song, artistTracks model.MediaFiles) {
-		agentsCombined.On("GetSimilarSongsByTrack", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
-			Return(returnedSongs, nil).Once()
-
-		// loadTracksByTitleAndArtist - queries by artist name
-		mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			and, ok := opt.Filters.(squirrel.And)
-			if !ok || len(and) < 2 {
-				return false
-			}
-			eq, hasEq := and[0].(squirrel.Eq)
-			if !hasEq {
-				return false
-			}
-			_, hasArtist := eq["order_artist_name"]
-			return hasArtist
-		})).Return(artistTracks, nil).Maybe()
-	}
-
-	Describe("matchSongsToLibrary priority matching", func() {
-		var track model.MediaFile
-
-		BeforeEach(func() {
-			DeferCleanup(configtest.SetupConfig())
-			// Disable fuzzy matching for these tests to avoid unexpected GetAll calls
-			conf.Server.SimilarSongsMatchThreshold = 100
-
-			track = model.MediaFile{ID: "track-1", Title: "Test Track", Artist: "Test Artist", MbzRecordingID: ""}
-
-			// Setup for GetEntityByID to return the track
-			artistRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
-			albumRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
-			mediaFileRepo.On("Get", "track-1").Return(&track, nil).Once()
-		})
-
-		setupExpectations := func(returnedSongs []agents.Song, idMatches, mbidMatches, artistTracks model.MediaFiles) {
-			agentsCombined.On("GetSimilarSongsByTrack", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
-				Return(returnedSongs, nil).Once()
-
-			// loadTracksByID
-			mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-				_, ok := opt.Filters.(squirrel.Eq)
-				return ok
-			})).Return(idMatches, nil).Once()
-
-			// loadTracksByMBID
-			mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-				and, ok := opt.Filters.(squirrel.And)
-				if !ok || len(and) < 1 {
-					return false
-				}
-				eq, hasEq := and[0].(squirrel.Eq)
-				if !hasEq {
-					return false
-				}
-				_, hasMBID := eq["mbz_recording_id"]
-				return hasMBID
-			})).Return(mbidMatches, nil).Once()
-
-			// loadTracksByTitleAndArtist - now queries by artist name
-			mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-				and, ok := opt.Filters.(squirrel.And)
-				if !ok || len(and) < 2 {
-					return false
-				}
-				eq, hasEq := and[0].(squirrel.Eq)
-				if !hasEq {
-					return false
-				}
-				_, hasArtist := eq["order_artist_name"]
-				return hasArtist
-			})).Return(artistTracks, nil).Maybe()
-		}
-
-		Context("when agent returns artist and album metadata", func() {
-			It("matches by title + artist MBID + album MBID (highest priority)", func() {
-				// Song in library with all MBIDs
-				correctMatch := model.MediaFile{
-					ID: "correct-match", Title: "Similar Song", Artist: "Depeche Mode", Album: "Violator",
-					MbzArtistID: "artist-mbid-123", MbzAlbumID: "album-mbid-456",
-				}
-				// Another song with same title but different MBIDs (should NOT match)
-				wrongMatch := model.MediaFile{
-					ID: "wrong-match", Title: "Similar Song", Artist: "Depeche Mode", Album: "Some Other Album",
-					MbzArtistID: "artist-mbid-123", MbzAlbumID: "different-album-mbid",
-				}
-				returnedSongs := []agents.Song{
-					{Name: "Similar Song", Artist: "Depeche Mode", ArtistMBID: "artist-mbid-123", Album: "Violator", AlbumMBID: "album-mbid-456"},
-				}
-
-				setupExpectations(returnedSongs, model.MediaFiles{}, model.MediaFiles{}, model.MediaFiles{wrongMatch, correctMatch})
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("correct-match"))
-			})
-
-			It("matches by title + artist name + album name when MBIDs unavailable", func() {
-				// Song in library without MBIDs but with matching artist/album names
-				correctMatch := model.MediaFile{
-					ID: "correct-match", Title: "Similar Song", Artist: "depeche mode", Album: "violator",
-				}
-				// Another song with same title but different artist (should NOT match)
-				wrongMatch := model.MediaFile{
-					ID: "wrong-match", Title: "Similar Song", Artist: "Other Artist", Album: "Other Album",
-				}
-
-				returnedSongs := []agents.Song{
-					{Name: "Similar Song", Artist: "Depeche Mode", Album: "Violator"}, // No MBIDs
-				}
-
-				setupExpectations(returnedSongs, model.MediaFiles{}, model.MediaFiles{}, model.MediaFiles{wrongMatch, correctMatch})
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("correct-match"))
-			})
-
-			It("matches by title + artist only when album info unavailable", func() {
-				// Song in library with matching artist
-				correctMatch := model.MediaFile{
-					ID: "correct-match", Title: "Similar Song", Artist: "depeche mode", Album: "Some Album",
-				}
-				// Another song with same title but different artist
-				wrongMatch := model.MediaFile{
-					ID: "wrong-match", Title: "Similar Song", Artist: "Other Artist", Album: "Other Album",
-				}
-				returnedSongs := []agents.Song{
-					{Name: "Similar Song", Artist: "Depeche Mode"}, // No album info
-				}
-
-				setupExpectations(returnedSongs, model.MediaFiles{}, model.MediaFiles{}, model.MediaFiles{wrongMatch, correctMatch})
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("correct-match"))
-			})
-
-			It("does not match songs without artist info", func() {
-				// Songs without artist info cannot be matched since we query by artist
-				returnedSongs := []agents.Song{
-					{Name: "Similar Song"}, // No artist/album info at all
-				}
-
-				// No artist to query, so no GetAll calls for title matching
-				setupExpectations(returnedSongs, model.MediaFiles{}, model.MediaFiles{}, model.MediaFiles{})
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(BeEmpty())
-			})
-		})
-
-		Context("when matching multiple songs with the same title but different artists", func() {
-			It("returns distinct matches for each artist's version (covers scenario)", func() {
-				// Multiple covers of the same song by different artists
-				cover1 := model.MediaFile{
-					ID: "cover-1", Title: "Yesterday", Artist: "The Beatles", Album: "Help!",
-				}
-				cover2 := model.MediaFile{
-					ID: "cover-2", Title: "Yesterday", Artist: "Ray Charles", Album: "Greatest Hits",
-				}
-				cover3 := model.MediaFile{
-					ID: "cover-3", Title: "Yesterday", Artist: "Frank Sinatra", Album: "My Way",
-				}
-
-				returnedSongs := []agents.Song{
-					{Name: "Yesterday", Artist: "The Beatles", Album: "Help!"},
-					{Name: "Yesterday", Artist: "Ray Charles", Album: "Greatest Hits"},
-					{Name: "Yesterday", Artist: "Frank Sinatra", Album: "My Way"},
-				}
-
-				setupExpectations(returnedSongs, model.MediaFiles{}, model.MediaFiles{}, model.MediaFiles{cover1, cover2, cover3})
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				// All three covers should be returned, not just the first one
-				Expect(songs).To(HaveLen(3))
-				// Verify all three different versions are included
-				ids := []string{songs[0].ID, songs[1].ID, songs[2].ID}
-				Expect(ids).To(ContainElements("cover-1", "cover-2", "cover-3"))
-			})
-		})
-
-		Context("when matching multiple songs with different precision levels", func() {
-			It("prefers more precise matches for each song", func() {
-				// Library has multiple versions of same song
-				preciseMatch := model.MediaFile{
-					ID: "precise", Title: "Song A", Artist: "Artist One", Album: "Album One",
-					MbzArtistID: "mbid-1", MbzAlbumID: "album-mbid-1",
-				}
-				lessAccurateMatch := model.MediaFile{
-					ID: "less-accurate", Title: "Song A", Artist: "Artist One", Album: "Compilation",
-					MbzArtistID: "mbid-1",
-				}
-				artistTwoMatch := model.MediaFile{
-					ID: "artist-two", Title: "Song B", Artist: "Artist Two",
-				}
-
-				returnedSongs := []agents.Song{
-					{Name: "Song A", Artist: "Artist One", ArtistMBID: "mbid-1", Album: "Album One", AlbumMBID: "album-mbid-1"},
-					{Name: "Song B", Artist: "Artist Two"}, // Different artist
-				}
-
-				setupExpectations(returnedSongs, model.MediaFiles{}, model.MediaFiles{}, model.MediaFiles{lessAccurateMatch, preciseMatch, artistTwoMatch})
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(2))
-				// First song should be the precise match (has all MBIDs)
-				Expect(songs[0].ID).To(Equal("precise"))
-				// Second song matches by title + artist
-				Expect(songs[1].ID).To(Equal("artist-two"))
-			})
-		})
-	})
-
-	Describe("Fuzzy matching fallback", func() {
-		var track model.MediaFile
-
-		BeforeEach(func() {
-			DeferCleanup(configtest.SetupConfig())
-			track = model.MediaFile{ID: "track-1", Title: "Test Track", Artist: "Test Artist"}
-
-			// Setup for GetEntityByID to return the track
-			artistRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
-			albumRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
-			mediaFileRepo.On("Get", "track-1").Return(&track, nil).Once()
-		})
-
-		Context("with default threshold (85%)", func() {
-			It("matches songs with remastered suffix", func() {
-				conf.Server.SimilarSongsMatchThreshold = 85
-
-				// Agent returns "Paranoid Android" but library has "Paranoid Android - Remastered"
-				returnedSongs := []agents.Song{
-					{Name: "Paranoid Android", Artist: "Radiohead"},
-				}
-				// Artist catalog has the remastered version (fuzzy match will find it)
-				artistTracks := model.MediaFiles{
-					{ID: "remastered", Title: "Paranoid Android - Remastered", Artist: "Radiohead"},
-				}
-
-				setupSimilarSongsExpectations(returnedSongs, artistTracks)
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("remastered"))
-			})
-
-			It("matches songs with live suffix", func() {
-				conf.Server.SimilarSongsMatchThreshold = 85
-
-				returnedSongs := []agents.Song{
-					{Name: "Bohemian Rhapsody", Artist: "Queen"},
-				}
-				artistTracks := model.MediaFiles{
-					{ID: "live", Title: "Bohemian Rhapsody (Live)", Artist: "Queen"},
-				}
-
-				setupSimilarSongsExpectations(returnedSongs, artistTracks)
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("live"))
-			})
-
-			It("does not match completely different songs", func() {
-				conf.Server.SimilarSongsMatchThreshold = 85
-
-				returnedSongs := []agents.Song{
-					{Name: "Yesterday", Artist: "The Beatles"},
-				}
-				// Artist catalog has completely different songs
-				artistTracks := model.MediaFiles{
-					{ID: "different", Title: "Tomorrow Never Knows", Artist: "The Beatles"},
-					{ID: "different2", Title: "Here Comes The Sun", Artist: "The Beatles"},
-				}
-
-				setupSimilarSongsExpectations(returnedSongs, artistTracks)
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(BeEmpty())
-			})
-		})
-
-		Context("with threshold set to 100 (exact match only)", func() {
-			It("only matches exact titles", func() {
-				conf.Server.SimilarSongsMatchThreshold = 100
-
-				returnedSongs := []agents.Song{
-					{Name: "Paranoid Android", Artist: "Radiohead"},
-				}
-				// Artist catalog has only remastered version - no exact match
-				artistTracks := model.MediaFiles{
-					{ID: "remastered", Title: "Paranoid Android - Remastered", Artist: "Radiohead"},
-				}
-
-				setupSimilarSongsExpectations(returnedSongs, artistTracks)
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(BeEmpty())
-			})
-		})
-
-		Context("with lower threshold (75%)", func() {
-			It("matches more aggressively", func() {
-				conf.Server.SimilarSongsMatchThreshold = 75
-
-				returnedSongs := []agents.Song{
-					{Name: "Song", Artist: "Artist"},
-				}
-				artistTracks := model.MediaFiles{
-					{ID: "extended", Title: "Song (Extended Mix)", Artist: "Artist"},
-				}
-
-				setupSimilarSongsExpectations(returnedSongs, artistTracks)
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("extended"))
-			})
-		})
-
-		Context("with fuzzy album matching", func() {
-			It("matches album with (Remaster) suffix", func() {
-				conf.Server.SimilarSongsMatchThreshold = 85
-
-				// Agent returns "A Night at the Opera" but library has remastered version
-				returnedSongs := []agents.Song{
-					{Name: "Bohemian Rhapsody", Artist: "Queen", Album: "A Night at the Opera"},
-				}
-				// Library has same album with remaster suffix
-				correctMatch := model.MediaFile{
-					ID: "correct", Title: "Bohemian Rhapsody", Artist: "Queen", Album: "A Night at the Opera (2011 Remaster)",
-				}
-				wrongMatch := model.MediaFile{
-					ID: "wrong", Title: "Bohemian Rhapsody", Artist: "Queen", Album: "Greatest Hits",
-				}
-
-				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{wrongMatch, correctMatch})
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				// Should prefer the fuzzy album match (Level 3) over title+artist only (Level 1)
-				Expect(songs[0].ID).To(Equal("correct"))
-			})
-
-			It("matches album with (Deluxe Edition) suffix", func() {
-				conf.Server.SimilarSongsMatchThreshold = 85
-
-				returnedSongs := []agents.Song{
-					{Name: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"},
-				}
-				correctMatch := model.MediaFile{
-					ID: "correct", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator (Deluxe Edition)",
-				}
-				wrongMatch := model.MediaFile{
-					ID: "wrong", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "101",
-				}
-
-				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{wrongMatch, correctMatch})
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("correct"))
-			})
-
-			It("prefers exact album match over fuzzy album match", func() {
-				conf.Server.SimilarSongsMatchThreshold = 85
-
-				returnedSongs := []agents.Song{
-					{Name: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"},
-				}
-				exactMatch := model.MediaFile{
-					ID: "exact", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator",
-				}
-				fuzzyMatch := model.MediaFile{
-					ID: "fuzzy", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator (Deluxe Edition)",
-				}
-
-				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{fuzzyMatch, exactMatch})
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				// Both have same title similarity (1.0), so should prefer exact album match (higher specificity via higher album similarity)
-				Expect(songs[0].ID).To(Equal("exact"))
-			})
-		})
-	})
-
-	Describe("Duration matching", func() {
-		var track model.MediaFile
-
-		BeforeEach(func() {
-			DeferCleanup(configtest.SetupConfig())
-			conf.Server.SimilarSongsMatchThreshold = 100 // Exact title match for predictable tests
-
-			track = model.MediaFile{ID: "track-1", Title: "Test Track", Artist: "Test Artist"}
-
-			// Setup for GetEntityByID to return the track
-			artistRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
-			albumRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
-			mediaFileRepo.On("Get", "track-1").Return(&track, nil).Once()
-		})
-
-		Context("when agent provides duration", func() {
-			It("prefers tracks with matching duration", func() {
-				// Agent returns song with duration 180000ms (180 seconds)
-				returnedSongs := []agents.Song{
-					{Name: "Similar Song", Artist: "Test Artist", Duration: 180000},
-				}
-				// Library has two versions: one matching duration, one not
-				correctMatch := model.MediaFile{
-					ID: "correct", Title: "Similar Song", Artist: "Test Artist", Duration: 180.0,
-				}
-				wrongDuration := model.MediaFile{
-					ID: "wrong", Title: "Similar Song", Artist: "Test Artist", Duration: 240.0,
-				}
-
-				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{wrongDuration, correctMatch})
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("correct"))
-			})
-
-			It("matches tracks with close duration", func() {
-				// Agent returns song with duration 180000ms (180 seconds)
-				returnedSongs := []agents.Song{
-					{Name: "Similar Song", Artist: "Test Artist", Duration: 180000},
-				}
-				// Library has track with 182.5 seconds (close to target)
-				closeDuration := model.MediaFile{
-					ID: "close-duration", Title: "Similar Song", Artist: "Test Artist", Duration: 182.5,
-				}
-
-				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{closeDuration})
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("close-duration"))
-			})
-
-			It("prefers closer duration over farther duration", func() {
-				// Agent returns song with duration 180000ms (180 seconds)
-				returnedSongs := []agents.Song{
-					{Name: "Similar Song", Artist: "Test Artist", Duration: 180000},
-				}
-				// Library has one close, one far
-				closeDuration := model.MediaFile{
-					ID: "close", Title: "Similar Song", Artist: "Test Artist", Duration: 181.0,
-				}
-				farDuration := model.MediaFile{
-					ID: "far", Title: "Similar Song", Artist: "Test Artist", Duration: 190.0,
-				}
-
-				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{farDuration, closeDuration})
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("close"))
-			})
-
-			It("still matches when no tracks have matching duration", func() {
-				// Agent returns song with duration 180000ms
-				returnedSongs := []agents.Song{
-					{Name: "Similar Song", Artist: "Test Artist", Duration: 180000},
-				}
-				// Library only has tracks with very different duration
-				differentDuration := model.MediaFile{
-					ID: "different", Title: "Similar Song", Artist: "Test Artist", Duration: 300.0,
-				}
-
-				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{differentDuration})
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				// Duration mismatch doesn't exclude the track; it's just scored lower
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("different"))
-			})
-
-			It("prefers title match over duration match when titles differ", func() {
-				// Agent returns "Similar Song" with duration 180000ms
-				returnedSongs := []agents.Song{
-					{Name: "Similar Song", Artist: "Test Artist", Duration: 180000},
-				}
-				// Library has:
-				// - differentTitle: matches duration but has different title (won't pass title threshold)
-				// - correctTitle: doesn't match duration but has correct title (wins on title similarity)
-				differentTitle := model.MediaFile{
-					ID: "wrong-title", Title: "Different Song", Artist: "Test Artist", Duration: 180.0,
-				}
-				correctTitle := model.MediaFile{
-					ID: "correct-title", Title: "Similar Song", Artist: "Test Artist", Duration: 300.0,
-				}
-
-				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{differentTitle, correctTitle})
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				// Title similarity is the top priority, so the correct title wins despite duration mismatch
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("correct-title"))
-			})
-		})
-
-		Context("when agent does not provide duration", func() {
-			It("matches without duration filtering (duration=0)", func() {
-				// Agent returns song without duration
-				returnedSongs := []agents.Song{
-					{Name: "Similar Song", Artist: "Test Artist", Duration: 0},
-				}
-				// Library tracks with various durations should all be candidates
-				anyTrack := model.MediaFile{
-					ID: "any", Title: "Similar Song", Artist: "Test Artist", Duration: 999.0,
-				}
-
-				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{anyTrack})
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("any"))
-			})
-		})
-
-		Context("edge cases", func() {
-			It("handles very short songs with close duration", func() {
-				// 30-second song with 1-second difference
-				returnedSongs := []agents.Song{
-					{Name: "Short Song", Artist: "Test Artist", Duration: 30000},
-				}
-				shortTrack := model.MediaFile{
-					ID: "short", Title: "Short Song", Artist: "Test Artist", Duration: 31.0,
-				}
-
-				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{shortTrack})
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("short"))
-			})
-		})
-	})
-
-	Describe("Deduplication of mismatched songs", func() {
-		var track model.MediaFile
-
-		BeforeEach(func() {
-			DeferCleanup(configtest.SetupConfig())
-			conf.Server.SimilarSongsMatchThreshold = 85 // Allow fuzzy matching
-
-			track = model.MediaFile{ID: "track-1", Title: "Test Track", Artist: "Test Artist"}
-
-			// Setup for GetEntityByID to return the track
-			artistRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
-			albumRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
-			mediaFileRepo.On("Get", "track-1").Return(&track, nil).Once()
-		})
-
-		It("removes duplicates when different input songs match the same library track", func() {
-			// Agent returns two different versions that will both fuzzy-match to the same library track
-			returnedSongs := []agents.Song{
-				{Name: "Bohemian Rhapsody (Live)", Artist: "Queen"},
-				{Name: "Bohemian Rhapsody (Original Mix)", Artist: "Queen"},
-			}
-			// Library only has one version
-			libraryTrack := model.MediaFile{
-				ID: "br-live", Title: "Bohemian Rhapsody (Live)", Artist: "Queen",
-			}
-
-			setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{libraryTrack})
-
-			songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			// Should only return one track, not two duplicates
-			Expect(songs).To(HaveLen(1))
-			Expect(songs[0].ID).To(Equal("br-live"))
-		})
-
-		It("preserves duplicates when identical input songs match the same library track", func() {
-			// Agent returns the exact same song twice (intentional repetition)
-			returnedSongs := []agents.Song{
-				{Name: "Bohemian Rhapsody", Artist: "Queen", Album: "A Night at the Opera"},
-				{Name: "Bohemian Rhapsody", Artist: "Queen", Album: "A Night at the Opera"},
-			}
-			// Library has matching track
-			libraryTrack := model.MediaFile{
-				ID: "br", Title: "Bohemian Rhapsody", Artist: "Queen", Album: "A Night at the Opera",
-			}
-
-			setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{libraryTrack})
-
-			songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			// Should return two tracks since input songs were identical
-			Expect(songs).To(HaveLen(2))
-			Expect(songs[0].ID).To(Equal("br"))
-			Expect(songs[1].ID).To(Equal("br"))
-		})
-
-		It("handles mixed scenario with both identical and different input songs", func() {
-			// Agent returns: Song A, Song B (different from A), Song A again (same as first)
-			// All three match to the same library track
-			returnedSongs := []agents.Song{
-				{Name: "Yesterday", Artist: "The Beatles", Album: "Help!"},
-				{Name: "Yesterday (Remastered)", Artist: "The Beatles", Album: "1"},        // Different version
-				{Name: "Yesterday", Artist: "The Beatles", Album: "Help!"},                 // Same as first
-				{Name: "Yesterday (Anthology)", Artist: "The Beatles", Album: "Anthology"}, // Another different version
-			}
-			// Library only has one version
-			libraryTrack := model.MediaFile{
-				ID: "yesterday", Title: "Yesterday", Artist: "The Beatles", Album: "Help!",
-			}
-
-			setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{libraryTrack})
-
-			songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			// Should return 2 tracks:
-			// 1. First "Yesterday" (original)
-			// 2. Third "Yesterday" (same as first, so kept)
-			// Skip: Second "Yesterday (Remastered)" (different input, same library track)
-			// Skip: Fourth "Yesterday (Anthology)" (different input, same library track)
-			Expect(songs).To(HaveLen(2))
-			Expect(songs[0].ID).To(Equal("yesterday"))
-			Expect(songs[1].ID).To(Equal("yesterday"))
-		})
-
-		It("does not deduplicate songs that match different library tracks", func() {
-			// Agent returns different songs that match different library tracks
-			returnedSongs := []agents.Song{
-				{Name: "Song A", Artist: "Artist"},
-				{Name: "Song B", Artist: "Artist"},
-				{Name: "Song C", Artist: "Artist"},
-			}
-			// Library has all three songs
-			trackA := model.MediaFile{ID: "track-a", Title: "Song A", Artist: "Artist"}
-			trackB := model.MediaFile{ID: "track-b", Title: "Song B", Artist: "Artist"}
-			trackC := model.MediaFile{ID: "track-c", Title: "Song C", Artist: "Artist"}
-
-			setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{trackA, trackB, trackC})
-
-			songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			// All three should be returned since they match different library tracks
-			Expect(songs).To(HaveLen(3))
-			Expect(songs[0].ID).To(Equal("track-a"))
-			Expect(songs[1].ID).To(Equal("track-b"))
-			Expect(songs[2].ID).To(Equal("track-c"))
-		})
-
-		It("respects count limit after deduplication", func() {
-			// Agent returns 4 songs: 2 unique + 2 that would create duplicates
-			returnedSongs := []agents.Song{
-				{Name: "Song A", Artist: "Artist"},
-				{Name: "Song A (Live)", Artist: "Artist"}, // Different, matches same track
-				{Name: "Song B", Artist: "Artist"},
-				{Name: "Song B (Remix)", Artist: "Artist"}, // Different, matches same track
-			}
-			trackA := model.MediaFile{ID: "track-a", Title: "Song A", Artist: "Artist"}
-			trackB := model.MediaFile{ID: "track-b", Title: "Song B", Artist: "Artist"}
-
-			setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{trackA, trackB})
-
-			// Request only 2 songs
-			songs, err := provider.SimilarSongs(ctx, "track-1", 2)
-
-			Expect(err).ToNot(HaveOccurred())
-			// Should return exactly 2: Song A and Song B (skipping duplicates)
-			Expect(songs).To(HaveLen(2))
-			Expect(songs[0].ID).To(Equal("track-a"))
-			Expect(songs[1].ID).To(Equal("track-b"))
-		})
-	})
-})

core/external/provider_similarsongs_test.go

@@ -1,443 +0,0 @@
-package external_test
-
-import (
-	"context"
-	"errors"
-
-	"github.com/Masterminds/squirrel"
-	"github.com/navidrome/navidrome/core/agents"
-	. "github.com/navidrome/navidrome/core/external"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-	"github.com/stretchr/testify/mock"
-)
-
-var _ = Describe("Provider - SimilarSongs", func() {
-	var ds model.DataStore
-	var provider Provider
-	var mockAgent *mockSimilarArtistAgent
-	var mockTopAgent agents.ArtistTopSongsRetriever
-	var mockSimilarAgent agents.ArtistSimilarRetriever
-	var agentsCombined *mockAgents
-	var artistRepo *mockArtistRepo
-	var mediaFileRepo *mockMediaFileRepo
-	var albumRepo *mockAlbumRepo
-	var ctx context.Context
-
-	BeforeEach(func() {
-		ctx = GinkgoT().Context()
-
-		artistRepo = newMockArtistRepo()
-		mediaFileRepo = newMockMediaFileRepo()
-		albumRepo = newMockAlbumRepo()
-
-		ds = &tests.MockDataStore{
-			MockedArtist:    artistRepo,
-			MockedMediaFile: mediaFileRepo,
-			MockedAlbum:     albumRepo,
-		}
-
-		mockAgent = &mockSimilarArtistAgent{}
-		mockTopAgent = mockAgent
-		mockSimilarAgent = mockAgent
-
-		agentsCombined = &mockAgents{
-			topSongsAgent: mockTopAgent,
-			similarAgent:  mockSimilarAgent,
-		}
-
-		provider = NewProvider(ds, agentsCombined)
-	})
-
-	Describe("dispatch by entity type", func() {
-		Context("when ID is a MediaFile (track)", func() {
-			It("calls GetSimilarSongsByTrack and returns matched songs", func() {
-				track := model.MediaFile{ID: "track-1", Title: "Just Can't Get Enough", Artist: "Depeche Mode", MbzRecordingID: "track-mbid"}
-				matchedSong := model.MediaFile{ID: "matched-1", Title: "Dreaming of Me", Artist: "Depeche Mode"}
-
-				// GetEntityByID tries Artist, Album, Playlist, then MediaFile
-				artistRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
-				albumRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
-				mediaFileRepo.On("Get", "track-1").Return(&track, nil).Once()
-
-				agentsCombined.On("GetSimilarSongsByTrack", mock.Anything, "track-1", "Just Can't Get Enough", "Depeche Mode", "track-mbid", 5).
-					Return([]agents.Song{
-						{Name: "Dreaming of Me", MBID: "", Artist: "Depeche Mode", ArtistMBID: "artist-mbid"},
-					}, nil).Once()
-
-				// Mock loadTracksByID - no ID matches
-				mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					_, ok := opt.Filters.(squirrel.Eq)
-					return ok
-				})).Return(model.MediaFiles{}, nil).Once()
-
-				// Mock loadTracksByMBID - no MBID matches (empty MBID means this won't be called)
-				mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					and, ok := opt.Filters.(squirrel.And)
-					if !ok || len(and) < 1 {
-						return false
-					}
-					eq, hasEq := and[0].(squirrel.Eq)
-					if !hasEq {
-						return false
-					}
-					_, hasMBID := eq["mbz_recording_id"]
-					return hasMBID
-				})).Return(model.MediaFiles{}, nil).Maybe()
-
-				// Mock loadTracksByTitleAndArtist - queries by artist name
-				mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					and, ok := opt.Filters.(squirrel.And)
-					if !ok || len(and) < 2 {
-						return false
-					}
-					eq, hasEq := and[0].(squirrel.Eq)
-					if !hasEq {
-						return false
-					}
-					_, hasArtist := eq["order_artist_name"]
-					return hasArtist
-				})).Return(model.MediaFiles{matchedSong}, nil).Maybe()
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("matched-1"))
-			})
-
-			It("falls back to artist-based algorithm when GetSimilarSongsByTrack returns empty", func() {
-				track := model.MediaFile{ID: "track-1", Title: "Track", Artist: "Artist", ArtistID: "artist-1"}
-				artist := model.Artist{ID: "artist-1", Name: "Artist"}
-				song := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-1"}
-
-				// GetEntityByID for the initial call tries Artist, Album, Playlist, then MediaFile
-				artistRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
-				albumRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
-				mediaFileRepo.On("Get", "track-1").Return(&track, nil).Once()
-
-				agentsCombined.On("GetSimilarSongsByTrack", mock.Anything, "track-1", "Track", "Artist", "", mock.Anything).
-					Return([]agents.Song{}, nil).Once()
-
-				// Fallback calls getArtist(id) which calls GetEntityByID again - this time it finds the mediafile
-				// and recursively calls getArtist(v.ArtistID)
-				artistRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
-				albumRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
-				mediaFileRepo.On("Get", "track-1").Return(&track, nil).Once()
-
-				// Then it recurses with the artist-1 ID
-				artistRepo.On("Get", "artist-1").Return(&artist, nil).Maybe()
-				artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					return opt.Max == 1 && opt.Filters != nil
-				})).Return(model.Artists{artist}, nil).Maybe()
-
-				mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist", "", 15).
-					Return([]agents.Artist{}, nil).Once()
-
-				artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					return opt.Max == 0 && opt.Filters != nil
-				})).Return(model.Artists{}, nil).Once()
-
-				mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist", "", mock.Anything).
-					Return([]agents.Song{{Name: "Song One", MBID: "mbid-1"}}, nil).Once()
-
-				mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song}, nil).Once()
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("song-1"))
-			})
-		})
-
-		Context("when ID is an Album", func() {
-			It("calls GetSimilarSongsByAlbum and returns matched songs", func() {
-				album := model.Album{ID: "album-1", Name: "Speak & Spell", AlbumArtist: "Depeche Mode", MbzAlbumID: "album-mbid"}
-				matchedSong := model.MediaFile{ID: "matched-1", Title: "New Life", Artist: "Depeche Mode", MbzRecordingID: "song-mbid"}
-
-				// GetEntityByID tries Artist, Album, Playlist, then MediaFile
-				artistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once()
-				albumRepo.On("Get", "album-1").Return(&album, nil).Once()
-
-				agentsCombined.On("GetSimilarSongsByAlbum", mock.Anything, "album-1", "Speak & Spell", "Depeche Mode", "album-mbid", 5).
-					Return([]agents.Song{
-						{Name: "New Life", MBID: "song-mbid", Artist: "Depeche Mode"},
-					}, nil).Once()
-
-				// Mock loadTracksByID - no ID matches
-				mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					_, ok := opt.Filters.(squirrel.Eq)
-					return ok
-				})).Return(model.MediaFiles{}, nil).Once()
-
-				// Mock loadTracksByMBID - MBID match
-				mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					and, ok := opt.Filters.(squirrel.And)
-					if !ok || len(and) < 1 {
-						return false
-					}
-					_, hasEq := and[0].(squirrel.Eq)
-					return hasEq
-				})).Return(model.MediaFiles{matchedSong}, nil).Once()
-
-				songs, err := provider.SimilarSongs(ctx, "album-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("matched-1"))
-			})
-
-			It("falls back when GetSimilarSongsByAlbum returns ErrNotFound", func() {
-				album := model.Album{ID: "album-1", Name: "Album", AlbumArtist: "Artist", AlbumArtistID: "artist-1"}
-				artist := model.Artist{ID: "artist-1", Name: "Artist"}
-				song := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-1"}
-
-				// GetEntityByID for the initial call tries Artist, Album, Playlist, then MediaFile
-				artistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once()
-				albumRepo.On("Get", "album-1").Return(&album, nil).Once()
-
-				agentsCombined.On("GetSimilarSongsByAlbum", mock.Anything, "album-1", "Album", "Artist", "", mock.Anything).
-					Return(nil, agents.ErrNotFound).Once()
-
-				// Fallback calls getArtist(id) which calls GetEntityByID again - this time it finds the album
-				// and recursively calls getArtist(v.AlbumArtistID)
-				artistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once()
-				albumRepo.On("Get", "album-1").Return(&album, nil).Once()
-
-				// Then it recurses with the artist-1 ID
-				artistRepo.On("Get", "artist-1").Return(&artist, nil).Maybe()
-				artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					return opt.Max == 1 && opt.Filters != nil
-				})).Return(model.Artists{artist}, nil).Maybe()
-
-				mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist", "", 15).
-					Return([]agents.Artist{}, nil).Once()
-
-				artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					return opt.Max == 0 && opt.Filters != nil
-				})).Return(model.Artists{}, nil).Once()
-
-				mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist", "", mock.Anything).
-					Return([]agents.Song{{Name: "Song One", MBID: "mbid-1"}}, nil).Once()
-
-				mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song}, nil).Once()
-
-				songs, err := provider.SimilarSongs(ctx, "album-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("song-1"))
-			})
-		})
-
-		Context("when ID is an Artist", func() {
-			It("calls GetSimilarSongsByArtist and returns matched songs", func() {
-				artist := model.Artist{ID: "artist-1", Name: "Depeche Mode", MbzArtistID: "artist-mbid"}
-				matchedSong := model.MediaFile{ID: "matched-1", Title: "Enjoy the Silence", Artist: "Depeche Mode", MbzRecordingID: "song-mbid"}
-
-				artistRepo.On("Get", "artist-1").Return(&artist, nil).Once()
-				agentsCombined.On("GetSimilarSongsByArtist", mock.Anything, "artist-1", "Depeche Mode", "artist-mbid", 5).
-					Return([]agents.Song{
-						{Name: "Enjoy the Silence", MBID: "song-mbid", Artist: "Depeche Mode"},
-					}, nil).Once()
-
-				// Mock loadTracksByID - no ID matches
-				mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					_, ok := opt.Filters.(squirrel.Eq)
-					return ok
-				})).Return(model.MediaFiles{}, nil).Once()
-
-				// Mock loadTracksByMBID - MBID match
-				mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					and, ok := opt.Filters.(squirrel.And)
-					if !ok || len(and) < 1 {
-						return false
-					}
-					_, hasEq := and[0].(squirrel.Eq)
-					return hasEq
-				})).Return(model.MediaFiles{matchedSong}, nil).Once()
-
-				songs, err := provider.SimilarSongs(ctx, "artist-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("matched-1"))
-			})
-		})
-	})
-
-	It("returns similar songs from main artist and similar artists", func() {
-		artist1 := model.Artist{ID: "artist-1", Name: "Artist One"}
-		similarArtist := model.Artist{ID: "artist-3", Name: "Similar Artist"}
-		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-1"}
-		song2 := model.MediaFile{ID: "song-2", Title: "Song Two", ArtistID: "artist-1", MbzRecordingID: "mbid-2"}
-		song3 := model.MediaFile{ID: "song-3", Title: "Song Three", ArtistID: "artist-3", MbzRecordingID: "mbid-3"}
-
-		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
-		artistRepo.On("Get", "artist-3").Return(&similarArtist, nil).Maybe()
-
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			return opt.Max == 1 && opt.Filters != nil
-		})).Return(model.Artists{artist1}, nil).Once()
-
-		// New similar songs by artist returns ErrNotFound to trigger fallback
-		agentsCombined.On("GetSimilarSongsByArtist", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
-			Return(nil, agents.ErrNotFound).Once()
-
-		similarAgentsResp := []agents.Artist{
-			{Name: "Similar Artist", MBID: "similar-mbid"},
-		}
-		mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist One", "", 15).
-			Return(similarAgentsResp, nil).Once()
-
-		// Mock the three-phase artist lookup: ID (skipped - no IDs), MBID, then Name
-		// MBID lookup returns empty (no match)
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			_, ok := opt.Filters.(squirrel.Eq)
-			return opt.Max == 0 && ok
-		})).Return(model.Artists{}, nil).Once()
-		// Name lookup returns the similar artist
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			_, ok := opt.Filters.(squirrel.Or)
-			return opt.Max == 0 && ok
-		})).Return(model.Artists{similarArtist}, nil).Once()
-
-		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
-			Return([]agents.Song{
-				{Name: "Song One", MBID: "mbid-1"},
-				{Name: "Song Two", MBID: "mbid-2"},
-			}, nil).Once()
-
-		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-3", "Similar Artist", "", mock.Anything).
-			Return([]agents.Song{
-				{Name: "Song Three", MBID: "mbid-3"},
-			}, nil).Once()
-
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1, song2}, nil).Once()
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song3}, nil).Once()
-
-		songs, err := provider.SimilarSongs(ctx, "artist-1", 3)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(songs).To(HaveLen(3))
-		for _, song := range songs {
-			Expect(song.ID).To(BeElementOf("song-1", "song-2", "song-3"))
-		}
-	})
-
-	It("returns ErrNotFound when artist is not found", func() {
-		artistRepo.On("Get", "artist-unknown-artist").Return(nil, model.ErrNotFound)
-		mediaFileRepo.On("Get", "artist-unknown-artist").Return(nil, model.ErrNotFound)
-		albumRepo.On("Get", "artist-unknown-artist").Return(nil, model.ErrNotFound)
-
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			return opt.Max == 1 && opt.Filters != nil
-		})).Return(model.Artists{}, nil).Maybe()
-
-		songs, err := provider.SimilarSongs(ctx, "artist-unknown-artist", 5)
-
-		Expect(err).To(Equal(model.ErrNotFound))
-		Expect(songs).To(BeNil())
-	})
-
-	It("returns songs from main artist when GetSimilarArtists returns error", func() {
-		artist1 := model.Artist{ID: "artist-1", Name: "Artist One"}
-		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-1"}
-
-		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			return opt.Max == 1 && opt.Filters != nil
-		})).Return(model.Artists{artist1}, nil).Maybe()
-
-		// New similar songs by artist returns ErrNotFound to trigger fallback
-		agentsCombined.On("GetSimilarSongsByArtist", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
-			Return(nil, agents.ErrNotFound).Once()
-
-		mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist One", "", 15).
-			Return(nil, errors.New("error getting similar artists")).Once()
-
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			return opt.Max == 0 && opt.Filters != nil
-		})).Return(model.Artists{}, nil).Once()
-
-		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
-			Return([]agents.Song{
-				{Name: "Song One", MBID: "mbid-1"},
-			}, nil).Once()
-
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1}, nil).Once()
-
-		songs, err := provider.SimilarSongs(ctx, "artist-1", 5)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(songs).To(HaveLen(1))
-		Expect(songs[0].ID).To(Equal("song-1"))
-	})
-
-	It("returns empty list when GetArtistTopSongs returns error", func() {
-		artist1 := model.Artist{ID: "artist-1", Name: "Artist One"}
-
-		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			return opt.Max == 1 && opt.Filters != nil
-		})).Return(model.Artists{artist1}, nil).Maybe()
-
-		// New similar songs by artist returns ErrNotFound to trigger fallback
-		agentsCombined.On("GetSimilarSongsByArtist", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
-			Return(nil, agents.ErrNotFound).Once()
-
-		mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist One", "", 15).
-			Return([]agents.Artist{}, nil).Once()
-
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			return opt.Max == 0 && opt.Filters != nil
-		})).Return(model.Artists{}, nil).Once()
-
-		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
-			Return(nil, errors.New("error getting top songs")).Once()
-
-		songs, err := provider.SimilarSongs(ctx, "artist-1", 5)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(songs).To(BeEmpty())
-	})
-
-	It("respects count parameter", func() {
-		artist1 := model.Artist{ID: "artist-1", Name: "Artist One"}
-		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-1"}
-		song2 := model.MediaFile{ID: "song-2", Title: "Song Two", ArtistID: "artist-1", MbzRecordingID: "mbid-2"}
-
-		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			return opt.Max == 1 && opt.Filters != nil
-		})).Return(model.Artists{artist1}, nil).Maybe()
-
-		// New similar songs by artist returns ErrNotFound to trigger fallback
-		agentsCombined.On("GetSimilarSongsByArtist", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
-			Return(nil, agents.ErrNotFound).Once()
-
-		mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist One", "", 15).
-			Return([]agents.Artist{}, nil).Once()
-
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			return opt.Max == 0 && opt.Filters != nil
-		})).Return(model.Artists{}, nil).Once()
-
-		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
-			Return([]agents.Song{
-				{Name: "Song One", MBID: "mbid-1"},
-				{Name: "Song Two", MBID: "mbid-2"},
-			}, nil).Once()
-
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1, song2}, nil).Once()
-
-		songs, err := provider.SimilarSongs(ctx, "artist-1", 1)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(songs).To(HaveLen(1))
-		Expect(songs[0].ID).To(BeElementOf("song-1", "song-2"))
-	})
-})

core/external/provider_topsongs_test.go

@@ -4,12 +4,10 @@ import (
 	"context"
 	"errors"
 
-	_ "github.com/navidrome/navidrome/adapters/lastfm"
-	_ "github.com/navidrome/navidrome/adapters/listenbrainz"
-	_ "github.com/navidrome/navidrome/adapters/spotify"
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/core/agents"
+	_ "github.com/navidrome/navidrome/core/agents/lastfm"
+	_ "github.com/navidrome/navidrome/core/agents/listenbrainz"
+	_ "github.com/navidrome/navidrome/core/agents/spotify"
 	. "github.com/navidrome/navidrome/core/external"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/tests"
@@ -28,10 +26,6 @@ var _ = Describe("Provider - TopSongs", func() {
 	)
 
 	BeforeEach(func() {
-		DeferCleanup(configtest.SetupConfig())
-		// Disable fuzzy matching for these tests to avoid unexpected GetAll calls
-		conf.Server.SimilarSongsMatchThreshold = 100
-
 		ctx = GinkgoT().Context()
 
 		artistRepo = newMockArtistRepo()       // Use helper mock
@@ -277,60 +271,4 @@ var _ = Describe("Provider - TopSongs", func() {
 		ag.AssertExpectations(GinkgoT())
 		mediaFileRepo.AssertExpectations(GinkgoT())
 	})
-
-	It("matches songs by ID first when agent provides IDs", func() {
-		// Mock finding the artist
-		artist1 := model.Artist{ID: "artist-1", Name: "Artist One", MbzArtistID: "mbid-artist-1"}
-		artistRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.Artists{artist1}, nil).Once()
-
-		// Mock agent response with IDs provided (highest priority matching)
-		// Note: Songs have no MBID to ensure only ID matching is used
-		agentSongs := []agents.Song{
-			{ID: "song-1", Name: "Song One"},
-			{ID: "song-2", Name: "Song Two"},
-		}
-		ag.On("GetArtistTopSongs", ctx, "artist-1", "Artist One", "mbid-artist-1", 2).Return(agentSongs, nil).Once()
-
-		// Mock ID lookup (first query - should match both songs directly)
-		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1"}
-		song2 := model.MediaFile{ID: "song-2", Title: "Song Two", ArtistID: "artist-1"}
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1, song2}, nil).Once()
-
-		songs, err := p.TopSongs(ctx, "Artist One", 2)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(songs).To(HaveLen(2))
-		Expect(songs[0].ID).To(Equal("song-1"))
-		Expect(songs[1].ID).To(Equal("song-2"))
-		artistRepo.AssertExpectations(GinkgoT())
-		ag.AssertExpectations(GinkgoT())
-		mediaFileRepo.AssertExpectations(GinkgoT())
-	})
-
-	It("falls back to MBID when ID is not found", func() {
-		// Mock finding the artist
-		artist1 := model.Artist{ID: "artist-1", Name: "Artist One", MbzArtistID: "mbid-artist-1"}
-		artistRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.Artists{artist1}, nil).Once()
-
-		// Mock agent response with ID that won't be found, but MBID that will
-		agentSongs := []agents.Song{
-			{ID: "non-existent-id", Name: "Song One", MBID: "mbid-song-1"},
-		}
-		ag.On("GetArtistTopSongs", ctx, "artist-1", "Artist One", "mbid-artist-1", 1).Return(agentSongs, nil).Once()
-
-		// Mock ID lookup - returns empty (ID not found)
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{}, nil).Once()
-		// Mock MBID lookup - finds the song
-		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-song-1"}
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1}, nil).Once()
-
-		songs, err := p.TopSongs(ctx, "Artist One", 1)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(songs).To(HaveLen(1))
-		Expect(songs[0].ID).To(Equal("song-1"))
-		artistRepo.AssertExpectations(GinkgoT())
-		ag.AssertExpectations(GinkgoT())
-		mediaFileRepo.AssertExpectations(GinkgoT())
-	})
 })

core/external/provider_updateartistinfo_test.go

@@ -226,88 +226,4 @@ var _ = Describe("Provider - UpdateArtistInfo", func() {
 		Expect(updatedArtist.ID).To(Equal("ar-agent-fail"))
 		ag.AssertExpectations(GinkgoT())
 	})
-
-	It("matches similar artists by ID first when agent provides IDs", func() {
-		originalArtist := &model.Artist{
-			ID:   "ar-id-match",
-			Name: "ID Match Artist",
-		}
-		similarByID := model.Artist{ID: "ar-similar-by-id", Name: "Similar By ID", MbzArtistID: "mbid-similar"}
-		mockArtistRepo.SetData(model.Artists{*originalArtist, similarByID})
-
-		// Agent returns similar artist with ID (highest priority matching)
-		rawSimilar := []agents.Artist{
-			{ID: "ar-similar-by-id", Name: "Different Name", MBID: "different-mbid"},
-		}
-
-		ag.On("GetArtistMBID", ctx, "ar-id-match", "ID Match Artist").Return("", nil).Once()
-		ag.On("GetArtistImages", ctx, "ar-id-match", "ID Match Artist", mock.Anything).Return(nil, nil).Maybe()
-		ag.On("GetArtistBiography", ctx, "ar-id-match", "ID Match Artist", mock.Anything).Return("", nil).Maybe()
-		ag.On("GetArtistURL", ctx, "ar-id-match", "ID Match Artist", mock.Anything).Return("", nil).Maybe()
-		ag.On("GetSimilarArtists", ctx, "ar-id-match", "ID Match Artist", mock.Anything, 100).Return(rawSimilar, nil).Once()
-
-		updatedArtist, err := p.UpdateArtistInfo(ctx, "ar-id-match", 10, false)
-
-		Expect(err).NotTo(HaveOccurred())
-		Expect(updatedArtist.SimilarArtists).To(HaveLen(1))
-		// Should match by ID, not by name or MBID
-		Expect(updatedArtist.SimilarArtists[0].ID).To(Equal("ar-similar-by-id"))
-		Expect(updatedArtist.SimilarArtists[0].Name).To(Equal("Similar By ID"))
-	})
-
-	It("matches similar artists by MBID when ID is empty", func() {
-		originalArtist := &model.Artist{
-			ID:   "ar-mbid-match",
-			Name: "MBID Match Artist",
-		}
-		similarByMBID := model.Artist{ID: "ar-similar-by-mbid", Name: "Similar By MBID", MbzArtistID: "mbid-similar"}
-		mockArtistRepo.SetData(model.Artists{*originalArtist, similarByMBID})
-
-		// Agent returns similar artist with only MBID (no ID)
-		rawSimilar := []agents.Artist{
-			{Name: "Different Name", MBID: "mbid-similar"},
-		}
-
-		ag.On("GetArtistMBID", ctx, "ar-mbid-match", "MBID Match Artist").Return("", nil).Once()
-		ag.On("GetArtistImages", ctx, "ar-mbid-match", "MBID Match Artist", mock.Anything).Return(nil, nil).Maybe()
-		ag.On("GetArtistBiography", ctx, "ar-mbid-match", "MBID Match Artist", mock.Anything).Return("", nil).Maybe()
-		ag.On("GetArtistURL", ctx, "ar-mbid-match", "MBID Match Artist", mock.Anything).Return("", nil).Maybe()
-		ag.On("GetSimilarArtists", ctx, "ar-mbid-match", "MBID Match Artist", mock.Anything, 100).Return(rawSimilar, nil).Once()
-
-		updatedArtist, err := p.UpdateArtistInfo(ctx, "ar-mbid-match", 10, false)
-
-		Expect(err).NotTo(HaveOccurred())
-		Expect(updatedArtist.SimilarArtists).To(HaveLen(1))
-		// Should match by MBID since ID was empty
-		Expect(updatedArtist.SimilarArtists[0].ID).To(Equal("ar-similar-by-mbid"))
-		Expect(updatedArtist.SimilarArtists[0].Name).To(Equal("Similar By MBID"))
-	})
-
-	It("falls back to name matching when ID and MBID don't match", func() {
-		originalArtist := &model.Artist{
-			ID:   "ar-name-match",
-			Name: "Name Match Artist",
-		}
-		similarByName := model.Artist{ID: "ar-similar-by-name", Name: "Similar By Name"}
-		mockArtistRepo.SetData(model.Artists{*originalArtist, similarByName})
-
-		// Agent returns similar artist with non-matching ID and MBID
-		rawSimilar := []agents.Artist{
-			{ID: "non-existent-id", Name: "Similar By Name", MBID: "non-existent-mbid"},
-		}
-
-		ag.On("GetArtistMBID", ctx, "ar-name-match", "Name Match Artist").Return("", nil).Once()
-		ag.On("GetArtistImages", ctx, "ar-name-match", "Name Match Artist", mock.Anything).Return(nil, nil).Maybe()
-		ag.On("GetArtistBiography", ctx, "ar-name-match", "Name Match Artist", mock.Anything).Return("", nil).Maybe()
-		ag.On("GetArtistURL", ctx, "ar-name-match", "Name Match Artist", mock.Anything).Return("", nil).Maybe()
-		ag.On("GetSimilarArtists", ctx, "ar-name-match", "Name Match Artist", mock.Anything, 100).Return(rawSimilar, nil).Once()
-
-		updatedArtist, err := p.UpdateArtistInfo(ctx, "ar-name-match", 10, false)
-
-		Expect(err).NotTo(HaveOccurred())
-		Expect(updatedArtist.SimilarArtists).To(HaveLen(1))
-		// Should fall back to name matching since ID and MBID didn't match
-		Expect(updatedArtist.SimilarArtists[0].ID).To(Equal("ar-similar-by-name"))
-		Expect(updatedArtist.SimilarArtists[0].Name).To(Equal("Similar By Name"))
-	})
 })

core/ffmpeg/ffmpeg.go

@@ -112,7 +112,7 @@ func (e *ffmpeg) start(ctx context.Context, args []string) (io.ReadCloser, error
 	log.Trace(ctx, "Executing ffmpeg command", "cmd", args)
 	j := &ffCmd{args: args}
 	j.PipeReader, j.out = io.Pipe()
-	err := j.start(ctx)
+	err := j.start()
 	if err != nil {
 		return nil, err
 	}
@@ -127,8 +127,8 @@ type ffCmd struct {
 	cmd  *exec.Cmd
 }
 
-func (j *ffCmd) start(ctx context.Context) error {
-	cmd := exec.CommandContext(ctx, j.args[0], j.args[1:]...) // #nosec
+func (j *ffCmd) start() error {
+	cmd := exec.Command(j.args[0], j.args[1:]...) // #nosec
 	cmd.Stdout = j.out
 	if log.IsGreaterOrEqualTo(log.LevelTrace) {
 		cmd.Stderr = os.Stderr

core/ffmpeg/ffmpeg_test.go

@@ -1,11 +1,7 @@
 package ffmpeg
 
 import (
-	"context"
-	"runtime"
-	sync "sync"
 	"testing"
-	"time"
 
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/tests"
@@ -69,98 +65,4 @@ var _ = Describe("ffmpeg", func() {
 			Expect(args).To(Equal([]string{"/usr/bin/with spaces/ffmpeg.exe", "-i", "one.mp3", "-f", "ffmetadata"}))
 		})
 	})
-
-	Describe("FFmpeg", func() {
-		Context("when FFmpeg is available", func() {
-			var ff FFmpeg
-
-			BeforeEach(func() {
-				ffOnce = sync.Once{}
-				ff = New()
-				// Skip if FFmpeg is not available
-				if !ff.IsAvailable() {
-					Skip("FFmpeg not available on this system")
-				}
-			})
-
-			It("should interrupt transcoding when context is cancelled", func() {
-				ctx, cancel := context.WithTimeout(GinkgoT().Context(), 5*time.Second)
-				defer cancel()
-
-				// Use a command that generates audio indefinitely
-				// -f lavfi uses FFmpeg's built-in audio source
-				// -t 0 means no time limit (runs forever)
-				command := "ffmpeg -f lavfi -i sine=frequency=1000:duration=0 -f mp3 -"
-
-				// The input file is not used here, but we need to provide a valid path to the Transcode function
-				stream, err := ff.Transcode(ctx, command, "tests/fixtures/test.mp3", 128, 0)
-				Expect(err).ToNot(HaveOccurred())
-				defer stream.Close()
-
-				// Read some data first to ensure FFmpeg is running
-				buf := make([]byte, 1024)
-				_, err = stream.Read(buf)
-				Expect(err).ToNot(HaveOccurred())
-
-				// Cancel the context
-				cancel()
-
-				// Next read should fail due to cancelled context
-				_, err = stream.Read(buf)
-				Expect(err).To(HaveOccurred())
-			})
-
-			It("should handle immediate context cancellation", func() {
-				ctx, cancel := context.WithCancel(GinkgoT().Context())
-				cancel() // Cancel immediately
-
-				// This should fail immediately
-				_, err := ff.Transcode(ctx, "ffmpeg -i %s -f mp3 -", "tests/fixtures/test.mp3", 128, 0)
-				Expect(err).To(MatchError(context.Canceled))
-			})
-		})
-
-		Context("with mock process behavior", func() {
-			var longRunningCmd string
-			BeforeEach(func() {
-				// Use a long-running command for testing cancellation
-				switch runtime.GOOS {
-				case "windows":
-					// Use PowerShell's Start-Sleep
-					ffmpegPath = "powershell"
-					longRunningCmd = "powershell -Command Start-Sleep -Seconds 10"
-				default:
-					// Use sleep on Unix-like systems
-					ffmpegPath = "sleep"
-					longRunningCmd = "sleep 10"
-				}
-			})
-
-			It("should terminate the underlying process when context is cancelled", func() {
-				ff := New()
-				ctx, cancel := context.WithTimeout(GinkgoT().Context(), 5*time.Second)
-				defer cancel()
-
-				// Start a process that will run for a while
-				stream, err := ff.Transcode(ctx, longRunningCmd, "tests/fixtures/test.mp3", 0, 0)
-				Expect(err).ToNot(HaveOccurred())
-				defer stream.Close()
-
-				// Give the process time to start
-				time.Sleep(50 * time.Millisecond)
-
-				// Cancel the context
-				cancel()
-
-				// Try to read from the stream, which should fail
-				buf := make([]byte, 100)
-				_, err = stream.Read(buf)
-				Expect(err).To(HaveOccurred(), "Expected stream to be closed due to process termination")
-
-				// Verify the stream is closed by attempting another read
-				_, err = stream.Read(buf)
-				Expect(err).To(HaveOccurred())
-			})
-		})
-	})
 })

core/library.go

@@ -37,21 +37,19 @@ type Library interface {
 }
 
 type libraryService struct {
-	ds            model.DataStore
-	scanner       model.Scanner
-	watcher       Watcher
-	broker        events.Broker
-	pluginManager PluginUnloader
+	ds      model.DataStore
+	scanner model.Scanner
+	watcher Watcher
+	broker  events.Broker
 }
 
 // NewLibrary creates a new Library service
-func NewLibrary(ds model.DataStore, scanner model.Scanner, watcher Watcher, broker events.Broker, pluginManager PluginUnloader) Library {
+func NewLibrary(ds model.DataStore, scanner model.Scanner, watcher Watcher, broker events.Broker) Library {
 	return &libraryService{
-		ds:            ds,
-		scanner:       scanner,
-		watcher:       watcher,
-		broker:        broker,
-		pluginManager: pluginManager,
+		ds:      ds,
+		scanner: scanner,
+		watcher: watcher,
+		broker:  broker,
 	}
 }
 
@@ -143,7 +141,6 @@ func (s *libraryService) NewRepository(ctx context.Context) rest.Repository {
 		scanner:           s.scanner,
 		watcher:           s.watcher,
 		broker:            s.broker,
-		pluginManager:     s.pluginManager,
 	}
 	return wrapper
 }
@@ -151,12 +148,11 @@ func (s *libraryService) NewRepository(ctx context.Context) rest.Repository {
 type libraryRepositoryWrapper struct {
 	rest.Repository
 	model.LibraryRepository
-	ctx           context.Context
-	ds            model.DataStore
-	scanner       model.Scanner
-	watcher       Watcher
-	broker        events.Broker
-	pluginManager PluginUnloader
+	ctx     context.Context
+	ds      model.DataStore
+	scanner model.Scanner
+	watcher Watcher
+	broker  events.Broker
 }
 
 func (r *libraryRepositoryWrapper) Save(entity interface{}) (string, error) {
@@ -276,10 +272,6 @@ func (r *libraryRepositoryWrapper) Delete(id string) error {
 		log.Debug(r.ctx, "Library deleted - sent refresh event", "libraryID", libID, "name", lib.Name)
 	}
 
-	// After successful deletion, check if any plugins were auto-disabled
-	// and need to be unloaded from memory
-	r.pluginManager.UnloadDisabledPlugins(r.ctx)
-
 	return nil
 }
 

core/library_test.go

@@ -9,7 +9,7 @@ import (
 	"sync"
 
 	"github.com/deluan/rest"
-	_ "github.com/navidrome/navidrome/adapters/gotaglib" // Register taglib extractor
+	_ "github.com/navidrome/navidrome/adapters/taglib" // Register taglib extractor
 	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/core"
 	_ "github.com/navidrome/navidrome/core/storage/local" // Register local storage
@@ -32,7 +32,6 @@ var _ = Describe("Library Service", func() {
 	var scanner *tests.MockScanner
 	var watcherManager *mockWatcherManager
 	var broker *mockEventBroker
-	var pluginManager *mockPluginUnloader
 
 	BeforeEach(func() {
 		DeferCleanup(configtest.SetupConfig())
@@ -51,9 +50,7 @@ var _ = Describe("Library Service", func() {
 		}
 		// Create a mock event broker
 		broker = &mockEventBroker{}
-		// Create a mock plugin unloader
-		pluginManager = &mockPluginUnloader{}
-		service = core.NewLibrary(ds, scanner, watcherManager, broker, pluginManager)
+		service = core.NewLibrary(ds, scanner, watcherManager, broker)
 		ctx = context.Background()
 
 		// Create a temporary directory for testing valid paths
@@ -872,45 +869,8 @@ var _ = Describe("Library Service", func() {
 			Expect(broker.Events).To(HaveLen(1))
 		})
 	})
-
-	Describe("Plugin Manager Integration", func() {
-		var repo rest.Persistable
-
-		BeforeEach(func() {
-			// Reset the call count for each test
-			pluginManager.unloadCalls = 0
-			r := service.NewRepository(ctx)
-			repo = r.(rest.Persistable)
-		})
-
-		It("calls UnloadDisabledPlugins after successful library deletion", func() {
-			libraryRepo.SetData(model.Libraries{
-				{ID: 2, Name: "Library to Delete", Path: tempDir},
-			})
-
-			err := repo.Delete("2")
-			Expect(err).NotTo(HaveOccurred())
-			Expect(pluginManager.unloadCalls).To(Equal(1))
-		})
-
-		It("does not call UnloadDisabledPlugins when library deletion fails", func() {
-			// Try to delete non-existent library
-			err := repo.Delete("999")
-			Expect(err).To(HaveOccurred())
-			Expect(pluginManager.unloadCalls).To(Equal(0))
-		})
-	})
 })
 
-// mockPluginUnloader is a simple mock for testing UnloadDisabledPlugins calls
-type mockPluginUnloader struct {
-	unloadCalls int
-}
-
-func (m *mockPluginUnloader) UnloadDisabledPlugins(ctx context.Context) {
-	m.unloadCalls++
-}
-
 // mockWatcherManager provides a simple mock implementation of core.Watcher for testing
 type mockWatcherManager struct {
 	StartedWatchers   []model.Library

core/media_streamer.go

@@ -204,20 +204,7 @@ func NewTranscodingCache() TranscodingCache {
 				log.Error(ctx, "Error loading transcoding command", "format", job.format, err)
 				return nil, os.ErrInvalid
 			}
-
-			// Choose the appropriate context based on EnableTranscodingCancellation configuration.
-			// This is where we decide whether transcoding processes should be cancellable or not.
-			var transcodingCtx context.Context
-			if conf.Server.EnableTranscodingCancellation {
-				// Use the request context directly, allowing cancellation when client disconnects
-				transcodingCtx = ctx
-			} else {
-				// Use background context with request values preserved.
-				// This prevents cancellation but maintains request metadata (user, client, etc.)
-				transcodingCtx = request.AddValues(context.Background(), ctx)
-			}
-
-			out, err := job.ms.transcoder.Transcode(transcodingCtx, t.Command, job.filePath, job.bitRate, job.offset)
+			out, err := job.ms.transcoder.Transcode(ctx, t.Command, job.filePath, job.bitRate, job.offset)
 			if err != nil {
 				log.Error(ctx, "Error starting transcoder", "id", job.mf.ID, err)
 				return nil, os.ErrInvalid

core/metrics/insights.go

@@ -23,8 +23,7 @@ import (
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/model/request"
-	"github.com/navidrome/navidrome/plugins"
-	"github.com/navidrome/navidrome/server/events"
+	"github.com/navidrome/navidrome/plugins/schema"
 	"github.com/navidrome/navidrome/utils/singleton"
 )
 
@@ -38,12 +37,18 @@ var (
 )
 
 type insightsCollector struct {
-	ds         model.DataStore
-	lastRun    atomic.Int64
-	lastStatus atomic.Bool
+	ds           model.DataStore
+	pluginLoader PluginLoader
+	lastRun      atomic.Int64
+	lastStatus   atomic.Bool
 }
 
-func GetInstance(ds model.DataStore) Insights {
+// PluginLoader defines an interface for loading plugins
+type PluginLoader interface {
+	PluginList() map[string]schema.PluginManifest
+}
+
+func GetInstance(ds model.DataStore, pluginLoader PluginLoader) Insights {
 	return singleton.GetInstance(func() *insightsCollector {
 		id, err := ds.Property(context.TODO()).Get(consts.InsightsIDKey)
 		if err != nil {
@@ -55,7 +60,7 @@ func GetInstance(ds model.DataStore) Insights {
 			}
 		}
 		insightsID = id
-		return &insightsCollector{ds: ds}
+		return &insightsCollector{ds: ds, pluginLoader: pluginLoader}
 	})
 }
 
@@ -215,11 +220,10 @@ var staticData = sync.OnceValue(func() insights.Data {
 	data.Config.BackupCount = conf.Server.Backup.Count
 	data.Config.DevActivityPanel = conf.Server.DevActivityPanel
 	data.Config.ScannerEnabled = conf.Server.Scanner.Enabled
-	data.Config.ScannerExtractor = conf.Server.Scanner.Extractor
 	data.Config.ScanSchedule = conf.Server.Scanner.Schedule
 	data.Config.ScanWatcherWait = uint64(math.Trunc(conf.Server.Scanner.WatcherWait.Seconds()))
 	data.Config.ScanOnStartup = conf.Server.Scanner.ScanOnStartup
-	data.Config.ReverseProxyConfigured = conf.Server.ExtAuth.TrustedSources != ""
+	data.Config.ReverseProxyConfigured = conf.Server.ReverseProxyWhitelist != ""
 	data.Config.HasCustomPID = conf.Server.PID.Track != "" || conf.Server.PID.Album != ""
 	data.Config.HasCustomTags = len(conf.Server.Tags) > 0
 
@@ -266,10 +270,6 @@ func (c *insightsCollector) collect(ctx context.Context) []byte {
 	if err != nil {
 		log.Trace(ctx, "Error reading active users count", err)
 	}
-	data.Library.FileSuffixes, err = c.ds.MediaFile(ctx).CountBySuffix()
-	if err != nil {
-		log.Trace(ctx, "Error reading file suffixes count", err)
-	}
 
 	// Check for smart playlists
 	data.Config.HasSmartPlaylists, err = c.hasSmartPlaylists(ctx)
@@ -319,16 +319,12 @@ func (c *insightsCollector) hasSmartPlaylists(ctx context.Context) (bool, error)
 
 // collectPlugins collects information about installed plugins
 func (c *insightsCollector) collectPlugins(_ context.Context) map[string]insights.PluginInfo {
-	// TODO Fix import/inject cycles
-	manager := plugins.GetManager(c.ds, events.GetBroker(), nil)
-	info := manager.GetPluginInfo()
-
-	result := make(map[string]insights.PluginInfo, len(info))
-	for name, p := range info {
-		result[name] = insights.PluginInfo{
-			Name:    p.Name,
-			Version: p.Version,
+	plugins := make(map[string]insights.PluginInfo)
+	for id, manifest := range c.pluginLoader.PluginList() {
+		plugins[id] = insights.PluginInfo{
+			Name:    manifest.Name,
+			Version: manifest.Version,
 		}
 	}
-	return result
+	return plugins
 }

core/metrics/insights/data.go

@@ -40,14 +40,12 @@ type Data struct {
 		Libraries     int64            `json:"libraries"`
 		ActiveUsers   int64            `json:"activeUsers"`
 		ActivePlayers map[string]int64 `json:"activePlayers,omitempty"`
-		FileSuffixes  map[string]int64 `json:"fileSuffixes,omitempty"`
 	} `json:"library"`
 	Config struct {
 		LogLevel                string `json:"logLevel,omitempty"`
 		LogFileConfigured       bool   `json:"logFileConfigured,omitempty"`
 		TLSConfigured           bool   `json:"tlsConfigured,omitempty"`
 		ScannerEnabled          bool   `json:"scannerEnabled,omitempty"`
-		ScannerExtractor        string `json:"scannerExtractor,omitempty"`
 		ScanSchedule            string `json:"scanSchedule,omitempty"`
 		ScanWatcherWait         uint64 `json:"scanWatcherWait,omitempty"`
 		ScanOnStartup           bool   `json:"scanOnStartup,omitempty"`

core/metrics/insights_linux.go

@@ -42,7 +42,6 @@ type MountInfo struct {
 
 var fsTypeMap = map[int64]string{
 	0x5346414f: "afs",
-	0x187:      "autofs",
 	0x61756673: "aufs",
 	0x9123683E: "btrfs",
 	0xc36400:   "ceph",
@@ -56,11 +55,9 @@ var fsTypeMap = map[int64]string{
 	0x6a656a63: "fakeowner", // FS inside a container
 	0x65735546: "fuse",
 	0x4244:     "hfs",
-	0x482b:     "hfs+",
 	0x9660:     "iso9660",
 	0x3153464a: "jfs",
 	0x00006969: "nfs",
-	0x5346544e: "ntfs", // NTFS_SB_MAGIC
 	0x7366746e: "ntfs",
 	0x794c7630: "overlayfs",
 	0x9fa0:     "proc",
@@ -72,16 +69,8 @@ var fsTypeMap = map[int64]string{
 	0x01021997: "v9fs",
 	0x786f4256: "vboxsf",
 	0x4d44:     "vfat",
-	0xca451a4e: "virtiofs",
 	0x58465342: "xfs",
 	0x2FC12FC1: "zfs",
-	0x7c7c6673: "prlfs", // Parallels Shared Folders
-
-	// Signed/unsigned conversion issues (negative hex values converted to uint32)
-	-0x6edc97c2: "btrfs", // 0x9123683e
-	-0x1acb2be:  "smb2",  // 0xfe534d42
-	-0xacb2be:   "cifs",  // 0xff534d42
-	-0xd0adff0:  "f2fs",  // 0xf2f52010
 }
 
 func getFilesystemType(path string) (string, error) {

core/mock_library_service.go

@@ -1,28 +1,27 @@
-package tests
+package core
 
 import (
 	"context"
 
 	"github.com/deluan/rest"
 	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
 )
 
-// MockLibraryService provides a simple wrapper around MockLibraryRepo
-// that implements the core.Library interface for testing.
-// Returns concrete type to avoid import cycles - callers assign to core.Library.
-type MockLibraryService struct {
-	*MockLibraryRepo
+// MockLibraryWrapper provides a simple wrapper around MockLibraryRepo
+// that implements the core.Library interface for testing
+type MockLibraryWrapper struct {
+	*tests.MockLibraryRepo
 }
 
 // MockLibraryRestAdapter adapts MockLibraryRepo to rest.Repository interface
 type MockLibraryRestAdapter struct {
-	*MockLibraryRepo
+	*tests.MockLibraryRepo
 }
 
-// NewMockLibraryService creates a new mock library service for testing.
-// Returns concrete type - assign to core.Library at call site.
-func NewMockLibraryService() *MockLibraryService {
-	repo := &MockLibraryRepo{
+// NewMockLibraryService creates a new mock library service for testing
+func NewMockLibraryService() Library {
+	repo := &tests.MockLibraryRepo{
 		Data: make(map[int]model.Library),
 	}
 	// Set up default test data
@@ -30,10 +29,10 @@ func NewMockLibraryService() *MockLibraryService {
 		{ID: 1, Name: "Test Library 1", Path: "/music/library1"},
 		{ID: 2, Name: "Test Library 2", Path: "/music/library2"},
 	})
-	return &MockLibraryService{MockLibraryRepo: repo}
+	return &MockLibraryWrapper{MockLibraryRepo: repo}
 }
 
-func (m *MockLibraryService) NewRepository(ctx context.Context) rest.Repository {
+func (m *MockLibraryWrapper) NewRepository(ctx context.Context) rest.Repository {
 	return &MockLibraryRestAdapter{MockLibraryRepo: m.MockLibraryRepo}
 }
 
@@ -42,3 +41,6 @@ func (m *MockLibraryService) NewRepository(ctx context.Context) rest.Repository
 func (a *MockLibraryRestAdapter) Delete(id string) error {
 	return a.DeleteByStringID(id)
 }
+
+var _ Library = (*MockLibraryWrapper)(nil)
+var _ rest.Repository = (*MockLibraryRestAdapter)(nil)

core/playlists.go

@@ -1,7 +1,6 @@
 package core
 
 import (
-	"cmp"
 	"context"
 	"encoding/json"
 	"errors"
@@ -10,7 +9,7 @@ import (
 	"net/url"
 	"os"
 	"path/filepath"
-	"slices"
+	"regexp"
 	"strings"
 	"time"
 
@@ -168,20 +167,13 @@ func (s *playlists) parseNSP(_ context.Context, pls *model.Playlist, reader io.R
 	if nsp.Comment != "" {
 		pls.Comment = nsp.Comment
 	}
-	if nsp.Public != nil {
-		pls.Public = *nsp.Public
-	} else {
-		pls.Public = conf.Server.DefaultPlaylistPublicVisibility
-	}
 	return nil
 }
 
 func (s *playlists) parseM3U(ctx context.Context, pls *model.Playlist, folder *model.Folder, reader io.Reader) error {
 	mediaFileRepository := s.ds.MediaFile(ctx)
 	var mfs model.MediaFiles
-	// Chunk size of 100 lines, as each line can generate up to 4 lookup candidates
-	// (NFC/NFD × raw/lowercase), and SQLite has a max expression tree depth of 1000.
-	for lines := range slice.CollectChunks(slice.LinesFrom(reader), 100) {
+	for lines := range slice.CollectChunks(slice.LinesFrom(reader), 400) {
 		filteredLines := make([]string, 0, len(lines))
 		for _, line := range lines {
 			line := strings.TrimSpace(line)
@@ -202,72 +194,26 @@ func (s *playlists) parseM3U(ctx context.Context, pls *model.Playlist, folder *m
 			}
 			filteredLines = append(filteredLines, line)
 		}
-		resolvedPaths, err := s.resolvePaths(ctx, folder, filteredLines)
+		paths, err := s.normalizePaths(ctx, pls, folder, filteredLines)
 		if err != nil {
-			log.Warn(ctx, "Error resolving paths in playlist", "playlist", pls.Name, err)
+			log.Warn(ctx, "Error normalizing paths in playlist", "playlist", pls.Name, err)
 			continue
 		}
-
-		// SQLite comparisons do not perform Unicode normalization, and filesystem normalization
-		// differs across platforms (macOS often yields NFD, while Linux/Windows typically use NFC).
-		// Generate lookup candidates for both forms so playlist entries match DB paths regardless
-		// of the original normalization. See https://github.com/navidrome/navidrome/issues/4884
-		//
-		// We also include the original (non-lowercased) paths because SQLite's COLLATE NOCASE
-		// only handles ASCII case-insensitivity. Non-ASCII characters like fullwidth letters
-		// (e.g., ＡＢＣＤ vs ａｂｃｄ) are not matched case-insensitively by NOCASE.
-		lookupCandidates := make([]string, 0, len(resolvedPaths)*4)
-		seen := make(map[string]struct{}, len(resolvedPaths)*4)
-		for _, path := range resolvedPaths {
-			// Add original paths first (for exact matching of non-ASCII characters)
-			nfcRaw := norm.NFC.String(path)
-			if _, ok := seen[nfcRaw]; !ok {
-				seen[nfcRaw] = struct{}{}
-				lookupCandidates = append(lookupCandidates, nfcRaw)
-			}
-			nfdRaw := norm.NFD.String(path)
-			if _, ok := seen[nfdRaw]; !ok {
-				seen[nfdRaw] = struct{}{}
-				lookupCandidates = append(lookupCandidates, nfdRaw)
-			}
-
-			// Add lowercased paths (for ASCII case-insensitive matching via NOCASE)
-			nfc := strings.ToLower(nfcRaw)
-			if _, ok := seen[nfc]; !ok {
-				seen[nfc] = struct{}{}
-				lookupCandidates = append(lookupCandidates, nfc)
-			}
-			nfd := strings.ToLower(nfdRaw)
-			if _, ok := seen[nfd]; !ok {
-				seen[nfd] = struct{}{}
-				lookupCandidates = append(lookupCandidates, nfd)
-			}
-		}
-
-		found, err := mediaFileRepository.FindByPaths(lookupCandidates)
+		found, err := mediaFileRepository.FindByPaths(paths)
 		if err != nil {
 			log.Warn(ctx, "Error reading files from DB", "playlist", pls.Name, err)
 			continue
 		}
-
-		// Build lookup map with library-qualified keys, normalized for comparison.
-		// Canonicalize to NFC so NFD/NFC become comparable.
 		existing := make(map[string]int, len(found))
 		for idx := range found {
-			key := fmt.Sprintf("%d:%s", found[idx].LibraryID, strings.ToLower(norm.NFC.String(found[idx].Path)))
-			existing[key] = idx
+			existing[normalizePathForComparison(found[idx].Path)] = idx
 		}
-
-		// Find media files in the order of the resolved paths, to keep playlist order
-		for _, path := range resolvedPaths {
-			key := strings.ToLower(norm.NFC.String(path))
-			idx, ok := existing[key]
+		for _, path := range paths {
+			idx, ok := existing[normalizePathForComparison(path)]
 			if ok {
 				mfs = append(mfs, found[idx])
 			} else {
-				// Prefer logging a composed representation when possible to avoid confusing output
-				// with decomposed combining marks.
-				log.Warn(ctx, "Path in playlist not found", "playlist", pls.Name, "path", norm.NFC.String(path))
+				log.Warn(ctx, "Path in playlist not found", "playlist", pls.Name, "path", path)
 			}
 		}
 	}
@@ -280,169 +226,75 @@ func (s *playlists) parseM3U(ctx context.Context, pls *model.Playlist, folder *m
 	return nil
 }
 
-// pathResolution holds the result of resolving a playlist path to a library-relative path.
-type pathResolution struct {
-	absolutePath string
-	libraryPath  string
-	libraryID    int
-	valid        bool
+// normalizePathForComparison normalizes a file path to NFC form and converts to lowercase
+// for consistent comparison. This fixes Unicode normalization issues on macOS where
+// Apple Music creates playlists with NFC-encoded paths but the filesystem uses NFD.
+func normalizePathForComparison(path string) string {
+	return strings.ToLower(norm.NFC.String(path))
 }
 
-// ToQualifiedString converts the path resolution to a library-qualified string with forward slashes.
-// Format: "libraryID:relativePath" with forward slashes for path separators.
-func (r pathResolution) ToQualifiedString() (string, error) {
-	if !r.valid {
-		return "", fmt.Errorf("invalid path resolution")
-	}
-	relativePath, err := filepath.Rel(r.libraryPath, r.absolutePath)
+// TODO This won't work for multiple libraries
+func (s *playlists) normalizePaths(ctx context.Context, pls *model.Playlist, folder *model.Folder, lines []string) ([]string, error) {
+	libRegex, err := s.compileLibraryPaths(ctx)
 	if err != nil {
-		return "", err
+		return nil, err
 	}
-	// Convert path separators to forward slashes
-	return fmt.Sprintf("%d:%s", r.libraryID, filepath.ToSlash(relativePath)), nil
-}
 
-// libraryMatcher holds sorted libraries with cleaned paths for efficient path matching.
-type libraryMatcher struct {
-	libraries    model.Libraries
-	cleanedPaths []string
-}
+	res := make([]string, 0, len(lines))
+	for idx, line := range lines {
+		var libPath string
+		var filePath string
 
-// findLibraryForPath finds which library contains the given absolute path.
-// Returns library ID and path, or 0 and empty string if not found.
-func (lm *libraryMatcher) findLibraryForPath(absolutePath string) (int, string) {
-	// Check sorted libraries (longest path first) to find the best match
-	for i, cleanLibPath := range lm.cleanedPaths {
-		// Check if absolutePath is under this library path
-		if strings.HasPrefix(absolutePath, cleanLibPath) {
-			// Ensure it's a proper path boundary (not just a prefix)
-			if len(absolutePath) == len(cleanLibPath) || absolutePath[len(cleanLibPath)] == filepath.Separator {
-				return lm.libraries[i].ID, cleanLibPath
+		if folder != nil && !filepath.IsAbs(line) {
+			libPath = folder.LibraryPath
+			filePath = filepath.Join(folder.AbsolutePath(), line)
+		} else {
+			cleanLine := filepath.Clean(line)
+			if libPath = libRegex.FindString(cleanLine); libPath != "" {
+				filePath = cleanLine
 			}
 		}
-	}
-	return 0, ""
-}
 
-// newLibraryMatcher creates a libraryMatcher with libraries sorted by path length (longest first).
-// This ensures correct matching when library paths are prefixes of each other.
-// Example: /music-classical must be checked before /music
-// Otherwise, /music-classical/track.mp3 would match /music instead of /music-classical
-func newLibraryMatcher(libs model.Libraries) *libraryMatcher {
-	// Sort libraries by path length (descending) to ensure longest paths match first.
-	slices.SortFunc(libs, func(i, j model.Library) int {
-		return cmp.Compare(len(j.Path), len(i.Path)) // Reverse order for descending
-	})
-
-	// Pre-clean all library paths once for efficient matching
-	cleanedPaths := make([]string, len(libs))
-	for i, lib := range libs {
-		cleanedPaths[i] = filepath.Clean(lib.Path)
-	}
-	return &libraryMatcher{
-		libraries:    libs,
-		cleanedPaths: cleanedPaths,
-	}
-}
-
-// pathResolver handles path resolution logic for playlist imports.
-type pathResolver struct {
-	matcher *libraryMatcher
-}
-
-// newPathResolver creates a pathResolver with libraries loaded from the datastore.
-func newPathResolver(ctx context.Context, ds model.DataStore) (*pathResolver, error) {
-	libs, err := ds.Library(ctx).GetAll()
-	if err != nil {
-		return nil, err
-	}
-	matcher := newLibraryMatcher(libs)
-	return &pathResolver{matcher: matcher}, nil
-}
-
-// resolvePath determines the absolute path and library path for a playlist entry.
-// For absolute paths, it uses them directly.
-// For relative paths, it resolves them relative to the playlist's folder location.
-// Example: playlist at /music/playlists/test.m3u with line "../songs/abc.mp3"
-//
-//	resolves to /music/songs/abc.mp3
-func (r *pathResolver) resolvePath(line string, folder *model.Folder) pathResolution {
-	var absolutePath string
-	if folder != nil && !filepath.IsAbs(line) {
-		// Resolve relative path to absolute path based on playlist location
-		absolutePath = filepath.Clean(filepath.Join(folder.AbsolutePath(), line))
-	} else {
-		// Use absolute path directly after cleaning
-		absolutePath = filepath.Clean(line)
-	}
-
-	return r.findInLibraries(absolutePath)
-}
-
-// findInLibraries matches an absolute path against all known libraries and returns
-// a pathResolution with the library information. Returns an invalid resolution if
-// the path is not found in any library.
-func (r *pathResolver) findInLibraries(absolutePath string) pathResolution {
-	libID, libPath := r.matcher.findLibraryForPath(absolutePath)
-	if libID == 0 {
-		return pathResolution{valid: false}
-	}
-	return pathResolution{
-		absolutePath: absolutePath,
-		libraryPath:  libPath,
-		libraryID:    libID,
-		valid:        true,
-	}
-}
-
-// resolvePaths converts playlist file paths to library-qualified paths (format: "libraryID:relativePath").
-// For relative paths, it resolves them to absolute paths first, then determines which
-// library they belong to. This allows playlists to reference files across library boundaries.
-func (s *playlists) resolvePaths(ctx context.Context, folder *model.Folder, lines []string) ([]string, error) {
-	resolver, err := newPathResolver(ctx, s.ds)
-	if err != nil {
-		return nil, err
-	}
-
-	results := make([]string, 0, len(lines))
-	for idx, line := range lines {
-		resolution := resolver.resolvePath(line, folder)
-
-		if !resolution.valid {
+		if libPath != "" {
+			if rel, err := filepath.Rel(libPath, filePath); err == nil {
+				res = append(res, rel)
+			} else {
+				log.Debug(ctx, "Error getting relative path", "playlist", pls.Name, "path", line, "libPath", libPath,
+					"filePath", filePath, err)
+			}
+		} else {
 			log.Warn(ctx, "Path in playlist not found in any library", "path", line, "line", idx)
-			continue
 		}
+	}
+	return slice.Map(res, filepath.ToSlash), nil
+}
 
-		qualifiedPath, err := resolution.ToQualifiedString()
-		if err != nil {
-			log.Debug(ctx, "Error getting library-qualified path", "path", line,
-				"libPath", resolution.libraryPath, "filePath", resolution.absolutePath, err)
-			continue
-		}
-
-		results = append(results, qualifiedPath)
+func (s *playlists) compileLibraryPaths(ctx context.Context) (*regexp.Regexp, error) {
+	libs, err := s.ds.Library(ctx).GetAll()
+	if err != nil {
+		return nil, err
 	}
 
-	return results, nil
+	// Create regex patterns for each library path
+	patterns := make([]string, len(libs))
+	for i, lib := range libs {
+		cleanPath := filepath.Clean(lib.Path)
+		escapedPath := regexp.QuoteMeta(cleanPath)
+		patterns[i] = fmt.Sprintf("^%s(?:/|$)", escapedPath)
+	}
+	// Combine all patterns into a single regex
+	combinedPattern := strings.Join(patterns, "|")
+	re, err := regexp.Compile(combinedPattern)
+	if err != nil {
+		return nil, fmt.Errorf("compiling library paths `%s`: %w", combinedPattern, err)
+	}
+	return re, nil
 }
 
 func (s *playlists) updatePlaylist(ctx context.Context, newPls *model.Playlist) error {
 	owner, _ := request.UserFrom(ctx)
 
-	// Try to find existing playlist by path. Since filesystem normalization differs across
-	// platforms (macOS uses NFD, Linux/Windows use NFC), we try both forms to match
-	// playlists that may have been imported on a different platform.
 	pls, err := s.ds.Playlist(ctx).FindByPath(newPls.Path)
-	if errors.Is(err, model.ErrNotFound) {
-		// Try alternate normalization form
-		altPath := norm.NFD.String(newPls.Path)
-		if altPath == newPls.Path {
-			altPath = norm.NFC.String(newPls.Path)
-		}
-		if altPath != newPls.Path {
-			pls, err = s.ds.Playlist(ctx).FindByPath(altPath)
-		}
-	}
 	if err != nil && !errors.Is(err, model.ErrNotFound) {
 		return err
 	}
@@ -462,10 +314,7 @@ func (s *playlists) updatePlaylist(ctx context.Context, newPls *model.Playlist)
 	} else {
 		log.Info(ctx, "Adding synced playlist", "playlist", newPls.Name, "path", newPls.Path, "owner", owner.UserName)
 		newPls.OwnerID = owner.ID
-		// For NSP files, Public may already be set from the file; for M3U, use server default
-		if !newPls.IsSmartPlaylist() {
-			newPls.Public = conf.Server.DefaultPlaylistPublicVisibility
-		}
+		newPls.Public = conf.Server.DefaultPlaylistPublicVisibility
 	}
 	return s.ds.Playlist(ctx).Put(newPls)
 }
@@ -529,7 +378,6 @@ type nspFile struct {
 	criteria.Criteria
 	Name    string `json:"name"`
 	Comment string `json:"comment"`
-	Public  *bool  `json:"public"`
 }
 
 func (i *nspFile) UnmarshalJSON(data []byte) error {
@@ -540,8 +388,5 @@ func (i *nspFile) UnmarshalJSON(data []byte) error {
 	}
 	i.Name, _ = m["name"].(string)
 	i.Comment, _ = m["comment"].(string)
-	if public, ok := m["public"].(bool); ok {
-		i.Public = &public
-	}
 	return json.Unmarshal(data, &i.Criteria)
 }

core/playlists_internal_test.go

@@ -1,406 +0,0 @@
-package core
-
-import (
-	"context"
-
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("libraryMatcher", func() {
-	var ds *tests.MockDataStore
-	var mockLibRepo *tests.MockLibraryRepo
-	ctx := context.Background()
-
-	BeforeEach(func() {
-		mockLibRepo = &tests.MockLibraryRepo{}
-		ds = &tests.MockDataStore{
-			MockedLibrary: mockLibRepo,
-		}
-	})
-
-	// Helper function to create a libraryMatcher from the mock datastore
-	createMatcher := func(ds model.DataStore) *libraryMatcher {
-		libs, err := ds.Library(ctx).GetAll()
-		Expect(err).ToNot(HaveOccurred())
-		return newLibraryMatcher(libs)
-	}
-
-	Describe("Longest library path matching", func() {
-		It("matches the longest library path when multiple libraries share a prefix", func() {
-			// Setup libraries with prefix conflicts
-			mockLibRepo.SetData([]model.Library{
-				{ID: 1, Path: "/music"},
-				{ID: 2, Path: "/music-classical"},
-				{ID: 3, Path: "/music-classical/opera"},
-			})
-
-			matcher := createMatcher(ds)
-
-			// Test that longest path matches first and returns correct library ID
-			testCases := []struct {
-				path            string
-				expectedLibID   int
-				expectedLibPath string
-			}{
-				{"/music-classical/opera/track.mp3", 3, "/music-classical/opera"},
-				{"/music-classical/track.mp3", 2, "/music-classical"},
-				{"/music/track.mp3", 1, "/music"},
-				{"/music-classical/opera/subdir/file.mp3", 3, "/music-classical/opera"},
-			}
-
-			for _, tc := range testCases {
-				libID, libPath := matcher.findLibraryForPath(tc.path)
-				Expect(libID).To(Equal(tc.expectedLibID), "Path %s should match library ID %d, but got %d", tc.path, tc.expectedLibID, libID)
-				Expect(libPath).To(Equal(tc.expectedLibPath), "Path %s should match library path %s, but got %s", tc.path, tc.expectedLibPath, libPath)
-			}
-		})
-
-		It("handles libraries with similar prefixes but different structures", func() {
-			mockLibRepo.SetData([]model.Library{
-				{ID: 1, Path: "/home/user/music"},
-				{ID: 2, Path: "/home/user/music-backup"},
-			})
-
-			matcher := createMatcher(ds)
-
-			// Test that music-backup library is matched correctly
-			libID, libPath := matcher.findLibraryForPath("/home/user/music-backup/track.mp3")
-			Expect(libID).To(Equal(2))
-			Expect(libPath).To(Equal("/home/user/music-backup"))
-
-			// Test that music library is still matched correctly
-			libID, libPath = matcher.findLibraryForPath("/home/user/music/track.mp3")
-			Expect(libID).To(Equal(1))
-			Expect(libPath).To(Equal("/home/user/music"))
-		})
-
-		It("matches path that is exactly the library root", func() {
-			mockLibRepo.SetData([]model.Library{
-				{ID: 1, Path: "/music"},
-				{ID: 2, Path: "/music-classical"},
-			})
-
-			matcher := createMatcher(ds)
-
-			// Exact library path should match
-			libID, libPath := matcher.findLibraryForPath("/music-classical")
-			Expect(libID).To(Equal(2))
-			Expect(libPath).To(Equal("/music-classical"))
-		})
-
-		It("handles complex nested library structures", func() {
-			mockLibRepo.SetData([]model.Library{
-				{ID: 1, Path: "/media"},
-				{ID: 2, Path: "/media/audio"},
-				{ID: 3, Path: "/media/audio/classical"},
-				{ID: 4, Path: "/media/audio/classical/baroque"},
-			})
-
-			matcher := createMatcher(ds)
-
-			testCases := []struct {
-				path            string
-				expectedLibID   int
-				expectedLibPath string
-			}{
-				{"/media/audio/classical/baroque/bach/track.mp3", 4, "/media/audio/classical/baroque"},
-				{"/media/audio/classical/mozart/track.mp3", 3, "/media/audio/classical"},
-				{"/media/audio/rock/track.mp3", 2, "/media/audio"},
-				{"/media/video/movie.mp4", 1, "/media"},
-			}
-
-			for _, tc := range testCases {
-				libID, libPath := matcher.findLibraryForPath(tc.path)
-				Expect(libID).To(Equal(tc.expectedLibID), "Path %s should match library ID %d", tc.path, tc.expectedLibID)
-				Expect(libPath).To(Equal(tc.expectedLibPath), "Path %s should match library path %s", tc.path, tc.expectedLibPath)
-			}
-		})
-	})
-
-	Describe("Edge cases", func() {
-		It("handles empty library list", func() {
-			mockLibRepo.SetData([]model.Library{})
-
-			matcher := createMatcher(ds)
-			Expect(matcher).ToNot(BeNil())
-
-			// Should not match anything
-			libID, libPath := matcher.findLibraryForPath("/music/track.mp3")
-			Expect(libID).To(Equal(0))
-			Expect(libPath).To(BeEmpty())
-		})
-
-		It("handles single library", func() {
-			mockLibRepo.SetData([]model.Library{
-				{ID: 1, Path: "/music"},
-			})
-
-			matcher := createMatcher(ds)
-
-			libID, libPath := matcher.findLibraryForPath("/music/track.mp3")
-			Expect(libID).To(Equal(1))
-			Expect(libPath).To(Equal("/music"))
-		})
-
-		It("handles libraries with special characters in paths", func() {
-			mockLibRepo.SetData([]model.Library{
-				{ID: 1, Path: "/music[test]"},
-				{ID: 2, Path: "/music(backup)"},
-			})
-
-			matcher := createMatcher(ds)
-			Expect(matcher).ToNot(BeNil())
-
-			// Special characters should match literally
-			libID, libPath := matcher.findLibraryForPath("/music[test]/track.mp3")
-			Expect(libID).To(Equal(1))
-			Expect(libPath).To(Equal("/music[test]"))
-		})
-	})
-
-	Describe("Path matching order", func() {
-		It("ensures longest paths match first", func() {
-			mockLibRepo.SetData([]model.Library{
-				{ID: 1, Path: "/a"},
-				{ID: 2, Path: "/ab"},
-				{ID: 3, Path: "/abc"},
-			})
-
-			matcher := createMatcher(ds)
-
-			// Verify that longer paths match correctly (not cut off by shorter prefix)
-			testCases := []struct {
-				path          string
-				expectedLibID int
-			}{
-				{"/abc/file.mp3", 3},
-				{"/ab/file.mp3", 2},
-				{"/a/file.mp3", 1},
-			}
-
-			for _, tc := range testCases {
-				libID, _ := matcher.findLibraryForPath(tc.path)
-				Expect(libID).To(Equal(tc.expectedLibID), "Path %s should match library ID %d", tc.path, tc.expectedLibID)
-			}
-		})
-	})
-})
-
-var _ = Describe("pathResolver", func() {
-	var ds *tests.MockDataStore
-	var mockLibRepo *tests.MockLibraryRepo
-	var resolver *pathResolver
-	ctx := context.Background()
-
-	BeforeEach(func() {
-		mockLibRepo = &tests.MockLibraryRepo{}
-		ds = &tests.MockDataStore{
-			MockedLibrary: mockLibRepo,
-		}
-
-		// Setup test libraries
-		mockLibRepo.SetData([]model.Library{
-			{ID: 1, Path: "/music"},
-			{ID: 2, Path: "/music-classical"},
-			{ID: 3, Path: "/podcasts"},
-		})
-
-		var err error
-		resolver, err = newPathResolver(ctx, ds)
-		Expect(err).ToNot(HaveOccurred())
-	})
-
-	Describe("resolvePath", func() {
-		It("resolves absolute paths", func() {
-			resolution := resolver.resolvePath("/music/artist/album/track.mp3", nil)
-
-			Expect(resolution.valid).To(BeTrue())
-			Expect(resolution.libraryID).To(Equal(1))
-			Expect(resolution.libraryPath).To(Equal("/music"))
-			Expect(resolution.absolutePath).To(Equal("/music/artist/album/track.mp3"))
-		})
-
-		It("resolves relative paths when folder is provided", func() {
-			folder := &model.Folder{
-				Path:        "playlists",
-				LibraryPath: "/music",
-				LibraryID:   1,
-			}
-
-			resolution := resolver.resolvePath("../artist/album/track.mp3", folder)
-
-			Expect(resolution.valid).To(BeTrue())
-			Expect(resolution.libraryID).To(Equal(1))
-			Expect(resolution.absolutePath).To(Equal("/music/artist/album/track.mp3"))
-		})
-
-		It("returns invalid resolution for paths outside any library", func() {
-			resolution := resolver.resolvePath("/outside/library/track.mp3", nil)
-
-			Expect(resolution.valid).To(BeFalse())
-		})
-	})
-
-	Describe("resolvePath", func() {
-		Context("With absolute paths", func() {
-			It("resolves path within a library", func() {
-				resolution := resolver.resolvePath("/music/track.mp3", nil)
-
-				Expect(resolution.valid).To(BeTrue())
-				Expect(resolution.libraryID).To(Equal(1))
-				Expect(resolution.libraryPath).To(Equal("/music"))
-				Expect(resolution.absolutePath).To(Equal("/music/track.mp3"))
-			})
-
-			It("resolves path to the longest matching library", func() {
-				resolution := resolver.resolvePath("/music-classical/track.mp3", nil)
-
-				Expect(resolution.valid).To(BeTrue())
-				Expect(resolution.libraryID).To(Equal(2))
-				Expect(resolution.libraryPath).To(Equal("/music-classical"))
-			})
-
-			It("returns invalid resolution for path outside libraries", func() {
-				resolution := resolver.resolvePath("/videos/movie.mp4", nil)
-
-				Expect(resolution.valid).To(BeFalse())
-			})
-
-			It("cleans the path before matching", func() {
-				resolution := resolver.resolvePath("/music//artist/../artist/track.mp3", nil)
-
-				Expect(resolution.valid).To(BeTrue())
-				Expect(resolution.absolutePath).To(Equal("/music/artist/track.mp3"))
-			})
-		})
-
-		Context("With relative paths", func() {
-			It("resolves relative path within same library", func() {
-				folder := &model.Folder{
-					Path:        "playlists",
-					LibraryPath: "/music",
-					LibraryID:   1,
-				}
-
-				resolution := resolver.resolvePath("../songs/track.mp3", folder)
-
-				Expect(resolution.valid).To(BeTrue())
-				Expect(resolution.libraryID).To(Equal(1))
-				Expect(resolution.absolutePath).To(Equal("/music/songs/track.mp3"))
-			})
-
-			It("resolves relative path to different library", func() {
-				folder := &model.Folder{
-					Path:        "playlists",
-					LibraryPath: "/music",
-					LibraryID:   1,
-				}
-
-				// Path goes up and into a different library
-				resolution := resolver.resolvePath("../../podcasts/episode.mp3", folder)
-
-				Expect(resolution.valid).To(BeTrue())
-				Expect(resolution.libraryID).To(Equal(3))
-				Expect(resolution.libraryPath).To(Equal("/podcasts"))
-			})
-
-			It("uses matcher to find correct library for resolved path", func() {
-				folder := &model.Folder{
-					Path:        "playlists",
-					LibraryPath: "/music",
-					LibraryID:   1,
-				}
-
-				// This relative path resolves to music-classical library
-				resolution := resolver.resolvePath("../../music-classical/track.mp3", folder)
-
-				Expect(resolution.valid).To(BeTrue())
-				Expect(resolution.libraryID).To(Equal(2))
-				Expect(resolution.libraryPath).To(Equal("/music-classical"))
-			})
-
-			It("returns invalid for relative paths escaping all libraries", func() {
-				folder := &model.Folder{
-					Path:        "playlists",
-					LibraryPath: "/music",
-					LibraryID:   1,
-				}
-
-				resolution := resolver.resolvePath("../../../../etc/passwd", folder)
-
-				Expect(resolution.valid).To(BeFalse())
-			})
-		})
-	})
-
-	Describe("Cross-library resolution scenarios", func() {
-		It("handles playlist in library A referencing file in library B", func() {
-			// Playlist is in /music/playlists
-			folder := &model.Folder{
-				Path:        "playlists",
-				LibraryPath: "/music",
-				LibraryID:   1,
-			}
-
-			// Relative path that goes to /podcasts library
-			resolution := resolver.resolvePath("../../podcasts/show/episode.mp3", folder)
-
-			Expect(resolution.valid).To(BeTrue())
-			Expect(resolution.libraryID).To(Equal(3), "Should resolve to podcasts library")
-			Expect(resolution.libraryPath).To(Equal("/podcasts"))
-		})
-
-		It("prefers longer library paths when resolving", func() {
-			// Ensure /music-classical is matched instead of /music
-			resolution := resolver.resolvePath("/music-classical/baroque/track.mp3", nil)
-
-			Expect(resolution.valid).To(BeTrue())
-			Expect(resolution.libraryID).To(Equal(2), "Should match /music-classical, not /music")
-		})
-	})
-})
-
-var _ = Describe("pathResolution", func() {
-	Describe("ToQualifiedString", func() {
-		It("converts valid resolution to qualified string with forward slashes", func() {
-			resolution := pathResolution{
-				absolutePath: "/music/artist/album/track.mp3",
-				libraryPath:  "/music",
-				libraryID:    1,
-				valid:        true,
-			}
-
-			qualifiedStr, err := resolution.ToQualifiedString()
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(qualifiedStr).To(Equal("1:artist/album/track.mp3"))
-		})
-
-		It("handles Windows-style paths by converting to forward slashes", func() {
-			resolution := pathResolution{
-				absolutePath: "/music/artist/album/track.mp3",
-				libraryPath:  "/music",
-				libraryID:    2,
-				valid:        true,
-			}
-
-			qualifiedStr, err := resolution.ToQualifiedString()
-
-			Expect(err).ToNot(HaveOccurred())
-			// Should always use forward slashes regardless of OS
-			Expect(qualifiedStr).To(ContainSubstring("2:"))
-			Expect(qualifiedStr).ToNot(ContainSubstring("\\"))
-		})
-
-		It("returns error for invalid resolution", func() {
-			resolution := pathResolution{valid: false}
-
-			_, err := resolution.ToQualifiedString()
-
-			Expect(err).To(HaveOccurred())
-		})
-	})
-})

core/playlists_test.go

@@ -1,4 +1,4 @@
-package core_test
+package core
 
 import (
 	"context"
@@ -9,7 +9,6 @@ import (
 
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/conf/configtest"
-	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/model/criteria"
 	"github.com/navidrome/navidrome/model/request"
@@ -21,7 +20,7 @@ import (
 
 var _ = Describe("Playlists", func() {
 	var ds *tests.MockDataStore
-	var ps core.Playlists
+	var ps Playlists
 	var mockPlsRepo mockedPlaylistRepo
 	var mockLibRepo *tests.MockLibraryRepo
 	ctx := context.Background()
@@ -34,16 +33,16 @@ var _ = Describe("Playlists", func() {
 			MockedLibrary:  mockLibRepo,
 		}
 		ctx = request.WithUser(ctx, model.User{ID: "123"})
+		// Path should be libPath, but we want to match the root folder referenced in the m3u, which is `/`
+		mockLibRepo.SetData([]model.Library{{ID: 1, Path: "/"}})
 	})
 
 	Describe("ImportFile", func() {
 		var folder *model.Folder
 		BeforeEach(func() {
-			ps = core.NewPlaylists(ds)
+			ps = NewPlaylists(ds)
 			ds.MockedMediaFile = &mockedMediaFileRepo{}
 			libPath, _ := os.Getwd()
-			// Set up library with the actual library path that matches the folder
-			mockLibRepo.SetData([]model.Library{{ID: 1, Path: libPath}})
 			folder = &model.Folder{
 				ID:          "1",
 				LibraryID:   1,
@@ -112,294 +111,6 @@ var _ = Describe("Playlists", func() {
 				_, err := ps.ImportFile(ctx, folder, "invalid_json.nsp")
 				Expect(err.Error()).To(ContainSubstring("line 19, column 1: invalid character '\\n'"))
 			})
-			It("parses NSP with public: true and creates public playlist", func() {
-				pls, err := ps.ImportFile(ctx, folder, "public_playlist.nsp")
-				Expect(err).ToNot(HaveOccurred())
-				Expect(pls.Name).To(Equal("Public Playlist"))
-				Expect(pls.Public).To(BeTrue())
-			})
-			It("parses NSP with public: false and creates private playlist", func() {
-				pls, err := ps.ImportFile(ctx, folder, "private_playlist.nsp")
-				Expect(err).ToNot(HaveOccurred())
-				Expect(pls.Name).To(Equal("Private Playlist"))
-				Expect(pls.Public).To(BeFalse())
-			})
-			It("uses server default when public field is absent", func() {
-				DeferCleanup(configtest.SetupConfig())
-				conf.Server.DefaultPlaylistPublicVisibility = true
-
-				pls, err := ps.ImportFile(ctx, folder, "recently_played.nsp")
-				Expect(err).ToNot(HaveOccurred())
-				Expect(pls.Name).To(Equal("Recently Played"))
-				Expect(pls.Public).To(BeTrue()) // Should be true since server default is true
-			})
-		})
-
-		DescribeTable("Playlist filename Unicode normalization (regression fix-playlist-filename-normalization)",
-			func(storedForm, filesystemForm string) {
-				// Use Polish characters that decompose: ó (U+00F3) -> o + combining acute (U+006F + U+0301)
-				plsNameNFC := "Piosenki_Polskie_zółć" // NFC form (composed)
-				plsNameNFD := norm.NFD.String(plsNameNFC)
-				Expect(plsNameNFD).ToNot(Equal(plsNameNFC)) // Verify they differ
-
-				nameByForm := map[string]string{"NFC": plsNameNFC, "NFD": plsNameNFD}
-				storedName := nameByForm[storedForm]
-				filesystemName := nameByForm[filesystemForm]
-
-				tmpDir := GinkgoT().TempDir()
-				mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})
-				ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{}}
-				ps = core.NewPlaylists(ds)
-
-				// Create the playlist file on disk with the filesystem's normalization form
-				plsFile := tmpDir + "/" + filesystemName + ".m3u"
-				Expect(os.WriteFile(plsFile, []byte("#PLAYLIST:Test\n"), 0600)).To(Succeed())
-
-				// Pre-populate mock repo with the stored normalization form
-				storedPath := tmpDir + "/" + storedName + ".m3u"
-				existingPls := &model.Playlist{
-					ID:   "existing-id",
-					Name: "Existing Playlist",
-					Path: storedPath,
-					Sync: true,
-				}
-				mockPlsRepo.data = map[string]*model.Playlist{storedPath: existingPls}
-
-				// Import using the filesystem's normalization form
-				plsFolder := &model.Folder{
-					ID:          "1",
-					LibraryID:   1,
-					LibraryPath: tmpDir,
-					Path:        "",
-					Name:        "",
-				}
-				pls, err := ps.ImportFile(ctx, plsFolder, filesystemName+".m3u")
-				Expect(err).ToNot(HaveOccurred())
-
-				// Should update existing playlist, not create new one
-				Expect(pls.ID).To(Equal("existing-id"))
-				Expect(pls.Name).To(Equal("Existing Playlist"))
-			},
-			Entry("finds NFD-stored playlist when filesystem provides NFC path", "NFD", "NFC"),
-			Entry("finds NFC-stored playlist when filesystem provides NFD path", "NFC", "NFD"),
-		)
-
-		Describe("Cross-library relative paths", func() {
-			var tmpDir, plsDir, songsDir string
-
-			BeforeEach(func() {
-				// Create temp directory structure
-				tmpDir = GinkgoT().TempDir()
-				plsDir = tmpDir + "/playlists"
-				songsDir = tmpDir + "/songs"
-				Expect(os.Mkdir(plsDir, 0755)).To(Succeed())
-				Expect(os.Mkdir(songsDir, 0755)).To(Succeed())
-
-				// Setup two different libraries with paths matching our temp structure
-				mockLibRepo.SetData([]model.Library{
-					{ID: 1, Path: songsDir},
-					{ID: 2, Path: plsDir},
-				})
-
-				// Create a mock media file repository that returns files for both libraries
-				// Note: The paths are relative to their respective library roots
-				ds.MockedMediaFile = &mockedMediaFileFromListRepo{
-					data: []string{
-						"abc.mp3", // This is songs/abc.mp3 relative to songsDir
-						"def.mp3", // This is playlists/def.mp3 relative to plsDir
-					},
-				}
-				ps = core.NewPlaylists(ds)
-			})
-
-			It("handles relative paths that reference files in other libraries", func() {
-				// Create a temporary playlist file with relative path
-				plsContent := "#PLAYLIST:Cross Library Test\n../songs/abc.mp3\ndef.mp3"
-				plsFile := plsDir + "/test.m3u"
-				Expect(os.WriteFile(plsFile, []byte(plsContent), 0600)).To(Succeed())
-
-				// Playlist is in the Playlists library folder
-				// Important: Path should be relative to LibraryPath, and Name is the folder name
-				plsFolder := &model.Folder{
-					ID:          "2",
-					LibraryID:   2,
-					LibraryPath: plsDir,
-					Path:        "",
-					Name:        "",
-				}
-
-				pls, err := ps.ImportFile(ctx, plsFolder, "test.m3u")
-				Expect(err).ToNot(HaveOccurred())
-				Expect(pls.Tracks).To(HaveLen(2))
-				Expect(pls.Tracks[0].Path).To(Equal("abc.mp3")) // From songsDir library
-				Expect(pls.Tracks[1].Path).To(Equal("def.mp3")) // From plsDir library
-			})
-
-			It("ignores paths that point outside all libraries", func() {
-				// Create a temporary playlist file with path outside libraries
-				plsContent := "#PLAYLIST:Outside Test\n../../outside.mp3\nabc.mp3"
-				plsFile := plsDir + "/test.m3u"
-				Expect(os.WriteFile(plsFile, []byte(plsContent), 0600)).To(Succeed())
-
-				plsFolder := &model.Folder{
-					ID:          "2",
-					LibraryID:   2,
-					LibraryPath: plsDir,
-					Path:        "",
-					Name:        "",
-				}
-
-				pls, err := ps.ImportFile(ctx, plsFolder, "test.m3u")
-				Expect(err).ToNot(HaveOccurred())
-				// Should only find abc.mp3, not outside.mp3
-				Expect(pls.Tracks).To(HaveLen(1))
-				Expect(pls.Tracks[0].Path).To(Equal("abc.mp3"))
-			})
-
-			It("handles relative paths with multiple '../' components", func() {
-				// Create a nested structure: tmpDir/playlists/subfolder/test.m3u
-				subFolder := plsDir + "/subfolder"
-				Expect(os.Mkdir(subFolder, 0755)).To(Succeed())
-
-				// Create the media file in the subfolder directory
-				// The mock will return it as "def.mp3" relative to plsDir
-				ds.MockedMediaFile = &mockedMediaFileFromListRepo{
-					data: []string{
-						"abc.mp3", // From songsDir library
-						"def.mp3", // From plsDir library root
-					},
-				}
-
-				// From subfolder, ../../songs/abc.mp3 should resolve to songs library
-				// ../def.mp3 should resolve to plsDir/def.mp3
-				plsContent := "#PLAYLIST:Nested Test\n../../songs/abc.mp3\n../def.mp3"
-				plsFile := subFolder + "/test.m3u"
-				Expect(os.WriteFile(plsFile, []byte(plsContent), 0600)).To(Succeed())
-
-				// The folder: AbsolutePath = LibraryPath + Path + Name
-				// So for /playlists/subfolder: LibraryPath=/playlists, Path="", Name="subfolder"
-				plsFolder := &model.Folder{
-					ID:          "2",
-					LibraryID:   2,
-					LibraryPath: plsDir,
-					Path:        "",          // Empty because subfolder is directly under library root
-					Name:        "subfolder", // The folder name
-				}
-
-				pls, err := ps.ImportFile(ctx, plsFolder, "test.m3u")
-				Expect(err).ToNot(HaveOccurred())
-				Expect(pls.Tracks).To(HaveLen(2))
-				Expect(pls.Tracks[0].Path).To(Equal("abc.mp3")) // From songsDir library
-				Expect(pls.Tracks[1].Path).To(Equal("def.mp3")) // From plsDir library root
-			})
-
-			It("correctly resolves libraries when one path is a prefix of another", func() {
-				// This tests the bug where /music would match before /music-classical
-				// Create temp directory structure with prefix conflict
-				tmpDir := GinkgoT().TempDir()
-				musicDir := tmpDir + "/music"
-				musicClassicalDir := tmpDir + "/music-classical"
-				Expect(os.Mkdir(musicDir, 0755)).To(Succeed())
-				Expect(os.Mkdir(musicClassicalDir, 0755)).To(Succeed())
-
-				// Setup two libraries where one is a prefix of the other
-				mockLibRepo.SetData([]model.Library{
-					{ID: 1, Path: musicDir},          // /tmp/xxx/music
-					{ID: 2, Path: musicClassicalDir}, // /tmp/xxx/music-classical
-				})
-
-				// Mock will return tracks from both libraries
-				ds.MockedMediaFile = &mockedMediaFileFromListRepo{
-					data: []string{
-						"rock.mp3", // From music library
-						"bach.mp3", // From music-classical library
-					},
-				}
-
-				// Create playlist in music library that references music-classical
-				plsContent := "#PLAYLIST:Cross Prefix Test\nrock.mp3\n../music-classical/bach.mp3"
-				plsFile := musicDir + "/test.m3u"
-				Expect(os.WriteFile(plsFile, []byte(plsContent), 0600)).To(Succeed())
-
-				plsFolder := &model.Folder{
-					ID:          "1",
-					LibraryID:   1,
-					LibraryPath: musicDir,
-					Path:        "",
-					Name:        "",
-				}
-
-				pls, err := ps.ImportFile(ctx, plsFolder, "test.m3u")
-				Expect(err).ToNot(HaveOccurred())
-				Expect(pls.Tracks).To(HaveLen(2))
-				Expect(pls.Tracks[0].Path).To(Equal("rock.mp3")) // From music library
-				Expect(pls.Tracks[1].Path).To(Equal("bach.mp3")) // From music-classical library (not music!)
-			})
-
-			It("correctly handles identical relative paths from different libraries", func() {
-				// This tests the bug where two libraries have files at the same relative path
-				// and only one appears in the playlist
-				tmpDir := GinkgoT().TempDir()
-				musicDir := tmpDir + "/music"
-				classicalDir := tmpDir + "/classical"
-				Expect(os.Mkdir(musicDir, 0755)).To(Succeed())
-				Expect(os.Mkdir(classicalDir, 0755)).To(Succeed())
-				Expect(os.MkdirAll(musicDir+"/album", 0755)).To(Succeed())
-				Expect(os.MkdirAll(classicalDir+"/album", 0755)).To(Succeed())
-				// Create placeholder files so paths resolve correctly
-				Expect(os.WriteFile(musicDir+"/album/track.mp3", []byte{}, 0600)).To(Succeed())
-				Expect(os.WriteFile(classicalDir+"/album/track.mp3", []byte{}, 0600)).To(Succeed())
-
-				// Both libraries have a file at "album/track.mp3"
-				mockLibRepo.SetData([]model.Library{
-					{ID: 1, Path: musicDir},
-					{ID: 2, Path: classicalDir},
-				})
-
-				// Mock returns files with same relative path but different IDs and library IDs
-				// Keys use the library-qualified format: "libraryID:path"
-				ds.MockedMediaFile = &mockedMediaFileRepo{
-					data: map[string]model.MediaFile{
-						"1:album/track.mp3": {ID: "music-track", Path: "album/track.mp3", LibraryID: 1, Title: "Rock Song"},
-						"2:album/track.mp3": {ID: "classical-track", Path: "album/track.mp3", LibraryID: 2, Title: "Classical Piece"},
-					},
-				}
-				// Recreate playlists service to pick up new mock
-				ps = core.NewPlaylists(ds)
-
-				// Create playlist in music library that references both tracks
-				plsContent := "#PLAYLIST:Same Path Test\nalbum/track.mp3\n../classical/album/track.mp3"
-				plsFile := musicDir + "/test.m3u"
-				Expect(os.WriteFile(plsFile, []byte(plsContent), 0600)).To(Succeed())
-
-				plsFolder := &model.Folder{
-					ID:          "1",
-					LibraryID:   1,
-					LibraryPath: musicDir,
-					Path:        "",
-					Name:        "",
-				}
-
-				pls, err := ps.ImportFile(ctx, plsFolder, "test.m3u")
-				Expect(err).ToNot(HaveOccurred())
-
-				// Should have BOTH tracks, not just one
-				Expect(pls.Tracks).To(HaveLen(2), "Playlist should contain both tracks with same relative path")
-
-				// Verify we got tracks from DIFFERENT libraries (the key fix!)
-				// Collect the library IDs
-				libIDs := make(map[int]bool)
-				for _, track := range pls.Tracks {
-					libIDs[track.LibraryID] = true
-				}
-				Expect(libIDs).To(HaveLen(2), "Tracks should come from two different libraries")
-				Expect(libIDs[1]).To(BeTrue(), "Should have track from library 1")
-				Expect(libIDs[2]).To(BeTrue(), "Should have track from library 2")
-
-				// Both tracks should have the same relative path
-				Expect(pls.Tracks[0].Path).To(Equal("album/track.mp3"))
-				Expect(pls.Tracks[1].Path).To(Equal("album/track.mp3"))
-			})
 		})
 	})
 
@@ -408,7 +119,7 @@ var _ = Describe("Playlists", func() {
 		BeforeEach(func() {
 			repo = &mockedMediaFileFromListRepo{}
 			ds.MockedMediaFile = repo
-			ps = core.NewPlaylists(ds)
+			ps = NewPlaylists(ds)
 			mockLibRepo.SetData([]model.Library{{ID: 1, Path: "/music"}, {ID: 2, Path: "/new"}})
 			ctx = request.WithUser(ctx, model.User{ID: "123"})
 		})
@@ -495,79 +206,53 @@ var _ = Describe("Playlists", func() {
 			Expect(pls.Tracks[0].Path).To(Equal("abc/tEsT1.Mp3"))
 		})
 
-		// Fullwidth characters (e.g., ＡＢＣＤ) are not handled by SQLite's NOCASE collation,
-		// so we need exact matching for non-ASCII characters.
-		It("matches fullwidth characters exactly (SQLite NOCASE limitation)", func() {
-			// Fullwidth uppercase ＡＣＲＯＳＳ (U+FF21, U+FF23, U+FF32, U+FF2F, U+FF33, U+FF33)
-			repo.data = []string{
-				"plex/02 - ＡＣＲＯＳＳ.flac",
-			}
-			m3u := "/music/plex/02 - ＡＣＲＯＳＳ.flac\n"
+		It("handles Unicode normalization when comparing paths", func() {
+			// Test case for Apple Music playlists that use NFC encoding vs macOS filesystem NFD
+			// The character "è" can be represented as NFC (single codepoint) or NFD (e + combining accent)
+
+			const pathWithAccents = "artist/Michèle Desrosiers/album/Noël.m4a"
+
+			// Simulate a database entry with NFD encoding (as stored by macOS filesystem)
+			nfdPath := norm.NFD.String(pathWithAccents)
+			repo.data = []string{nfdPath}
+
+			// Simulate an Apple Music M3U playlist entry with NFC encoding
+			nfcPath := norm.NFC.String("/music/" + pathWithAccents)
+			m3u := strings.Join([]string{
+				nfcPath,
+			}, "\n")
 			f := strings.NewReader(m3u)
+
 			pls, err := ps.ImportM3U(ctx, f)
 			Expect(err).ToNot(HaveOccurred())
-			Expect(pls.Tracks).To(HaveLen(1))
-			Expect(pls.Tracks[0].Path).To(Equal("plex/02 - ＡＣＲＯＳＳ.flac"))
+			Expect(pls.Tracks).To(HaveLen(1), "Should find the track despite Unicode normalization differences")
+			Expect(pls.Tracks[0].Path).To(Equal(nfdPath))
+		})
+	})
+
+	Describe("normalizePathForComparison", func() {
+		It("normalizes Unicode characters to NFC form and converts to lowercase", func() {
+			// Test with NFD (decomposed) input - as would come from macOS filesystem
+			nfdPath := norm.NFD.String("Michèle") // Explicitly convert to NFD form
+			normalized := normalizePathForComparison(nfdPath)
+			Expect(normalized).To(Equal("michèle"))
+
+			// Test with NFC (composed) input - as would come from Apple Music M3U
+			nfcPath := "Michèle" // This might be in NFC form
+			normalizedNfc := normalizePathForComparison(nfcPath)
+
+			// Ensure the two paths are not equal in their original forms
+			Expect(nfdPath).ToNot(Equal(nfcPath))
+
+			// Both should normalize to the same result
+			Expect(normalized).To(Equal(normalizedNfc))
 		})
 
-		// Unicode normalization tests: NFC (composed) vs NFD (decomposed) forms
-		// macOS stores paths in NFD, Linux/Windows use NFC. Playlists may use either form.
-		DescribeTable("matches paths across Unicode NFC/NFD normalization",
-			func(description, pathNFC string, dbForm, playlistForm norm.Form) {
-				pathNFD := norm.NFD.String(pathNFC)
-				Expect(pathNFD).ToNot(Equal(pathNFC), "test path should have decomposable characters")
-
-				// Set up DB with specified normalization form
-				var dbPath string
-				if dbForm == norm.NFC {
-					dbPath = pathNFC
-				} else {
-					dbPath = pathNFD
-				}
-				repo.data = []string{dbPath}
-
-				// Set up playlist with specified normalization form
-				var playlistPath string
-				if playlistForm == norm.NFC {
-					playlistPath = pathNFC
-				} else {
-					playlistPath = pathNFD
-				}
-				m3u := "/music/" + playlistPath + "\n"
-				f := strings.NewReader(m3u)
-
-				pls, err := ps.ImportM3U(ctx, f)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(pls.Tracks).To(HaveLen(1))
-				Expect(pls.Tracks[0].Path).To(Equal(dbPath))
-			},
-			// French: è (U+00E8) decomposes to e + combining grave (U+0065 + U+0300)
-			Entry("French diacritics - DB:NFD, playlist:NFC",
-				"macOS DB with Apple Music playlist",
-				"artist/Michèle/song.mp3", norm.NFD, norm.NFC),
-
-			// Japanese Katakana: ド (U+30C9) decomposes to ト (U+30C8) + combining dakuten (U+3099)
-			Entry("Japanese Katakana with dakuten - DB:NFC, playlist:NFC (#4884)",
-				"Linux/Windows DB with NFC playlist",
-				"artist/\u30a2\u30a4\u30c9\u30eb/\u30c9\u30ea\u30fc\u30e0\u30bd\u30f3\u30b0.mp3", norm.NFC, norm.NFC),
-			Entry("Japanese Katakana with dakuten - DB:NFD, playlist:NFC (#4884)",
-				"macOS DB with NFC playlist",
-				"artist/\u30a2\u30a4\u30c9\u30eb/\u30c9\u30ea\u30fc\u30e0\u30bd\u30f3\u30b0.mp3", norm.NFD, norm.NFC),
-
-			// Cyrillic: й (U+0439) decomposes to и (U+0438) + combining breve (U+0306)
-			Entry("Cyrillic characters - DB:NFD, playlist:NFC (#4791)",
-				"macOS DB with NFC playlist",
-				"Жуки/Батарейка/01 - Разлюбила.mp3", norm.NFD, norm.NFC),
-
-			// Polish: ó (U+00F3) decomposes to o + combining acute (U+0301)
-			Entry("Polish diacritics - DB:NFD, playlist:NFC (#4663)",
-				"macOS DB with NFC playlist",
-				"Zespół/Człowiek/Piosenka o miłości.mp3", norm.NFD, norm.NFC),
-			Entry("Polish diacritics - DB:NFC, playlist:NFD",
-				"Linux/Windows DB with macOS-exported playlist",
-				"Zespół/Człowiek/Piosenka o miłości.mp3", norm.NFC, norm.NFD),
-		)
-
+		It("handles paths with mixed case and Unicode characters", func() {
+			path := "Artist/Noël Coward/Album/Song.mp3"
+			normalized := normalizePathForComparison(path)
+			Expect(normalized).To(Equal("artist/noël coward/album/song.mp3"))
+		})
 	})
 
 	Describe("InPlaylistsPath", func() {
@@ -584,27 +269,27 @@ var _ = Describe("Playlists", func() {
 
 		It("returns true if PlaylistsPath is empty", func() {
 			conf.Server.PlaylistsPath = ""
-			Expect(core.InPlaylistsPath(folder)).To(BeTrue())
+			Expect(InPlaylistsPath(folder)).To(BeTrue())
 		})
 
 		It("returns true if PlaylistsPath is any (**/**)", func() {
 			conf.Server.PlaylistsPath = "**/**"
-			Expect(core.InPlaylistsPath(folder)).To(BeTrue())
+			Expect(InPlaylistsPath(folder)).To(BeTrue())
 		})
 
 		It("returns true if folder is in PlaylistsPath", func() {
 			conf.Server.PlaylistsPath = "other/**:playlists/**"
-			Expect(core.InPlaylistsPath(folder)).To(BeTrue())
+			Expect(InPlaylistsPath(folder)).To(BeTrue())
 		})
 
 		It("returns false if folder is not in PlaylistsPath", func() {
 			conf.Server.PlaylistsPath = "other"
-			Expect(core.InPlaylistsPath(folder)).To(BeFalse())
+			Expect(InPlaylistsPath(folder)).To(BeFalse())
 		})
 
 		It("returns true if for a playlist in root of MusicFolder if PlaylistsPath is '.'", func() {
 			conf.Server.PlaylistsPath = "."
-			Expect(core.InPlaylistsPath(folder)).To(BeFalse())
+			Expect(InPlaylistsPath(folder)).To(BeFalse())
 
 			folder2 := model.Folder{
 				LibraryPath: "/music",
@@ -612,47 +297,22 @@ var _ = Describe("Playlists", func() {
 				Name:        ".",
 			}
 
-			Expect(core.InPlaylistsPath(folder2)).To(BeTrue())
+			Expect(InPlaylistsPath(folder2)).To(BeTrue())
 		})
 	})
 })
 
-// mockedMediaFileRepo's FindByPaths method returns MediaFiles for the given paths.
-// If data map is provided, looks up files by key; otherwise creates them from paths.
+// mockedMediaFileRepo's FindByPaths method returns a list of MediaFiles with the same paths as the input
 type mockedMediaFileRepo struct {
 	model.MediaFileRepository
-	data map[string]model.MediaFile
 }
 
 func (r *mockedMediaFileRepo) FindByPaths(paths []string) (model.MediaFiles, error) {
 	var mfs model.MediaFiles
-
-	// If data map provided, look up files
-	if r.data != nil {
-		for _, path := range paths {
-			if mf, ok := r.data[path]; ok {
-				mfs = append(mfs, mf)
-			}
-		}
-		return mfs, nil
-	}
-
-	// Otherwise, create MediaFiles from paths
 	for idx, path := range paths {
-		// Strip library qualifier if present (format: "libraryID:path")
-		actualPath := path
-		libraryID := 1
-		if parts := strings.SplitN(path, ":", 2); len(parts) == 2 {
-			if id, err := strconv.Atoi(parts[0]); err == nil {
-				libraryID = id
-				actualPath = parts[1]
-			}
-		}
-
 		mfs = append(mfs, model.MediaFile{
-			ID:        strconv.Itoa(idx),
-			Path:      actualPath,
-			LibraryID: libraryID,
+			ID:   strconv.Itoa(idx),
+			Path: path,
 		})
 	}
 	return mfs, nil
@@ -664,48 +324,23 @@ type mockedMediaFileFromListRepo struct {
 	data []string
 }
 
-func (r *mockedMediaFileFromListRepo) FindByPaths(paths []string) (model.MediaFiles, error) {
+func (r *mockedMediaFileFromListRepo) FindByPaths([]string) (model.MediaFiles, error) {
 	var mfs model.MediaFiles
-
-	for idx, dataPath := range r.data {
-		for _, requestPath := range paths {
-			// Strip library qualifier if present (format: "libraryID:path")
-			actualPath := requestPath
-			libraryID := 1
-			if parts := strings.SplitN(requestPath, ":", 2); len(parts) == 2 {
-				if id, err := strconv.Atoi(parts[0]); err == nil {
-					libraryID = id
-					actualPath = parts[1]
-				}
-			}
-
-			// Case-insensitive comparison (like SQL's "collate nocase"), but with no
-			// implicit Unicode normalization (SQLite does not normalize NFC/NFD).
-			if strings.EqualFold(actualPath, dataPath) {
-				mfs = append(mfs, model.MediaFile{
-					ID:        strconv.Itoa(idx),
-					Path:      dataPath, // Return original path from DB
-					LibraryID: libraryID,
-				})
-				break
-			}
-		}
+	for idx, path := range r.data {
+		mfs = append(mfs, model.MediaFile{
+			ID:   strconv.Itoa(idx),
+			Path: path,
+		})
 	}
 	return mfs, nil
 }
 
 type mockedPlaylistRepo struct {
 	last *model.Playlist
-	data map[string]*model.Playlist // keyed by path
 	model.PlaylistRepository
 }
 
-func (r *mockedPlaylistRepo) FindByPath(path string) (*model.Playlist, error) {
-	if r.data != nil {
-		if pls, ok := r.data[path]; ok {
-			return pls, nil
-		}
-	}
+func (r *mockedPlaylistRepo) FindByPath(string) (*model.Playlist, error) {
 	return nil, model.ErrNotFound
 }
 

core/publicurl/publicurl.go

@@ -1,81 +0,0 @@
-package publicurl
-
-import (
-	"cmp"
-	"net/http"
-	"net/url"
-	"path"
-	"strconv"
-	"strings"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/consts"
-	"github.com/navidrome/navidrome/core/auth"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
-)
-
-// ImageURL generates a public URL for artwork images.
-// It creates a signed token for the artwork ID and builds a complete public URL.
-func ImageURL(req *http.Request, artID model.ArtworkID, size int) string {
-	token, _ := auth.CreatePublicToken(map[string]any{"id": artID.String()})
-	uri := path.Join(consts.URLPathPublicImages, token)
-	params := url.Values{}
-	if size > 0 {
-		params.Add("size", strconv.Itoa(size))
-	}
-	return PublicURL(req, uri, params)
-}
-
-// PublicURL builds a full URL for public-facing resources.
-// It uses ShareURL from config if available, otherwise falls back to extracting
-// the scheme and host from the provided http.Request.
-// If req is nil and ShareURL is not set, it defaults to http://localhost.
-func PublicURL(req *http.Request, u string, params url.Values) string {
-	if conf.Server.ShareURL == "" {
-		return AbsoluteURL(req, u, params)
-	}
-	shareUrl, err := url.Parse(conf.Server.ShareURL)
-	if err != nil {
-		return AbsoluteURL(req, u, params)
-	}
-	buildUrl, err := url.Parse(u)
-	if err != nil {
-		return AbsoluteURL(req, u, params)
-	}
-	buildUrl.Scheme = shareUrl.Scheme
-	buildUrl.Host = shareUrl.Host
-	if len(params) > 0 {
-		buildUrl.RawQuery = params.Encode()
-	}
-	return buildUrl.String()
-}
-
-// AbsoluteURL builds an absolute URL from a relative path.
-// It uses BaseHost/BaseScheme from config if available, otherwise extracts
-// the scheme and host from the http.Request.
-// If req is nil and BaseHost is not set, it defaults to http://localhost.
-func AbsoluteURL(req *http.Request, u string, params url.Values) string {
-	buildUrl, err := url.Parse(u)
-	if err != nil {
-		log.Error(req.Context(), "Failed to parse URL path", "url", u, err)
-		return ""
-	}
-	if strings.HasPrefix(u, "/") {
-		buildUrl.Path = path.Join(conf.Server.BasePath, buildUrl.Path)
-		if conf.Server.BaseHost != "" {
-			buildUrl.Scheme = cmp.Or(conf.Server.BaseScheme, "http")
-			buildUrl.Host = conf.Server.BaseHost
-		} else if req != nil {
-			buildUrl.Scheme = req.URL.Scheme
-			buildUrl.Host = req.Host
-		} else {
-			buildUrl.Scheme = "http"
-			buildUrl.Host = "localhost"
-		}
-	}
-	if len(params) > 0 {
-		buildUrl.RawQuery = params.Encode()
-	}
-	return buildUrl.String()
-}

core/publicurl/publicurl_test.go

@@ -1,174 +0,0 @@
-package publicurl_test
-
-import (
-	"net/http"
-	"net/url"
-	"testing"
-
-	"github.com/go-chi/jwtauth/v5"
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/conf/configtest"
-	"github.com/navidrome/navidrome/core/auth"
-	"github.com/navidrome/navidrome/core/publicurl"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-func TestPublicURL(t *testing.T) {
-	tests.Init(t, false)
-	log.SetLevel(log.LevelFatal)
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Public URL Suite")
-}
-
-var _ = Describe("Public URL Utilities", func() {
-	BeforeEach(func() {
-		DeferCleanup(configtest.SetupConfig())
-	})
-
-	Describe("PublicURL", func() {
-		When("ShareURL is set", func() {
-			BeforeEach(func() {
-				conf.Server.ShareURL = "https://share.example.com"
-			})
-
-			It("uses ShareURL as the base", func() {
-				r, _ := http.NewRequest("GET", "http://localhost/test", nil)
-				result := publicurl.PublicURL(r, "/path/to/resource", nil)
-				Expect(result).To(Equal("https://share.example.com/path/to/resource"))
-			})
-
-			It("includes query parameters", func() {
-				r, _ := http.NewRequest("GET", "http://localhost/test", nil)
-				params := url.Values{"size": []string{"300"}, "format": []string{"png"}}
-				result := publicurl.PublicURL(r, "/image/123", params)
-				Expect(result).To(ContainSubstring("https://share.example.com/image/123"))
-				Expect(result).To(ContainSubstring("size=300"))
-				Expect(result).To(ContainSubstring("format=png"))
-			})
-
-			It("works without a request", func() {
-				result := publicurl.PublicURL(nil, "/path/to/resource", nil)
-				Expect(result).To(Equal("https://share.example.com/path/to/resource"))
-			})
-		})
-
-		When("ShareURL is not set", func() {
-			BeforeEach(func() {
-				conf.Server.ShareURL = ""
-			})
-
-			It("falls back to AbsoluteURL with request", func() {
-				r, _ := http.NewRequest("GET", "https://myserver.com/test", nil)
-				r.Host = "myserver.com"
-				result := publicurl.PublicURL(r, "/path/to/resource", nil)
-				Expect(result).To(Equal("https://myserver.com/path/to/resource"))
-			})
-
-			It("falls back to localhost without request", func() {
-				result := publicurl.PublicURL(nil, "/path/to/resource", nil)
-				Expect(result).To(Equal("http://localhost/path/to/resource"))
-			})
-		})
-	})
-
-	Describe("AbsoluteURL", func() {
-		When("BaseHost is set", func() {
-			BeforeEach(func() {
-				conf.Server.BaseHost = "configured.example.com"
-				conf.Server.BaseScheme = "https"
-				conf.Server.BasePath = ""
-			})
-
-			It("uses BaseHost and BaseScheme", func() {
-				r, _ := http.NewRequest("GET", "http://localhost/test", nil)
-				result := publicurl.AbsoluteURL(r, "/path/to/resource", nil)
-				Expect(result).To(Equal("https://configured.example.com/path/to/resource"))
-			})
-
-			It("defaults to http scheme if BaseScheme is empty", func() {
-				conf.Server.BaseScheme = ""
-				r, _ := http.NewRequest("GET", "http://localhost/test", nil)
-				result := publicurl.AbsoluteURL(r, "/path/to/resource", nil)
-				Expect(result).To(Equal("http://configured.example.com/path/to/resource"))
-			})
-		})
-
-		When("BaseHost is not set", func() {
-			BeforeEach(func() {
-				conf.Server.BaseHost = ""
-				conf.Server.BasePath = ""
-			})
-
-			It("extracts host from request", func() {
-				r, _ := http.NewRequest("GET", "https://request.example.com/test", nil)
-				r.Host = "request.example.com"
-				result := publicurl.AbsoluteURL(r, "/path/to/resource", nil)
-				Expect(result).To(Equal("https://request.example.com/path/to/resource"))
-			})
-
-			It("falls back to localhost without request", func() {
-				result := publicurl.AbsoluteURL(nil, "/path/to/resource", nil)
-				Expect(result).To(Equal("http://localhost/path/to/resource"))
-			})
-		})
-
-		When("BasePath is set", func() {
-			BeforeEach(func() {
-				conf.Server.BasePath = "/navidrome"
-				conf.Server.BaseHost = "example.com"
-				conf.Server.BaseScheme = "https"
-			})
-
-			It("prepends BasePath to the URL", func() {
-				r, _ := http.NewRequest("GET", "http://localhost/test", nil)
-				result := publicurl.AbsoluteURL(r, "/path/to/resource", nil)
-				Expect(result).To(Equal("https://example.com/navidrome/path/to/resource"))
-			})
-		})
-
-		It("passes through absolute URLs unchanged", func() {
-			r, _ := http.NewRequest("GET", "http://localhost/test", nil)
-			result := publicurl.AbsoluteURL(r, "https://other.example.com/path", nil)
-			Expect(result).To(Equal("https://other.example.com/path"))
-		})
-
-		It("includes query parameters", func() {
-			conf.Server.BaseHost = "example.com"
-			conf.Server.BaseScheme = "https"
-			r, _ := http.NewRequest("GET", "http://localhost/test", nil)
-			params := url.Values{"key": []string{"value"}}
-			result := publicurl.AbsoluteURL(r, "/path", params)
-			Expect(result).To(Equal("https://example.com/path?key=value"))
-		})
-	})
-
-	Describe("ImageURL", func() {
-		BeforeEach(func() {
-			conf.Server.ShareURL = "https://share.example.com"
-			// Initialize JWT auth for token generation
-			auth.TokenAuth = jwtauth.New("HS256", []byte("test secret"), nil)
-		})
-
-		It("generates a URL with the artwork token", func() {
-			artID := model.NewArtworkID(model.KindAlbumArtwork, "album-123", nil)
-			result := publicurl.ImageURL(nil, artID, 0)
-			Expect(result).To(HavePrefix("https://share.example.com/share/img/"))
-		})
-
-		It("includes size parameter when provided", func() {
-			artID := model.NewArtworkID(model.KindArtistArtwork, "artist-1", nil)
-			result := publicurl.ImageURL(nil, artID, 300)
-			Expect(result).To(ContainSubstring("size=300"))
-		})
-
-		It("omits size parameter when zero", func() {
-			artID := model.NewArtworkID(model.KindMediaFileArtwork, "track-1", nil)
-			result := publicurl.ImageURL(nil, artID, 0)
-			Expect(result).ToNot(ContainSubstring("size="))
-		})
-	})
-})

core/scrobbler/buffered_scrobbler.go

@@ -9,27 +9,11 @@ import (
 	"github.com/navidrome/navidrome/model"
 )
 
-// Loader is a function that loads a scrobbler by name.
-// It returns the scrobbler and true if found, or nil and false if not available.
-// This allows the buffered scrobbler to always get the current plugin instance.
-type Loader func() (Scrobbler, bool)
-
-// newBufferedScrobbler creates a buffered scrobbler that wraps a static scrobbler instance.
-// Use this for builtin scrobblers that don't change.
 func newBufferedScrobbler(ds model.DataStore, s Scrobbler, service string) *bufferedScrobbler {
-	return newBufferedScrobblerWithLoader(ds, service, func() (Scrobbler, bool) {
-		return s, true
-	})
-}
-
-// newBufferedScrobblerWithLoader creates a buffered scrobbler that dynamically loads
-// the underlying scrobbler on each call. Use this for plugin scrobblers that may be
-// reloaded (e.g., after configuration changes).
-func newBufferedScrobblerWithLoader(ds model.DataStore, service string, loader Loader) *bufferedScrobbler {
 	ctx, cancel := context.WithCancel(context.Background())
 	b := &bufferedScrobbler{
 		ds:         ds,
-		loader:     loader,
+		wrapped:    s,
 		service:    service,
 		wakeSignal: make(chan struct{}, 1),
 		ctx:        ctx,
@@ -41,7 +25,7 @@ func newBufferedScrobblerWithLoader(ds model.DataStore, service string, loader L
 
 type bufferedScrobbler struct {
 	ds         model.DataStore
-	loader     Loader
+	wrapped    Scrobbler
 	service    string
 	wakeSignal chan struct{}
 	ctx        context.Context
@@ -55,19 +39,11 @@ func (b *bufferedScrobbler) Stop() {
 }
 
 func (b *bufferedScrobbler) IsAuthorized(ctx context.Context, userId string) bool {
-	s, ok := b.loader()
-	if !ok {
-		return false
-	}
-	return s.IsAuthorized(ctx, userId)
+	return b.wrapped.IsAuthorized(ctx, userId)
 }
 
 func (b *bufferedScrobbler) NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) error {
-	s, ok := b.loader()
-	if !ok {
-		return errors.New("scrobbler not available")
-	}
-	return s.NowPlaying(ctx, userId, track, position)
+	return b.wrapped.NowPlaying(ctx, userId, track, position)
 }
 
 func (b *bufferedScrobbler) Scrobble(ctx context.Context, userId string, s Scrobble) error {
@@ -131,13 +107,8 @@ func (b *bufferedScrobbler) processUserQueue(ctx context.Context, userId string)
 		if entry == nil {
 			return true
 		}
-		s, ok := b.loader()
-		if !ok {
-			log.Warn(ctx, "Scrobbler not available, will retry later", "scrobbler", b.service)
-			return false
-		}
 		log.Debug(ctx, "Sending scrobble", "scrobbler", b.service, "track", entry.Title, "artist", entry.Artist)
-		err = s.Scrobble(ctx, entry.UserID, Scrobble{
+		err = b.wrapped.Scrobble(ctx, entry.UserID, Scrobble{
 			MediaFile: entry.MediaFile,
 			TimeStamp: entry.PlayTime,
 		})

core/scrobbler/buffered_scrobbler_test.go

@@ -38,9 +38,9 @@ var _ = Describe("BufferedScrobbler", func() {
 	It("forwards NowPlaying calls", func() {
 		track := &model.MediaFile{ID: "123", Title: "Test Track"}
 		Expect(bs.NowPlaying(ctx, "user1", track, 0)).To(Succeed())
-		Expect(scr.GetNowPlayingCalled()).To(BeTrue())
-		Expect(scr.GetUserID()).To(Equal("user1"))
-		Expect(scr.GetTrack()).To(Equal(track))
+		Expect(scr.NowPlayingCalled).To(BeTrue())
+		Expect(scr.UserID).To(Equal("user1"))
+		Expect(scr.Track).To(Equal(track))
 	})
 
 	It("enqueues scrobbles to buffer", func() {
@@ -51,10 +51,9 @@ var _ = Describe("BufferedScrobbler", func() {
 		Expect(scr.ScrobbleCalled.Load()).To(BeFalse())
 
 		Expect(bs.Scrobble(ctx, "user1", scrobble)).To(Succeed())
+		Expect(buffer.Length()).To(Equal(int64(1)))
 
-		// Wait for the background goroutine to process the scrobble.
-		// We don't check buffer.Length() here because the background goroutine
-		// may dequeue the entry before we can observe it.
+		// Wait for the scrobble to be sent
 		Eventually(scr.ScrobbleCalled.Load).Should(BeTrue())
 
 		lastScrobble := scr.LastScrobble.Load()