Initial plan

.devcontainer/Dockerfile

@@ -9,21 +9,12 @@ ARG INSTALL_NODE="true"
 ARG NODE_VERSION="lts/*"
 RUN if [ "${INSTALL_NODE}" = "true" ]; then su vscode -c "source /usr/local/share/nvm/nvm.sh && nvm install ${NODE_VERSION} 2>&1"; fi
 
-# Install additional OS packages
+# [Optional] Uncomment this section to install additional OS packages.
 RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
-    && apt-get -y install --no-install-recommends ffmpeg
+    && apt-get -y install --no-install-recommends libtag1-dev ffmpeg
 
-# Install TagLib from cross-taglib releases
+# [Optional] Uncomment the next line to use go get to install anything else you need
-ARG CROSS_TAGLIB_VERSION="2.1.1-1"
+# RUN go get -x <your-dependency-or-tool>
-ARG TARGETARCH
-RUN DOWNLOAD_ARCH="linux-${TARGETARCH}" \
-    && wget -q "https://github.com/navidrome/cross-taglib/releases/download/v${CROSS_TAGLIB_VERSION}/taglib-${DOWNLOAD_ARCH}.tar.gz" -O /tmp/cross-taglib.tar.gz \
-    && tar -xzf /tmp/cross-taglib.tar.gz -C /usr --strip-components=1 \
-    && mv /usr/include/taglib/* /usr/include/ \
-    && 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

.devcontainer/devcontainer.json

@@ -7,8 +7,7 @@
 			"VARIANT": "1.25",
 			// Options
 			"INSTALL_NODE": "true",
-			"NODE_VERSION": "v24",
+			"NODE_VERSION": "v24"
-			"CROSS_TAGLIB_VERSION": "2.1.1-1"
 		}
 	},
 	"workspaceMount": "",
@@ -55,6 +54,8 @@
 		4533,
 		4633
 	],
+	// Use 'postCreateCommand' to run commands after the container is created.
+	// "postCreateCommand": "make setup-dev",
 	// Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
 	"remoteUser": "vscode",
 	"remoteEnv": {

.github/workflows/pipeline.yml

@@ -14,8 +14,7 @@ concurrency:
   cancel-in-progress: true
 
 env:
-  CROSS_TAGLIB_VERSION: "2.1.1-2"
+  CROSS_TAGLIB_VERSION: "2.1.1-1"
-  CGO_CFLAGS_ALLOW: "--define-prefix"
   IS_RELEASE: ${{ startsWith(github.ref, 'refs/tags/') && 'true' || 'false' }}
 
 jobs:
@@ -26,7 +25,7 @@ jobs:
       git_tag: ${{ steps.git-version.outputs.GIT_TAG }}
       git_sha: ${{ steps.git-version.outputs.GIT_SHA }}
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
         with:
           fetch-depth: 0
           fetch-tags: true
@@ -64,7 +63,7 @@ jobs:
     name: Lint Go code
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
 
       - name: Download TagLib
         uses: ./.github/actions/download-taglib
@@ -72,7 +71,7 @@ jobs:
           version: ${{ env.CROSS_TAGLIB_VERSION }}
 
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v9
+        uses: golangci/golangci-lint-action@v8
         with:
           version: latest
           problem-matchers: true
@@ -89,22 +88,12 @@ 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
     steps:
       - name: Check out code into the Go module directory
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
 
       - name: Download TagLib
         uses: ./.github/actions/download-taglib
@@ -119,20 +108,13 @@ 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
     env:
       NODE_OPTIONS: "--max_old_space_size=4096"
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
       - uses: actions/setup-node@v6
         with:
           node-version: 24
@@ -163,7 +145,7 @@ jobs:
     name: Lint i18n files
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
       - run: |
           set -e
           for file in resources/i18n/*.json; do
@@ -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' }}
@@ -209,7 +191,7 @@ jobs:
           PLATFORM=$(echo ${{ matrix.platform }} | tr '/' '_')
           echo "PLATFORM=$PLATFORM" >> $GITHUB_ENV
 
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
 
       - name: Prepare Docker Buildx
         uses: ./.github/actions/prepare-docker
@@ -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,55 +256,18 @@ jobs:
           if-no-files-found: error
           retention-days: 1
 
-  push-manifest-ghcr:
+  push-manifest:
-    name: Push to GHCR
+    name: Push Docker manifest
-    permissions:
-      contents: read
-      packages: write
     runs-on: ubuntu-latest
     needs: [build, check-push-enabled]
     if: needs.check-push-enabled.outputs.is_enabled == 'true'
     env:
       REGISTRY_IMAGE: ghcr.io/${{ github.repository }}
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
 
       - name: Download digests
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v6
-        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
         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
+        working-directory: /tmp/digests
-        with:
+        if: vars.DOCKER_HUB_REPO != ''
-          timeout_minutes: 5
+        run: |
-          max_attempts: 3
+          docker buildx imagetools create $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-          retry_wait_seconds: 30
+            $(printf '${{ vars.DOCKER_HUB_REPO }}@sha256:%s ' *)          
-          command: |
+
-            cd /tmp/digests
+      - name: Inspect image in ghcr.io
-            docker buildx imagetools create $(jq -cr '.tags | map(select(startswith("ghcr.io") | not)) | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
+        run: |
-              $(printf 'ghcr.io/${{ github.repository }}@sha256:%s ' *)
+          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 }}
@@ -372,9 +318,9 @@ jobs:
     runs-on: ubuntu-24.04
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
 
-      - 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
@@ -406,12 +352,12 @@ jobs:
     outputs:
       package_list: ${{ steps.set-package-list.outputs.package_list }}
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
         with:
           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

@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     if: ${{ github.repository_owner == 'navidrome' }}
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
       - name: Get updated translations
         id: poeditor
         env:
@@ -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,7 +17,6 @@ master.zip
 testDB
 cache/*
 *.swp
-coverage.out
 dist
 music
 *.db*
@@ -26,7 +25,6 @@ docker-compose.yml
 !contrib/docker-compose.yml
 binaries
 navidrome-*
-/ndpgen
 AGENTS.md
 .github/prompts
 .github/instructions
@@ -34,6 +32,3 @@ AGENTS.md
 *.exe
 *.test
 *.wasm
-*.ndp
-openspec/
-go.work*

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
+# v1.5.0
-ENV XX_VERSION=a5592eab7a57895e8d385394ff12241bc65ecd50
+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"
 
@@ -138,6 +137,7 @@ ENV ND_MUSICFOLDER=/music
 ENV ND_DATAFOLDER=/data
 ENV ND_CONFIGFILE=/data/navidrome.toml
 ENV ND_PORT=4533
+ENV GODEBUG="asyncpreemptoff=1"
 RUN touch /.nddockerenv
 
 EXPOSE ${ND_PORT}

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
+CROSS_TAGLIB_VERSION ?= 2.1.1-1
-GOLANGCI_LINT_VERSION ?= v2.8.0
+GOLANGCI_LINT_VERSION ?= v2.5.0
 
 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,15 +50,11 @@ 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
+testall: test-race test-i18n test-js ##@Development Run Go and JS tests
-	cd plugins/cmd/ndpgen && go test ./......
-.PHONY: test-ndpgen
-
-testall: test test-ndpgen test-i18n test-js ##@Development Run Go and JS tests
 .PHONY: testall
 
 test-race: ##@Development Run Go tests with race detector
-	go test -tags netgo -race -shuffle=on  $(PKG)
+	go test -tags netgo -race -shuffle=on ./...
 .PHONY: test-race
 
 test-js: ##@Development Run JS tests
@@ -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/client.go

@@ -1,217 +0,0 @@
-package deezer
-
-import (
-	bytes "bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-
-	"github.com/microcosm-cc/bluemonday"
-	"github.com/navidrome/navidrome/log"
-)
-
-const apiBaseURL = "https://api.deezer.com"
-const authBaseURL = "https://auth.deezer.com"
-
-var (
-	ErrNotFound = errors.New("deezer: not found")
-)
-
-type httpDoer interface {
-	Do(req *http.Request) (*http.Response, error)
-}
-
-type client struct {
-	httpDoer httpDoer
-	jwt      jwtToken
-}
-
-func newClient(hc httpDoer) *client {
-	return &client{
-		httpDoer: hc,
-	}
-}
-
-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 {
-		return nil, err
-	}
-	req.URL.RawQuery = params.Encode()
-
-	var results SearchArtistResults
-	err = c.makeRequest(req, &results)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(results.Data) == 0 {
-		return nil, ErrNotFound
-	}
-	return results.Data, nil
-}
-
-func (c *client) makeRequest(req *http.Request, response any) error {
-	log.Trace(req.Context(), fmt.Sprintf("Sending Deezer %s request", req.Method), "url", req.URL)
-	resp, err := c.httpDoer.Do(req)
-	if err != nil {
-		return err
-	}
-
-	defer resp.Body.Close()
-	data, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return err
-	}
-
-	if resp.StatusCode != 200 {
-		return c.parseError(data)
-	}
-
-	return json.Unmarshal(data, response)
-}
-
-func (c *client) parseError(data []byte) error {
-	var deezerError Error
-	err := json.Unmarshal(data, &deezerError)
-	if err != nil {
-		return err
-	}
-	return fmt.Errorf("deezer error(%d): %s", deezerError.Error.Code, deezerError.Error.Message)
-}
-
-func (c *client) getRelatedArtists(ctx context.Context, artistID int) ([]Artist, error) {
-	req, err := http.NewRequestWithContext(ctx, "GET", fmt.Sprintf("%s/artist/%d/related", apiBaseURL, artistID), nil)
-	if err != nil {
-		return nil, err
-	}
-
-	var results RelatedArtists
-	err = c.makeRequest(req, &results)
-	if err != nil {
-		return nil, err
-	}
-
-	return results.Data, nil
-}
-
-func (c *client) getTopTracks(ctx context.Context, artistID int, limit int) ([]Track, error) {
-	params := url.Values{}
-	params.Add("limit", strconv.Itoa(limit))
-	req, err := http.NewRequestWithContext(ctx, "GET", fmt.Sprintf("%s/artist/%d/top", apiBaseURL, artistID), nil)
-	if err != nil {
-		return nil, err
-	}
-	req.URL.RawQuery = params.Encode()
-
-	var results TopTracks
-	err = c.makeRequest(req, &results)
-	if err != nil {
-		return nil, err
-	}
-
-	return results.Data, nil
-}
-
-const pipeAPIURL = "https://pipe.deezer.com/api"
-
-var strictPolicy = bluemonday.StrictPolicy()
-
-func (c *client) getArtistBio(ctx context.Context, artistID int, lang string) (string, error) {
-	jwt, err := c.getJWT(ctx)
-	if err != nil {
-		return "", fmt.Errorf("deezer: failed to get JWT: %w", err)
-	}
-
-	query := map[string]any{
-		"operationName": "ArtistBio",
-		"variables": map[string]any{
-			"artistId": strconv.Itoa(artistID),
-		},
-		"query": `query ArtistBio($artistId: String!) {
-			artist(artistId: $artistId) {
-				bio {
-					full
-				}
-			}
-		}`,
-	}
-
-	body, err := json.Marshal(query)
-	if err != nil {
-		return "", err
-	}
-
-	req, err := http.NewRequestWithContext(ctx, "POST", pipeAPIURL, bytes.NewReader(body))
-	if err != nil {
-		return "", err
-	}
-
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Accept-Language", lang)
-	req.Header.Set("Authorization", "Bearer "+jwt)
-
-	log.Trace(ctx, "Fetching Deezer artist biography via GraphQL", "artistId", artistID, "language", lang)
-	resp, err := c.httpDoer.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != 200 {
-		return "", fmt.Errorf("deezer: failed to fetch biography: %s", resp.Status)
-	}
-
-	data, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", err
-	}
-
-	type graphQLResponse struct {
-		Data struct {
-			Artist struct {
-				Bio struct {
-					Full string `json:"full"`
-				} `json:"bio"`
-			} `json:"artist"`
-		} `json:"data"`
-		Errors []struct {
-			Message string `json:"message"`
-		}
-	}
-
-	var result graphQLResponse
-	if err := json.Unmarshal(data, &result); err != nil {
-		return "", fmt.Errorf("deezer: failed to parse GraphQL response: %w", err)
-	}
-
-	if len(result.Errors) > 0 {
-		var errs []error
-		for m := range result.Errors {
-			errs = append(errs, errors.New(result.Errors[m].Message))
-		}
-		err := errors.Join(errs...)
-		return "", fmt.Errorf("deezer: GraphQL error: %w", err)
-	}
-
-	if result.Data.Artist.Bio.Full == "" {
-		return "", errors.New("deezer: biography not found")
-	}
-
-	return cleanBio(result.Data.Artist.Bio.Full), nil
-}
-
-func cleanBio(bio string) string {
-	bio = strings.ReplaceAll(bio, "</p>", "\n")
-	return strictPolicy.Sanitize(bio)
-}

adapters/deezer/client_auth.go

@@ -1,101 +0,0 @@
-package deezer
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"sync"
-	"time"
-
-	"github.com/lestrrat-go/jwx/v2/jwt"
-	"github.com/navidrome/navidrome/log"
-)
-
-type jwtToken struct {
-	token     string
-	expiresAt time.Time
-	mu        sync.RWMutex
-}
-
-func (j *jwtToken) get() (string, bool) {
-	j.mu.RLock()
-	defer j.mu.RUnlock()
-	if time.Now().Before(j.expiresAt) {
-		return j.token, true
-	}
-	return "", false
-}
-
-func (j *jwtToken) set(token string, expiresIn time.Duration) {
-	j.mu.Lock()
-	defer j.mu.Unlock()
-	j.token = token
-	j.expiresAt = time.Now().Add(expiresIn)
-}
-
-func (c *client) getJWT(ctx context.Context) (string, error) {
-	// Check if we have a valid cached token
-	if token, valid := c.jwt.get(); valid {
-		return token, nil
-	}
-
-	// Fetch a new anonymous token
-	req, err := http.NewRequestWithContext(ctx, "GET", authBaseURL+"/login/anonymous?jo=p&rto=c", nil)
-	if err != nil {
-		return "", err
-	}
-	req.Header.Set("Accept", "application/json")
-
-	resp, err := c.httpDoer.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != 200 {
-		return "", fmt.Errorf("deezer: failed to get JWT token: %s", resp.Status)
-	}
-
-	data, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", err
-	}
-
-	type authResponse struct {
-		JWT string `json:"jwt"`
-	}
-
-	var result authResponse
-	if err := json.Unmarshal(data, &result); err != nil {
-		return "", fmt.Errorf("deezer: failed to parse auth response: %w", err)
-	}
-
-	if result.JWT == "" {
-		return "", errors.New("deezer: no JWT token in response")
-	}
-
-	// Parse JWT to get actual expiration time
-	token, err := jwt.ParseString(result.JWT, jwt.WithVerify(false), jwt.WithValidate(false))
-	if err != nil {
-		return "", fmt.Errorf("deezer: failed to parse JWT token: %w", err)
-	}
-
-	// Calculate TTL with a 1-minute buffer for clock skew and network delays
-	expiresAt := token.Expiration()
-	if expiresAt.IsZero() {
-		return "", errors.New("deezer: JWT token has no expiration time")
-	}
-
-	ttl := time.Until(expiresAt) - 1*time.Minute
-	if ttl <= 0 {
-		return "", errors.New("deezer: JWT token already expired or expires too soon")
-	}
-
-	c.jwt.set(result.JWT, ttl)
-	log.Trace(ctx, "Fetched new Deezer JWT token", "expiresAt", expiresAt, "ttl", ttl)
-
-	return result.JWT, nil
-}

adapters/deezer/client_auth_test.go

@@ -1,293 +0,0 @@
-package deezer
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"io"
-	"net/http"
-	"sync"
-	"time"
-
-	"github.com/lestrrat-go/jwx/v2/jwt"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("JWT Authentication", func() {
-	var httpClient *fakeHttpClient
-	var client *client
-	var ctx context.Context
-
-	BeforeEach(func() {
-		httpClient = &fakeHttpClient{}
-		client = newClient(httpClient)
-		ctx = context.Background()
-	})
-
-	Describe("getJWT", func() {
-		Context("with a valid JWT response", func() {
-			It("successfully fetches and caches a JWT token", func() {
-				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"}`, testJWT))),
-				})
-
-				token, err := client.getJWT(ctx)
-				Expect(err).To(BeNil())
-				Expect(token).To(Equal(testJWT))
-			})
-
-			It("returns the cached token on subsequent calls", func() {
-				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"}`, testJWT))),
-				})
-
-				// First call should fetch from API
-				token1, err := client.getJWT(ctx)
-				Expect(err).To(BeNil())
-				Expect(token1).To(Equal(testJWT))
-				Expect(httpClient.lastRequest.URL.Path).To(Equal("/login/anonymous"))
-
-				// Second call should return cached token without hitting API
-				httpClient.lastRequest = nil // Clear last request to verify no new request is made
-				token2, err := client.getJWT(ctx)
-				Expect(err).To(BeNil())
-				Expect(token2).To(Equal(testJWT))
-				Expect(httpClient.lastRequest).To(BeNil()) // No new request made
-			})
-
-			It("parses the JWT expiration time correctly", func() {
-				expectedExpiration := time.Now().Add(5 * time.Minute)
-				testToken, err := jwt.NewBuilder().
-					Expiration(expectedExpiration).
-					Build()
-				Expect(err).To(BeNil())
-				testJWT, err := jwt.Sign(testToken, jwt.WithInsecureNoSignature())
-				Expect(err).To(BeNil())
-
-				httpClient.mock("https://auth.deezer.com/login/anonymous", http.Response{
-					StatusCode: 200,
-					Body:       io.NopCloser(bytes.NewBufferString(fmt.Sprintf(`{"jwt":"%s"}`, string(testJWT)))),
-				})
-
-				token, err := client.getJWT(ctx)
-				Expect(err).To(BeNil())
-				Expect(token).ToNot(BeEmpty())
-
-				// Verify the token is cached until close to expiration
-				// The cache should expire 1 minute before the JWT expires
-				expectedCacheExpiry := expectedExpiration.Add(-1 * time.Minute)
-				Expect(client.jwt.expiresAt).To(BeTemporally("~", expectedCacheExpiry, 2*time.Second))
-			})
-		})
-
-		Context("with JWT tokens that expire soon", func() {
-			It("rejects tokens that expire in less than 1 minute", func() {
-				// Create a token that expires in 30 seconds (less than 1-minute buffer)
-				testJWT := createTestJWT(30 * time.Second)
-				httpClient.mock("https://auth.deezer.com/login/anonymous", http.Response{
-					StatusCode: 200,
-					Body:       io.NopCloser(bytes.NewBufferString(fmt.Sprintf(`{"jwt":"%s"}`, testJWT))),
-				})
-
-				_, err := client.getJWT(ctx)
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("JWT token already expired or expires too soon"))
-			})
-
-			It("rejects already expired tokens", func() {
-				// Create a token that expired 1 minute ago
-				testJWT := createTestJWT(-1 * time.Minute)
-				httpClient.mock("https://auth.deezer.com/login/anonymous", http.Response{
-					StatusCode: 200,
-					Body:       io.NopCloser(bytes.NewBufferString(fmt.Sprintf(`{"jwt":"%s"}`, testJWT))),
-				})
-
-				_, err := client.getJWT(ctx)
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("JWT token already expired or expires too soon"))
-			})
-
-			It("accepts tokens that expire in more than 1 minute", func() {
-				// Create a token that expires in 2 minutes (just over the 1-minute buffer)
-				testJWT := createTestJWT(2 * time.Minute)
-				httpClient.mock("https://auth.deezer.com/login/anonymous", http.Response{
-					StatusCode: 200,
-					Body:       io.NopCloser(bytes.NewBufferString(fmt.Sprintf(`{"jwt":"%s"}`, testJWT))),
-				})
-
-				token, err := client.getJWT(ctx)
-				Expect(err).To(BeNil())
-				Expect(token).ToNot(BeEmpty())
-			})
-		})
-
-		Context("with invalid responses", func() {
-			It("handles HTTP error responses", func() {
-				httpClient.mock("https://auth.deezer.com/login/anonymous", http.Response{
-					StatusCode: 500,
-					Body:       io.NopCloser(bytes.NewBufferString(`{"error":"Internal server error"}`)),
-				})
-
-				_, err := client.getJWT(ctx)
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("failed to get JWT token"))
-			})
-
-			It("handles malformed JSON responses", func() {
-				httpClient.mock("https://auth.deezer.com/login/anonymous", http.Response{
-					StatusCode: 200,
-					Body:       io.NopCloser(bytes.NewBufferString(`{invalid json}`)),
-				})
-
-				_, err := client.getJWT(ctx)
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("failed to parse auth response"))
-			})
-
-			It("handles responses with empty JWT field", func() {
-				httpClient.mock("https://auth.deezer.com/login/anonymous", http.Response{
-					StatusCode: 200,
-					Body:       io.NopCloser(bytes.NewBufferString(`{"jwt":""}`)),
-				})
-
-				_, err := client.getJWT(ctx)
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(Equal("deezer: no JWT token in response"))
-			})
-
-			It("handles invalid JWT tokens", func() {
-				httpClient.mock("https://auth.deezer.com/login/anonymous", http.Response{
-					StatusCode: 200,
-					Body:       io.NopCloser(bytes.NewBufferString(`{"jwt":"not-a-valid-jwt"}`)),
-				})
-
-				_, err := client.getJWT(ctx)
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("failed to parse JWT token"))
-			})
-
-			It("rejects JWT tokens without expiration", func() {
-				// Create a JWT without expiration claim
-				testToken, err := jwt.NewBuilder().
-					Claim("custom", "value").
-					Build()
-				Expect(err).To(BeNil())
-
-				// Verify token has no expiration
-				Expect(testToken.Expiration().IsZero()).To(BeTrue())
-
-				testJWT, err := jwt.Sign(testToken, jwt.WithInsecureNoSignature())
-				Expect(err).To(BeNil())
-
-				httpClient.mock("https://auth.deezer.com/login/anonymous", http.Response{
-					StatusCode: 200,
-					Body:       io.NopCloser(bytes.NewBufferString(fmt.Sprintf(`{"jwt":"%s"}`, string(testJWT)))),
-				})
-
-				_, err = client.getJWT(ctx)
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(Equal("deezer: JWT token has no expiration time"))
-			})
-		})
-
-		Context("token caching behavior", func() {
-			It("fetches a new token when the cached token expires", func() {
-				// First token expires in 5 minutes
-				firstJWT := 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"}`, firstJWT))),
-				})
-
-				token1, err := client.getJWT(ctx)
-				Expect(err).To(BeNil())
-				Expect(token1).To(Equal(firstJWT))
-
-				// Manually expire the cached token
-				client.jwt.expiresAt = time.Now().Add(-1 * time.Second)
-
-				// Second token with different expiration (10 minutes)
-				secondJWT := createTestJWT(10 * time.Minute)
-				httpClient.mock("https://auth.deezer.com/login/anonymous", http.Response{
-					StatusCode: 200,
-					Body:       io.NopCloser(bytes.NewBufferString(fmt.Sprintf(`{"jwt":"%s"}`, secondJWT))),
-				})
-
-				token2, err := client.getJWT(ctx)
-				Expect(err).To(BeNil())
-				Expect(token2).To(Equal(secondJWT))
-				Expect(token2).ToNot(Equal(token1))
-			})
-		})
-	})
-
-	Describe("jwtToken cache", func() {
-		var cache *jwtToken
-
-		BeforeEach(func() {
-			cache = &jwtToken{}
-		})
-
-		It("returns false for expired tokens", func() {
-			cache.set("test-token", -1*time.Second) // Already expired
-			token, valid := cache.get()
-			Expect(valid).To(BeFalse())
-			Expect(token).To(BeEmpty())
-		})
-
-		It("returns true for valid tokens", func() {
-			cache.set("test-token", 4*time.Minute)
-			token, valid := cache.get()
-			Expect(valid).To(BeTrue())
-			Expect(token).To(Equal("test-token"))
-		})
-
-		It("is thread-safe for concurrent access", func() {
-			wg := sync.WaitGroup{}
-
-			// Writer goroutine
-			wg.Go(func() {
-				for i := 0; i < 100; i++ {
-					cache.set(fmt.Sprintf("token-%d", i), 1*time.Hour)
-					time.Sleep(1 * time.Millisecond)
-				}
-			})
-
-			// Reader goroutine
-			wg.Go(func() {
-				for i := 0; i < 100; i++ {
-					cache.get()
-					time.Sleep(1 * time.Millisecond)
-				}
-			})
-
-			// Wait for both goroutines to complete
-			wg.Wait()
-
-			// Verify final state is valid
-			token, valid := cache.get()
-			Expect(valid).To(BeTrue())
-			Expect(token).To(HavePrefix("token-"))
-		})
-	})
-})
-
-// createTestJWT creates a valid JWT token for testing purposes
-func createTestJWT(expiresIn time.Duration) string {
-	token, err := jwt.NewBuilder().
-		Expiration(time.Now().Add(expiresIn)).
-		Build()
-	if err != nil {
-		panic(fmt.Sprintf("failed to create test JWT: %v", err))
-	}
-	signed, err := jwt.Sign(token, jwt.WithInsecureNoSignature())
-	if err != nil {
-		panic(fmt.Sprintf("failed to sign test JWT: %v", err))
-	}
-	return string(signed)
-}

adapters/deezer/client_test.go

@@ -1,210 +0,0 @@
-package deezer
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"time"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("client", func() {
-	var httpClient *fakeHttpClient
-	var client *client
-
-	BeforeEach(func() {
-		httpClient = &fakeHttpClient{}
-		client = newClient(httpClient)
-	})
-
-	Describe("ArtistImages", func() {
-		It("returns artist images from a successful request", func() {
-			f, err := os.Open("tests/fixtures/deezer.search.artist.json")
-			Expect(err).To(BeNil())
-			httpClient.mock("https://api.deezer.com/search/artist", http.Response{Body: f, StatusCode: 200})
-
-			artists, err := client.searchArtists(GinkgoT().Context(), "Michael Jackson", 20)
-			Expect(err).To(BeNil())
-			Expect(artists).To(HaveLen(17))
-			Expect(artists[0].Name).To(Equal("Michael Jackson"))
-			Expect(artists[0].PictureXl).To(Equal("https://cdn-images.dzcdn.net/images/artist/97fae13b2b30e4aec2e8c9e0c7839d92/1000x1000-000000-80-0-0.jpg"))
-		})
-
-		It("fails if artist was not found", func() {
-			httpClient.mock("https://api.deezer.com/search/artist", http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"data":[],"total":0}`)),
-			})
-
-			_, err := client.searchArtists(GinkgoT().Context(), "Michael Jackson", 20)
-			Expect(err).To(MatchError(ErrNotFound))
-		})
-	})
-
-	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
-			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))),
-			})
-		})
-
-		It("returns artist bio from a successful request", func() {
-			f, err := os.Open("tests/fixtures/deezer.artist.bio.en.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")
-			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")
-			Expect(err).To(BeNil())
-			httpClient.mock("https://pipe.deezer.com/api", http.Response{Body: f, StatusCode: 200})
-
-			_, err = client.getArtistBio(GinkgoT().Context(), 27, "fr")
-			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")
-			Expect(err).To(BeNil())
-			httpClient.mock("https://pipe.deezer.com/api", http.Response{Body: f, StatusCode: 200})
-
-			_, err = client.getArtistBio(GinkgoT().Context(), 27, "en")
-			Expect(err).To(BeNil())
-			// Verify that the Authorization header has the Bearer token format
-			authHeader := httpClient.lastRequest.Header.Get("Authorization")
-			Expect(authHeader).To(HavePrefix("Bearer "))
-			Expect(len(authHeader)).To(BeNumerically(">", 20)) // JWT tokens are longer than 20 chars
-		})
-
-		It("handles GraphQL errors", func() {
-			errorResponse := `{
-				"data": {
-					"artist": {
-						"bio": {
-							"full": ""
-						}
-					}
-				},
-				"errors": [
-					{
-						"message": "Artist not found"
-					},
-					{
-						"message": "Invalid artist ID"
-					}
-				]
-			}`
-			httpClient.mock("https://pipe.deezer.com/api", http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(errorResponse)),
-			})
-
-			_, err := client.getArtistBio(GinkgoT().Context(), 999, "en")
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("GraphQL error"))
-			Expect(err.Error()).To(ContainSubstring("Artist not found"))
-			Expect(err.Error()).To(ContainSubstring("Invalid artist ID"))
-		})
-
-		It("handles empty biography", func() {
-			emptyBioResponse := `{
-				"data": {
-					"artist": {
-						"bio": {
-							"full": ""
-						}
-					}
-				}
-			}`
-			httpClient.mock("https://pipe.deezer.com/api", http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(emptyBioResponse)),
-			})
-
-			_, err := client.getArtistBio(GinkgoT().Context(), 27, "en")
-			Expect(err).To(MatchError("deezer: biography not found"))
-		})
-
-		It("handles JWT token fetch failure", func() {
-			httpClient.mock("https://auth.deezer.com/login/anonymous", http.Response{
-				StatusCode: 500,
-				Body:       io.NopCloser(bytes.NewBufferString(`{"error":"Internal server error"}`)),
-			})
-
-			_, err := client.getArtistBio(GinkgoT().Context(), 27, "en")
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("failed to get JWT"))
-		})
-
-		It("handles JWT token that expires too soon", func() {
-			// Create a JWT that expires in 30 seconds (less than the 1-minute buffer)
-			expiredJWT := createTestJWT(30 * time.Second)
-			httpClient.mock("https://auth.deezer.com/login/anonymous", http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(fmt.Sprintf(`{"jwt":"%s","refresh_token":""}`, expiredJWT))),
-			})
-
-			_, err := client.getArtistBio(GinkgoT().Context(), 27, "en")
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("JWT token already expired or expires too soon"))
-		})
-	})
-})
-
-type fakeHttpClient struct {
-	responses   map[string]*http.Response
-	lastRequest *http.Request
-}
-
-func (c *fakeHttpClient) mock(url string, response http.Response) {
-	if c.responses == nil {
-		c.responses = make(map[string]*http.Response)
-	}
-	c.responses[url] = &response
-}
-
-func (c *fakeHttpClient) Do(req *http.Request) (*http.Response, error) {
-	c.lastRequest = req
-	u := req.URL
-	u.RawQuery = ""
-	if resp, ok := c.responses[u.String()]; ok {
-		return resp, nil
-	}
-	panic("URL not mocked: " + u.String())
-}

adapters/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/deezer/responses.go

@@ -1,66 +0,0 @@
-package deezer
-
-type SearchArtistResults struct {
-	Data  []Artist `json:"data"`
-	Total int      `json:"total"`
-	Next  string   `json:"next"`
-}
-
-type Artist struct {
-	ID            int    `json:"id"`
-	Name          string `json:"name"`
-	Link          string `json:"link"`
-	Picture       string `json:"picture"`
-	PictureSmall  string `json:"picture_small"`
-	PictureMedium string `json:"picture_medium"`
-	PictureBig    string `json:"picture_big"`
-	PictureXl     string `json:"picture_xl"`
-	NbAlbum       int    `json:"nb_album"`
-	NbFan         int    `json:"nb_fan"`
-	Radio         bool   `json:"radio"`
-	Tracklist     string `json:"tracklist"`
-	Type          string `json:"type"`
-}
-
-type Error struct {
-	Error struct {
-		Type    string `json:"type"`
-		Message string `json:"message"`
-		Code    int    `json:"code"`
-	} `json:"error"`
-}
-
-type RelatedArtists struct {
-	Data  []Artist `json:"data"`
-	Total int      `json:"total"`
-}
-
-type TopTracks struct {
-	Data  []Track `json:"data"`
-	Total int     `json:"total"`
-	Next  string  `json:"next"`
-}
-
-type Track struct {
-	ID           int      `json:"id"`
-	Title        string   `json:"title"`
-	Link         string   `json:"link"`
-	Duration     int      `json:"duration"`
-	Rank         int      `json:"rank"`
-	Preview      string   `json:"preview"`
-	Artist       Artist   `json:"artist"`
-	Album        Album    `json:"album"`
-	Contributors []Artist `json:"contributors"`
-}
-
-type Album struct {
-	ID          int    `json:"id"`
-	Title       string `json:"title"`
-	Cover       string `json:"cover"`
-	CoverSmall  string `json:"cover_small"`
-	CoverMedium string `json:"cover_medium"`
-	CoverBig    string `json:"cover_big"`
-	CoverXl     string `json:"cover_xl"`
-	Tracklist   string `json:"tracklist"`
-	Type        string `json:"type"`
-}

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 {
-		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),
-		Codec:      props.Codec,
-	}
-
-	// 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/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) {
+func runExporter() {
-	ds, ctx := getAdminContext(ctx)
+	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)
+		user, err := ds.User(ctx).FindByUsername(userID)
-		if err != nil {
+
-			log.Fatal(ctx, "Error retrieving user", "username or id", 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,20 +330,23 @@ 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
 	}
 }
 
 // TODO: Implement some struct tags to map flags to viper
 func init() {
 	cobra.OnInitialize(func() {
-		conf.InitConfig(cfgFile, true)
+		conf.InitConfig(cfgFile)
 	})
 
 	rootCmd.PersistentFlags().StringVarP(&cfgFile, "configfile", "c", "", `config file (default "./navidrome.toml")`)
@@ -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,17 +1,13 @@
 package cmd
 
 import (
-	"bufio"
 	"context"
 	"encoding/gob"
-	"fmt"
 	"os"
-	"strings"
 
 	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/db"
 	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/persistence"
 	"github.com/navidrome/navidrome/scanner"
 	"github.com/navidrome/navidrome/utils/pl"
@@ -21,15 +17,11 @@ import (
 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,25 +68,7 @@ func runScanner(ctx context.Context) {
 	ds := persistence.New(sqlDB)
 	pls := core.NewPlaylists(ds)
 
-	// Parse targets from command line or file
+	progress, err := scanner.CallScan(ctx, ds, pls, fullScan)
-	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 {
-		scanTargets, err = model.ParseTargets(targets)
-		if err != nil {
-			log.Fatal(ctx, "Failed to parse targets", err)
-		}
-		log.Info(ctx, "Scanning specific folders", "numTargets", len(scanTargets))
-	}
-
-	progress, err := scanner.CallScan(ctx, ds, pls, fullScan, scanTargets)
 	if err != nil {
 		log.Fatal(ctx, "Failed to scan", err)
 	}
@@ -106,31 +80,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,17 +9,16 @@ 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"
 	"github.com/navidrome/navidrome/core/metrics"
 	"github.com/navidrome/navidrome/core/playback"
 	"github.com/navidrome/navidrome/core/scrobbler"
-	"github.com/navidrome/navidrome/core/transcode"
 	"github.com/navidrome/navidrome/db"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/persistence"
@@ -33,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"
 )
 
@@ -53,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
 }
@@ -63,22 +59,20 @@ 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)
-	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
+	broker := events.GetBroker()
-	watcher := scanner.GetWatcher(dataStore, modelScanner)
+	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
-	library := core.NewLibrary(dataStore, modelScanner, watcher, broker, manager)
+	watcher := scanner.GetWatcher(dataStore, scannerScanner)
-	user := core.NewUser(dataStore, manager)
+	library := core.NewLibrary(dataStore, scannerScanner, watcher, broker)
-	maintenance := core.NewMaintenance(dataStore)
+	router := nativeapi.New(dataStore, share, playlists, insights, library)
-	router := nativeapi.New(dataStore, share, playlists, insights, library, user, maintenance, manager)
 	return router
 }
 
@@ -87,9 +81,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)
@@ -99,12 +92,12 @@ 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)
+	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
 	playTracker := scrobbler.GetPlayTracker(dataStore, broker, manager)
 	playbackServer := playback.GetInstance(dataStore)
-	decider := transcode.NewDecider(dataStore)
+	router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, scannerScanner, broker, playlists, playTracker, share, playbackServer, metricsMetrics)
-	router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, modelScanner, broker, playlists, playTracker, share, playbackServer, metricsMetrics, decider)
 	return router
 }
 
@@ -113,9 +106,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)
@@ -144,7 +136,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
 }
 
@@ -155,21 +149,21 @@ func CreatePrometheus() metrics.Metrics {
 	return metricsMetrics
 }
 
-func CreateScanner(ctx context.Context) model.Scanner {
+func CreateScanner(ctx context.Context) scanner.Scanner {
 	sqlDB := db.Db()
 	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)
+	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
-	return modelScanner
+	return scannerScanner
 }
 
 func CreateScanWatcher(ctx context.Context) scanner.Watcher {
@@ -177,16 +171,16 @@ 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)
+	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
-	watcher := scanner.GetWatcher(dataStore, modelScanner)
+	watcher := scanner.GetWatcher(dataStore, scannerScanner)
 	return watcher
 }
 
@@ -197,20 +191,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.Scanner), new(scanner.Scanner)), 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,13 @@ 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(agents.PluginLoader), new(*plugins.Manager)),
+	wire.Bind(new(scrobbler.PluginLoader), new(plugins.Manager)),
-	wire.Bind(new(scrobbler.PluginLoader), new(*plugins.Manager)),
+	wire.Bind(new(metrics.PluginLoader), new(plugins.Manager)),
-	wire.Bind(new(nativeapi.PluginManager), new(*plugins.Manager)),
+	wire.Bind(new(core.Scanner), new(scanner.Scanner)),
-	wire.Bind(new(core.PluginUnloader), new(*plugins.Manager)),
-	wire.Bind(new(plugins.PluginMetricsRecorder), new(metrics.Metrics)),
 	wire.Bind(new(core.Watcher), new(scanner.Watcher)),
 )
 
@@ -104,7 +103,7 @@ func CreatePrometheus() metrics.Metrics {
 	))
 }
 
-func CreateScanner(ctx context.Context) model.Scanner {
+func CreateScanner(ctx context.Context) scanner.Scanner {
 	panic(wire.Build(
 		allProviders,
 	))
@@ -122,13 +121,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,34 @@ 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"`
+	DevLogLevels                     map[string]string `json:",omitempty"`
-	DevLogSourceLine                  bool
+	DevLogSourceLine                 bool
-	DevEnableProfiler                 bool
+	DevEnableProfiler                bool
-	DevAutoCreateAdminPassword        string
+	DevAutoCreateAdminPassword       string
-	DevAutoLoginUsername              string
+	DevAutoLoginUsername             string
-	DevActivityPanel                  bool
+	DevActivityPanel                 bool
-	DevActivityPanelUpdateRate        time.Duration
+	DevActivityPanelUpdateRate       time.Duration
-	DevSidebarPlaylists               bool
+	DevSidebarPlaylists              bool
-	DevShowArtistPage                 bool
+	DevShowArtistPage                bool
-	DevUIShowConfig                   bool
+	DevUIShowConfig                  bool
-	DevNewEventStream                 bool
+	DevNewEventStream                bool
-	DevOffsetOptimize                 int
+	DevOffsetOptimize                int
-	DevArtworkMaxRequests             int
+	DevArtworkMaxRequests            int
-	DevArtworkThrottleBacklogLimit    int
+	DevArtworkThrottleBacklogLimit   int
-	DevArtworkThrottleBacklogTimeout  time.Duration
+	DevArtworkThrottleBacklogTimeout time.Duration
-	DevArtistInfoTimeToLive           time.Duration
+	DevArtistInfoTimeToLive          time.Duration
-	DevAlbumInfoTimeToLive            time.Duration
+	DevAlbumInfoTimeToLive           time.Duration
-	DevExternalScanner                bool
+	DevExternalScanner               bool
-	DevScannerThreads                 uint
+	DevScannerThreads                uint
-	DevSelectiveWatcher               bool
+	DevInsightsInitialDelay          time.Duration
-	DevLegacyEmbedImage               bool
+	DevEnablePlayerInsights          bool
-	DevInsightsInitialDelay           time.Duration
+	DevEnablePluginsInsights         bool
-	DevEnablePlayerInsights           bool
+	DevPluginCompilationTimeout      time.Duration
-	DevEnablePluginsInsights          bool
+	DevExternalArtistFetchMultiplier float64
-	DevPluginCompilationTimeout       time.Duration
-	DevExternalArtistFetchMultiplier  float64
-	DevOptimizeDB                     bool
-	DevPreserveUnicodeInExternalCalls bool
 }
 
 type scannerOptions struct {
@@ -155,9 +149,7 @@ type subsonicOptions struct {
 	AppendSubtitle        bool
 	ArtistParticipations  bool
 	DefaultReportRealPath bool
-	EnableAverageRating   bool
 	LegacyClients         string
-	MinimalClients        string
 }
 
 type TagConf struct {
@@ -175,9 +167,6 @@ type lastfmOptions struct {
 	Secret                  string
 	Language                string
 	ScrobbleFirstArtistOnly bool
-
-	// Computed values
-	Languages []string // Computed from Language, split by comma
 }
 
 type spotifyOptions struct {
@@ -186,11 +175,7 @@ type spotifyOptions struct {
 }
 
 type deezerOptions struct {
-	Enabled  bool
+	Enabled bool
-	Language string
-
-	// Computed values
-	Languages []string // Computed from Language, split by comma
 }
 
 type listenBrainzOptions struct {
@@ -198,8 +183,8 @@ type listenBrainzOptions struct {
 	BaseURL string
 }
 
-type httpHeaderOptions struct {
+type secureOptions struct {
-	FrameOptions string
+	CustomFrameOptionsValue string
 }
 
 type prometheusOptions struct {
@@ -236,16 +221,9 @@ type inspectOptions struct {
 }
 
 type pluginsOptions struct {
-	Enabled    bool
+	Enabled   bool
-	Folder     string
+	Folder    string
-	CacheSize  string
+	CacheSize string
-	AutoReload bool
-	LogLevel   string
-}
-
-type extAuthOptions struct {
-	TrustedSources string
-	UserHeader     string
 }
 
 var (
@@ -266,11 +244,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)
@@ -354,18 +327,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)
 		}
@@ -376,22 +340,13 @@ func Load(noConfigDump bool) {
 		disableExternalServices()
 	}
 
-	// Make sure we don't have empty PIDs
+	if Server.Scanner.Extractor != consts.DefaultScannerExtractor {
-	Server.PID.Album = cmp.Or(Server.PID.Album, consts.DefaultAlbumPID)
+		log.Warn(fmt.Sprintf("Extractor '%s' is not implemented, using 'taglib'", Server.Scanner.Extractor))
-	Server.PID.Track = cmp.Or(Server.PID.Track, consts.DefaultTrackPID)
+		Server.Scanner.Extractor = consts.DefaultScannerExtractor
-
+	}
-	// Parse LastFM.Language into Languages slice (comma-separated, with fallback to DefaultInfoLanguage)
+	logDeprecatedOptions("Scanner.GenreSeparators")
-	Server.LastFM.Languages = parseLanguages(Server.LastFM.Language)
+	logDeprecatedOptions("Scanner.GroupAlbumReleases")
-
+	logDeprecatedOptions("DevEnableBufferedScrobble") // Deprecated: Buffered scrobbling is now always enabled and this option is ignored
-	// 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")
 
 	// Call init hooks
 	for _, hook := range hooks {
@@ -399,29 +354,15 @@ func Load(noConfigDump bool) {
 	}
 }
 
-func logDeprecatedOptions(oldName, newName string) {
+func logDeprecatedOptions(options ...string) {
-	envVar := "ND_" + strings.ToUpper(strings.ReplaceAll(oldName, ".", "_"))
+	for _, option := range options {
-	newEnvVar := "ND_" + strings.ToUpper(strings.ReplaceAll(newName, ".", "_"))
+		envVar := "ND_" + strings.ToUpper(strings.ReplaceAll(option, ".", "_"))
-	logWarning := func(oldName, newName string) {
+		if os.Getenv(envVar) != "" {
-		if newName != "" {
+			log.Warn(fmt.Sprintf("Option '%s' is deprecated and will be ignored in a future release", envVar))
-			log.Warn(fmt.Sprintf("Option '%s' is deprecated and will be ignored in a future release. Please use the new '%s'", oldName, newName))
+		}
-		} else {
+		if viper.InConfig(option) {
-			log.Warn(fmt.Sprintf("Option '%s' is deprecated and will be ignored in a future release", oldName))
+			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))
 	}
 }
 
@@ -474,22 +415,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
@@ -500,7 +425,7 @@ func validatePurgeMissingOption() error {
 		}
 	}
 	if !valid {
-		err := fmt.Errorf("invalid Scanner.PurgeMissing value: '%s'. Must be one of: %v", Server.Scanner.PurgeMissing, allowedValues)
+		err := fmt.Errorf("Invalid Scanner.PurgeMissing value: '%s'. Must be one of: %v", Server.Scanner.PurgeMissing, allowedValues)
 		log.Error(err.Error())
 		Server.Scanner.PurgeMissing = consts.PurgeMissingNever
 		return err
@@ -547,16 +472,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", "")
@@ -574,7 +489,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)
@@ -589,7 +503,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")
@@ -620,8 +533,8 @@ func setViperDefaults() {
 	viper.SetDefault("authrequestlimit", 5)
 	viper.SetDefault("authwindowlength", 20*time.Second)
 	viper.SetDefault("passwordencryptionkey", "")
-	viper.SetDefault("extauth.userheader", "Remote-User")
+	viper.SetDefault("reverseproxyuserheader", "Remote-User")
-	viper.SetDefault("extauth.trustedsources", "")
+	viper.SetDefault("reverseproxywhitelist", "")
 	viper.SetDefault("prometheus.enabled", false)
 	viper.SetDefault("prometheus.metricspath", consts.PrometheusDefaultPath)
 	viper.SetDefault("prometheus.password", "")
@@ -642,23 +555,19 @@ 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("listenbrainz.enabled", true)
 	viper.SetDefault("listenbrainz.baseurl", "https://api.listenbrainz.org/1/")
-	viper.SetDefault("enablescrobblehistory", true)
+	viper.SetDefault("httpsecurityheaders.customframeoptionsvalue", "DENY")
-	viper.SetDefault("httpheaders.frameoptions", "DENY")
 	viper.SetDefault("backup.path", "")
 	viper.SetDefault("backup.schedule", "")
 	viper.SetDefault("backup.count", 0)
@@ -669,9 +578,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.enabled", false)
-	viper.SetDefault("plugins.cachesize", "200MB")
+	viper.SetDefault("plugins.cachesize", "100MB")
-	viper.SetDefault("plugins.autoreload", false)
 
 	// DevFlags. These are used to enable/disable debugging and incomplete features
 	viper.SetDefault("devlogsourceline", false)
@@ -692,28 +600,20 @@ func setViperDefaults() {
 	viper.SetDefault("devalbuminfotimetolive", consts.AlbumInfoTimeToLive)
 	viper.SetDefault("devexternalscanner", true)
 	viper.SetDefault("devscannerthreads", 5)
-	viper.SetDefault("devselectivewatcher", true)
 	viper.SetDefault("devinsightsinitialdelay", consts.InsightsInitialDelay)
 	viper.SetDefault("devenableplayerinsights", true)
 	viper.SetDefault("devenablepluginsinsights", true)
 	viper.SetDefault("devplugincompilationtimeout", time.Minute)
 	viper.SetDefault("devexternalartistfetchmultiplier", 1.5)
-	viper.SetDefault("devoptimizedb", true)
-	viper.SetDefault("devpreserveunicodeinexternalcalls", false)
 }
 
 func init() {
 	setViperDefaults()
 }
 
-func InitConfig(cfgFile string, loadEnvVars bool) {
+func InitConfig(cfgFile string) {
 	codecRegistry := viper.NewCodecRegistry()
-	_ = codecRegistry.RegisterCodec("ini", ini.Codec{
+	_ = codecRegistry.RegisterCodec("ini", ini.Codec{})
-		LoadOptions: ini.LoadOptions{
-			UnescapeValueDoubleQuotes:   true,
-			UnescapeValueCommentSymbols: true,
-		},
-	})
 	viper.SetOptions(viper.WithCodecRegistry(codecRegistry))
 
 	cfgFile = getConfigFile(cfgFile)
@@ -727,12 +627,10 @@ func InitConfig(cfgFile string, loadEnvVars bool) {
 	}
 
 	_ = viper.BindEnv("port")
-	if loadEnvVars {
+	viper.SetEnvPrefix("ND")
-		viper.SetEnvPrefix("ND")
+	replacer := strings.NewReplacer(".", "_")
-		replacer := strings.NewReplacer(".", "_")
+	viper.SetEnvKeyReplacer(replacer)
-		viper.SetEnvKeyReplacer(replacer)
+	viper.AutomaticEnv()
-		viper.AutomaticEnv()
-	}
 
 	err := viper.ReadInConfig()
 	if viper.ConfigFileUsed() != "" && err != nil {

conf/configuration_test.go

@@ -26,38 +26,12 @@ 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)
 
 			// Initialize config with the test file
-			conf.InitConfig(filename, false)
+			conf.InitConfig(filename)
 			// Load the configuration (with noConfigDump=true)
 			conf.Load(true)
 
@@ -65,10 +39,6 @@ var _ = Describe("Configuration", func() {
 			Expect(conf.Server.MusicFolder).To(Equal(fmt.Sprintf("/%s/music", format)))
 			Expect(conf.Server.UIWelcomeMessage).To(Equal("Welcome " + format))
 			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,8 +1,6 @@
 [default]
 MusicFolder = /ini/music
-UIWelcomeMessage = 'Welcome ini' ; Just a comment to test the LoadOptions
+UIWelcomeMessage = Welcome ini
-ReverseProxyUserHeader = 'X-Auth-User'
 
 [Tags]
 Custom.Aliases = ini,test
-artist.Split = ";" # Should be able to read ; as a separator

conf/testdata/cfg.json

@@ -1,11 +1,7 @@
 {
   "musicFolder": "/json/music",
   "uiWelcomeMessage": "Welcome json",
-  "reverseProxyUserHeader": "X-Auth-User",
   "Tags": {
-    "artist": {
-      "split": ";"
-    },
     "custom": {
       "aliases": [
         "json",

conf/testdata/cfg.toml

@@ -1,8 +1,5 @@
 musicFolder = "/toml/music"
 uiWelcomeMessage = "Welcome toml"
-ReverseProxyUserHeader = "X-Auth-User"
-
-Tags.artist.Split = ';'
 
 [Tags.custom]
 aliases = ["toml", "test"]

conf/testdata/cfg.yaml

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

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
@@ -152,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, ",")
 
@@ -90,7 +87,7 @@ func (a *Agents) getEnabledAgentNames() []enabledAgent {
 		} else if isPlugin {
 			validAgents = append(validAgents, enabledAgent{name: name, isPlugin: true})
 		} else {
-			log.Debug("Unknown agent ignored", "name", name)
+			log.Warn("Unknown agent ignored", "name", name)
 		}
 	}
 	return validAgents
@@ -131,14 +128,26 @@ func (a *Agents) GetArtistMBID(ctx context.Context, id string, name string) (str
 	case consts.VariousArtistsID:
 		return "", nil
 	}
-
+	start := time.Now()
-	return callAgentMethod(ctx, a, "GetArtistMBID", func(ag Interface) (string, error) {
+	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
 	}
-
+	start := time.Now()
-	return callAgentMethod(ctx, a, "GetArtistURL", func(ag Interface) (string, error) {
+	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
 	}
-
+	start := time.Now()
-	return callAgentMethod(ctx, a, "GetArtistBiography", func(ag Interface) (string, error) {
+	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
 	}
-
+	start := time.Now()
-	return callAgentSliceMethod(ctx, a, "GetArtistImages", func(ag Interface) ([]ExternalImage, error) {
+	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
 	}
-
+	start := time.Now()
-	return callAgentMethod(ctx, a, "GetAlbumInfo", func(ag Interface) (*AlbumInfo, error) {
+	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
 	}
-
+	start := time.Now()
-	return callAgentSliceMethod(ctx, a, "GetAlbumImages", func(ag Interface) ([]ExternalImage, error) {
+	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) {
+		images, err := retriever.GetAlbumImages(ctx, name, artist, mbid)
-			break
+		if len(images) > 0 && err == nil {
-		}
+			log.Debug(ctx, "Got Album Images", "agent", ag.AgentName(), "album", name, "artist", artist,
-		result, err := fn(ag)
+				"mbid", mbid, "elapsed", time.Since(start))
-		if err != nil {
+			return images, 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
 		}
 	}
 	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

@@ -0,0 +1,83 @@
+package deezer
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strconv"
+
+	"github.com/navidrome/navidrome/log"
+)
+
+const apiBaseURL = "https://api.deezer.com"
+
+var (
+	ErrNotFound = errors.New("deezer: not found")
+)
+
+type httpDoer interface {
+	Do(req *http.Request) (*http.Response, error)
+}
+
+type client struct {
+	httpDoer httpDoer
+}
+
+func newClient(hc httpDoer) *client {
+	return &client{hc}
+}
+
+func (c *client) searchArtists(ctx context.Context, name string, limit int) ([]Artist, error) {
+	params := url.Values{}
+	params.Add("q", name)
+	params.Add("limit", strconv.Itoa(limit))
+	req, err := http.NewRequestWithContext(ctx, "GET", apiBaseURL+"/search/artist", nil)
+	if err != nil {
+		return nil, err
+	}
+	req.URL.RawQuery = params.Encode()
+
+	var results SearchArtistResults
+	err = c.makeRequest(req, &results)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(results.Data) == 0 {
+		return nil, ErrNotFound
+	}
+	return results.Data, nil
+}
+
+func (c *client) makeRequest(req *http.Request, response interface{}) error {
+	log.Trace(req.Context(), fmt.Sprintf("Sending Deezer %s request", req.Method), "url", req.URL)
+	resp, err := c.httpDoer.Do(req)
+	if err != nil {
+		return err
+	}
+
+	defer resp.Body.Close()
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	if resp.StatusCode != 200 {
+		return c.parseError(data)
+	}
+
+	return json.Unmarshal(data, response)
+}
+
+func (c *client) parseError(data []byte) error {
+	var deezerError Error
+	err := json.Unmarshal(data, &deezerError)
+	if err != nil {
+		return err
+	}
+	return fmt.Errorf("deezer error(%d): %s", deezerError.Error.Code, deezerError.Error.Message)
+}

core/agents/deezer/client_test.go

@@ -0,0 +1,68 @@
+package deezer
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"net/http"
+	"os"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("client", func() {
+	var httpClient *fakeHttpClient
+	var client *client
+
+	BeforeEach(func() {
+		httpClient = &fakeHttpClient{}
+		client = newClient(httpClient)
+	})
+
+	Describe("ArtistImages", func() {
+		It("returns artist images from a successful request", func() {
+			f, err := os.Open("tests/fixtures/deezer.search.artist.json")
+			Expect(err).To(BeNil())
+			httpClient.mock("https://api.deezer.com/search/artist", http.Response{Body: f, StatusCode: 200})
+
+			artists, err := client.searchArtists(context.TODO(), "Michael Jackson", 20)
+			Expect(err).To(BeNil())
+			Expect(artists).To(HaveLen(17))
+			Expect(artists[0].Name).To(Equal("Michael Jackson"))
+			Expect(artists[0].PictureXl).To(Equal("https://cdn-images.dzcdn.net/images/artist/97fae13b2b30e4aec2e8c9e0c7839d92/1000x1000-000000-80-0-0.jpg"))
+		})
+
+		It("fails if artist was not found", func() {
+			httpClient.mock("https://api.deezer.com/search/artist", http.Response{
+				StatusCode: 200,
+				Body:       io.NopCloser(bytes.NewBufferString(`{"data":[],"total":0}`)),
+			})
+
+			_, err := client.searchArtists(context.TODO(), "Michael Jackson", 20)
+			Expect(err).To(MatchError(ErrNotFound))
+		})
+	})
+})
+
+type fakeHttpClient struct {
+	responses   map[string]*http.Response
+	lastRequest *http.Request
+}
+
+func (c *fakeHttpClient) mock(url string, response http.Response) {
+	if c.responses == nil {
+		c.responses = make(map[string]*http.Response)
+	}
+	c.responses[url] = &response
+}
+
+func (c *fakeHttpClient) Do(req *http.Request) (*http.Response, error) {
+	c.lastRequest = req
+	u := req.URL
+	u.RawQuery = ""
+	if resp, ok := c.responses[u.String()]; ok {
+		return resp, nil
+	}
+	panic("URL not mocked: " + u.String())
+}

core/agents/deezer/deezer.go

@@ -3,7 +3,6 @@ package deezer
 import (
 	"context"
 	"errors"
-	"fmt"
 	"net/http"
 	"strings"
 
@@ -13,7 +12,6 @@ import (
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/utils/cache"
-	"github.com/navidrome/navidrome/utils/slice"
 )
 
 const deezerAgentName = "deezer"
@@ -26,14 +24,10 @@ const deezerArtistSearchLimit = 50
 type deezerAgent struct {
 	dataStore model.DataStore
 	client    *client
-	languages []string
 }
 
 func deezerConstructor(dataStore model.DataStore) agents.Interface {
-	agent := &deezerAgent{
+	agent := &deezerAgent{dataStore: dataStore}
-		dataStore: dataStore,
-		languages: conf.Server.Deezer.Languages,
-	}
 	httpClient := &http.Client{
 		Timeout: consts.DefaultHttpClientTimeOut,
 	}
@@ -87,82 +81,13 @@ 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
 }
 
-func (s *deezerAgent) GetSimilarArtists(ctx context.Context, _, name, _ string, limit int) ([]agents.Artist, error) {
-	artist, err := s.searchArtist(ctx, name)
-	if err != nil {
-		return nil, err
-	}
-
-	related, err := s.client.getRelatedArtists(ctx, artist.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	res := slice.Map(related, func(r Artist) agents.Artist {
-		return agents.Artist{
-			Name: r.Name,
-		}
-	})
-	if len(res) > limit {
-		res = res[:limit]
-	}
-	return res, nil
-}
-
-func (s *deezerAgent) GetArtistTopSongs(ctx context.Context, _, artistName, _ string, count int) ([]agents.Song, error) {
-	artist, err := s.searchArtist(ctx, artistName)
-	if err != nil {
-		return nil, err
-	}
-
-	tracks, err := s.client.getTopTracks(ctx, artist.ID, count)
-	if err != nil {
-		return nil, err
-	}
-
-	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
-		}
-	})
-	return res, nil
-}
-
-func (s *deezerAgent) GetArtistBiography(ctx context.Context, _, name, _ string) (string, error) {
-	artist, err := s.searchArtist(ctx, name)
-	if err != nil {
-		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
-}
-
 func init() {
 	conf.AddHook(func() {
 		if conf.Server.Deezer.Enabled {

core/agents/deezer/responses.go

@@ -0,0 +1,31 @@
+package deezer
+
+type SearchArtistResults struct {
+	Data  []Artist `json:"data"`
+	Total int      `json:"total"`
+	Next  string   `json:"next"`
+}
+
+type Artist struct {
+	ID            int    `json:"id"`
+	Name          string `json:"name"`
+	Link          string `json:"link"`
+	Picture       string `json:"picture"`
+	PictureSmall  string `json:"picture_small"`
+	PictureMedium string `json:"picture_medium"`
+	PictureBig    string `json:"picture_big"`
+	PictureXl     string `json:"picture_xl"`
+	NbAlbum       int    `json:"nb_album"`
+	NbFan         int    `json:"nb_fan"`
+	Radio         bool   `json:"radio"`
+	Tracklist     string `json:"tracklist"`
+	Type          string `json:"type"`
+}
+
+type Error struct {
+	Error struct {
+		Type    string `json:"type"`
+		Message string `json:"message"`
+		Code    int    `json:"code"`
+	} `json:"error"`
+}

core/agents/deezer/responses_test.go

@@ -35,35 +35,4 @@ var _ = Describe("Responses", func() {
 			Expect(errorResp.Error.Message).To(Equal("Missing parameters: q"))
 		})
 	})
-
-	Describe("Related Artists", func() {
-		It("parses the related artists response correctly", func() {
-			var resp RelatedArtists
-			body, err := os.ReadFile("tests/fixtures/deezer.artist.related.json")
-			Expect(err).To(BeNil())
-			err = json.Unmarshal(body, &resp)
-			Expect(err).To(BeNil())
-
-			Expect(resp.Data).To(HaveLen(20))
-			justice := resp.Data[0]
-			Expect(justice.Name).To(Equal("Justice"))
-			Expect(justice.ID).To(Equal(6404))
-		})
-	})
-
-	Describe("Top Tracks", func() {
-		It("parses the top tracks response correctly", func() {
-			var resp TopTracks
-			body, err := os.ReadFile("tests/fixtures/deezer.artist.top.json")
-			Expect(err).To(BeNil())
-			err = json.Unmarshal(body, &resp)
-			Expect(err).To(BeNil())
-
-			Expect(resp.Data).To(HaveLen(5))
-			track := resp.Data[0]
-			Expect(track.Title).To(Equal("Instant Crush (feat. Julian Casablancas)"))
-			Expect(track.ID).To(Equal(67238732))
-			Expect(track.Album.Title).To(Equal("Random Access Memories"))
-		})
-	})
 })

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
-	Name       string
+	MBID string
-	MBID       string
-	ISRC       string
-	Artist     string
-	ArtistMBID string
-	Album      string
-	AlbumMBID  string
-	Duration   uint32 // Duration in milliseconds, 0 means unknown
 }
 
 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,8 +26,8 @@ const (
 	sessionKeyProperty = "LastFMSessionKey"
 )
 
-var ignoredContent = []string{
+var ignoredBiographies = []string{
-	// Empty Artist/Album
+	// Unknown Artist
 	`<a href="https://www.last.fm/music/`,
 }
 
@@ -36,9 +36,8 @@ type lastfmAgent struct {
 	sessionKeys  *agents.SessionKeys
 	apiKey       string
 	secret       string
-	languages    []string
+	lang         string
 	client       *client
-	httpClient   httpDoer
 	getInfoMutex sync.Mutex
 }
 
@@ -48,7 +47,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},
@@ -57,8 +56,7 @@ func lastFMConstructor(ds model.DataStore) *lastfmAgent {
 		Timeout: consts.DefaultHttpClientTimeOut,
 	}
 	chc := cache.NewHTTPClient(hc, consts.DefaultHttpClientTimeOut)
-	l.httpClient = chc
+	l.client = newClient(l.apiKey, l.secret, l.lang, chc)
-	l.client = newClient(l.apiKey, l.secret, chc)
 	return l
 }
 
@@ -68,47 +66,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
+	a, err := l.callAlbumGetInfo(ctx, name, artist, mbid)
-	var resp agents.AlbumInfo
+	if err != nil {
-	for _, lang := range l.languages {
+		return nil, err
-		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 = strings.TrimSpace(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)
 	}
-	// This condition should not be hit (languages default to ["en"]), but just in case
+
-	if a == nil {
+	return &agents.AlbumInfo{
-		return nil, agents.ErrNotFound
+		Name:        a.Name,
-	}
+		MBID:        a.MBID,
-	return &resp, nil
+		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
 	}
@@ -143,7 +116,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
 	}
@@ -154,7 +127,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
 	}
@@ -165,17 +138,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)
-		a, err := l.callArtistGetInfo(ctx, name, lang)
+	if err != nil {
-		if err != nil {
+		return "", err
-			return "", err
-		}
-		if isValidContent(a.Bio.Summary) {
-			return strings.TrimSpace(a.Bio.Summary), nil
-		}
-		log.Debug(ctx, "LastFM/artist.getInfo returned empty/ignored biography, trying next language", "artist", name, "lang", lang)
 	}
-	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) {
@@ -214,34 +190,14 @@ 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) {
+var artistOpenGraphQuery = cascadia.MustCompile(`html > head > meta[property="og:image"]`)
-	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
-)
 
 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])
+	hc := http.Client{
+		Timeout: consts.DefaultHttpClientTimeOut,
+	}
+	a, err := l.callArtistGetInfo(ctx, name)
 	if err != nil {
 		return nil, fmt.Errorf("get artist info: %w", err)
 	}
@@ -249,7 +205,7 @@ func (l *lastfmAgent) GetArtistImages(ctx context.Context, _, name, mbid string)
 	if err != nil {
 		return nil, fmt.Errorf("create artist image request: %w", err)
 	}
-	resp, err := l.httpClient.Do(req)
+	resp, err := hc.Do(req)
 	if err != nil {
 		return nil, fmt.Errorf("get artist url: %w", err)
 	}
@@ -266,29 +222,24 @@ func (l *lastfmAgent) GetArtistImages(ctx context.Context, _, name, mbid string)
 		return res, nil
 	}
 	for _, attr := range n.Attr {
-		if attr.Key != "content" {
+		if attr.Key == "content" {
-			continue
+			res = []agents.ExternalImage{
-		}
+				{URL: attr.Val},
-		if strings.Contains(attr.Val, artistIgnoredImage) {
+			}
-			log.Debug(ctx, "Artist image is ignored default image", "name", name, "url", attr.Val)
+			break
-			return res, nil
-		}
-
-		res = []agents.ExternalImage{
-			{URL: attr.Val},
 		}
 	}
 	return res, nil
 }
 
-func (l *lastfmAgent) callAlbumGetInfo(ctx context.Context, name, artist, mbid string, lang string) (*Album, error) {
+func (l *lastfmAgent) callAlbumGetInfo(ctx context.Context, name, artist, mbid string) (*Album, error) {
-	a, err := l.client.albumGetInfo(ctx, name, artist, mbid, lang)
+	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 {
@@ -302,11 +253,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
@@ -332,20 +283,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) {
+func (l *lastfmAgent) getArtistForScrobble(track *model.MediaFile) string {
-	s, err := l.client.trackGetSimilar(ctx, name, artist, count)
+	if conf.Server.LastFM.ScrobbleFirstArtistOnly && len(track.Participants[model.RoleArtist]) > 0 {
-	if err != nil {
+		return track.Participants[model.RoleArtist][0].Name
-		log.Error(ctx, "Error calling LastFM/track.getSimilar", "track", name, "artist", artist, err)
-		return nil, err
 	}
-	return s.Track, nil
+	return track.Artist
-}
-
-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
 }
 
 func (l *lastfmAgent) NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) error {
@@ -355,13 +297,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)
@@ -381,13 +323,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() {
+			It("uses configured api key and language", func() {
-				conf.Server.LastFM.Languages = []string{"pt", "en"}
+				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
 		})
@@ -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 := httpClient.SavedRequest.URL.Query()
-				sentParams, _ := url.ParseQuery(string(body))
 				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 := httpClient.SavedRequest.URL.Query()
-				sentParams, _ := url.ParseQuery(string(body))
 				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 := httpClient.SavedRequest.URL.Query()
-					sentParams, _ := url.ParseQuery(string(body))
 					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
 		})
@@ -585,101 +393,4 @@ var _ = Describe("lastfmAgent", func() {
 			})
 		})
 	})
-
-	Describe("GetArtistImages", func() {
-		var agent *lastfmAgent
-		var apiClient *tests.FakeHttpClient
-		var httpClient *tests.FakeHttpClient
-
-		BeforeEach(func() {
-			apiClient = &tests.FakeHttpClient{}
-			httpClient = &tests.FakeHttpClient{}
-			client := newClient("API_KEY", "SECRET", apiClient)
-			agent = lastFMConstructor(ds)
-			agent.client = client
-			agent.httpClient = httpClient
-		})
-
-		It("returns the artist image from the page", func() {
-			fApi, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
-			apiClient.Res = http.Response{Body: fApi, StatusCode: 200}
-
-			fScraper, _ := os.Open("tests/fixtures/lastfm.artist.page.html")
-			httpClient.Res = http.Response{Body: fScraper, StatusCode: 200}
-
-			images, err := agent.GetArtistImages(ctx, "123", "U2", "")
-			Expect(err).ToNot(HaveOccurred())
-			Expect(images).To(HaveLen(1))
-			Expect(images[0].URL).To(Equal("https://lastfm.freetls.fastly.net/i/u/ar0/818148bf682d429dc21b59a73ef6f68e.png"))
-		})
-
-		It("returns empty list if image is the ignored default image", func() {
-			fApi, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
-			apiClient.Res = http.Response{Body: fApi, StatusCode: 200}
-
-			fScraper, _ := os.Open("tests/fixtures/lastfm.artist.page.ignored.html")
-			httpClient.Res = http.Response{Body: fScraper, StatusCode: 200}
-
-			images, err := agent.GetArtistImages(ctx, "123", "U2", "")
-			Expect(err).ToNot(HaveOccurred())
-			Expect(images).To(BeEmpty())
-		})
-
-		It("returns empty list if page has no meta tags", func() {
-			fApi, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
-			apiClient.Res = http.Response{Body: fApi, StatusCode: 200}
-
-			fScraper, _ := os.Open("tests/fixtures/lastfm.artist.page.no_meta.html")
-			httpClient.Res = http.Response{Body: fScraper, StatusCode: 200}
-
-			images, err := agent.GetArtistImages(ctx, "123", "U2", "")
-			Expect(err).ToNot(HaveOccurred())
-			Expect(images).To(BeEmpty())
-		})
-
-		It("returns error if API call fails", func() {
-			apiClient.Err = errors.New("api error")
-			_, err := agent.GetArtistImages(ctx, "123", "U2", "")
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("get artist info"))
-		})
-
-		It("returns error if scraper call fails", func() {
-			fApi, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
-			apiClient.Res = http.Response{Body: fApi, StatusCode: 200}
-
-			httpClient.Err = errors.New("scraper error")
-			_, err := agent.GetArtistImages(ctx, "123", "U2", "")
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("get artist url"))
-		})
-	})
 })
-
-// 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 {
+func newClient(apiKey string, secret string, lang string, hc httpDoer) *client {
-	return &client{apiKey, secret, hc}
+	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
+	req, _ := http.NewRequestWithContext(ctx, method, apiBaseUrl, nil)
-	if method == http.MethodPost {
+	req.URL.RawQuery = params.Encode()
-		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()
-	}
 
 	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/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/cache_warmer_test.go

@@ -90,7 +90,6 @@ var _ = Describe("CacheWarmer", func() {
 		})
 
 		It("deduplicates items in buffer", func() {
-			fc.SetReady(false) // Make cache unavailable so items stay in buffer
 			cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
 			cw.PreCache(model.MustParseArtworkID("al-1"))
 			cw.PreCache(model.MustParseArtworkID("al-1"))

core/artwork/reader_album.go

@@ -1,7 +1,6 @@
 package artwork
 
 import (
-	"cmp"
 	"context"
 	"crypto/md5"
 	"fmt"
@@ -12,7 +11,6 @@ import (
 	"time"
 
 	"github.com/Masterminds/squirrel"
-	"github.com/maruel/natural"
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/core/external"
@@ -118,30 +116,8 @@ func loadAlbumFoldersPaths(ctx context.Context, ds model.DataStore, albums ...mo
 	}
 
 	// Sort image files to ensure consistent selection of cover art
-	// This prioritizes files without numeric suffixes (e.g., cover.jpg over cover.1.jpg)
+	// This prioritizes files from lower-numbered disc folders by sorting the paths
-	// by comparing base filenames without extensions
+	slices.Sort(imgFiles)
-	slices.SortFunc(imgFiles, compareImageFiles)
 
 	return paths, imgFiles, &updatedAt, nil
 }
-
-// compareImageFiles compares two image file paths for sorting.
-// It extracts the base filename (without extension) and compares case-insensitively.
-// This ensures that "cover.jpg" sorts before "cover.1.jpg" since "cover" < "cover.1".
-// Note: This function is called O(n log n) times during sorting, but in practice albums
-// typically have only 1-20 image files, making the repeated string operations negligible.
-func compareImageFiles(a, b string) int {
-	// Case-insensitive comparison
-	a = strings.ToLower(a)
-	b = strings.ToLower(b)
-
-	// Extract base filenames without extensions
-	baseA := strings.TrimSuffix(filepath.Base(a), filepath.Ext(a))
-	baseB := strings.TrimSuffix(filepath.Base(b), filepath.Ext(b))
-
-	// Compare base names first, then full paths if equal
-	return cmp.Or(
-		natural.Compare(baseA, baseB),
-		natural.Compare(a, b),
-	)
-}

core/artwork/reader_album_test.go

@@ -27,7 +27,26 @@ var _ = Describe("Album Artwork Reader", func() {
 			expectedAt = now.Add(5 * time.Minute)
 
 			// Set up the test folders with image files
-			repo = &fakeFolderRepo{}
+			repo = &fakeFolderRepo{
+				result: []model.Folder{
+					{
+						Path:            "Artist/Album/Disc1",
+						ImagesUpdatedAt: expectedAt,
+						ImageFiles:      []string{"cover.jpg", "back.jpg"},
+					},
+					{
+						Path:            "Artist/Album/Disc2",
+						ImagesUpdatedAt: now,
+						ImageFiles:      []string{"cover.jpg"},
+					},
+					{
+						Path:            "Artist/Album/Disc10",
+						ImagesUpdatedAt: now,
+						ImageFiles:      []string{"cover.jpg"},
+					},
+				},
+				err: nil,
+			}
 			ds = &fakeDataStore{
 				folderRepo: repo,
 			}
@@ -39,82 +58,19 @@ var _ = Describe("Album Artwork Reader", func() {
 		})
 
 		It("returns sorted image files", func() {
-			repo.result = []model.Folder{
-				{
-					Path:            "Artist/Album/Disc1",
-					ImagesUpdatedAt: expectedAt,
-					ImageFiles:      []string{"cover.jpg", "back.jpg", "cover.1.jpg"},
-				},
-				{
-					Path:            "Artist/Album/Disc2",
-					ImagesUpdatedAt: now,
-					ImageFiles:      []string{"cover.jpg"},
-				},
-				{
-					Path:            "Artist/Album/Disc10",
-					ImagesUpdatedAt: now,
-					ImageFiles:      []string{"cover.jpg"},
-				},
-			}
-
 			_, imgFiles, imagesUpdatedAt, err := loadAlbumFoldersPaths(ctx, ds, album)
 
 			Expect(err).ToNot(HaveOccurred())
 			Expect(*imagesUpdatedAt).To(Equal(expectedAt))
 
-			// Check that image files are sorted by base name (without extension)
+			// Check that image files are sorted alphabetically
-			Expect(imgFiles).To(HaveLen(5))
+			Expect(imgFiles).To(HaveLen(4))
 
-			// Files should be sorted by base filename without extension, then by full path
+			// The files should be sorted by full path
-			// "back" < "cover", so back.jpg comes first
-			// Then all cover.jpg files, sorted by path
 			Expect(imgFiles[0]).To(Equal(filepath.FromSlash("Artist/Album/Disc1/back.jpg")))
 			Expect(imgFiles[1]).To(Equal(filepath.FromSlash("Artist/Album/Disc1/cover.jpg")))
-			Expect(imgFiles[2]).To(Equal(filepath.FromSlash("Artist/Album/Disc2/cover.jpg")))
+			Expect(imgFiles[2]).To(Equal(filepath.FromSlash("Artist/Album/Disc10/cover.jpg")))
-			Expect(imgFiles[3]).To(Equal(filepath.FromSlash("Artist/Album/Disc10/cover.jpg")))
+			Expect(imgFiles[3]).To(Equal(filepath.FromSlash("Artist/Album/Disc2/cover.jpg")))
-			Expect(imgFiles[4]).To(Equal(filepath.FromSlash("Artist/Album/Disc1/cover.1.jpg")))
-		})
-
-		It("prioritizes files without numeric suffixes", func() {
-			// Test case for issue #4683: cover.jpg should come before cover.1.jpg
-			repo.result = []model.Folder{
-				{
-					Path:            "Artist/Album",
-					ImagesUpdatedAt: now,
-					ImageFiles:      []string{"cover.1.jpg", "cover.jpg", "cover.2.jpg"},
-				},
-			}
-
-			_, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(imgFiles).To(HaveLen(3))
-
-			// cover.jpg should come first because "cover" < "cover.1" < "cover.2"
-			Expect(imgFiles[0]).To(Equal(filepath.FromSlash("Artist/Album/cover.jpg")))
-			Expect(imgFiles[1]).To(Equal(filepath.FromSlash("Artist/Album/cover.1.jpg")))
-			Expect(imgFiles[2]).To(Equal(filepath.FromSlash("Artist/Album/cover.2.jpg")))
-		})
-
-		It("handles case-insensitive sorting", func() {
-			// Test that Cover.jpg and cover.jpg are treated as equivalent
-			repo.result = []model.Folder{
-				{
-					Path:            "Artist/Album",
-					ImagesUpdatedAt: now,
-					ImageFiles:      []string{"Folder.jpg", "cover.jpg", "BACK.jpg"},
-				},
-			}
-
-			_, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(imgFiles).To(HaveLen(3))
-
-			// Files should be sorted case-insensitively: BACK, cover, Folder
-			Expect(imgFiles[0]).To(Equal(filepath.FromSlash("Artist/Album/BACK.jpg")))
-			Expect(imgFiles[1]).To(Equal(filepath.FromSlash("Artist/Album/cover.jpg")))
-			Expect(imgFiles[2]).To(Equal(filepath.FromSlash("Artist/Album/Folder.jpg")))
 		})
 	})
 })

core/artwork/reader_artist.go

@@ -8,7 +8,6 @@ import (
 	"io/fs"
 	"os"
 	"path/filepath"
-	"slices"
 	"strings"
 	"time"
 
@@ -140,22 +139,11 @@ func findImageInFolder(ctx context.Context, folder, pattern string) (io.ReadClos
 		return nil, "", err
 	}
 
-	// Filter to valid image files
-	var imagePaths []string
 	for _, m := range matches {
 		if !model.IsImageFile(m) {
 			continue
 		}
-		imagePaths = append(imagePaths, m)
+		filePath := filepath.Join(folder, m)
-	}
-
-	// Sort image files by prioritizing base filenames without numeric
-	// suffixes (e.g., artist.jpg before artist.1.jpg)
-	slices.SortFunc(imagePaths, compareImageFiles)
-
-	// Try to open files in sorted order
-	for _, p := range imagePaths {
-		filePath := filepath.Join(folder, p)
 		f, err := os.Open(filePath)
 		if err != nil {
 			log.Warn(ctx, "Could not open cover art file", "file", filePath, err)

core/artwork/reader_artist_test.go

@@ -240,79 +240,24 @@ var _ = Describe("artistArtworkReader", func() {
 				Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
 
 				// Create multiple matching files
-				Expect(os.WriteFile(filepath.Join(artistDir, "artist.abc"), []byte("text file"), 0600)).To(Succeed())
-				Expect(os.WriteFile(filepath.Join(artistDir, "artist.png"), []byte("png image"), 0600)).To(Succeed())
 				Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("jpg image"), 0600)).To(Succeed())
+				Expect(os.WriteFile(filepath.Join(artistDir, "artist.png"), []byte("png image"), 0600)).To(Succeed())
+				Expect(os.WriteFile(filepath.Join(artistDir, "artist.txt"), []byte("text file"), 0600)).To(Succeed())
 
 				testFunc = fromArtistFolder(ctx, artistDir, "artist.*")
 			})
 
-			It("returns the first valid image file in sorted order", func() {
+			It("returns the first valid image file", func() {
 				reader, path, err := testFunc()
 				Expect(err).ToNot(HaveOccurred())
 				Expect(reader).ToNot(BeNil())
 
-				// Should return an image file,
+				// Should return an image file, not the text file
-				// Files are sorted: jpg comes before png alphabetically.
+				Expect(path).To(SatisfyAny(
-				// .abc comes first, but it's not an image.
+					ContainSubstring("artist.jpg"),
-				Expect(path).To(ContainSubstring("artist.jpg"))
+					ContainSubstring("artist.png"),
-				reader.Close()
+				))
-			})
+				Expect(path).ToNot(ContainSubstring("artist.txt"))
-		})
-
-		When("prioritizing files without numeric suffixes", func() {
-			BeforeEach(func() {
-				// Test case for issue #4683: artist.jpg should come before artist.1.jpg
-				artistDir := filepath.Join(tempDir, "artist")
-				Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
-				// Create multiple matches with and without numeric suffixes
-				Expect(os.WriteFile(filepath.Join(artistDir, "artist.1.jpg"), []byte("artist 1"), 0600)).To(Succeed())
-				Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("artist main"), 0600)).To(Succeed())
-				Expect(os.WriteFile(filepath.Join(artistDir, "artist.2.jpg"), []byte("artist 2"), 0600)).To(Succeed())
-
-				testFunc = fromArtistFolder(ctx, artistDir, "artist.*")
-			})
-
-			It("returns artist.jpg before artist.1.jpg and artist.2.jpg", func() {
-				reader, path, err := testFunc()
-				Expect(err).ToNot(HaveOccurred())
-				Expect(reader).ToNot(BeNil())
-				Expect(path).To(ContainSubstring("artist.jpg"))
-
-				// Verify it's the main file, not a numbered variant
-				data, err := io.ReadAll(reader)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(string(data)).To(Equal("artist main"))
-				reader.Close()
-			})
-		})
-
-		When("handling case-insensitive sorting", func() {
-			BeforeEach(func() {
-				// Test case to ensure case-insensitive natural sorting
-				artistDir := filepath.Join(tempDir, "artist")
-				Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
-				// Create files with mixed case names
-				Expect(os.WriteFile(filepath.Join(artistDir, "Folder.jpg"), []byte("folder"), 0600)).To(Succeed())
-				Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("artist"), 0600)).To(Succeed())
-				Expect(os.WriteFile(filepath.Join(artistDir, "BACK.jpg"), []byte("back"), 0600)).To(Succeed())
-
-				testFunc = fromArtistFolder(ctx, artistDir, "*.*")
-			})
-
-			It("sorts case-insensitively", func() {
-				reader, path, err := testFunc()
-				Expect(err).ToNot(HaveOccurred())
-				Expect(reader).ToNot(BeNil())
-
-				// Should return artist.jpg first (case-insensitive: "artist" < "back" < "folder")
-				Expect(path).To(ContainSubstring("artist.jpg"))
-
-				data, err := io.ReadAll(reader)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(string(data)).To(Equal("artist"))
 				reader.Close()
 			})
 		})

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/auth/auth.go

@@ -113,9 +113,9 @@ func WithAdminUser(ctx context.Context, ds model.DataStore) context.Context {
 	if err != nil {
 		c, err := ds.User(ctx).CountAll()
 		if c == 0 && err == nil {
-			log.Debug(ctx, "No admin user yet!", err)
+			log.Debug(ctx, "Scanner: No admin user yet!", err)
 		} else {
-			log.Error(ctx, "No admin user found!", err)
+			log.Error(ctx, "Scanner: No admin user found!", err)
 		}
 		u = &model.User{}
 	}

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 string
-
-// 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)
 }
 
 type auxArtist struct {
 	model.Artist
-}
+	Name string
-
-// 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)
 }
 
 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, album.Name, album.AlbumArtist, album.MbzAlbumID)
-	info, err := e.ag.GetAlbumInfo(ctx, albumName, 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) {
+func (e *provider) ArtistRadio(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) {
 	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, album.Name, album.AlbumArtist, album.MbzAlbumID)
-	images, err := e.ag.GetAlbumImages(ctx, albumName, 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, artist.Name, artist.MbzArtistID, count)
-	songs, err := agent.GetArtistTopSongs(ctx, artist.ID, artistName, 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)
+	mbidMatches, err := e.loadTracksByMBID(ctx, songs)
-	for i := range songs {
+	if err != nil {
-		if songs[i].Artist == "" {
+		return nil, fmt.Errorf("failed to load tracks by MBID: %w", err)
-			songs[i].Artist = artistName
+	}
-		}
+	titleMatches, err := e.loadTracksByTitle(ctx, songs, artist, mbidMatches)
-		if songs[i].ArtistMBID == "" {
+	if err != nil {
-			songs[i].ArtistMBID = artist.MbzArtistID
+		return nil, fmt.Errorf("failed to load tracks by title: %w", err)
-		}
 	}
 
-	mfs, err := e.matchSongsToLibrary(ctx, songs, count)
+	log.Trace(ctx, "Top Songs loaded", "name", artist.Name, "numSongs", len(songs), "numMBIDMatches", len(mbidMatches), "numTitleMatches", len(titleMatches))
-	if err != nil {
+	mfs := e.selectTopSongs(songs, mbidMatches, titleMatches, count)
-		return nil, err
-	}
 
 	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, artist.Name, artist.MbzArtistID, limit)
-	similar, err := agent.GetSimilarArtists(ctx, artist.ID, artistName, 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)
+	artistNames := slice.Map(similar, func(artist agents.Artist) string { return artist.Name })
-	idMatches, err := e.loadArtistsByID(ctx, similar)
+
+	// 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)
+	// Create a map for quick lookup
-	mbidMatches, err := e.loadArtistsByMBID(ctx, similar, idMatches)
+	artistMap := make(map[string]model.Artist)
-	if err != nil {
+	for _, artist := range artists {
-		return nil, err
+		artistMap[artist.Name] = artist
-	}
-
-	// Load artists by name (lowest priority, fallback)
-	nameMatches, err := e.loadArtistsByName(ctx, similar, idMatches, mbidMatches)
-	if err != nil {
-		return nil, err
 	}
 
 	count := 0
 
-	// Process the similar artists using priority: ID → MBID → Name
+	// Process the similar artists
 	for _, s := range similar {
-		if count >= limit {
+		if artist, found := artistMap[s.Name]; found {
-			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 {
 			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 {
+func (j *ffCmd) start() error {
-	cmd := exec.CommandContext(ctx, j.args[0], j.args[1:]...) // #nosec
+	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

@@ -21,6 +21,11 @@ import (
 	"github.com/navidrome/navidrome/utils/slice"
 )
 
+// Scanner interface for triggering scans
+type Scanner interface {
+	ScanAll(ctx context.Context, fullScan bool) (warnings []string, err error)
+}
+
 // Watcher interface for managing file system watchers
 type Watcher interface {
 	Watch(ctx context.Context, lib *model.Library) error
@@ -37,21 +42,19 @@ type Library interface {
 }
 
 type libraryService struct {
-	ds            model.DataStore
+	ds      model.DataStore
-	scanner       model.Scanner
+	scanner Scanner
-	watcher       Watcher
+	watcher Watcher
-	broker        events.Broker
+	broker  events.Broker
-	pluginManager PluginUnloader
 }
 
 // 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 Scanner, watcher Watcher, broker events.Broker) Library {
 	return &libraryService{
-		ds:            ds,
+		ds:      ds,
-		scanner:       scanner,
+		scanner: scanner,
-		watcher:       watcher,
+		watcher: watcher,
-		broker:        broker,
+		broker:  broker,
-		pluginManager: pluginManager,
 	}
 }
 
@@ -143,7 +146,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 +153,11 @@ func (s *libraryService) NewRepository(ctx context.Context) rest.Repository {
 type libraryRepositoryWrapper struct {
 	rest.Repository
 	model.LibraryRepository
-	ctx           context.Context
+	ctx     context.Context
-	ds            model.DataStore
+	ds      model.DataStore
-	scanner       model.Scanner
+	scanner Scanner
-	watcher       Watcher
+	watcher Watcher
-	broker        events.Broker
+	broker  events.Broker
-	pluginManager PluginUnloader
 }
 
 func (r *libraryRepositoryWrapper) Save(entity interface{}) (string, error) {
@@ -191,7 +192,7 @@ func (r *libraryRepositoryWrapper) Save(entity interface{}) (string, error) {
 	return strconv.Itoa(lib.ID), nil
 }
 
-func (r *libraryRepositoryWrapper) Update(id string, entity interface{}, _ ...string) error {
+func (r *libraryRepositoryWrapper) Update(id string, entity interface{}, cols ...string) error {
 	lib := entity.(*model.Library)
 	libID, err := strconv.Atoi(id)
 	if err != nil {
@@ -276,10 +277,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
@@ -29,10 +29,9 @@ var _ = Describe("Library Service", func() {
 	var userRepo *tests.MockedUserRepo
 	var ctx context.Context
 	var tempDir string
-	var scanner *tests.MockScanner
+	var scanner *mockScanner
 	var watcherManager *mockWatcherManager
 	var broker *mockEventBroker
-	var pluginManager *mockPluginUnloader
 
 	BeforeEach(func() {
 		DeferCleanup(configtest.SetupConfig())
@@ -44,16 +43,14 @@ var _ = Describe("Library Service", func() {
 		ds.MockedUser = userRepo
 
 		// Create a mock scanner that tracks calls
-		scanner = tests.NewMockScanner()
+		scanner = &mockScanner{}
 		// Create a mock watcher manager
 		watcherManager = &mockWatcherManager{
 			libraryStates: make(map[int]model.Library),
 		}
 		// Create a mock event broker
 		broker = &mockEventBroker{}
-		// Create a mock plugin unloader
+		service = core.NewLibrary(ds, scanner, watcherManager, broker)
-		pluginManager = &mockPluginUnloader{}
-		service = core.NewLibrary(ds, scanner, watcherManager, broker, pluginManager)
 		ctx = context.Background()
 
 		// Create a temporary directory for testing valid paths
@@ -619,12 +616,11 @@ var _ = Describe("Library Service", func() {
 
 			// Wait briefly for the goroutine to complete
 			Eventually(func() int {
-				return scanner.GetScanAllCallCount()
+				return scanner.len()
 			}, "1s", "10ms").Should(Equal(1))
 
 			// Verify scan was called with correct parameters
-			calls := scanner.GetScanAllCalls()
+			Expect(scanner.ScanCalls[0].FullScan).To(BeFalse()) // Should be quick scan
-			Expect(calls[0].FullScan).To(BeFalse()) // Should be quick scan
 		})
 
 		It("triggers scan when updating library path", func() {
@@ -645,12 +641,11 @@ var _ = Describe("Library Service", func() {
 
 			// Wait briefly for the goroutine to complete
 			Eventually(func() int {
-				return scanner.GetScanAllCallCount()
+				return scanner.len()
 			}, "1s", "10ms").Should(Equal(1))
 
 			// Verify scan was called with correct parameters
-			calls := scanner.GetScanAllCalls()
+			Expect(scanner.ScanCalls[0].FullScan).To(BeFalse()) // Should be quick scan
-			Expect(calls[0].FullScan).To(BeFalse()) // Should be quick scan
 		})
 
 		It("does not trigger scan when updating library without path change", func() {
@@ -666,7 +661,7 @@ var _ = Describe("Library Service", func() {
 
 			// Wait a bit to ensure no scan was triggered
 			Consistently(func() int {
-				return scanner.GetScanAllCallCount()
+				return scanner.len()
 			}, "100ms", "10ms").Should(Equal(0))
 		})
 
@@ -679,7 +674,7 @@ var _ = Describe("Library Service", func() {
 
 			// Ensure no scan was triggered since creation failed
 			Consistently(func() int {
-				return scanner.GetScanAllCallCount()
+				return scanner.len()
 			}, "100ms", "10ms").Should(Equal(0))
 		})
 
@@ -696,7 +691,7 @@ var _ = Describe("Library Service", func() {
 
 			// Ensure no scan was triggered since update failed
 			Consistently(func() int {
-				return scanner.GetScanAllCallCount()
+				return scanner.len()
 			}, "100ms", "10ms").Should(Equal(0))
 		})
 
@@ -712,12 +707,11 @@ var _ = Describe("Library Service", func() {
 
 			// Wait briefly for the goroutine to complete
 			Eventually(func() int {
-				return scanner.GetScanAllCallCount()
+				return scanner.len()
 			}, "1s", "10ms").Should(Equal(1))
 
 			// Verify scan was called with correct parameters
-			calls := scanner.GetScanAllCalls()
+			Expect(scanner.ScanCalls[0].FullScan).To(BeFalse()) // Should be quick scan
-			Expect(calls[0].FullScan).To(BeFalse()) // Should be quick scan
 		})
 
 		It("does not trigger scan when library deletion fails", func() {
@@ -727,7 +721,7 @@ var _ = Describe("Library Service", func() {
 
 			// Ensure no scan was triggered since deletion failed
 			Consistently(func() int {
-				return scanner.GetScanAllCallCount()
+				return scanner.len()
 			}, "100ms", "10ms").Should(Equal(0))
 		})
 
@@ -872,43 +866,31 @@ 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
+// mockScanner provides a simple mock implementation of core.Scanner for testing
-type mockPluginUnloader struct {
+type mockScanner struct {
-	unloadCalls int
+	ScanCalls []ScanCall
+	mu        sync.RWMutex
 }
 
-func (m *mockPluginUnloader) UnloadDisabledPlugins(ctx context.Context) {
+type ScanCall struct {
-	m.unloadCalls++
+	FullScan bool
+}
+
+func (m *mockScanner) ScanAll(ctx context.Context, fullScan bool) (warnings []string, err error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.ScanCalls = append(m.ScanCalls, ScanCall{
+		FullScan: fullScan,
+	})
+	return []string{}, nil
+}
+
+func (m *mockScanner) len() int {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return len(m.ScanCalls)
 }
 
 // mockWatcherManager provides a simple mock implementation of core.Watcher for testing

core/maintenance.go

@@ -1,226 +0,0 @@
-package core
-
-import (
-	"context"
-	"fmt"
-	"slices"
-	"sync"
-	"time"
-
-	"github.com/Masterminds/squirrel"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/model/request"
-	"github.com/navidrome/navidrome/utils/slice"
-)
-
-type Maintenance interface {
-	// DeleteMissingFiles deletes specific missing files by their IDs
-	DeleteMissingFiles(ctx context.Context, ids []string) error
-	// DeleteAllMissingFiles deletes all files marked as missing
-	DeleteAllMissingFiles(ctx context.Context) error
-}
-
-type maintenanceService struct {
-	ds model.DataStore
-	wg sync.WaitGroup
-}
-
-func NewMaintenance(ds model.DataStore) Maintenance {
-	return &maintenanceService{
-		ds: ds,
-	}
-}
-
-func (s *maintenanceService) DeleteMissingFiles(ctx context.Context, ids []string) error {
-	return s.deleteMissing(ctx, ids)
-}
-
-func (s *maintenanceService) DeleteAllMissingFiles(ctx context.Context) error {
-	return s.deleteMissing(ctx, nil)
-}
-
-// deleteMissing handles the deletion of missing files and triggers necessary cleanup operations
-func (s *maintenanceService) deleteMissing(ctx context.Context, ids []string) error {
-	// Track affected album IDs before deletion for refresh
-	affectedAlbumIDs, err := s.getAffectedAlbumIDs(ctx, ids)
-	if err != nil {
-		log.Warn(ctx, "Error tracking affected albums for refresh", err)
-		// Don't fail the operation, just log the warning
-	}
-
-	// Delete missing files within a transaction
-	err = s.ds.WithTx(func(tx model.DataStore) error {
-		if len(ids) == 0 {
-			_, err := tx.MediaFile(ctx).DeleteAllMissing()
-			return err
-		}
-		return tx.MediaFile(ctx).DeleteMissing(ids)
-	})
-	if err != nil {
-		log.Error(ctx, "Error deleting missing tracks from DB", "ids", ids, err)
-		return err
-	}
-
-	// Run garbage collection to clean up orphaned records
-	if err := s.ds.GC(ctx); err != nil {
-		log.Error(ctx, "Error running GC after deleting missing tracks", err)
-		return err
-	}
-
-	// Refresh statistics in background
-	s.refreshStatsAsync(ctx, affectedAlbumIDs)
-
-	return nil
-}
-
-// refreshAlbums recalculates album attributes (size, duration, song count, etc.) from media files.
-// It uses batch queries to minimize database round-trips for efficiency.
-func (s *maintenanceService) refreshAlbums(ctx context.Context, albumIDs []string) error {
-	if len(albumIDs) == 0 {
-		return nil
-	}
-
-	log.Debug(ctx, "Refreshing albums", "count", len(albumIDs))
-
-	// Process in chunks to avoid query size limits
-	const chunkSize = 100
-	for chunk := range slice.CollectChunks(slices.Values(albumIDs), chunkSize) {
-		if err := s.refreshAlbumChunk(ctx, chunk); err != nil {
-			return fmt.Errorf("refreshing album chunk: %w", err)
-		}
-	}
-
-	log.Debug(ctx, "Successfully refreshed albums", "count", len(albumIDs))
-	return nil
-}
-
-// refreshAlbumChunk processes a single chunk of album IDs
-func (s *maintenanceService) refreshAlbumChunk(ctx context.Context, albumIDs []string) error {
-	albumRepo := s.ds.Album(ctx)
-	mfRepo := s.ds.MediaFile(ctx)
-
-	// Batch load existing albums
-	albums, err := albumRepo.GetAll(model.QueryOptions{
-		Filters: squirrel.Eq{"album.id": albumIDs},
-	})
-	if err != nil {
-		return fmt.Errorf("loading albums: %w", err)
-	}
-
-	// Create a map for quick lookup
-	albumMap := make(map[string]*model.Album, len(albums))
-	for i := range albums {
-		albumMap[albums[i].ID] = &albums[i]
-	}
-
-	// Batch load all media files for these albums
-	mediaFiles, err := mfRepo.GetAll(model.QueryOptions{
-		Filters: squirrel.Eq{"album_id": albumIDs},
-		Sort:    "album_id, path",
-	})
-	if err != nil {
-		return fmt.Errorf("loading media files: %w", err)
-	}
-
-	// Group media files by album ID
-	filesByAlbum := make(map[string]model.MediaFiles)
-	for i := range mediaFiles {
-		albumID := mediaFiles[i].AlbumID
-		filesByAlbum[albumID] = append(filesByAlbum[albumID], mediaFiles[i])
-	}
-
-	// Recalculate each album from its media files
-	for albumID, oldAlbum := range albumMap {
-		mfs, hasTracks := filesByAlbum[albumID]
-		if !hasTracks {
-			// Album has no tracks anymore, skip (will be cleaned up by GC)
-			log.Debug(ctx, "Skipping album with no tracks", "albumID", albumID)
-			continue
-		}
-
-		// Recalculate album from media files
-		newAlbum := mfs.ToAlbum()
-
-		// Only update if something changed (avoid unnecessary writes)
-		if !oldAlbum.Equals(newAlbum) {
-			// Preserve original timestamps
-			newAlbum.UpdatedAt = time.Now()
-			newAlbum.CreatedAt = oldAlbum.CreatedAt
-
-			if err := albumRepo.Put(&newAlbum); err != nil {
-				log.Error(ctx, "Error updating album during refresh", "albumID", albumID, err)
-				// Continue with other albums instead of failing entirely
-				continue
-			}
-			log.Trace(ctx, "Refreshed album", "albumID", albumID, "name", newAlbum.Name)
-		}
-	}
-
-	return nil
-}
-
-// getAffectedAlbumIDs returns distinct album IDs from missing media files
-func (s *maintenanceService) getAffectedAlbumIDs(ctx context.Context, ids []string) ([]string, error) {
-	var filters squirrel.Sqlizer = squirrel.Eq{"missing": true}
-	if len(ids) > 0 {
-		filters = squirrel.And{
-			squirrel.Eq{"missing": true},
-			squirrel.Eq{"media_file.id": ids},
-		}
-	}
-
-	mfs, err := s.ds.MediaFile(ctx).GetAll(model.QueryOptions{
-		Filters: filters,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	// Extract unique album IDs
-	albumIDMap := make(map[string]struct{}, len(mfs))
-	for _, mf := range mfs {
-		if mf.AlbumID != "" {
-			albumIDMap[mf.AlbumID] = struct{}{}
-		}
-	}
-
-	albumIDs := make([]string, 0, len(albumIDMap))
-	for id := range albumIDMap {
-		albumIDs = append(albumIDs, id)
-	}
-
-	return albumIDs, nil
-}
-
-// refreshStatsAsync refreshes artist and album statistics in background goroutines
-func (s *maintenanceService) refreshStatsAsync(ctx context.Context, affectedAlbumIDs []string) {
-	// Refresh artist stats in background
-	s.wg.Add(1)
-	go func() {
-		defer s.wg.Done()
-		bgCtx := request.AddValues(context.Background(), ctx)
-		if _, err := s.ds.Artist(bgCtx).RefreshStats(true); err != nil {
-			log.Error(bgCtx, "Error refreshing artist stats after deleting missing files", err)
-		} else {
-			log.Debug(bgCtx, "Successfully refreshed artist stats after deleting missing files")
-		}
-
-		// Refresh album stats in background if we have affected albums
-		if len(affectedAlbumIDs) > 0 {
-			if err := s.refreshAlbums(bgCtx, affectedAlbumIDs); err != nil {
-				log.Error(bgCtx, "Error refreshing album stats after deleting missing files", err)
-			} else {
-				log.Debug(bgCtx, "Successfully refreshed album stats after deleting missing files", "count", len(affectedAlbumIDs))
-			}
-		}
-	}()
-}
-
-// Wait waits for all background goroutines to complete.
-// WARNING: This method is ONLY for testing. Never call this in production code.
-// Calling Wait() in production will block until ALL background operations complete
-// and may cause race conditions with new operations starting.
-func (s *maintenanceService) wait() {
-	s.wg.Wait()
-}

core/maintenance_test.go

@@ -1,364 +0,0 @@
-package core
-
-import (
-	"context"
-	"errors"
-	"sync"
-
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/model/request"
-	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-	"github.com/sirupsen/logrus"
-)
-
-var _ = Describe("Maintenance", func() {
-	var ds *tests.MockDataStore
-	var mfRepo *extendedMediaFileRepo
-	var service Maintenance
-	var ctx context.Context
-
-	BeforeEach(func() {
-		ctx = context.Background()
-		ctx = request.WithUser(ctx, model.User{ID: "user1", IsAdmin: true})
-
-		ds = createTestDataStore()
-		mfRepo = ds.MockedMediaFile.(*extendedMediaFileRepo)
-		service = NewMaintenance(ds)
-	})
-
-	Describe("DeleteMissingFiles", func() {
-		Context("with specific IDs", func() {
-			It("deletes specific missing files and runs GC", func() {
-				// Setup: mock missing files with album IDs
-				mfRepo.SetData(model.MediaFiles{
-					{ID: "mf1", AlbumID: "album1", Missing: true},
-					{ID: "mf2", AlbumID: "album2", Missing: true},
-				})
-
-				err := service.DeleteMissingFiles(ctx, []string{"mf1", "mf2"})
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(mfRepo.deleteMissingCalled).To(BeTrue())
-				Expect(mfRepo.deletedIDs).To(Equal([]string{"mf1", "mf2"}))
-				Expect(ds.GCCalled).To(BeTrue(), "GC should be called after deletion")
-			})
-
-			It("triggers artist stats refresh and album refresh after deletion", func() {
-				artistRepo := ds.MockedArtist.(*extendedArtistRepo)
-				// Setup: mock missing files with albums
-				albumRepo := ds.MockedAlbum.(*extendedAlbumRepo)
-				albumRepo.SetData(model.Albums{
-					{ID: "album1", Name: "Test Album", SongCount: 5},
-				})
-				mfRepo.SetData(model.MediaFiles{
-					{ID: "mf1", AlbumID: "album1", Missing: true},
-					{ID: "mf2", AlbumID: "album1", Missing: false, Size: 1000, Duration: 180},
-					{ID: "mf3", AlbumID: "album1", Missing: false, Size: 2000, Duration: 200},
-				})
-
-				err := service.DeleteMissingFiles(ctx, []string{"mf1"})
-
-				Expect(err).ToNot(HaveOccurred())
-
-				// Wait for background goroutines to complete
-				service.(*maintenanceService).wait()
-
-				// RefreshStats should be called
-				Expect(artistRepo.IsRefreshStatsCalled()).To(BeTrue(), "Artist stats should be refreshed")
-
-				// Album should be updated with new calculated values
-				Expect(albumRepo.GetPutCallCount()).To(BeNumerically(">", 0), "Album.Put() should be called to refresh album data")
-			})
-
-			It("returns error if deletion fails", func() {
-				mfRepo.deleteMissingError = errors.New("delete failed")
-
-				err := service.DeleteMissingFiles(ctx, []string{"mf1"})
-
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("delete failed"))
-			})
-
-			It("continues even if album tracking fails", func() {
-				mfRepo.SetError(true)
-
-				err := service.DeleteMissingFiles(ctx, []string{"mf1"})
-
-				// Should not fail, just log warning
-				Expect(err).ToNot(HaveOccurred())
-				Expect(mfRepo.deleteMissingCalled).To(BeTrue())
-			})
-
-			It("returns error if GC fails", func() {
-				mfRepo.SetData(model.MediaFiles{
-					{ID: "mf1", AlbumID: "album1", Missing: true},
-				})
-
-				// Set GC to return error
-				ds.GCError = errors.New("gc failed")
-
-				err := service.DeleteMissingFiles(ctx, []string{"mf1"})
-
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("gc failed"))
-			})
-		})
-
-		Context("album ID extraction", func() {
-			It("extracts unique album IDs from missing files", func() {
-				mfRepo.SetData(model.MediaFiles{
-					{ID: "mf1", AlbumID: "album1", Missing: true},
-					{ID: "mf2", AlbumID: "album1", Missing: true},
-					{ID: "mf3", AlbumID: "album2", Missing: true},
-				})
-
-				err := service.DeleteMissingFiles(ctx, []string{"mf1", "mf2", "mf3"})
-
-				Expect(err).ToNot(HaveOccurred())
-			})
-
-			It("skips files without album IDs", func() {
-				mfRepo.SetData(model.MediaFiles{
-					{ID: "mf1", AlbumID: "", Missing: true},
-					{ID: "mf2", AlbumID: "album1", Missing: true},
-				})
-
-				err := service.DeleteMissingFiles(ctx, []string{"mf1", "mf2"})
-
-				Expect(err).ToNot(HaveOccurred())
-			})
-		})
-	})
-
-	Describe("DeleteAllMissingFiles", func() {
-		It("deletes all missing files and runs GC", func() {
-			mfRepo.SetData(model.MediaFiles{
-				{ID: "mf1", AlbumID: "album1", Missing: true},
-				{ID: "mf2", AlbumID: "album2", Missing: true},
-				{ID: "mf3", AlbumID: "album3", Missing: true},
-			})
-
-			err := service.DeleteAllMissingFiles(ctx)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(ds.GCCalled).To(BeTrue(), "GC should be called after deletion")
-		})
-
-		It("returns error if deletion fails", func() {
-			mfRepo.SetError(true)
-
-			err := service.DeleteAllMissingFiles(ctx)
-
-			Expect(err).To(HaveOccurred())
-		})
-
-		It("handles empty result gracefully", func() {
-			mfRepo.SetData(model.MediaFiles{})
-
-			err := service.DeleteAllMissingFiles(ctx)
-
-			Expect(err).ToNot(HaveOccurred())
-		})
-	})
-
-	Describe("Album refresh logic", func() {
-		var albumRepo *extendedAlbumRepo
-
-		BeforeEach(func() {
-			albumRepo = ds.MockedAlbum.(*extendedAlbumRepo)
-		})
-
-		Context("when album has no tracks after deletion", func() {
-			It("skips the album without updating it", func() {
-				// Setup album with no remaining tracks
-				albumRepo.SetData(model.Albums{
-					{ID: "album1", Name: "Empty Album", SongCount: 1},
-				})
-				mfRepo.SetData(model.MediaFiles{
-					{ID: "mf1", AlbumID: "album1", Missing: true},
-				})
-
-				err := service.DeleteMissingFiles(ctx, []string{"mf1"})
-
-				Expect(err).ToNot(HaveOccurred())
-
-				// Wait for background goroutines to complete
-				service.(*maintenanceService).wait()
-
-				// Album should NOT be updated because it has no tracks left
-				Expect(albumRepo.GetPutCallCount()).To(Equal(0), "Album with no tracks should not be updated")
-			})
-		})
-
-		Context("when Put fails for one album", func() {
-			It("continues processing other albums", func() {
-				albumRepo.SetData(model.Albums{
-					{ID: "album1", Name: "Album 1"},
-					{ID: "album2", Name: "Album 2"},
-				})
-				mfRepo.SetData(model.MediaFiles{
-					{ID: "mf1", AlbumID: "album1", Missing: true},
-					{ID: "mf2", AlbumID: "album1", Missing: false, Size: 1000, Duration: 180},
-					{ID: "mf3", AlbumID: "album2", Missing: true},
-					{ID: "mf4", AlbumID: "album2", Missing: false, Size: 2000, Duration: 200},
-				})
-
-				// Make Put fail on first call but succeed on subsequent calls
-				albumRepo.putError = errors.New("put failed")
-				albumRepo.failOnce = true
-
-				err := service.DeleteMissingFiles(ctx, []string{"mf1", "mf3"})
-
-				// Should not fail even if one album's Put fails
-				Expect(err).ToNot(HaveOccurred())
-
-				// Wait for background goroutines to complete
-				service.(*maintenanceService).wait()
-
-				// Put should have been called multiple times
-				Expect(albumRepo.GetPutCallCount()).To(BeNumerically(">", 0), "Put should be attempted")
-			})
-		})
-
-		Context("when media file loading fails", func() {
-			It("logs warning but continues when tracking affected albums fails", func() {
-				// Set up log capturing
-				hook, cleanup := tests.LogHook()
-				defer cleanup()
-
-				albumRepo.SetData(model.Albums{
-					{ID: "album1", Name: "Album 1"},
-				})
-				mfRepo.SetData(model.MediaFiles{
-					{ID: "mf1", AlbumID: "album1", Missing: true},
-				})
-				// Make GetAll fail when loading media files
-				mfRepo.SetError(true)
-
-				err := service.DeleteMissingFiles(ctx, []string{"mf1"})
-
-				// Deletion should succeed despite the tracking error
-				Expect(err).ToNot(HaveOccurred())
-				Expect(mfRepo.deleteMissingCalled).To(BeTrue())
-
-				// Verify the warning was logged
-				Expect(hook.LastEntry()).ToNot(BeNil())
-				Expect(hook.LastEntry().Level).To(Equal(logrus.WarnLevel))
-				Expect(hook.LastEntry().Message).To(Equal("Error tracking affected albums for refresh"))
-			})
-		})
-	})
-})
-
-// Test helper to create a mock DataStore with controllable behavior
-func createTestDataStore() *tests.MockDataStore {
-	ds := &tests.MockDataStore{}
-
-	// Create extended album repo with Put tracking
-	albumRepo := &extendedAlbumRepo{
-		MockAlbumRepo: tests.CreateMockAlbumRepo(),
-	}
-	ds.MockedAlbum = albumRepo
-
-	// Create extended artist repo with RefreshStats tracking
-	artistRepo := &extendedArtistRepo{
-		MockArtistRepo: tests.CreateMockArtistRepo(),
-	}
-	ds.MockedArtist = artistRepo
-
-	// Create extended media file repo with DeleteMissing support
-	mfRepo := &extendedMediaFileRepo{
-		MockMediaFileRepo: tests.CreateMockMediaFileRepo(),
-	}
-	ds.MockedMediaFile = mfRepo
-
-	return ds
-}
-
-// Extension of MockMediaFileRepo to add DeleteMissing method
-type extendedMediaFileRepo struct {
-	*tests.MockMediaFileRepo
-	deleteMissingCalled bool
-	deletedIDs          []string
-	deleteMissingError  error
-}
-
-func (m *extendedMediaFileRepo) DeleteMissing(ids []string) error {
-	m.deleteMissingCalled = true
-	m.deletedIDs = ids
-	if m.deleteMissingError != nil {
-		return m.deleteMissingError
-	}
-	// Actually delete from the mock data
-	for _, id := range ids {
-		delete(m.Data, id)
-	}
-	return nil
-}
-
-// Extension of MockAlbumRepo to track Put calls
-type extendedAlbumRepo struct {
-	*tests.MockAlbumRepo
-	mu           sync.RWMutex
-	putCallCount int
-	lastPutData  *model.Album
-	putError     error
-	failOnce     bool
-}
-
-func (m *extendedAlbumRepo) Put(album *model.Album) error {
-	m.mu.Lock()
-	m.putCallCount++
-	m.lastPutData = album
-
-	// Handle failOnce behavior
-	var err error
-	if m.putError != nil {
-		if m.failOnce {
-			err = m.putError
-			m.putError = nil // Clear error after first failure
-			m.mu.Unlock()
-			return err
-		}
-		err = m.putError
-		m.mu.Unlock()
-		return err
-	}
-	m.mu.Unlock()
-
-	return m.MockAlbumRepo.Put(album)
-}
-
-func (m *extendedAlbumRepo) GetPutCallCount() int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.putCallCount
-}
-
-// Extension of MockArtistRepo to track RefreshStats calls
-type extendedArtistRepo struct {
-	*tests.MockArtistRepo
-	mu                 sync.RWMutex
-	refreshStatsCalled bool
-	refreshStatsError  error
-}
-
-func (m *extendedArtistRepo) RefreshStats(allArtists bool) (int64, error) {
-	m.mu.Lock()
-	m.refreshStatsCalled = true
-	err := m.refreshStatsError
-	m.mu.Unlock()
-
-	if err != nil {
-		return 0, err
-	}
-	return m.MockArtistRepo.RefreshStats(allArtists)
-}
-
-func (m *extendedArtistRepo) IsRefreshStatsCalled() bool {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.refreshStatsCalled
-}

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
 			}
-
+			out, err := job.ms.transcoder.Transcode(ctx, t.Command, job.filePath, job.bitRate, job.offset)
-			// 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)
 			if err != nil {
 				log.Error(ctx, "Error starting transcoder", "id", job.mf.ID, err)
 				return nil, os.ErrInvalid

core/metrics/insights.go

@@ -6,7 +6,6 @@ import (
 	"encoding/json"
 	"math"
 	"net/http"
-	"os"
 	"path/filepath"
 	"runtime"
 	"runtime/debug"
@@ -22,9 +21,7 @@ import (
 	"github.com/navidrome/navidrome/core/metrics/insights"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/model/request"
+	"github.com/navidrome/navidrome/plugins/schema"
-	"github.com/navidrome/navidrome/plugins"
-	"github.com/navidrome/navidrome/server/events"
 	"github.com/navidrome/navidrome/utils/singleton"
 )
 
@@ -38,12 +35,18 @@ var (
 )
 
 type insightsCollector struct {
-	ds         model.DataStore
+	ds           model.DataStore
-	lastRun    atomic.Int64
+	pluginLoader PluginLoader
-	lastStatus atomic.Bool
+	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,21 +58,14 @@ func GetInstance(ds model.DataStore) Insights {
 			}
 		}
 		insightsID = id
-		return &insightsCollector{ds: ds}
+		return &insightsCollector{ds: ds, pluginLoader: pluginLoader}
 	})
 }
 
 func (c *insightsCollector) Run(ctx context.Context) {
+	ctx = auth.WithAdminUser(ctx, c.ds)
 	for {
-		// Refresh admin context on each iteration to handle cases where
+		c.sendInsights(ctx)
-		// admin user wasn't available on previous runs
-		insightsCtx := auth.WithAdminUser(ctx, c.ds)
-		u, _ := request.UserFrom(insightsCtx)
-		if !u.IsAdmin {
-			log.Trace(insightsCtx, "No admin user available, skipping insights collection")
-		} else {
-			c.sendInsights(insightsCtx)
-		}
 		select {
 		case <-time.After(consts.InsightsUpdateInterval):
 			continue
@@ -164,13 +160,6 @@ var staticData = sync.OnceValue(func() insights.Data {
 	data.Build.Settings, data.Build.GoVersion = buildInfo()
 	data.OS.Containerized = consts.InContainer
 
-	// Install info
-	packageFilename := filepath.Join(conf.Server.DataFolder, ".package")
-	packageFileData, err := os.ReadFile(packageFilename)
-	if err == nil {
-		data.OS.Package = string(packageFileData)
-	}
-
 	// OS info
 	data.OS.Type = runtime.GOOS
 	data.OS.Arch = runtime.GOARCH
@@ -215,11 +204,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 +254,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 +303,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
+	plugins := make(map[string]insights.PluginInfo)
-	manager := plugins.GetManager(c.ds, events.GetBroker(), nil)
+	for id, manifest := range c.pluginLoader.PluginList() {
-	info := manager.GetPluginInfo()
+		plugins[id] = insights.PluginInfo{
-
+			Name:    manifest.Name,
-	result := make(map[string]insights.PluginInfo, len(info))
+			Version: manifest.Version,
-	for name, p := range info {
-		result[name] = insights.PluginInfo{
-			Name:    p.Name,
-			Version: p.Version,
 		}
 	}
-	return result
+	return plugins
 }

core/metrics/insights/data.go

@@ -16,7 +16,6 @@ type Data struct {
 		Containerized bool   `json:"containerized"`
 		Arch          string `json:"arch"`
 		NumCPU        int    `json:"numCPU"`
-		Package       string `json:"package,omitempty"`
 	} `json:"os"`
 	Mem struct {
 		Alloc      uint64 `json:"alloc"`
@@ -40,14 +39,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) {