fix(mcp-agent): stream native mcp-server stderr to logs

The previous implementation buffered stderr from the native mcp-server process and only logged the full buffer content when the process exited. This prevented real-time viewing of logs from the server.

This change modifies the native process startup logic (`startProcess_locked`) to use `cmd.StderrPipe()` instead of assigning `cmd.Stderr` to a buffer. A separate goroutine is now launched within the process monitoring goroutine. This new goroutine uses a `bufio.Scanner` to continuously read lines from the stderr pipe and logs them using the Navidrome logger (`log.Info`) with an `[MCP-SERVER]` prefix.

This ensures logs from the native mcp-server appear in Navidrome's logs immediately as they are written.

(Note: Also includes update to McpServerPath constant to point to the native binary.)

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

.devcontainer/Dockerfile

@@ -9,19 +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
-ARG CROSS_TAGLIB_VERSION="2.1.1-1"
-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
+# [Optional] Uncomment the next line to use go get to install anything else you need
+# RUN go get -x <your-dependency-or-tool>
 
 # [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

@@ -4,11 +4,10 @@
 		"dockerfile": "Dockerfile",
 		"args": {
 			// Update the VARIANT arg to pick a version of Go: 1, 1.15, 1.14
-			"VARIANT": "1.25",
+			"VARIANT": "1.24",
 			// Options
 			"INSTALL_NODE": "true",
-			"NODE_VERSION": "v24",
-			"CROSS_TAGLIB_VERSION": "2.1.1-1"
+			"NODE_VERSION": "v20"
 		}
 	},
 	"workspaceMount": "",
@@ -55,10 +54,12 @@
 		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": {
 		"ND_MUSICFOLDER": "./music",
 		"ND_DATAFOLDER": "./data"
 	}
-}
+}

.github/pull_request_template.md

@@ -1,38 +0,0 @@
-### Description
-<!-- Please provide a clear and concise description of what this PR does and why it is needed. -->
-
-### Related Issues
-<!-- List any related issues, e.g., "Fixes #123" or "Related to #456". -->
-
-### Type of Change
-- [ ] Bug fix
-- [ ] New feature
-- [ ] Documentation update
-- [ ] Refactor
-- [ ] Other (please describe):
-
-### Checklist
-Please review and check all that apply:
-
-- [ ] My code follows the project’s coding style
-- [ ] I have tested the changes locally
-- [ ] I have added or updated documentation as needed
-- [ ] I have added tests that prove my fix/feature works (or explain why not)
-- [ ] All existing and new tests pass
-
-### How to Test
-<!-- Describe the steps to test your changes. Include setup, commands, and expected results. -->
-
-### Screenshots / Demos (if applicable)
-<!-- Add screenshots, GIFs, or links to demos if your change includes UI updates or visual changes. -->
-
-### Additional Notes
-<!-- Anything else the maintainer should know? Potential side effects, breaking changes, or areas of concern? -->
-
-<!-- 
-**Tips for Contributors:**
-- Be concise but thorough.
-- If your PR is large, consider breaking it into smaller PRs.
-- Tag the maintainer if you need a prompt review.
-- Avoid force pushing to the branch after opening the PR, as it can complicate the review process.
--->

.github/workflows/pipeline.yml

@@ -14,7 +14,7 @@ concurrency:
   cancel-in-progress: true
 
 env:
-  CROSS_TAGLIB_VERSION: "2.1.1-1"
+  CROSS_TAGLIB_VERSION: "2.0.2-1"
   IS_RELEASE: ${{ startsWith(github.ref, 'refs/tags/') && 'true' || 'false' }}
 
 jobs:
@@ -25,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@v4
         with:
           fetch-depth: 0
           fetch-tags: true
@@ -63,7 +63,7 @@ jobs:
     name: Lint Go code
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
 
       - name: Download TagLib
         uses: ./.github/actions/download-taglib
@@ -71,14 +71,14 @@ jobs:
           version: ${{ env.CROSS_TAGLIB_VERSION }}
 
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v9
+        uses: golangci/golangci-lint-action@v7
         with:
           version: latest
           problem-matchers: true
           args: --timeout 2m
 
       - name: Run go goimports
-        run: go run golang.org/x/tools/cmd/goimports@latest -w `find . -name '*.go' | grep -v '_gen.go$' | grep -v '.pb.go$'`
+        run: go run golang.org/x/tools/cmd/goimports@latest -w `find . -name '*.go' | grep -v '_gen.go$'`
       - run: go mod tidy
       - name: Verify no changes from goimports and go mod tidy
         run: |
@@ -88,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@v4
 
       - name: Download TagLib
         uses: ./.github/actions/download-taglib
@@ -116,7 +106,7 @@ jobs:
       - name: Test
         run: |
           pkg-config --define-prefix --cflags --libs taglib # for debugging
-          go test -shuffle=on -tags netgo -race ./... -v
+          go test -shuffle=on -tags netgo -race -cover ./... -v
 
   js:
     name: Test JS code
@@ -124,10 +114,10 @@ jobs:
     env:
       NODE_OPTIONS: "--max_old_space_size=4096"
     steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
-          node-version: 24
+          node-version: 20
           cache: "npm"
           cache-dependency-path: "**/package-lock.json"
 
@@ -155,7 +145,7 @@ jobs:
     name: Lint i18n files
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
       - run: |
           set -e
           for file in resources/i18n/*.json; do
@@ -167,8 +157,6 @@ jobs:
               exit 1
             fi
           done
-      - run: ./.github/workflows/validate-translations.sh -v
-
 
   check-push-enabled:
     name: Check Docker configuration
@@ -201,7 +189,7 @@ jobs:
           PLATFORM=$(echo ${{ matrix.platform }} | tr '/' '_')
           echo "PLATFORM=$PLATFORM" >> $GITHUB_ENV
 
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
 
       - name: Prepare Docker Buildx
         uses: ./.github/actions/prepare-docker
@@ -227,7 +215,7 @@ jobs:
             CROSS_TAGLIB_VERSION=${{ env.CROSS_TAGLIB_VERSION }}
 
       - name: Upload Binaries
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v4
         with:
           name: navidrome-${{ env.PLATFORM }}
           path: ./output
@@ -258,7 +246,7 @@ jobs:
           touch "/tmp/digests/${digest#sha256:}"          
 
       - name: Upload digest
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v4
         if: env.IS_LINUX == 'true' && env.IS_DOCKER_PUSH_CONFIGURED == 'true' && env.IS_ARMV5 == 'false'
         with:
           name: digests-${{ env.PLATFORM }}
@@ -266,55 +254,18 @@ jobs:
           if-no-files-found: error
           retention-days: 1
 
-  push-manifest-ghcr:
-    name: Push to GHCR
-    permissions:
-      contents: read
-      packages: write
+  push-manifest:
+    name: Push Docker manifest
     runs-on: ubuntu-latest
     needs: [build, check-push-enabled]
     if: needs.check-push-enabled.outputs.is_enabled == 'true'
     env:
       REGISTRY_IMAGE: ghcr.io/${{ github.repository }}
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
 
       - name: Download digests
-        uses: actions/download-artifact@v7
-        with:
-          path: /tmp/digests
-          pattern: digests-*
-          merge-multiple: true
-
-      - name: Prepare Docker Buildx
-        uses: ./.github/actions/prepare-docker
-        id: docker
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Create manifest list and push to ghcr.io
-        working-directory: /tmp/digests
-        run: |
-          docker buildx imagetools create $(jq -cr '.tags | map(select(startswith("ghcr.io"))) | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-            $(printf '${{ env.REGISTRY_IMAGE }}@sha256:%s ' *)          
-
-      - name: Inspect image in ghcr.io
-        run: |
-          docker buildx imagetools inspect ${{ env.REGISTRY_IMAGE }}:${{ steps.docker.outputs.version }}
-
-  push-manifest-dockerhub:
-    name: Push to Docker Hub
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-    needs: [build, check-push-enabled]
-    if: needs.check-push-enabled.outputs.is_enabled == 'true' && vars.DOCKER_HUB_REPO != ''
-    continue-on-error: true
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Download digests
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v4
         with:
           path: /tmp/digests
           pattern: digests-*
@@ -329,27 +280,28 @@ jobs:
           hub_username: ${{ secrets.DOCKER_HUB_USERNAME }}
           hub_password: ${{ secrets.DOCKER_HUB_PASSWORD }}
 
+      - name: Create manifest list and push to ghcr.io
+        working-directory: /tmp/digests
+        run: |
+          docker buildx imagetools create $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
+            $(printf '${{ env.REGISTRY_IMAGE }}@sha256:%s ' *)          
+
       - name: Create manifest list and push to Docker Hub
-        uses: nick-fields/retry@v3
-        with:
-          timeout_minutes: 5
-          max_attempts: 3
-          retry_wait_seconds: 30
-          command: |
-            cd /tmp/digests
-            docker buildx imagetools create $(jq -cr '.tags | map(select(startswith("ghcr.io") | not)) | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-              $(printf 'ghcr.io/${{ github.repository }}@sha256:%s ' *)
+        working-directory: /tmp/digests
+        if: vars.DOCKER_HUB_REPO != ''
+        run: |
+          docker buildx imagetools create $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
+            $(printf '${{ vars.DOCKER_HUB_REPO }}@sha256:%s ' *)          
+
+      - name: Inspect image in ghcr.io
+        run: |
+          docker buildx imagetools inspect ${{ env.REGISTRY_IMAGE }}:${{ steps.docker.outputs.version }}
 
       - name: Inspect image in Docker Hub
+        if: vars.DOCKER_HUB_REPO != ''
         run: |
           docker buildx imagetools inspect ${{ vars.DOCKER_HUB_REPO }}:${{ steps.docker.outputs.version }}
 
-  cleanup-digests:
-    name: Cleanup digest artifacts
-    runs-on: ubuntu-latest
-    needs: [push-manifest-ghcr, push-manifest-dockerhub]
-    if: always() && needs.push-manifest-ghcr.result == 'success'
-    steps:
       - name: Delete unnecessary digest artifacts
         env:
           GH_TOKEN: ${{ github.token }}
@@ -364,9 +316,9 @@ jobs:
     runs-on: ubuntu-24.04
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
 
-      - uses: actions/download-artifact@v7
+      - uses: actions/download-artifact@v4
         with:
           path: ./binaries
           pattern: navidrome-windows*
@@ -385,7 +337,7 @@ jobs:
           du -h binaries/msi/*.msi
 
       - name: Upload MSI files
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v4
         with:
           name: navidrome-windows-installers
           path: binaries/msi/*.msi
@@ -398,12 +350,12 @@ jobs:
     outputs:
       package_list: ${{ steps.set-package-list.outputs.package_list }}
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
           fetch-tags: true
 
-      - uses: actions/download-artifact@v7
+      - uses: actions/download-artifact@v4
         with:
           path: ./binaries
           pattern: navidrome-*
@@ -429,7 +381,7 @@ jobs:
           rm ./dist/*.tar.gz ./dist/*.zip
 
       - name: Upload all-packages artifact
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v4
         with:
           name: packages
           path: dist/navidrome_0*
@@ -452,13 +404,13 @@ jobs:
         item: ${{ fromJson(needs.release.outputs.package_list) }}
     steps:
       - name: Download all-packages artifact
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v4
         with:
           name: packages
           path: ./dist
 
       - name: Upload all-packages artifact
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v4
         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@v4
       - 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>"

.github/workflows/validate-translations.sh

@@ -1,236 +0,0 @@
-#!/bin/bash
-
-# validate-translations.sh
-# 
-# This script validates the structure of JSON translation files by comparing them 
-# against the reference English translation file (ui/src/i18n/en.json).
-#
-# The script performs the following validations:
-# 1. JSON syntax validation using jq
-# 2. Structural validation - ensures all keys from English file are present
-# 3. Reports missing keys (translation incomplete)
-# 4. Reports extra keys (keys not in English reference, possibly deprecated)
-# 5. Emits GitHub Actions annotations for CI/CD integration
-#
-# Usage:
-#   ./validate-translations.sh
-#
-# Environment Variables:
-#   EN_FILE          - Path to reference English file (default: ui/src/i18n/en.json)
-#   TRANSLATION_DIR  - Directory containing translation files (default: resources/i18n)
-#
-# Exit codes:
-#   0 - All translations are valid
-#   1 - One or more translations have structural issues
-#
-# GitHub Actions Integration:
-#   The script outputs GitHub Actions annotations using ::error and ::warning
-#   format that will be displayed in PR checks and workflow summaries.
-
-# Script to validate JSON translation files structure against en.json
-set -e
-
-# Path to the reference English translation file
-EN_FILE="${EN_FILE:-ui/src/i18n/en.json}"
-TRANSLATION_DIR="${TRANSLATION_DIR:-resources/i18n}"
-VERBOSE=false
-
-# Parse command line arguments
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        -v|--verbose)
-            VERBOSE=true
-            shift
-            ;;
-        -h|--help)
-    echo "Usage: $0 [options]"
-    echo ""
-    echo "Validates JSON translation files structure against English reference file."
-    echo ""
-    echo "Options:"
-    echo "  -h, --help     Show this help message"
-    echo "  -v, --verbose  Show detailed output (default: only show errors)"
-    echo ""
-    echo "Environment Variables:"
-    echo "  EN_FILE          Path to reference English file (default: ui/src/i18n/en.json)"
-    echo "  TRANSLATION_DIR  Directory with translation files (default: resources/i18n)"
-    echo ""
-    echo "Examples:"
-    echo "  $0                                    # Validate all translation files (quiet mode)"
-    echo "  $0 -v                                 # Validate with detailed output"
-    echo "  EN_FILE=custom/en.json $0             # Use custom reference file"
-    echo "  TRANSLATION_DIR=custom/i18n $0        # Use custom translations directory"
-    exit 0
-        ;;
-        *)
-            echo "Unknown option: $1" >&2
-            echo "Use --help for usage information" >&2
-            exit 1
-            ;;
-    esac
-done
-
-# Color codes for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-if [[ "$VERBOSE" == "true" ]]; then
-    echo "Validating translation files structure against ${EN_FILE}..."
-fi
-
-# Check if English reference file exists
-if [[ ! -f "$EN_FILE" ]]; then
-    echo "::error::Reference file $EN_FILE not found"
-    exit 1
-fi
-
-# Function to extract all JSON keys from a file, creating a flat list of dot-separated paths
-extract_keys() {
-    local file="$1"
-    jq -r 'paths(scalars) as $p | $p | join(".")' "$file" 2>/dev/null | sort
-}
-
-# Function to extract all non-empty string keys (to identify structural issues)
-extract_structure_keys() {
-    local file="$1"
-    # Get only keys where values are not empty strings
-    jq -r 'paths(scalars) as $p | select(getpath($p) != "") | $p | join(".")' "$file" 2>/dev/null | sort
-}
-
-# Function to validate a single translation file
-validate_translation() {
-    local translation_file="$1"
-    local filename=$(basename "$translation_file")
-    local has_errors=false
-    local verbose=${2:-false}
-    
-    if [[ "$verbose" == "true" ]]; then
-        echo "Validating $filename..."
-    fi
-    
-    # First validate JSON syntax
-    if ! jq empty "$translation_file" 2>/dev/null; then
-        echo "::error file=$translation_file::Invalid JSON syntax"
-        echo -e "${RED}✗ $filename has invalid JSON syntax${NC}"
-        return 1
-    fi
-    
-    # Extract all keys from both files (for statistics)
-    local en_keys_file=$(mktemp)
-    local translation_keys_file=$(mktemp)
-    
-    extract_keys "$EN_FILE" > "$en_keys_file"
-    extract_keys "$translation_file" > "$translation_keys_file"
-    
-    # Extract only non-empty structure keys (to validate structural issues)
-    local en_structure_file=$(mktemp)
-    local translation_structure_file=$(mktemp)
-    
-    extract_structure_keys "$EN_FILE" > "$en_structure_file"
-    extract_structure_keys "$translation_file" > "$translation_structure_file"
-    
-    # Find structural issues: keys in translation not in English (misplaced)
-    local extra_keys=$(comm -13 "$en_keys_file" "$translation_keys_file")
-    
-    # Find missing keys (for statistics only)
-    local missing_keys=$(comm -23 "$en_keys_file" "$translation_keys_file")
-    
-    # Count keys for statistics
-    local total_en_keys=$(wc -l < "$en_keys_file")
-    local total_translation_keys=$(wc -l < "$translation_keys_file") 
-    local missing_count=0
-    local extra_count=0
-    
-    if [[ -n "$missing_keys" ]]; then
-        missing_count=$(echo "$missing_keys" | grep -c '^' || echo 0)
-    fi
-    
-    if [[ -n "$extra_keys" ]]; then
-        extra_count=$(echo "$extra_keys" | grep -c '^' || echo 0)
-        has_errors=true
-    fi
-    
-    # Report extra/misplaced keys (these are structural issues)
-    if [[ -n "$extra_keys" ]]; then
-        if [[ "$verbose" == "true" ]]; then
-            echo -e "${YELLOW}Misplaced keys in $filename ($extra_count):${NC}"
-        fi
-        
-        while IFS= read -r key; do
-            # Try to find the line number
-            line=$(grep -n "\"$(echo "$key" | sed 's/.*\.//')" "$translation_file" | head -1 | cut -d: -f1)
-            line=${line:-1} # Default to line 1 if not found
-            
-            echo "::error file=$translation_file,line=$line::Misplaced key: $key"
-            
-            if [[ "$verbose" == "true" ]]; then
-                echo "  + $key (line ~$line)"
-            fi
-        done <<< "$extra_keys"
-    fi
-    
-    # Clean up temp files
-    rm -f "$en_keys_file" "$translation_keys_file" "$en_structure_file" "$translation_structure_file"
-    
-    # Print statistics
-    if [[ "$verbose" == "true" ]]; then
-        echo "  Keys: $total_translation_keys/$total_en_keys (Missing: $missing_count, Extra/Misplaced: $extra_count)"
-    
-        if [[ "$has_errors" == "true" ]]; then
-            echo -e "${RED}✗ $filename has structural issues${NC}"
-        else
-            echo -e "${GREEN}✓ $filename structure is valid${NC}"
-        fi
-    elif [[ "$has_errors" == "true" ]]; then
-        echo -e "${RED}✗ $filename has structural issues (Extra/Misplaced: $extra_count)${NC}"
-    fi
-    
-    return $([[ "$has_errors" == "true" ]] && echo 1 || echo 0)
-}
-
-# Main validation loop
-validation_failed=false
-total_files=0
-failed_files=0
-valid_files=0
-
-for translation_file in "$TRANSLATION_DIR"/*.json; do
-    if [[ -f "$translation_file" ]]; then
-        total_files=$((total_files + 1))
-        if ! validate_translation "$translation_file" "$VERBOSE"; then
-            validation_failed=true
-            failed_files=$((failed_files + 1))
-        else
-            valid_files=$((valid_files + 1))
-        fi
-        
-        if [[ "$VERBOSE" == "true" ]]; then
-            echo "" # Add spacing between files
-        fi
-    fi
-done
-
-# Summary
-if [[ "$VERBOSE" == "true" ]]; then
-    echo "========================================="
-    echo "Translation Validation Summary:"
-    echo "  Total files: $total_files"
-    echo "  Valid files: $valid_files"
-    echo "  Files with structural issues: $failed_files"
-    echo "========================================="
-fi
-
-if [[ "$validation_failed" == "true" ]]; then
-    if [[ "$VERBOSE" == "true" ]]; then
-        echo -e "${RED}Translation validation failed - $failed_files file(s) have structural issues${NC}"
-    else
-        echo -e "${RED}Translation validation failed - $failed_files/$total_files file(s) have structural issues${NC}"
-    fi
-    exit 1
-elif [[ "$VERBOSE" == "true" ]]; then
-    echo -e "${GREEN}All translation files are structurally valid${NC}"
-fi
-
-exit 0

.gitignore

@@ -5,7 +5,6 @@
 /navidrome
 /iTunes*.xml
 /tmp
-/bin
 data/*
 vendor/*/
 wiki
@@ -17,7 +16,6 @@ master.zip
 testDB
 cache/*
 *.swp
-coverage.out
 dist
 music
 *.db*
@@ -25,14 +23,5 @@ music
 docker-compose.yml
 !contrib/docker-compose.yml
 binaries
-navidrome-*
-/ndpgen
-AGENTS.md
-.github/prompts
-.github/instructions
-.github/git-commit-instructions.md
-*.exe
-*.test
-*.wasm
-*.ndp
-openspec/
+navidrome-master
+*.exe

.nvmrc

@@ -1 +1 @@
-v24
+v20

Dockerfile

@@ -1,11 +1,11 @@
 FROM --platform=$BUILDPLATFORM ghcr.io/crazy-max/osxcross:14.5-debian AS osxcross
 
 ########################################################################################################################
-### Build xx (original image: tonistiigi/xx)
-FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/alpine:3.20 AS xx-build
+### Build xx (orignal image: tonistiigi/xx)
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/alpine:3.21 AS xx-build
 
-# v1.9.0
-ENV XX_VERSION=a5592eab7a57895e8d385394ff12241bc65ecd50
+# v1.5.0
+ENV XX_VERSION=b4e4c451c778822e6742bfc9d9a91d7c7d885c8a
 
 RUN apk add -U --no-cache git
 RUN git clone https://github.com/tonistiigi/xx && \
@@ -26,14 +26,12 @@ 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.21 AS taglib-build
 ARG TARGETPLATFORM
-ARG CROSS_TAGLIB_VERSION=2.1.1-1
+ARG CROSS_TAGLIB_VERSION=2.0.2-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
 RUN <<EOT
-    apk add --no-cache wget
     PLATFORM=$(echo ${TARGETPLATFORM} | tr '/' '-')
     FILE=taglib-${PLATFORM}.tar.gz
 
@@ -63,7 +61,7 @@ COPY --from=ui /build /build
 
 ########################################################################################################################
 ### Build Navidrome binary
-FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.25-bookworm AS base
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.24-bookworm AS base
 RUN apt-get update && apt-get install -y clang lld
 COPY --from=xx / /
 WORKDIR /workspace
@@ -122,7 +120,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.21 AS final
 LABEL maintainer="deluan@navidrome.org"
 LABEL org.opencontainers.image.source="https://github.com/navidrome/navidrome"
 
@@ -137,6 +135,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

@@ -15,12 +15,11 @@ 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-1
-GOLANGCI_LINT_VERSION ?= v2.7.2
+CROSS_TAGLIB_VERSION ?= 2.0.2-1
 
 UI_SRC_FILES := $(shell find ui -type f -not -path "ui/build/*" -not -path "ui/node_modules/*")
 
-setup: check_env download-deps install-golangci-lint setup-git ##@1_Run_First Install dependencies and prepare development environment
+setup: check_env download-deps setup-git ##@1_Run_First Install dependencies and prepare development environment
 	@echo Downloading Node dependencies...
 	@(cd ./ui && npm ci)
 .PHONY: setup
@@ -33,59 +32,24 @@ server: check_go_env buildjs ##@Development Start the backend in development mod
 	@ND_ENABLEINSIGHTSCOLLECTOR="false" go tool reflex -d none -c reflex.conf
 .PHONY: server
 
-stop: ##@Development Stop development servers (UI and backend)
-	@echo "Stopping development servers..."
-	@-pkill -f "vite"
-	@-pkill -f "go tool reflex.*reflex.conf"
-	@-pkill -f "go run.*netgo"
-	@echo "Development servers stopped."
-.PHONY: stop
-
 watch: ##@Development Start Go tests in watch mode (re-run when code changes)
 	go tool ginkgo watch -tags=netgo -notify ./...
 .PHONY: watch
 
-PKG ?= ./...
-test: ##@Development Run Go tests. Use PKG variable to specify packages to test, e.g. make test PKG=./server
-	go test -tags netgo $(PKG)
+test: ##@Development Run Go tests
+	go test -tags netgo ./...
 .PHONY: test
 
-testall: test test-i18n test-js ##@Development Run Go and JS tests
+testrace: ##@Development Run Go tests with race detector
+	go test -tags netgo -race -shuffle=on ./...
+.PHONY: test
+
+testall: testrace ##@Development Run Go and JS tests
+	@(cd ./ui && npm run test:ci)
 .PHONY: testall
 
-test-race: ##@Development Run Go tests with race detector
-	go test -tags netgo -race -shuffle=on  $(PKG)
-.PHONY: test-race
-
-test-js: ##@Development Run JS tests
-	@(cd ./ui && npm run test)
-.PHONY: test-js
-
-test-i18n: ##@Development Validate all translations files
-	./.github/workflows/validate-translations.sh 
-.PHONY: test-i18n
-
-install-golangci-lint: ##@Development Install golangci-lint if not present
-	@INSTALL=false; \
-	if PATH=$$PATH:./bin which golangci-lint > /dev/null 2>&1; then \
-		CURRENT_VERSION=$$(PATH=$$PATH:./bin golangci-lint version 2>/dev/null | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -n1); \
-		REQUIRED_VERSION=$$(echo "$(GOLANGCI_LINT_VERSION)" | sed 's/^v//'); \
-		if [ "$$CURRENT_VERSION" != "$$REQUIRED_VERSION" ]; then \
-			echo "Found golangci-lint $$CURRENT_VERSION, but $$REQUIRED_VERSION is required. Reinstalling..."; \
-			rm -f ./bin/golangci-lint; \
-			INSTALL=true; \
-		fi; \
-	else \
-		INSTALL=true; \
-	fi; \
-	if [ "$$INSTALL" = "true" ]; then \
-		echo "Installing golangci-lint $(GOLANGCI_LINT_VERSION)..."; \
-		curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/HEAD/install.sh | sh -s $(GOLANGCI_LINT_VERSION); \
-	fi
-.PHONY: install-golangci-lint
-
-lint: install-golangci-lint ##@Development Lint Go code
-	PATH=$$PATH:./bin golangci-lint run --timeout 5m
+lint: ##@Development Lint Go code
+	go run github.com/golangci/golangci-lint/v2/cmd/golangci-lint@latest run -v --timeout 5m
 .PHONY: lint
 
 lintall: lint ##@Development Lint Go and JS code
@@ -95,7 +59,7 @@ lintall: lint ##@Development Lint Go and JS code
 
 format: ##@Development Format code
 	@(cd ./ui && npm run prettier)
-	@go tool goimports -w `find . -name '*.go' | grep -v _gen.go$$ | grep -v .pb.go$$`
+	@go tool goimports -w `find . -name '*.go' | grep -v _gen.go$$`
 	@go mod tidy
 .PHONY: format
 
@@ -103,15 +67,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
@@ -193,20 +148,6 @@ docker-msi: ##@Cross_Compilation Build MSI installer for Windows
 	@du -h binaries/msi/*.msi
 .PHONY: docker-msi
 
-run-docker: ##@Development Run a Navidrome Docker image. Usage: make run-docker tag=<tag>
-	@if [ -z "$(tag)" ]; then echo "Usage: make run-docker tag=<tag>"; exit 1; fi
-	@TAG_DIR="tmp/$$(echo '$(tag)' | tr '/:' '_')"; mkdir -p "$$TAG_DIR"; \
-    VOLUMES="-v $(PWD)/$$TAG_DIR:/data"; \
-	if [ -f navidrome.toml ]; then \
-		VOLUMES="$$VOLUMES -v $(PWD)/navidrome.toml:/data/navidrome.toml:ro"; \
-		MUSIC_FOLDER=$$(grep '^MusicFolder' navidrome.toml | head -n1 | sed 's/.*= *"//' | sed 's/".*//'); \
-		if [ -n "$$MUSIC_FOLDER" ] && [ -d "$$MUSIC_FOLDER" ]; then \
-		  VOLUMES="$$VOLUMES -v $$MUSIC_FOLDER:/music:ro"; \
-	  	fi; \
-	fi; \
-	echo "Running: docker run --rm -p 4533:4533 $$VOLUMES $(tag)"; docker run --rm -p 4533:4533 $$VOLUMES $(tag)
-.PHONY: run-docker
-
 package: docker-build ##@Cross_Compilation Create binaries and packages for ALL supported platforms
 	@if [ -z `which goreleaser` ]; then echo "Please install goreleaser first: https://goreleaser.com/install/"; exit 1; fi
 	goreleaser release -f release/goreleaser.yml --clean --skip=publish --snapshot
@@ -215,10 +156,10 @@ package: docker-build ##@Cross_Compilation Create binaries and packages for ALL
 get-music: ##@Development Download some free music from Navidrome's demo instance
 	mkdir -p music
 	( cd music; \
-	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=2Y3qQA6zJC3ObbBrF9ZBoV" > brock.zip; \
-	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=04HrSORpypcLGNUdQp37gn" > back_on_earth.zip; \
-	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=5xcMPJdeEgNrGtnzYbzAqb" > ugress.zip; \
-	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=1jjQMAZrG3lUsJ0YH6ZRS0" > voodoocuts.zip; \
+	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=ec2093ec4801402f1e17cc462195cdbb" > brock.zip; \
+	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=b376eeb4652d2498aa2b25ba0696725e" > back_on_earth.zip; \
+	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=e49c609b542fc51899ee8b53aa858cb4" > ugress.zip; \
+	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=350bcab3a4c1d93869e39ce496464f03" > voodoocuts.zip; \
 	for file in *.zip; do unzip -n $${file}; done )
 	@echo "Done. Remember to set your MusicFolder to ./music"
 .PHONY: get-music

adapters/taglib/end_to_end_test.go

@@ -8,7 +8,6 @@ import (
 	"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"
 )
@@ -79,116 +78,22 @@ var _ = Describe("Extractor", func() {
 
 	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{}
 	})
 
-	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")
-
-			// 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) {
-			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)
+			path := "tests/fixtures/test." + format
+			mds, err := e.Parse(path)
+			Expect(err).ToNot(HaveOccurred())
+
+			info := mds[path]
+			fileInfo, _ := os.Stat(path)
+			info.FileInfo = testFileInfo{FileInfo: fileInfo}
+
+			metadata := metadata.New(path, info)
+			mf := metadata.ToMediaFile(1, "folderID")
 
 			for _, data := range roles {
 				role := data.Role
@@ -239,40 +144,11 @@ var _ = Describe("Extractor", func() {
 			Entry("FLAC format", "flac"),
 			Entry("M4a format", "m4a"),
 			Entry("OGG format", "ogg"),
-			Entry("WV format", "wv"),
+			Entry("WMA 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/taglib/taglib.go

@@ -7,7 +7,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/core/storage/local"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model/metadata"
@@ -43,21 +42,23 @@ func (e extractor) extractMetadata(filePath string) (*metadata.Info, error) {
 
 	// Parse audio properties
 	ap := metadata.AudioProperties{}
-	ap.BitRate = parseProp(tags, "__bitrate")
-	ap.Channels = parseProp(tags, "__channels")
-	ap.SampleRate = parseProp(tags, "__samplerate")
-	ap.BitDepth = parseProp(tags, "__bitspersample")
-	length := parseProp(tags, "__lengthinmilliseconds")
-	ap.Duration = (time.Millisecond * time.Duration(length)).Round(time.Millisecond * 10)
-
-	// Extract basic tags
-	parseBasicTag(tags, "__title", "title")
-	parseBasicTag(tags, "__artist", "artist")
-	parseBasicTag(tags, "__album", "album")
-	parseBasicTag(tags, "__comment", "comment")
-	parseBasicTag(tags, "__genre", "genre")
-	parseBasicTag(tags, "__year", "year")
-	parseBasicTag(tags, "__track", "tracknumber")
+	if length, ok := tags["_lengthinmilliseconds"]; ok && len(length) > 0 {
+		millis, _ := strconv.Atoi(length[0])
+		if millis > 0 {
+			ap.Duration = (time.Millisecond * time.Duration(millis)).Round(time.Millisecond * 10)
+		}
+		delete(tags, "_lengthinmilliseconds")
+	}
+	parseProp := func(prop string, target *int) {
+		if value, ok := tags[prop]; ok && len(value) > 0 {
+			*target, _ = strconv.Atoi(value[0])
+			delete(tags, prop)
+		}
+	}
+	parseProp("_bitrate", &ap.BitRate)
+	parseProp("_channels", &ap.Channels)
+	parseProp("_samplerate", &ap.SampleRate)
+	parseProp("_bitspersample", &ap.BitDepth)
 
 	// Parse track/disc totals
 	parseTuple := func(prop string) {
@@ -105,31 +106,6 @@ var tiplMapping = map[string]string{
 	"DJ-mix":   "djmixer",
 }
 
-// parseProp parses a property from the tags map and sets it to the target integer.
-// It also deletes the property from the tags map after parsing.
-func parseProp(tags map[string][]string, prop string) int {
-	if value, ok := tags[prop]; ok && len(value) > 0 {
-		v, _ := strconv.Atoi(value[0])
-		delete(tags, prop)
-		return v
-	}
-	return 0
-}
-
-// parseBasicTag checks if a basic tag (like __title, __artist, etc.) exists in the tags map.
-// If it does, it moves the value to a more appropriate tag name (like title, artist, etc.),
-// and deletes the basic tag from the map. If the target tag already exists, it ignores the basic tag.
-func parseBasicTag(tags map[string][]string, basicName string, tagName string) {
-	basicValue := tags[basicName]
-	if len(basicValue) == 0 {
-		return
-	}
-	delete(tags, basicName)
-	if len(tags[tagName]) == 0 {
-		tags[tagName] = basicValue
-	}
-}
-
 // 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".
@@ -172,7 +148,4 @@ func init() {
 		// ignores fs, as taglib extractor only works with local files
 		return &extractor{baseDir}
 	})
-	conf.AddHook(func() {
-		log.Debug("TagLib version", "version", Version())
-	})
 }

adapters/taglib/taglib_test.go

@@ -82,15 +82,15 @@ var _ = Describe("Extractor", func() {
 
 			// 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.BitRate).To(BeElementOf(18, 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())
+			Expect(m.HasPicture).To(BeFalse())
 		})
 
 		DescribeTable("Format-Specific tests",
-			func(file, duration string, channels, samplerate, bitdepth int, albumGain, albumPeak, trackGain, trackPeak string, id3Lyrics bool, image bool) {
+			func(file, duration string, channels, samplerate, bitdepth int, albumGain, albumPeak, trackGain, trackPeak string, id3Lyrics bool) {
 				file = "tests/fixtures/" + file
 				mds, err := e.Parse(file)
 				Expect(err).NotTo(HaveOccurred())
@@ -98,7 +98,7 @@ var _ = Describe("Extractor", func() {
 
 				m := mds[file]
 
-				Expect(m.HasPicture).To(Equal(image))
+				Expect(m.HasPicture).To(BeFalse())
 				Expect(m.AudioProperties.Duration.String()).To(Equal(duration))
 				Expect(m.AudioProperties.Channels).To(Equal(channels))
 				Expect(m.AudioProperties.SampleRate).To(Equal(samplerate))
@@ -168,24 +168,24 @@ var _ = Describe("Extractor", func() {
 			},
 
 			// 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 flac tags", "test.flac", "1s", 1, 44100, 16, "+4.06 dB", "0.12496948", "+4.06 dB", "0.12496948", false),
 
-			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),
+			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),
+			Entry("correctly parses m4a (aac) gain tags (uppercase)", "test.m4a", "1.04s", 2, 44100, 16, "0.37", "0.48", "0.37", "0.48", false),
+			Entry("correctly parses ogg (vorbis) tags", "test.ogg", "1.04s", 2, 8000, 0, "+7.64 dB", "0.11772506", "+7.64 dB", "0.11772506", false),
 
 			// 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),
+			Entry("correctly parses wma/asf tags", "test.wma", "1.02s", 1, 44100, 16, "3.27 dB", "0.132914", "3.27 dB", "0.132914", false),
 
 			// 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),
+			Entry("correctly parses wv (wavpak) tags", "test.wv", "1s", 1, 44100, 16, "3.43 dB", "0.125061", "3.43 dB", "0.125061", false),
 
 			// 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),
+			Entry("correctly parses wav tags", "test.wav", "1s", 1, 44100, 16, "3.06 dB", "0.125056", "3.06 dB", "0.125056", 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),
+			Entry("correctly parses aiff tags", "test.aiff", "1s", 1, 44100, 16, "2.00 dB", "0.124972", "2.00 dB", "0.124972", true),
 		)
 
 		// Skip these tests when running as root

adapters/taglib/taglib_wrapper.cpp

@@ -1,5 +1,6 @@
 #include <stdlib.h>
 #include <string.h>
+#include <typeinfo>
 
 #define TAGLIB_STATIC
 #include <apeproperties.h>
@@ -45,63 +46,31 @@ int taglib_read(const FILENAME_CHAR_T *filename, unsigned long id) {
 
   // Add audio properties to the tags
   const TagLib::AudioProperties *props(f.audioProperties());
-  goPutInt(id, (char *)"__lengthinmilliseconds", props->lengthInMilliseconds());
-  goPutInt(id, (char *)"__bitrate", props->bitrate());
-  goPutInt(id, (char *)"__channels", props->channels());
-  goPutInt(id, (char *)"__samplerate", props->sampleRate());
+  goPutInt(id, (char *)"_lengthinmilliseconds", props->lengthInMilliseconds());
+  goPutInt(id, (char *)"_bitrate", props->bitrate());
+  goPutInt(id, (char *)"_channels", props->channels());
+  goPutInt(id, (char *)"_samplerate", props->sampleRate());
 
-  // Extract bits per sample for supported formats
-  int bitsPerSample = 0;
   if (const auto* apeProperties{ dynamic_cast<const TagLib::APE::Properties*>(props) })
-      bitsPerSample = apeProperties->bitsPerSample();
-  else if (const auto* asfProperties{ dynamic_cast<const TagLib::ASF::Properties*>(props) })
-      bitsPerSample = asfProperties->bitsPerSample();
+      goPutInt(id, (char *)"_bitspersample",  apeProperties->bitsPerSample());
+  if (const auto* asfProperties{ dynamic_cast<const TagLib::ASF::Properties*>(props) })
+      goPutInt(id, (char *)"_bitspersample",  asfProperties->bitsPerSample());
   else if (const auto* flacProperties{ dynamic_cast<const TagLib::FLAC::Properties*>(props) })
-      bitsPerSample = flacProperties->bitsPerSample();
+      goPutInt(id, (char *)"_bitspersample",  flacProperties->bitsPerSample());
   else if (const auto* mp4Properties{ dynamic_cast<const TagLib::MP4::Properties*>(props) })
-      bitsPerSample = mp4Properties->bitsPerSample();
+      goPutInt(id, (char *)"_bitspersample",  mp4Properties->bitsPerSample());
   else if (const auto* wavePackProperties{ dynamic_cast<const TagLib::WavPack::Properties*>(props) })
-      bitsPerSample = wavePackProperties->bitsPerSample();
+      goPutInt(id, (char *)"_bitspersample",  wavePackProperties->bitsPerSample());
   else if (const auto* aiffProperties{ dynamic_cast<const TagLib::RIFF::AIFF::Properties*>(props) })
-      bitsPerSample = aiffProperties->bitsPerSample();
+      goPutInt(id, (char *)"_bitspersample",  aiffProperties->bitsPerSample());
   else if (const auto* wavProperties{ dynamic_cast<const TagLib::RIFF::WAV::Properties*>(props) })
-      bitsPerSample = wavProperties->bitsPerSample();
+      goPutInt(id, (char *)"_bitspersample",  wavProperties->bitsPerSample());
   else if (const auto* dsfProperties{ dynamic_cast<const TagLib::DSF::Properties*>(props) })
-      bitsPerSample = dsfProperties->bitsPerSample();
-  
-  if (bitsPerSample > 0) {
-      goPutInt(id, (char *)"__bitspersample", bitsPerSample);
-  }
+      goPutInt(id, (char *)"_bitspersample",  dsfProperties->bitsPerSample());
 
   // Send all properties to the Go map
   TagLib::PropertyMap tags = f.file()->properties();
 
-  // Make sure at least the basic properties are extracted
-  TagLib::Tag *basic = f.file()->tag();
-  if (!basic->isEmpty()) {
-    if (!basic->title().isEmpty()) {
-      tags.insert("__title", basic->title());
-    }
-    if (!basic->artist().isEmpty()) {
-      tags.insert("__artist", basic->artist());
-    }
-    if (!basic->album().isEmpty()) {
-      tags.insert("__album", basic->album());
-    }
-    if (!basic->comment().isEmpty()) {
-      tags.insert("__comment", basic->comment());
-    }
-    if (!basic->genre().isEmpty()) {
-      tags.insert("__genre", basic->genre());
-    }
-    if (basic->year() > 0) {
-      tags.insert("__year", TagLib::String::number(basic->year()));
-    }
-    if (basic->track() > 0) {
-      tags.insert("__track", TagLib::String::number(basic->track()));
-    }
-  }
-
   TagLib::ID3v2::Tag *id3Tags = NULL;
 
   // Get some extended/non-standard ID3-only tags (ex: iTunes extended frames)
@@ -144,7 +113,7 @@ int taglib_read(const FILENAME_CHAR_T *filename, unsigned long id) {
             strncpy(language, bv.data(), 3);
           }
 
-          char *val = const_cast<char*>(frame->text().toCString(true));
+          char *val = (char *)frame->text().toCString(true);
 
           goPutLyrics(id, language, val);
         }
@@ -163,7 +132,7 @@ int taglib_read(const FILENAME_CHAR_T *filename, unsigned long id) {
           if (format == TagLib::ID3v2::SynchronizedLyricsFrame::AbsoluteMilliseconds) {
 
             for (const auto &line: frame->synchedText()) {
-              char *text = const_cast<char*>(line.text.toCString(true));
+              char *text = (char *)line.text.toCString(true);
               goPutLyricLine(id, language, text, line.time);
             }
           } else if (format == TagLib::ID3v2::SynchronizedLyricsFrame::AbsoluteMpegFrames) {
@@ -172,7 +141,7 @@ int taglib_read(const FILENAME_CHAR_T *filename, unsigned long id) {
             if (sampleRate != 0) {
               for (const auto &line: frame->synchedText()) {
                 const int timeInMs = (line.time * 1000) / sampleRate;
-                char *text = const_cast<char*>(line.text.toCString(true));
+                char *text = (char *)line.text.toCString(true);
                 goPutLyricLine(id, language, text, timeInMs);
               }
             }
@@ -191,9 +160,9 @@ int taglib_read(const FILENAME_CHAR_T *filename, unsigned long id) {
   if (m4afile != NULL) {
     const auto itemListMap = m4afile->tag()->itemMap();
     for (const auto item: itemListMap) {
-      char *key = const_cast<char*>(item.first.toCString(true));
+      char *key = (char *)item.first.toCString(true);
       for (const auto value: item.second.toStringList()) {
-        char *val = const_cast<char*>(value.toCString(true));
+        char *val = (char *)value.toCString(true);
         goPutM4AStr(id, key, val);
       }
     }
@@ -205,24 +174,17 @@ int taglib_read(const FILENAME_CHAR_T *filename, unsigned long id) {
     const TagLib::ASF::Tag *asfTags{asfFile->tag()};
     const auto itemListMap = asfTags->attributeListMap();
     for (const auto item : itemListMap) {
-      char *key = const_cast<char*>(item.first.toCString(true));
-
-      for (auto j = item.second.begin();
-           j != item.second.end(); ++j) {
-
-        char *val = const_cast<char*>(j->toString().toCString(true));
-        goPutStr(id, key, val);
-      }
+      tags.insert(item.first, item.second.front().toString());
     }
   }
 
   // Send all collected tags to the Go map
   for (TagLib::PropertyMap::ConstIterator i = tags.begin(); i != tags.end();
        ++i) {
-    char *key = const_cast<char*>(i->first.toCString(true));
+    char *key = (char *)i->first.toCString(true);
     for (TagLib::StringList::ConstIterator j = i->second.begin();
          j != i->second.end(); ++j) {
-      char *val = const_cast<char*>((*j).toCString(true));
+      char *val = (char *)(*j).toCString(true);
       goPutStr(id, key, val);
     }
   }
@@ -263,35 +225,16 @@ char has_cover(const TagLib::FileRef f) {
   else if (TagLib::Ogg::Opus::File * opusFile{dynamic_cast<TagLib::Ogg::Opus::File *>(f.file())}) {
     hasCover = !opusFile->tag()->pictureList().isEmpty();
   }
+  // ----- WMA
+  else if (TagLib::ASF::File * asfFile{dynamic_cast<TagLib::ASF::File *>(f.file())}) {
+    const TagLib::ASF::Tag *tag{asfFile->tag()};
+    hasCover = tag && tag->attributeListMap().contains("WM/Picture");
+  }
   // ----- WAV
   else if (TagLib::RIFF::WAV::File * wavFile{ dynamic_cast<TagLib::RIFF::WAV::File*>(f.file()) }) {
     if (wavFile->hasID3v2Tag()) {
-      const auto& frameListMap{ wavFile->ID3v2Tag()->frameListMap() };
-      hasCover = !frameListMap["APIC"].isEmpty();
-    }
-  }
-  // ----- AIFF 
-  else if (TagLib::RIFF::AIFF::File * aiffFile{ dynamic_cast<TagLib::RIFF::AIFF::File *>(f.file())}) {
-    if (aiffFile->hasID3v2Tag()) {
-      const auto& frameListMap{ aiffFile->tag()->frameListMap() };
-      hasCover = !frameListMap["APIC"].isEmpty();
-    }
-  }
-  // ----- WMA
-  else if (TagLib::ASF::File * asfFile{dynamic_cast<TagLib::ASF::File *>(f.file())}) {
-    const TagLib::ASF::Tag *tag{ asfFile->tag() };
-    hasCover = tag && tag->attributeListMap().contains("WM/Picture");
-  }
-  // ----- DSF
-  else if (TagLib::DSF::File * dsffile{ dynamic_cast<TagLib::DSF::File *>(f.file())}) {
-    const TagLib::ID3v2::Tag *tag { dsffile->tag() };
-    hasCover = tag && !tag->frameListMap()["APIC"].isEmpty();
-  }
-  // ----- WAVPAK (APE tag)
-  else if (TagLib::WavPack::File * wvFile{dynamic_cast<TagLib::WavPack::File *>(f.file())}) {
-    if (wvFile->hasAPETag()) {
-      // This is the particular string that Picard uses
-      hasCover = !wvFile->APETag()->itemListMap()["COVER ART (FRONT)"].isEmpty();
+        const auto& frameListMap{ wavFile->ID3v2Tag()->frameListMap() };
+        hasCover = !frameListMap["APIC"].isEmpty();
     }
   }
 

cmd/cmd_suite_test.go

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

cmd/pls.go

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

cmd/root.go

@@ -82,9 +82,8 @@ func runNavidrome(ctx context.Context) {
 	g.Go(schedulePeriodicBackup(ctx))
 	g.Go(startInsightsCollector(ctx))
 	g.Go(scheduleDBOptimizer(ctx))
-	g.Go(startPluginManager(ctx))
-	g.Go(runInitialScan(ctx))
 	if conf.Server.Scanner.Enabled {
+		g.Go(runInitialScan(ctx))
 		g.Go(startScanWatcher(ctx))
 		g.Go(schedulePeriodicScan(ctx))
 	} else {
@@ -110,7 +109,7 @@ func mainContext(ctx context.Context) (context.Context, context.CancelFunc) {
 func startServer(ctx context.Context) func() error {
 	return func() error {
 		a := CreateServer()
-		a.MountRouter("Native API", consts.URLPathNativeAPI, CreateNativeAPIRouter(ctx))
+		a.MountRouter("Native API", consts.URLPathNativeAPI, CreateNativeAPIRouter())
 		a.MountRouter("Subsonic API", consts.URLPathSubsonicAPI, CreateSubsonicAPIRouter(ctx))
 		a.MountRouter("Public Endpoints", consts.URLPathPublic, CreatePublicRouter())
 		if conf.Server.LastFM.Enabled {
@@ -148,7 +147,7 @@ func schedulePeriodicScan(ctx context.Context) func() error {
 		schedulerInstance := scheduler.GetInstance()
 
 		log.Info("Scheduling periodic scan", "schedule", schedule)
-		_, err := schedulerInstance.Add(schedule, func() {
+		err := schedulerInstance.Add(schedule, func() {
 			_, err := s.ScanAll(ctx, false)
 			if err != nil {
 				log.Error(ctx, "Error executing periodic scan", err)
@@ -173,7 +172,6 @@ func pidHashChanged(ds model.DataStore) (bool, error) {
 	return !strings.EqualFold(pidAlbum, conf.Server.PID.Album) || !strings.EqualFold(pidTrack, conf.Server.PID.Track), nil
 }
 
-// runInitialScan runs an initial scan of the music library if needed.
 func runInitialScan(ctx context.Context) func() error {
 	return func() error {
 		ds := CreateDataStore()
@@ -192,7 +190,7 @@ func runInitialScan(ctx context.Context) func() error {
 		scanNeeded := conf.Server.Scanner.ScanOnStartup || inProgress || fullScanRequired == "1" || pidHasChanged
 		time.Sleep(2 * time.Second) // Wait 2 seconds before the initial scan
 		if scanNeeded {
-			s := CreateScanner(ctx)
+			scanner := CreateScanner(ctx)
 			switch {
 			case fullScanRequired == "1":
 				log.Warn(ctx, "Full scan required after migration")
@@ -206,7 +204,7 @@ func runInitialScan(ctx context.Context) func() error {
 				log.Info("Executing initial scan")
 			}
 
-			_, err = s.ScanAll(ctx, fullScanRequired == "1")
+			_, err = scanner.ScanAll(ctx, fullScanRequired == "1")
 			if err != nil {
 				log.Error(ctx, "Scan failed", err)
 			} else {
@@ -245,7 +243,7 @@ func schedulePeriodicBackup(ctx context.Context) func() error {
 		schedulerInstance := scheduler.GetInstance()
 
 		log.Info("Scheduling periodic backup", "schedule", schedule)
-		_, err := schedulerInstance.Add(schedule, func() {
+		err := schedulerInstance.Add(schedule, func() {
 			start := time.Now()
 			path, err := db.Backup(ctx)
 			elapsed := time.Since(start)
@@ -273,7 +271,7 @@ func scheduleDBOptimizer(ctx context.Context) func() error {
 	return func() error {
 		log.Info(ctx, "Scheduling DB optimizer", "schedule", consts.OptimizeDBSchedule)
 		schedulerInstance := scheduler.GetInstance()
-		_, err := schedulerInstance.Add(consts.OptimizeDBSchedule, func() {
+		err := schedulerInstance.Add(consts.OptimizeDBSchedule, func() {
 			if scanner.IsScanning() {
 				log.Debug(ctx, "Skipping DB optimization because a scan is in progress")
 				return
@@ -327,23 +325,10 @@ 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")
-			return nil
-		}
-		log.Info(ctx, "Starting plugin manager")
-		return manager.Start(ctx)
-	}
-}
-
 // 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")`)
@@ -371,7 +356,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")
@@ -395,7 +379,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,15 @@
 package cmd
 
 import (
-	"bufio"
 	"context"
 	"encoding/gob"
-	"fmt"
 	"os"
-	"strings"
 
 	"github.com/navidrome/navidrome/core"
+	"github.com/navidrome/navidrome/core/artwork"
+	"github.com/navidrome/navidrome/core/metrics"
 	"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 +19,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 +70,7 @@ func runScanner(ctx context.Context) {
 	ds := persistence.New(sqlDB)
 	pls := core.NewPlaylists(ds)
 
-	// Parse targets from command line or file
-	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)
+	progress, err := scanner.CallScan(ctx, ds, artwork.NoopCacheWarmer(), pls, metrics.NewNoopInstance(), fullScan)
 	if err != nil {
 		log.Fatal(ctx, "Failed to scan", err)
 	}
@@ -106,31 +82,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

@@ -22,7 +22,6 @@ import (
 	"github.com/navidrome/navidrome/db"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/persistence"
-	"github.com/navidrome/navidrome/plugins"
 	"github.com/navidrome/navidrome/scanner"
 	"github.com/navidrome/navidrome/server"
 	"github.com/navidrome/navidrome/server/events"
@@ -52,26 +51,13 @@ func CreateServer() *server.Server {
 	return serverServer
 }
 
-func CreateNativeAPIRouter(ctx context.Context) *nativeapi.Router {
+func CreateNativeAPIRouter() *nativeapi.Router {
 	sqlDB := db.Db()
 	dataStore := persistence.New(sqlDB)
 	share := core.NewShare(dataStore)
 	playlists := core.NewPlaylists(dataStore)
 	insights := metrics.GetInstance(dataStore)
-	fileCache := artwork.GetImageCache()
-	fFmpeg := ffmpeg.New()
-	broker := events.GetBroker()
-	manager := plugins.GetManager(dataStore, broker)
-	agentsAgents := agents.GetAgents(dataStore, manager)
-	provider := external.NewProvider(dataStore, agentsAgents)
-	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
-	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
-	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
-	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
-	watcher := scanner.GetWatcher(dataStore, modelScanner)
-	library := core.NewLibrary(dataStore, modelScanner, watcher, broker)
-	maintenance := core.NewMaintenance(dataStore)
-	router := nativeapi.New(dataStore, share, playlists, insights, library, maintenance, manager)
+	router := nativeapi.New(dataStore, share, playlists, insights)
 	return router
 }
 
@@ -80,9 +66,7 @@ func CreateSubsonicAPIRouter(ctx context.Context) *subsonic.Router {
 	dataStore := persistence.New(sqlDB)
 	fileCache := artwork.GetImageCache()
 	fFmpeg := ffmpeg.New()
-	broker := events.GetBroker()
-	manager := plugins.GetManager(dataStore, broker)
-	agentsAgents := agents.GetAgents(dataStore, manager)
+	agentsAgents := agents.GetAgents(dataStore)
 	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	transcodingCache := core.GetTranscodingCache()
@@ -91,12 +75,13 @@ 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)
-	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
-	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
-	playTracker := scrobbler.GetPlayTracker(dataStore, broker, manager)
+	metricsMetrics := metrics.NewPrometheusInstance(dataStore)
+	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
+	playTracker := scrobbler.GetPlayTracker(dataStore, broker)
 	playbackServer := playback.GetInstance(dataStore)
-	router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, modelScanner, broker, playlists, playTracker, share, playbackServer, metricsMetrics)
+	router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, scannerScanner, broker, playlists, playTracker, share, playbackServer)
 	return router
 }
 
@@ -105,9 +90,7 @@ func CreatePublicRouter() *public.Router {
 	dataStore := persistence.New(sqlDB)
 	fileCache := artwork.GetImageCache()
 	fFmpeg := ffmpeg.New()
-	broker := events.GetBroker()
-	manager := plugins.GetManager(dataStore, broker)
-	agentsAgents := agents.GetAgents(dataStore, manager)
+	agentsAgents := agents.GetAgents(dataStore)
 	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	transcodingCache := core.GetTranscodingCache()
@@ -142,25 +125,24 @@ func CreateInsights() metrics.Insights {
 func CreatePrometheus() metrics.Metrics {
 	sqlDB := db.Db()
 	dataStore := persistence.New(sqlDB)
-	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
+	metricsMetrics := metrics.NewPrometheusInstance(dataStore)
 	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()
-	manager := plugins.GetManager(dataStore, broker)
-	agentsAgents := agents.GetAgents(dataStore, manager)
+	agentsAgents := agents.GetAgents(dataStore)
 	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
+	broker := events.GetBroker()
 	playlists := core.NewPlaylists(dataStore)
-	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
-	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
-	return modelScanner
+	metricsMetrics := metrics.NewPrometheusInstance(dataStore)
+	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
+	return scannerScanner
 }
 
 func CreateScanWatcher(ctx context.Context) scanner.Watcher {
@@ -168,16 +150,15 @@ func CreateScanWatcher(ctx context.Context) scanner.Watcher {
 	dataStore := persistence.New(sqlDB)
 	fileCache := artwork.GetImageCache()
 	fFmpeg := ffmpeg.New()
-	broker := events.GetBroker()
-	manager := plugins.GetManager(dataStore, broker)
-	agentsAgents := agents.GetAgents(dataStore, manager)
+	agentsAgents := agents.GetAgents(dataStore)
 	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
+	broker := events.GetBroker()
 	playlists := core.NewPlaylists(dataStore)
-	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
-	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
-	watcher := scanner.GetWatcher(dataStore, modelScanner)
+	metricsMetrics := metrics.NewPrometheusInstance(dataStore)
+	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
+	watcher := scanner.NewWatcher(dataStore, scannerScanner)
 	return watcher
 }
 
@@ -188,20 +169,6 @@ func GetPlaybackServer() playback.PlaybackServer {
 	return playbackServer
 }
 
-func getPluginManager() *plugins.Manager {
-	sqlDB := db.Db()
-	dataStore := persistence.New(sqlDB)
-	broker := events.GetBroker()
-	manager := plugins.GetManager(dataStore, broker)
-	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.Watcher), new(scanner.Watcher)))
-
-func GetPluginManager(ctx context.Context) *plugins.Manager {
-	manager := getPluginManager()
-	manager.SetSubsonicRouter(CreateSubsonicAPIRouter(ctx))
-	return manager
-}
+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.NewWatcher, metrics.NewPrometheusInstance, db.Db)

cmd/wire_injectors.go

@@ -7,17 +7,14 @@ import (
 
 	"github.com/google/wire"
 	"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"
-	"github.com/navidrome/navidrome/core/scrobbler"
 	"github.com/navidrome/navidrome/db"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/persistence"
-	"github.com/navidrome/navidrome/plugins"
 	"github.com/navidrome/navidrome/scanner"
 	"github.com/navidrome/navidrome/server"
 	"github.com/navidrome/navidrome/server/events"
@@ -38,14 +35,9 @@ var allProviders = wire.NewSet(
 	listenbrainz.NewRouter,
 	events.GetBroker,
 	scanner.New,
-	scanner.GetWatcher,
-	metrics.GetPrometheusInstance,
+	scanner.NewWatcher,
+	metrics.NewPrometheusInstance,
 	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.Watcher), new(scanner.Watcher)),
 )
 
 func CreateDataStore() model.DataStore {
@@ -60,7 +52,7 @@ func CreateServer() *server.Server {
 	))
 }
 
-func CreateNativeAPIRouter(ctx context.Context) *nativeapi.Router {
+func CreateNativeAPIRouter() *nativeapi.Router {
 	panic(wire.Build(
 		allProviders,
 	))
@@ -102,7 +94,7 @@ func CreatePrometheus() metrics.Metrics {
 	))
 }
 
-func CreateScanner(ctx context.Context) model.Scanner {
+func CreateScanner(ctx context.Context) scanner.Scanner {
 	panic(wire.Build(
 		allProviders,
 	))
@@ -119,15 +111,3 @@ func GetPlaybackServer() playback.PlaybackServer {
 		allProviders,
 	))
 }
-
-func getPluginManager() *plugins.Manager {
-	panic(wire.Build(
-		allProviders,
-	))
-}
-
-func GetPluginManager(ctx context.Context) *plugins.Manager {
-	manager := getPluginManager()
-	manager.SetSubsonicRouter(CreateSubsonicAPIRouter(ctx))
-	return manager
-}

conf/configuration.go

@@ -14,7 +14,7 @@ import (
 	"github.com/kr/pretty"
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/utils/run"
+	"github.com/navidrome/navidrome/utils/chain"
 	"github.com/robfig/cron/v3"
 	"github.com/spf13/viper"
 )
@@ -41,7 +41,6 @@ type configOptions struct {
 	UIWelcomeMessage                string
 	MaxSidebarPlaylists             int
 	EnableTranscodingConfig         bool
-	EnableTranscodingCancellation   bool
 	EnableDownloads                 bool
 	EnableExternalServices          bool
 	EnableInsightsCollector         bool
@@ -67,72 +66,61 @@ type configOptions struct {
 	CoverArtPriority                string
 	CoverJpegQuality                int
 	ArtistArtPriority               string
-	LyricsPriority                  string
 	EnableGravatar                  bool
 	EnableFavourites                bool
 	EnableStarRating                bool
 	EnableUserEditing               bool
 	EnableSharing                   bool
 	ShareURL                        string
-	DefaultShareExpiration          time.Duration
 	DefaultDownloadableShare        bool
 	DefaultTheme                    string
 	DefaultLanguage                 string
 	DefaultUIVolume                 int
 	EnableReplayGain                bool
 	EnableCoverAnimation            bool
-	EnableNowPlaying                bool
 	GATrackingID                    string
 	EnableLogRedacting              bool
 	AuthRequestLimit                int
 	AuthWindowLength                time.Duration
 	PasswordEncryptionKey           string
-	ExtAuth                         extAuthOptions
-	Plugins                         pluginsOptions
-	HTTPHeaders                     httpHeaderOptions   `json:",omitzero"`
-	Prometheus                      prometheusOptions   `json:",omitzero"`
-	Scanner                         scannerOptions      `json:",omitzero"`
-	Jukebox                         jukeboxOptions      `json:",omitzero"`
-	Backup                          backupOptions       `json:",omitzero"`
-	PID                             pidOptions          `json:",omitzero"`
-	Inspect                         inspectOptions      `json:",omitzero"`
-	Subsonic                        subsonicOptions     `json:",omitzero"`
-	LastFM                          lastfmOptions       `json:",omitzero"`
-	Spotify                         spotifyOptions      `json:",omitzero"`
-	Deezer                          deezerOptions       `json:",omitzero"`
-	ListenBrainz                    listenBrainzOptions `json:",omitzero"`
-	EnableScrobbleHistory           bool
-	Tags                            map[string]TagConf `json:",omitempty"`
-	Agents                          string
+	ReverseProxyUserHeader          string
+	ReverseProxyWhitelist           string
+	HTTPSecurityHeaders             secureOptions
+	Prometheus                      prometheusOptions
+	Scanner                         scannerOptions
+	Jukebox                         jukeboxOptions
+	Backup                          backupOptions
+	PID                             pidOptions
+	Inspect                         inspectOptions
+	Subsonic                        subsonicOptions
+
+	Agents       string
+	LastFM       lastfmOptions
+	Spotify      spotifyOptions
+	ListenBrainz listenBrainzOptions
+	Tags         map[string]TagConf
 
 	// DevFlags. These are used to enable/disable debugging and incomplete features
-	DevLogLevels                      map[string]string `json:",omitempty"`
-	DevLogSourceLine                  bool
-	DevEnableProfiler                 bool
-	DevAutoCreateAdminPassword        string
-	DevAutoLoginUsername              string
-	DevActivityPanel                  bool
-	DevActivityPanelUpdateRate        time.Duration
-	DevSidebarPlaylists               bool
-	DevShowArtistPage                 bool
-	DevUIShowConfig                   bool
-	DevNewEventStream                 bool
-	DevOffsetOptimize                 int
-	DevArtworkMaxRequests             int
-	DevArtworkThrottleBacklogLimit    int
-	DevArtworkThrottleBacklogTimeout  time.Duration
-	DevArtistInfoTimeToLive           time.Duration
-	DevAlbumInfoTimeToLive            time.Duration
-	DevExternalScanner                bool
-	DevScannerThreads                 uint
-	DevSelectiveWatcher               bool
-	DevInsightsInitialDelay           time.Duration
-	DevEnablePlayerInsights           bool
-	DevEnablePluginsInsights          bool
-	DevPluginCompilationTimeout       time.Duration
-	DevExternalArtistFetchMultiplier  float64
-	DevOptimizeDB                     bool
-	DevPreserveUnicodeInExternalCalls bool
+	DevLogSourceLine                 bool
+	DevLogLevels                     map[string]string
+	DevEnableProfiler                bool
+	DevAutoCreateAdminPassword       string
+	DevAutoLoginUsername             string
+	DevActivityPanel                 bool
+	DevActivityPanelUpdateRate       time.Duration
+	DevSidebarPlaylists              bool
+	DevEnableBufferedScrobble        bool
+	DevShowArtistPage                bool
+	DevOffsetOptimize                int
+	DevArtworkMaxRequests            int
+	DevArtworkThrottleBacklogLimit   int
+	DevArtworkThrottleBacklogTimeout time.Duration
+	DevArtistInfoTimeToLive          time.Duration
+	DevAlbumInfoTimeToLive           time.Duration
+	DevExternalScanner               bool
+	DevScannerThreads                uint
+	DevInsightsInitialDelay          time.Duration
+	DevEnablePlayerInsights          bool
 }
 
 type scannerOptions struct {
@@ -144,8 +132,6 @@ type scannerOptions struct {
 	ArtistJoiner       string
 	GenreSeparators    string // Deprecated: Use Tags.genre.Split instead
 	GroupAlbumReleases bool   // Deprecated: Use PID.Album instead
-	FollowSymlinks     bool   // Whether to follow symlinks when scanning directories
-	PurgeMissing       string // Values: "never", "always", "full"
 }
 
 type subsonicOptions struct {
@@ -156,20 +142,19 @@ type subsonicOptions struct {
 }
 
 type TagConf struct {
-	Ignore    bool     `yaml:"ignore" json:",omitempty"`
-	Aliases   []string `yaml:"aliases" json:",omitempty"`
-	Type      string   `yaml:"type" json:",omitempty"`
-	MaxLength int      `yaml:"maxLength" json:",omitempty"`
-	Split     []string `yaml:"split" json:",omitempty"`
-	Album     bool     `yaml:"album" json:",omitempty"`
+	Ignore    bool     `yaml:"ignore"`
+	Aliases   []string `yaml:"aliases"`
+	Type      string   `yaml:"type"`
+	MaxLength int      `yaml:"maxLength"`
+	Split     []string `yaml:"split"`
+	Album     bool     `yaml:"album"`
 }
 
 type lastfmOptions struct {
-	Enabled                 bool
-	ApiKey                  string
-	Secret                  string
-	Language                string
-	ScrobbleFirstArtistOnly bool
+	Enabled  bool
+	ApiKey   string
+	Secret   string
+	Language string
 }
 
 type spotifyOptions struct {
@@ -177,18 +162,13 @@ type spotifyOptions struct {
 	Secret string
 }
 
-type deezerOptions struct {
-	Enabled  bool
-	Language string
-}
-
 type listenBrainzOptions struct {
 	Enabled bool
 	BaseURL string
 }
 
-type httpHeaderOptions struct {
-	FrameOptions string
+type secureOptions struct {
+	CustomFrameOptionsValue string
 }
 
 type prometheusOptions struct {
@@ -224,19 +204,6 @@ type inspectOptions struct {
 	BacklogTimeout int
 }
 
-type pluginsOptions struct {
-	Enabled    bool
-	Folder     string
-	CacheSize  string
-	AutoReload bool
-	LogLevel   string
-}
-
-type extAuthOptions struct {
-	TrustedSources string
-	UserHeader     string
-}
-
 var (
 	Server = &configOptions{}
 	hooks  []func()
@@ -255,11 +222,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)
@@ -281,17 +243,6 @@ func Load(noConfigDump bool) {
 		os.Exit(1)
 	}
 
-	if Server.Plugins.Enabled {
-		if Server.Plugins.Folder == "" {
-			Server.Plugins.Folder = filepath.Join(Server.DataFolder, "plugins")
-		}
-		err = os.MkdirAll(Server.Plugins.Folder, 0700)
-		if err != nil {
-			_, _ = fmt.Fprintln(os.Stderr, "FATAL: Error creating plugins path:", err)
-			os.Exit(1)
-		}
-	}
-
 	Server.ConfigFile = viper.GetViper().ConfigFileUsed()
 	if Server.DbPath == "" {
 		Server.DbPath = filepath.Join(Server.DataFolder, consts.DefaultDbPath)
@@ -320,11 +271,10 @@ func Load(noConfigDump bool) {
 	log.SetLogSourceLine(Server.DevLogSourceLine)
 	log.SetRedacting(Server.EnableLogRedacting)
 
-	err = run.Sequentially(
+	err = chain.RunSequentially(
 		validateScanSchedule,
 		validateBackupSchedule,
 		validatePlaylistsPath,
-		validatePurgeMissingOption,
 	)
 	if err != nil {
 		os.Exit(1)
@@ -343,18 +293,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)
 		}
@@ -369,12 +310,8 @@ func Load(noConfigDump bool) {
 		log.Warn(fmt.Sprintf("Extractor '%s' is not implemented, using 'taglib'", Server.Scanner.Extractor))
 		Server.Scanner.Extractor = consts.DefaultScannerExtractor
 	}
-	logDeprecatedOptions("Scanner.GenreSeparators", "")
-	logDeprecatedOptions("Scanner.GroupAlbumReleases", "")
-	logDeprecatedOptions("DevEnableBufferedScrobble", "") // Deprecated: Buffered scrobbling is now always enabled and this option is ignored
-	logDeprecatedOptions("ReverseProxyWhitelist", "ExtAuth.TrustedSources")
-	logDeprecatedOptions("ReverseProxyUserHeader", "ExtAuth.UserHeader")
-	logDeprecatedOptions("HTTPSecurityHeaders.CustomFrameOptionsValue", "HTTPHeaders.FrameOptions")
+	logDeprecatedOptions("Scanner.GenreSeparators")
+	logDeprecatedOptions("Scanner.GroupAlbumReleases")
 
 	// Call init hooks
 	for _, hook := range hooks {
@@ -382,29 +319,15 @@ func Load(noConfigDump bool) {
 	}
 }
 
-func logDeprecatedOptions(oldName, newName string) {
-	envVar := "ND_" + strings.ToUpper(strings.ReplaceAll(oldName, ".", "_"))
-	newEnvVar := "ND_" + strings.ToUpper(strings.ReplaceAll(newName, ".", "_"))
-	logWarning := func(oldName, newName string) {
-		if newName != "" {
-			log.Warn(fmt.Sprintf("Option '%s' is deprecated and will be ignored in a future release. Please use the new '%s'", oldName, newName))
-		} else {
-			log.Warn(fmt.Sprintf("Option '%s' is deprecated and will be ignored in a future release", oldName))
+func logDeprecatedOptions(options ...string) {
+	for _, option := range options {
+		envVar := "ND_" + strings.ToUpper(strings.ReplaceAll(option, ".", "_"))
+		if os.Getenv(envVar) != "" {
+			log.Warn(fmt.Sprintf("Option '%s' is deprecated and will be ignored in a future release", envVar))
+		}
+		if viper.InConfig(option) {
+			log.Warn(fmt.Sprintf("Option '%s' is deprecated and will be ignored in a future release", option))
 		}
-	}
-	if os.Getenv(envVar) != "" {
-		logWarning(envVar, newEnvVar)
-	}
-	if viper.InConfig(oldName) {
-		logWarning(oldName, newName)
-	}
-}
-
-// mapDeprecatedOption is used to provide backwards compatibility for deprecated options. It should be called after
-// the config has been read by viper, but before unmarshalling it into the Config struct.
-func mapDeprecatedOption(legacyName, newName string) {
-	if viper.IsSet(legacyName) {
-		viper.Set(newName, viper.Get(legacyName))
 	}
 }
 
@@ -438,7 +361,6 @@ func disableExternalServices() {
 	Server.EnableInsightsCollector = false
 	Server.LastFM.Enabled = false
 	Server.Spotify.ID = ""
-	Server.Deezer.Enabled = false
 	Server.ListenBrainz.Enabled = false
 	Server.Agents = ""
 	if Server.UILoginBackgroundURL == consts.DefaultUILoginBackgroundURL {
@@ -457,24 +379,6 @@ func validatePlaylistsPath() error {
 	return nil
 }
 
-func validatePurgeMissingOption() error {
-	allowedValues := []string{consts.PurgeMissingNever, consts.PurgeMissingAlways, consts.PurgeMissingFull}
-	valid := false
-	for _, v := range allowedValues {
-		if v == Server.Scanner.PurgeMissing {
-			valid = true
-			break
-		}
-	}
-	if !valid {
-		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
-	}
-	return nil
-}
-
 func validateScanSchedule() error {
 	if Server.Scanner.Schedule == "0" || Server.Scanner.Schedule == "" {
 		Server.Scanner.Schedule = ""
@@ -514,17 +418,7 @@ 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() {
+func init() {
 	viper.SetDefault("musicfolder", filepath.Join(".", "music"))
 	viper.SetDefault("cachefolder", "")
 	viper.SetDefault("datafolder", ".")
@@ -541,7 +435,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)
@@ -561,11 +454,11 @@ func setViperDefaults() {
 	viper.SetDefault("ignoredarticles", "The El La Los Las Le Les Os As O A")
 	viper.SetDefault("indexgroups", "A B C D E F G H I J K L M N O P Q R S T U V W X-Z(XYZ) [Unknown]([)")
 	viper.SetDefault("ffmpegpath", "")
-	viper.SetDefault("mpvcmdtemplate", "mpv --audio-device=%d --no-audio-display %f --input-ipc-server=%s")
+	viper.SetDefault("mpvcmdtemplate", "mpv --audio-device=%d --no-audio-display --pause %f --input-ipc-server=%s")
+
 	viper.SetDefault("coverartpriority", "cover.*, folder.*, front.*, embedded, external")
 	viper.SetDefault("coverjpegquality", 75)
 	viper.SetDefault("artistartpriority", "artist.*, album/artist.*, external")
-	viper.SetDefault("lyricspriority", ".lrc,.txt,embedded")
 	viper.SetDefault("enablegravatar", false)
 	viper.SetDefault("enablefavourites", true)
 	viper.SetDefault("enablestarrating", true)
@@ -575,10 +468,8 @@ func setViperDefaults() {
 	viper.SetDefault("defaultuivolume", consts.DefaultUIVolume)
 	viper.SetDefault("enablereplaygain", true)
 	viper.SetDefault("enablecoveranimation", true)
-	viper.SetDefault("enablenowplaying", true)
 	viper.SetDefault("enablesharing", false)
 	viper.SetDefault("shareurl", "")
-	viper.SetDefault("defaultshareexpiration", 8760*time.Hour)
 	viper.SetDefault("defaultdownloadableshare", false)
 	viper.SetDefault("gatrackingid", "")
 	viper.SetDefault("enableinsightscollector", true)
@@ -586,15 +477,19 @@ func setViperDefaults() {
 	viper.SetDefault("authrequestlimit", 5)
 	viper.SetDefault("authwindowlength", 20*time.Second)
 	viper.SetDefault("passwordencryptionkey", "")
-	viper.SetDefault("extauth.userheader", "Remote-User")
-	viper.SetDefault("extauth.trustedsources", "")
+
+	viper.SetDefault("reverseproxyuserheader", "Remote-User")
+	viper.SetDefault("reverseproxywhitelist", "")
+
 	viper.SetDefault("prometheus.enabled", false)
 	viper.SetDefault("prometheus.metricspath", consts.PrometheusDefaultPath)
 	viper.SetDefault("prometheus.password", "")
+
 	viper.SetDefault("jukebox.enabled", false)
 	viper.SetDefault("jukebox.devices", []AudioDeviceDefinition{})
 	viper.SetDefault("jukebox.default", "")
 	viper.SetDefault("jukebox.adminonly", true)
+
 	viper.SetDefault("scanner.enabled", true)
 	viper.SetDefault("scanner.schedule", "0")
 	viper.SetDefault("scanner.extractor", consts.DefaultScannerExtractor)
@@ -603,39 +498,35 @@ func setViperDefaults() {
 	viper.SetDefault("scanner.artistjoiner", consts.ArtistJoiner)
 	viper.SetDefault("scanner.genreseparators", "")
 	viper.SetDefault("scanner.groupalbumreleases", false)
-	viper.SetDefault("scanner.followsymlinks", true)
-	viper.SetDefault("scanner.purgemissing", consts.PurgeMissingNever)
+
 	viper.SetDefault("subsonic.appendsubtitle", true)
 	viper.SetDefault("subsonic.artistparticipations", false)
 	viper.SetDefault("subsonic.defaultreportrealpath", false)
-	viper.SetDefault("subsonic.legacyclients", "DSub,SubMusic")
-	viper.SetDefault("agents", "lastfm,spotify,deezer")
+	viper.SetDefault("subsonic.legacyclients", "DSub")
+
+	viper.SetDefault("agents", "lastfm,spotify")
 	viper.SetDefault("lastfm.enabled", true)
 	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", "en")
 	viper.SetDefault("listenbrainz.enabled", true)
 	viper.SetDefault("listenbrainz.baseurl", "https://api.listenbrainz.org/1/")
-	viper.SetDefault("enablescrobblehistory", true)
-	viper.SetDefault("httpheaders.frameoptions", "DENY")
+
+	viper.SetDefault("httpsecurityheaders.customframeoptionsvalue", "DENY")
+
 	viper.SetDefault("backup.path", "")
 	viper.SetDefault("backup.schedule", "")
 	viper.SetDefault("backup.count", 0)
+
 	viper.SetDefault("pid.track", consts.DefaultTrackPID)
 	viper.SetDefault("pid.album", consts.DefaultAlbumPID)
+
 	viper.SetDefault("inspect.enabled", true)
 	viper.SetDefault("inspect.maxrequests", 1)
 	viper.SetDefault("inspect.backloglimit", consts.RequestThrottleBacklogLimit)
 	viper.SetDefault("inspect.backlogtimeout", consts.RequestThrottleBacklogTimeout)
-	viper.SetDefault("plugins.folder", "")
-	viper.SetDefault("plugins.enabled", false)
-	viper.SetDefault("plugins.cachesize", "200MB")
-	viper.SetDefault("plugins.autoreload", false)
 
 	// DevFlags. These are used to enable/disable debugging and incomplete features
 	viper.SetDefault("devlogsourceline", false)
@@ -644,10 +535,9 @@ func setViperDefaults() {
 	viper.SetDefault("devautologinusername", "")
 	viper.SetDefault("devactivitypanel", true)
 	viper.SetDefault("devactivitypanelupdaterate", 300*time.Millisecond)
+	viper.SetDefault("devenablebufferedscrobble", true)
 	viper.SetDefault("devsidebarplaylists", true)
 	viper.SetDefault("devshowartistpage", true)
-	viper.SetDefault("devuishowconfig", true)
-	viper.SetDefault("devneweventstream", true)
 	viper.SetDefault("devoffsetoptimize", 50000)
 	viper.SetDefault("devartworkmaxrequests", max(2, runtime.NumCPU()/3))
 	viper.SetDefault("devartworkthrottlebackloglimit", consts.RequestThrottleBacklogLimit)
@@ -656,28 +546,13 @@ 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{
-		LoadOptions: ini.LoadOptions{
-			UnescapeValueDoubleQuotes:   true,
-			UnescapeValueCommentSymbols: true,
-		},
-	})
+	_ = codecRegistry.RegisterCodec("ini", ini.Codec{})
 	viper.SetOptions(viper.WithCodecRegistry(codecRegistry))
 
 	cfgFile = getConfigFile(cfgFile)
@@ -691,12 +566,10 @@ func InitConfig(cfgFile string, loadEnvVars bool) {
 	}
 
 	_ = viper.BindEnv("port")
-	if loadEnvVars {
-		viper.SetEnvPrefix("ND")
-		replacer := strings.NewReplacer(".", "_")
-		viper.SetEnvKeyReplacer(replacer)
-		viper.AutomaticEnv()
-	}
+	viper.SetEnvPrefix("ND")
+	replacer := strings.NewReplacer(".", "_")
+	viper.SetEnvKeyReplacer(replacer)
+	viper.AutomaticEnv()
 
 	err := viper.ReadInConfig()
 	if viper.ConfigFileUsed() != "" && err != nil {

conf/configuration_test.go

@@ -5,7 +5,7 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/navidrome/navidrome/conf"
+	. "github.com/navidrome/navidrome/conf"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	"github.com/spf13/viper"
@@ -20,10 +20,9 @@ var _ = Describe("Configuration", func() {
 	BeforeEach(func() {
 		// Reset viper configuration
 		viper.Reset()
-		conf.SetViperDefaults()
 		viper.SetDefault("datafolder", GinkgoT().TempDir())
 		viper.SetDefault("loglevel", "error")
-		conf.ResetConf()
+		ResetConf()
 	})
 
 	DescribeTable("should load configuration from",
@@ -31,21 +30,17 @@ var _ = Describe("Configuration", func() {
 			filename := filepath.Join("testdata", "cfg."+format)
 
 			// Initialize config with the test file
-			conf.InitConfig(filename, false)
+			InitConfig(filename)
 			// Load the configuration (with noConfigDump=true)
-			conf.Load(true)
+			Load(true)
 
 			// Execute the format-specific assertions
-			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"))
+			Expect(Server.MusicFolder).To(Equal(fmt.Sprintf("/%s/music", format)))
+			Expect(Server.UIWelcomeMessage).To(Equal("Welcome " + format))
+			Expect(Server.Tags["custom"].Aliases).To(Equal([]string{format, "test"}))
 
 			// The config file used should be the one we created
-			Expect(conf.Server.ConfigFile).To(Equal(filename))
+			Expect(Server.ConfigFile).To(Equal(filename))
 		},
 		Entry("TOML format", "toml"),
 		Entry("YAML format", "yaml"),

conf/export_test.go

@@ -3,5 +3,3 @@ package conf
 func ResetConf() {
 	Server = &configOptions{}
 }
-
-var SetViperDefaults = setViperDefaults

conf/testdata/cfg.ini

@@ -1,8 +1,6 @@
 [default]
 MusicFolder = /ini/music
-UIWelcomeMessage = 'Welcome ini' ; Just a comment to test the LoadOptions
-ReverseProxyUserHeader = 'X-Auth-User'
+UIWelcomeMessage = Welcome ini
 
 [Tags]
-Custom.Aliases = ini,test
-artist.Split = ";" # Should be able to read ; as a separator
+Custom.Aliases = ini,test

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

@@ -14,9 +14,6 @@ const (
 	DefaultDbPath                 = "navidrome.db?cache=shared&_busy_timeout=15000&_journal_mode=WAL&_foreign_keys=on&synchronous=normal"
 	InitialSetupFlagKey           = "InitialSetup"
 	FullScanAfterMigrationFlagKey = "FullScanAfterMigration"
-	LastScanErrorKey              = "LastScanError"
-	LastScanTypeKey               = "LastScanType"
-	LastScanStartTimeKey          = "LastScanStartTime"
 
 	UIAuthorizationHeader  = "X-ND-Authorization"
 	UIClientUniqueIDHeader = "X-ND-Client-Unique-Id"
@@ -115,12 +112,6 @@ const (
 	InsightsInitialDelay   = 30 * time.Minute
 )
 
-const (
-	PurgeMissingNever  = "never"
-	PurgeMissingAlways = "always"
-	PurgeMissingFull   = "full"
-)
-
 var (
 	DefaultDownsamplingFormat = "opus"
 	DefaultTranscodings       = []struct {
@@ -150,8 +141,6 @@ var (
 	}
 )
 
-var HTTPUserAgent = "Navidrome" + "/" + Version
-
 var (
 	VariousArtists = "Various Artists"
 	// TODO This will be dynamic when using disambiguation

core/agents/agents.go

@@ -2,7 +2,6 @@ package agents
 
 import (
 	"context"
-	"slices"
 	"strings"
 	"time"
 
@@ -14,108 +13,43 @@ import (
 	"github.com/navidrome/navidrome/utils/singleton"
 )
 
-// PluginLoader defines an interface for loading plugins
-type PluginLoader interface {
-	// PluginNames returns the names of all plugins that implement a particular service
-	PluginNames(capability string) []string
-	// LoadMediaAgent loads and returns a media agent plugin
-	LoadMediaAgent(name string) (Interface, bool)
-}
-
 type Agents struct {
-	ds           model.DataStore
-	pluginLoader PluginLoader
+	ds     model.DataStore
+	agents []Interface
 }
 
-// GetAgents returns the singleton instance of Agents
-func GetAgents(ds model.DataStore, pluginLoader PluginLoader) *Agents {
+func GetAgents(ds model.DataStore) *Agents {
 	return singleton.GetInstance(func() *Agents {
-		return createAgents(ds, pluginLoader)
+		return createAgents(ds)
 	})
 }
 
-// createAgents creates a new Agents instance. Used in tests
-func createAgents(ds model.DataStore, pluginLoader PluginLoader) *Agents {
-	return &Agents{
-		ds:           ds,
-		pluginLoader: pluginLoader,
+func createAgents(ds model.DataStore) *Agents {
+	var order []string
+	if conf.Server.Agents != "" {
+		order = strings.Split(conf.Server.Agents, ",")
 	}
-}
-
-// enabledAgent represents an enabled agent with its type information
-type enabledAgent struct {
-	name     string
-	isPlugin bool
-}
-
-// getEnabledAgentNames returns the current list of enabled agents, including:
-// 1. Built-in agents and plugins from config (in the specified order)
-// 2. Always include LocalAgentName
-// 3. If config is empty, include ONLY LocalAgentName
-// Each enabledAgent contains the name and whether it's a plugin (true) or built-in (false)
-func (a *Agents) getEnabledAgentNames() []enabledAgent {
-	// If no agents configured, ONLY use the local agent
-	if conf.Server.Agents == "" {
-		return []enabledAgent{{name: LocalAgentName, isPlugin: false}}
-	}
-
-	// Get all available plugin names
-	var availablePlugins []string
-	if a.pluginLoader != nil {
-		availablePlugins = a.pluginLoader.PluginNames("MetadataAgent")
-	}
-	log.Trace("Available MetadataAgent plugins", "plugins", availablePlugins)
-
-	configuredAgents := strings.Split(conf.Server.Agents, ",")
-
-	// Always add LocalAgentName if not already included
-	hasLocalAgent := slices.Contains(configuredAgents, LocalAgentName)
-	if !hasLocalAgent {
-		configuredAgents = append(configuredAgents, LocalAgentName)
-	}
-
-	// Filter to only include valid agents (built-in or plugins)
-	var validAgents []enabledAgent
-	for _, name := range configuredAgents {
-		// Check if it's a built-in agent
-		isBuiltIn := Map[name] != nil
-
-		// Check if it's a plugin
-		isPlugin := slices.Contains(availablePlugins, name)
-
-		if isBuiltIn {
-			validAgents = append(validAgents, enabledAgent{name: name, isPlugin: false})
-		} else if isPlugin {
-			validAgents = append(validAgents, enabledAgent{name: name, isPlugin: true})
-		} else {
-			log.Debug("Unknown agent ignored", "name", name)
+	order = append(order, LocalAgentName)
+	var res []Interface
+	var enabled []string
+	for _, name := range order {
+		init, ok := Map[name]
+		if !ok {
+			log.Error("Invalid agent. Check `Agents` configuration", "name", name, "conf", conf.Server.Agents)
+			continue
 		}
-	}
-	return validAgents
-}
 
-func (a *Agents) getAgent(ea enabledAgent) Interface {
-	if ea.isPlugin {
-		// Try to load WASM plugin agent (if plugin loader is available)
-		if a.pluginLoader != nil {
-			agent, ok := a.pluginLoader.LoadMediaAgent(ea.name)
-			if ok && agent != nil {
-				return agent
-			}
-		}
-	} else {
-		// Try to get built-in agent
-		constructor, ok := Map[ea.name]
-		if ok {
-			agent := constructor(a.ds)
-			if agent != nil {
-				return agent
-			}
-			log.Debug("Built-in agent not available. Missing configuration?", "name", ea.name)
+		agent := init(ds)
+		if agent == nil {
+			log.Debug("Agent not available. Missing configuration?", "name", name)
+			continue
 		}
+		enabled = append(enabled, name)
+		res = append(res, agent)
 	}
+	log.Debug("List of agents enabled", "names", enabled)
 
-	return nil
+	return &Agents{ds: ds, agents: res}
 }
 
 func (a *Agents) AgentName() string {
@@ -130,19 +64,15 @@ func (a *Agents) GetArtistMBID(ctx context.Context, id string, name string) (str
 		return "", nil
 	}
 	start := time.Now()
-	for _, enabledAgent := range a.getEnabledAgentNames() {
-		ag := a.getAgent(enabledAgent)
-		if ag == nil {
-			continue
-		}
+	for _, ag := range a.agents {
 		if utils.IsCtxDone(ctx) {
 			break
 		}
-		retriever, ok := ag.(ArtistMBIDRetriever)
+		agent, ok := ag.(ArtistMBIDRetriever)
 		if !ok {
 			continue
 		}
-		mbid, err := retriever.GetArtistMBID(ctx, id, name)
+		mbid, err := agent.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
@@ -159,19 +89,15 @@ func (a *Agents) GetArtistURL(ctx context.Context, id, name, mbid string) (strin
 		return "", nil
 	}
 	start := time.Now()
-	for _, enabledAgent := range a.getEnabledAgentNames() {
-		ag := a.getAgent(enabledAgent)
-		if ag == nil {
-			continue
-		}
+	for _, ag := range a.agents {
 		if utils.IsCtxDone(ctx) {
 			break
 		}
-		retriever, ok := ag.(ArtistURLRetriever)
+		agent, ok := ag.(ArtistURLRetriever)
 		if !ok {
 			continue
 		}
-		url, err := retriever.GetArtistURL(ctx, id, name, mbid)
+		url, err := agent.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
@@ -188,19 +114,15 @@ func (a *Agents) GetArtistBiography(ctx context.Context, id, name, mbid string)
 		return "", nil
 	}
 	start := time.Now()
-	for _, enabledAgent := range a.getEnabledAgentNames() {
-		ag := a.getAgent(enabledAgent)
-		if ag == nil {
-			continue
-		}
+	for _, ag := range a.agents {
 		if utils.IsCtxDone(ctx) {
 			break
 		}
-		retriever, ok := ag.(ArtistBiographyRetriever)
+		agent, ok := ag.(ArtistBiographyRetriever)
 		if !ok {
 			continue
 		}
-		bio, err := retriever.GetArtistBiography(ctx, id, name, mbid)
+		bio, err := agent.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
@@ -209,8 +131,6 @@ func (a *Agents) GetArtistBiography(ctx context.Context, id, name, mbid string)
 	return "", ErrNotFound
 }
 
-// GetSimilarArtists returns similar artists by id, name, and/or mbid. Because some artists returned from an enabled
-// agent may not exist in the database, return at most limit * conf.Server.DevExternalArtistFetchMultiplier items.
 func (a *Agents) GetSimilarArtists(ctx context.Context, id, name, mbid string, limit int) ([]Artist, error) {
 	switch id {
 	case consts.UnknownArtistID:
@@ -218,23 +138,16 @@ func (a *Agents) GetSimilarArtists(ctx context.Context, id, name, mbid string, l
 	case consts.VariousArtistsID:
 		return nil, nil
 	}
-
-	overLimit := int(float64(limit) * conf.Server.DevExternalArtistFetchMultiplier)
-
 	start := time.Now()
-	for _, enabledAgent := range a.getEnabledAgentNames() {
-		ag := a.getAgent(enabledAgent)
-		if ag == nil {
-			continue
-		}
+	for _, ag := range a.agents {
 		if utils.IsCtxDone(ctx) {
 			break
 		}
-		retriever, ok := ag.(ArtistSimilarRetriever)
+		agent, ok := ag.(ArtistSimilarRetriever)
 		if !ok {
 			continue
 		}
-		similar, err := retriever.GetSimilarArtists(ctx, id, name, mbid, overLimit)
+		similar, err := agent.GetSimilarArtists(ctx, id, name, mbid, limit)
 		if len(similar) > 0 && err == nil {
 			if log.IsGreaterOrEqualTo(log.LevelTrace) {
 				log.Debug(ctx, "Got Similar Artists", "agent", ag.AgentName(), "artist", name, "similar", similar, "elapsed", time.Since(start))
@@ -255,19 +168,15 @@ func (a *Agents) GetArtistImages(ctx context.Context, id, name, mbid string) ([]
 		return nil, nil
 	}
 	start := time.Now()
-	for _, enabledAgent := range a.getEnabledAgentNames() {
-		ag := a.getAgent(enabledAgent)
-		if ag == nil {
-			continue
-		}
+	for _, ag := range a.agents {
 		if utils.IsCtxDone(ctx) {
 			break
 		}
-		retriever, ok := ag.(ArtistImageRetriever)
+		agent, ok := ag.(ArtistImageRetriever)
 		if !ok {
 			continue
 		}
-		images, err := retriever.GetArtistImages(ctx, id, name, mbid)
+		images, err := agent.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
@@ -276,8 +185,6 @@ func (a *Agents) GetArtistImages(ctx context.Context, id, name, mbid string) ([]
 	return nil, ErrNotFound
 }
 
-// GetArtistTopSongs returns top songs by id, name, and/or mbid. Because some songs returned from an enabled
-// agent may not exist in the database, return at most limit * conf.Server.DevExternalArtistFetchMultiplier items.
 func (a *Agents) GetArtistTopSongs(ctx context.Context, id, artistName, mbid string, count int) ([]Song, error) {
 	switch id {
 	case consts.UnknownArtistID:
@@ -285,23 +192,16 @@ func (a *Agents) GetArtistTopSongs(ctx context.Context, id, artistName, mbid str
 	case consts.VariousArtistsID:
 		return nil, nil
 	}
-
-	overLimit := int(float64(count) * conf.Server.DevExternalArtistFetchMultiplier)
-
 	start := time.Now()
-	for _, enabledAgent := range a.getEnabledAgentNames() {
-		ag := a.getAgent(enabledAgent)
-		if ag == nil {
-			continue
-		}
+	for _, ag := range a.agents {
 		if utils.IsCtxDone(ctx) {
 			break
 		}
-		retriever, ok := ag.(ArtistTopSongsRetriever)
+		agent, ok := ag.(ArtistTopSongsRetriever)
 		if !ok {
 			continue
 		}
-		songs, err := retriever.GetArtistTopSongs(ctx, id, artistName, mbid, overLimit)
+		songs, err := agent.GetArtistTopSongs(ctx, id, artistName, mbid, count)
 		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
@@ -315,19 +215,15 @@ func (a *Agents) GetAlbumInfo(ctx context.Context, name, artist, mbid string) (*
 		return nil, ErrNotFound
 	}
 	start := time.Now()
-	for _, enabledAgent := range a.getEnabledAgentNames() {
-		ag := a.getAgent(enabledAgent)
-		if ag == nil {
-			continue
-		}
+	for _, ag := range a.agents {
 		if utils.IsCtxDone(ctx) {
 			break
 		}
-		retriever, ok := ag.(AlbumInfoRetriever)
+		agent, ok := ag.(AlbumInfoRetriever)
 		if !ok {
 			continue
 		}
-		album, err := retriever.GetAlbumInfo(ctx, name, artist, mbid)
+		album, err := agent.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))
@@ -337,36 +233,6 @@ func (a *Agents) GetAlbumInfo(ctx context.Context, name, artist, mbid string) (*
 	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()
-	for _, enabledAgent := range a.getEnabledAgentNames() {
-		ag := a.getAgent(enabledAgent)
-		if ag == nil {
-			continue
-		}
-		if utils.IsCtxDone(ctx) {
-			break
-		}
-		retriever, ok := ag.(AlbumImageRetriever)
-		if !ok {
-			continue
-		}
-		images, err := retriever.GetAlbumImages(ctx, name, artist, mbid)
-		if err != nil {
-			log.Trace(ctx, "Agent GetAlbumImages failed", "agent", ag.AgentName(), "album", name, "artist", artist, "mbid", mbid, err)
-		}
-		if len(images) > 0 && err == nil {
-			log.Debug(ctx, "Got Album Images", "agent", ag.AgentName(), "album", name, "artist", artist,
-				"mbid", mbid, "elapsed", time.Since(start))
-			return images, nil
-		}
-	}
-	return nil, ErrNotFound
-}
-
 var _ Interface = (*Agents)(nil)
 var _ ArtistMBIDRetriever = (*Agents)(nil)
 var _ ArtistURLRetriever = (*Agents)(nil)
@@ -375,4 +241,3 @@ var _ ArtistSimilarRetriever = (*Agents)(nil)
 var _ ArtistImageRetriever = (*Agents)(nil)
 var _ ArtistTopSongsRetriever = (*Agents)(nil)
 var _ AlbumInfoRetriever = (*Agents)(nil)
-var _ AlbumImageRetriever = (*Agents)(nil)

core/agents/agents_plugin_test.go

@@ -1,281 +0,0 @@
-package agents
-
-import (
-	"context"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/utils/slice"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-// MockPluginLoader implements PluginLoader for testing
-type MockPluginLoader struct {
-	pluginNames     []string
-	loadedAgents    map[string]*MockAgent
-	pluginCallCount map[string]int
-}
-
-func NewMockPluginLoader() *MockPluginLoader {
-	return &MockPluginLoader{
-		pluginNames:     []string{},
-		loadedAgents:    make(map[string]*MockAgent),
-		pluginCallCount: make(map[string]int),
-	}
-}
-
-func (m *MockPluginLoader) PluginNames(serviceName string) []string {
-	return m.pluginNames
-}
-
-func (m *MockPluginLoader) LoadMediaAgent(name string) (Interface, bool) {
-	m.pluginCallCount[name]++
-	agent, exists := m.loadedAgents[name]
-	return agent, exists
-}
-
-// MockAgent is a mock agent implementation for testing
-type MockAgent struct {
-	name string
-	mbid string
-}
-
-func (m *MockAgent) AgentName() string {
-	return m.name
-}
-
-func (m *MockAgent) GetArtistMBID(ctx context.Context, id string, name string) (string, error) {
-	return m.mbid, nil
-}
-
-var _ Interface = (*MockAgent)(nil)
-var _ ArtistMBIDRetriever = (*MockAgent)(nil)
-
-var _ PluginLoader = (*MockPluginLoader)(nil)
-
-var _ = Describe("Agents with Plugin Loading", func() {
-	var mockLoader *MockPluginLoader
-	var agents *Agents
-
-	BeforeEach(func() {
-		mockLoader = NewMockPluginLoader()
-
-		// Create the agents instance with our mock loader
-		agents = createAgents(nil, mockLoader)
-	})
-
-	Context("Dynamic agent discovery", func() {
-		It("should include ONLY local agent when no config is specified", func() {
-			// Ensure no specific agents are configured
-			conf.Server.Agents = ""
-
-			// Add some plugin agents that should be ignored
-			mockLoader.pluginNames = append(mockLoader.pluginNames, "plugin_agent", "another_plugin")
-
-			// Should only include the local agent
-			enabledAgents := agents.getEnabledAgentNames()
-			Expect(enabledAgents).To(HaveLen(1))
-			Expect(enabledAgents[0].name).To(Equal(LocalAgentName))
-			Expect(enabledAgents[0].isPlugin).To(BeFalse()) // LocalAgent is built-in, not plugin
-		})
-
-		It("should NOT include plugin agents when no config is specified", func() {
-			// Ensure no specific agents are configured
-			conf.Server.Agents = ""
-
-			// Add a plugin agent
-			mockLoader.pluginNames = append(mockLoader.pluginNames, "plugin_agent")
-
-			// Should only include the local agent
-			enabledAgents := agents.getEnabledAgentNames()
-			Expect(enabledAgents).To(HaveLen(1))
-			Expect(enabledAgents[0].name).To(Equal(LocalAgentName))
-			Expect(enabledAgents[0].isPlugin).To(BeFalse()) // LocalAgent is built-in, not plugin
-		})
-
-		It("should include plugin agents in the enabled agents list ONLY when explicitly configured", func() {
-			// Add a plugin agent
-			mockLoader.pluginNames = append(mockLoader.pluginNames, "plugin_agent")
-
-			// With no config, should not include plugin
-			conf.Server.Agents = ""
-			enabledAgents := agents.getEnabledAgentNames()
-			Expect(enabledAgents).To(HaveLen(1))
-			Expect(enabledAgents[0].name).To(Equal(LocalAgentName))
-
-			// When explicitly configured, should include plugin
-			conf.Server.Agents = "plugin_agent"
-			enabledAgents = agents.getEnabledAgentNames()
-			var agentNames []string
-			var pluginAgentFound bool
-			for _, agent := range enabledAgents {
-				agentNames = append(agentNames, agent.name)
-				if agent.name == "plugin_agent" {
-					pluginAgentFound = true
-					Expect(agent.isPlugin).To(BeTrue()) // plugin_agent is a plugin
-				}
-			}
-			Expect(agentNames).To(ContainElements(LocalAgentName, "plugin_agent"))
-			Expect(pluginAgentFound).To(BeTrue())
-		})
-
-		It("should only include configured plugin agents when config is specified", func() {
-			// Add two plugin agents
-			mockLoader.pluginNames = append(mockLoader.pluginNames, "plugin_one", "plugin_two")
-
-			// Configure only one of them
-			conf.Server.Agents = "plugin_one"
-
-			// Verify only the configured one is included
-			enabledAgents := agents.getEnabledAgentNames()
-			var agentNames []string
-			var pluginOneFound bool
-			for _, agent := range enabledAgents {
-				agentNames = append(agentNames, agent.name)
-				if agent.name == "plugin_one" {
-					pluginOneFound = true
-					Expect(agent.isPlugin).To(BeTrue()) // plugin_one is a plugin
-				}
-			}
-			Expect(agentNames).To(ContainElements(LocalAgentName, "plugin_one"))
-			Expect(agentNames).NotTo(ContainElement("plugin_two"))
-			Expect(pluginOneFound).To(BeTrue())
-		})
-
-		It("should load plugin agents on demand", func() {
-			ctx := context.Background()
-
-			// Configure to use our plugin
-			conf.Server.Agents = "plugin_agent"
-
-			// Add a plugin agent
-			mockLoader.pluginNames = append(mockLoader.pluginNames, "plugin_agent")
-			mockLoader.loadedAgents["plugin_agent"] = &MockAgent{
-				name: "plugin_agent",
-				mbid: "plugin-mbid",
-			}
-
-			// Try to get data from it
-			mbid, err := agents.GetArtistMBID(ctx, "123", "Artist")
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(mbid).To(Equal("plugin-mbid"))
-			Expect(mockLoader.pluginCallCount["plugin_agent"]).To(Equal(1))
-		})
-
-		It("should try both built-in and plugin agents", func() {
-			// Create a mock built-in agent
-			Register("built_in", func(ds model.DataStore) Interface {
-				return &MockAgent{
-					name: "built_in",
-					mbid: "built-in-mbid",
-				}
-			})
-			defer func() {
-				delete(Map, "built_in")
-			}()
-
-			// Configure to use both built-in and plugin
-			conf.Server.Agents = "built_in,plugin_agent"
-
-			// Add a plugin agent
-			mockLoader.pluginNames = append(mockLoader.pluginNames, "plugin_agent")
-			mockLoader.loadedAgents["plugin_agent"] = &MockAgent{
-				name: "plugin_agent",
-				mbid: "plugin-mbid",
-			}
-
-			// Verify that both are in the enabled list
-			enabledAgents := agents.getEnabledAgentNames()
-			var agentNames []string
-			var builtInFound, pluginFound bool
-			for _, agent := range enabledAgents {
-				agentNames = append(agentNames, agent.name)
-				if agent.name == "built_in" {
-					builtInFound = true
-					Expect(agent.isPlugin).To(BeFalse()) // built-in agent
-				}
-				if agent.name == "plugin_agent" {
-					pluginFound = true
-					Expect(agent.isPlugin).To(BeTrue()) // plugin agent
-				}
-			}
-			Expect(agentNames).To(ContainElements("built_in", "plugin_agent", LocalAgentName))
-			Expect(builtInFound).To(BeTrue())
-			Expect(pluginFound).To(BeTrue())
-		})
-
-		It("should respect the order specified in configuration", func() {
-			// Create mock built-in agents
-			Register("agent_a", func(ds model.DataStore) Interface {
-				return &MockAgent{name: "agent_a"}
-			})
-			Register("agent_b", func(ds model.DataStore) Interface {
-				return &MockAgent{name: "agent_b"}
-			})
-			defer func() {
-				delete(Map, "agent_a")
-				delete(Map, "agent_b")
-			}()
-
-			// Add plugin agents
-			mockLoader.pluginNames = append(mockLoader.pluginNames, "plugin_x", "plugin_y")
-
-			// Configure specific order - plugin first, then built-ins
-			conf.Server.Agents = "plugin_y,agent_b,plugin_x,agent_a"
-
-			// Get the agent names
-			enabledAgents := agents.getEnabledAgentNames()
-
-			// Extract just the names to verify the order
-			agentNames := slice.Map(enabledAgents, func(a enabledAgent) string { return a.name })
-
-			// Verify the order matches configuration, with LocalAgentName at the end
-			Expect(agentNames).To(HaveExactElements("plugin_y", "agent_b", "plugin_x", "agent_a", LocalAgentName))
-		})
-
-		It("should NOT call LoadMediaAgent for built-in agents", func() {
-			ctx := context.Background()
-
-			// Create a mock built-in agent
-			Register("builtin_agent", func(ds model.DataStore) Interface {
-				return &MockAgent{
-					name: "builtin_agent",
-					mbid: "builtin-mbid",
-				}
-			})
-			defer func() {
-				delete(Map, "builtin_agent")
-			}()
-
-			// Configure to use only built-in agents
-			conf.Server.Agents = "builtin_agent"
-
-			// Call GetArtistMBID which should only use the built-in agent
-			mbid, err := agents.GetArtistMBID(ctx, "123", "Artist")
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(mbid).To(Equal("builtin-mbid"))
-
-			// Verify LoadMediaAgent was NEVER called (no plugin loading for built-in agents)
-			Expect(mockLoader.pluginCallCount).To(BeEmpty())
-		})
-
-		It("should NOT call LoadMediaAgent for invalid agent names", func() {
-			ctx := context.Background()
-
-			// Configure with an invalid agent name (not built-in, not a plugin)
-			conf.Server.Agents = "invalid_agent"
-
-			// This should only result in using the local agent (as the invalid one is ignored)
-			_, err := agents.GetArtistMBID(ctx, "123", "Artist")
-
-			// Should get ErrNotFound since only local agent is available and it returns not found for this operation
-			Expect(err).To(MatchError(ErrNotFound))
-
-			// Verify LoadMediaAgent was NEVER called for the invalid agent
-			Expect(mockLoader.pluginCallCount).To(BeEmpty())
-		})
-	})
-})

core/agents/agents_test.go

@@ -4,10 +4,10 @@ import (
 	"context"
 	"errors"
 
-	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/tests"
+	"github.com/navidrome/navidrome/utils/slice"
 
 	"github.com/navidrome/navidrome/conf"
 	. "github.com/onsi/ginkgo/v2"
@@ -20,7 +20,6 @@ var _ = Describe("Agents", func() {
 	var ds model.DataStore
 	var mfRepo *tests.MockMediaFileRepo
 	BeforeEach(func() {
-		DeferCleanup(configtest.SetupConfig())
 		ctx, cancel = context.WithCancel(context.Background())
 		mfRepo = tests.CreateMockMediaFileRepo()
 		ds = &tests.MockDataStore{MockedMediaFile: mfRepo}
@@ -30,7 +29,7 @@ var _ = Describe("Agents", func() {
 		var ag *Agents
 		BeforeEach(func() {
 			conf.Server.Agents = ""
-			ag = createAgents(ds, nil)
+			ag = createAgents(ds)
 		})
 
 		It("calls the placeholder GetArtistImages", func() {
@@ -50,18 +49,12 @@ var _ = Describe("Agents", func() {
 			Register("disabled", func(model.DataStore) Interface { return nil })
 			Register("empty", func(model.DataStore) Interface { return &emptyAgent{} })
 			conf.Server.Agents = "empty,fake,disabled"
-			ag = createAgents(ds, nil)
+			ag = createAgents(ds)
 			Expect(ag.AgentName()).To(Equal("agents"))
 		})
 
 		It("does not register disabled agents", func() {
-			var ags []string
-			for _, enabledAgent := range ag.getEnabledAgentNames() {
-				agent := ag.getAgent(enabledAgent)
-				if agent != nil {
-					ags = append(ags, agent.AgentName())
-				}
-			}
+			ags := slice.Map(ag.agents, func(a Interface) string { return a.AgentName() })
 			// local agent is always appended to the end of the agents list
 			Expect(ags).To(HaveExactElements("empty", "fake", "local"))
 			Expect(ags).ToNot(ContainElement("disabled"))
@@ -180,42 +173,6 @@ var _ = Describe("Agents", func() {
 				Expect(err).To(MatchError(ErrNotFound))
 				Expect(mock.Args).To(BeEmpty())
 			})
-
-			Context("with multiple image agents", func() {
-				var first *testImageAgent
-				var second *testImageAgent
-
-				BeforeEach(func() {
-					first = &testImageAgent{Name: "imgFail", Err: errors.New("fail")}
-					second = &testImageAgent{Name: "imgOk", Images: []ExternalImage{{URL: "ok", Size: 1}}}
-					Register("imgFail", func(model.DataStore) Interface { return first })
-					Register("imgOk", func(model.DataStore) Interface { return second })
-				})
-
-				It("falls back to the next agent on error", func() {
-					conf.Server.Agents = "imgFail,imgOk"
-					ag = createAgents(ds, nil)
-
-					images, err := ag.GetArtistImages(ctx, "id", "artist", "mbid")
-					Expect(err).ToNot(HaveOccurred())
-					Expect(images).To(Equal([]ExternalImage{{URL: "ok", Size: 1}}))
-					Expect(first.Args).To(HaveExactElements("id", "artist", "mbid"))
-					Expect(second.Args).To(HaveExactElements("id", "artist", "mbid"))
-				})
-
-				It("falls back if the first agent returns no images", func() {
-					first.Err = nil
-					first.Images = []ExternalImage{}
-					conf.Server.Agents = "imgFail,imgOk"
-					ag = createAgents(ds, nil)
-
-					images, err := ag.GetArtistImages(ctx, "id", "artist", "mbid")
-					Expect(err).ToNot(HaveOccurred())
-					Expect(images).To(Equal([]ExternalImage{{URL: "ok", Size: 1}}))
-					Expect(first.Args).To(HaveExactElements("id", "artist", "mbid"))
-					Expect(second.Args).To(HaveExactElements("id", "artist", "mbid"))
-				})
-			})
 		})
 
 		Describe("GetSimilarArtists", func() {
@@ -242,7 +199,6 @@ var _ = Describe("Agents", func() {
 
 		Describe("GetArtistTopSongs", func() {
 			It("returns on first match", func() {
-				conf.Server.DevExternalArtistFetchMultiplier = 1
 				Expect(ag.GetArtistTopSongs(ctx, "123", "test", "mb123", 2)).To(Equal([]Song{{
 					Name: "A Song",
 					MBID: "mbid444",
@@ -250,7 +206,6 @@ var _ = Describe("Agents", func() {
 				Expect(mock.Args).To(HaveExactElements("123", "test", "mb123", 2))
 			})
 			It("skips the agent if it returns an error", func() {
-				conf.Server.DevExternalArtistFetchMultiplier = 1
 				mock.Err = errors.New("error")
 				_, err := ag.GetArtistTopSongs(ctx, "123", "test", "mb123", 2)
 				Expect(err).To(MatchError(ErrNotFound))
@@ -262,14 +217,6 @@ var _ = Describe("Agents", func() {
 				Expect(err).To(MatchError(ErrNotFound))
 				Expect(mock.Args).To(BeEmpty())
 			})
-			It("fetches with multiplier", func() {
-				conf.Server.DevExternalArtistFetchMultiplier = 2
-				Expect(ag.GetArtistTopSongs(ctx, "123", "test", "mb123", 2)).To(Equal([]Song{{
-					Name: "A Song",
-					MBID: "mbid444",
-				}}))
-				Expect(mock.Args).To(HaveExactElements("123", "test", "mb123", 4))
-			})
 		})
 
 		Describe("GetAlbumInfo", func() {
@@ -279,6 +226,18 @@ var _ = Describe("Agents", func() {
 					MBID:        "mbid444",
 					Description: "A Description",
 					URL:         "External URL",
+					Images: []ExternalImage{
+						{
+							Size: 174,
+							URL:  "https://lastfm.freetls.fastly.net/i/u/174s/00000000000000000000000000000000.png",
+						}, {
+							Size: 64,
+							URL:  "https://lastfm.freetls.fastly.net/i/u/64s/00000000000000000000000000000000.png",
+						}, {
+							Size: 34,
+							URL:  "https://lastfm.freetls.fastly.net/i/u/34s/00000000000000000000000000000000.png",
+						},
+					},
 				}))
 				Expect(mock.Args).To(HaveExactElements("album", "artist", "mbid"))
 			})
@@ -374,6 +333,18 @@ func (a *mockAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid string)
 		MBID:        "mbid444",
 		Description: "A Description",
 		URL:         "External URL",
+		Images: []ExternalImage{
+			{
+				Size: 174,
+				URL:  "https://lastfm.freetls.fastly.net/i/u/174s/00000000000000000000000000000000.png",
+			}, {
+				Size: 64,
+				URL:  "https://lastfm.freetls.fastly.net/i/u/64s/00000000000000000000000000000000.png",
+			}, {
+				Size: 34,
+				URL:  "https://lastfm.freetls.fastly.net/i/u/34s/00000000000000000000000000000000.png",
+			},
+		},
 	}, nil
 }
 
@@ -384,17 +355,3 @@ type emptyAgent struct {
 func (e *emptyAgent) AgentName() string {
 	return "empty"
 }
-
-type testImageAgent struct {
-	Name   string
-	Images []ExternalImage
-	Err    error
-	Args   []interface{}
-}
-
-func (t *testImageAgent) AgentName() string { return t.Name }
-
-func (t *testImageAgent) GetArtistImages(_ context.Context, id, name, mbid string) ([]ExternalImage, error) {
-	t.Args = []interface{}{id, name, mbid}
-	return t.Images, t.Err
-}

core/agents/deezer/client.go

@@ -1,219 +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
-	language string
-	jwt      jwtToken
-}
-
-func newClient(hc httpDoer, language string) *client {
-	return &client{
-		httpDoer: hc,
-		language: language,
-	}
-}
-
-func (c *client) searchArtists(ctx context.Context, name string, limit int) ([]Artist, error) {
-	params := url.Values{}
-	params.Add("q", name)
-	params.Add("order", "RANKING")
-	params.Add("limit", strconv.Itoa(limit))
-	req, err := http.NewRequestWithContext(ctx, "GET", apiBaseURL+"/search/artist", nil)
-	if err != nil {
-		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) (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", c.language)
-	req.Header.Set("Authorization", "Bearer "+jwt)
-
-	log.Trace(ctx, "Fetching Deezer artist biography via GraphQL", "artistId", artistID, "language", c.language)
-	resp, err := c.httpDoer.Do(req)
-	if err != nil {
-		return "", err
-	}
-	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)
-}

core/agents/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
-}

core/agents/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, "en")
-		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)
-}

core/agents/deezer/client_test.go

@@ -1,195 +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, "en")
-	})
-
-	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("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.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)
-			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 configured language", func() {
-			client = newClient(httpClient, "fr")
-			// Mock JWT token for the new client instance with a valid JWT
-			testJWT := createTestJWT(5 * time.Minute)
-			httpClient.mock("https://auth.deezer.com/login/anonymous", http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(fmt.Sprintf(`{"jwt":"%s","refresh_token":""}`, testJWT))),
-			})
-			f, err := os.Open("tests/fixtures/deezer.artist.bio.json")
-			Expect(err).To(BeNil())
-			httpClient.mock("https://pipe.deezer.com/api", http.Response{Body: f, StatusCode: 200})
-
-			_, err = client.getArtistBio(GinkgoT().Context(), 27)
-			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.json")
-			Expect(err).To(BeNil())
-			httpClient.mock("https://pipe.deezer.com/api", http.Response{Body: f, StatusCode: 200})
-
-			_, err = client.getArtistBio(GinkgoT().Context(), 27)
-			Expect(err).To(BeNil())
-			// Verify that the Authorization header has the Bearer token format
-			authHeader := httpClient.lastRequest.Header.Get("Authorization")
-			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)
-			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)
-			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)
-			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)
-			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())
-}

core/agents/deezer/deezer.go

@@ -1,159 +0,0 @@
-package deezer
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"strings"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/consts"
-	"github.com/navidrome/navidrome/core/agents"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/utils/cache"
-	"github.com/navidrome/navidrome/utils/slice"
-)
-
-const deezerAgentName = "deezer"
-const deezerApiPictureXlSize = 1000
-const deezerApiPictureBigSize = 500
-const deezerApiPictureMediumSize = 250
-const deezerApiPictureSmallSize = 56
-const deezerArtistSearchLimit = 50
-
-type deezerAgent struct {
-	dataStore model.DataStore
-	client    *client
-}
-
-func deezerConstructor(dataStore model.DataStore) agents.Interface {
-	agent := &deezerAgent{dataStore: dataStore}
-	httpClient := &http.Client{
-		Timeout: consts.DefaultHttpClientTimeOut,
-	}
-	cachedHttpClient := cache.NewHTTPClient(httpClient, consts.DefaultHttpClientTimeOut)
-	agent.client = newClient(cachedHttpClient, conf.Server.Deezer.Language)
-	return agent
-}
-
-func (s *deezerAgent) AgentName() string {
-	return deezerAgentName
-}
-
-func (s *deezerAgent) GetArtistImages(ctx context.Context, _, name, _ string) ([]agents.ExternalImage, error) {
-	artist, err := s.searchArtist(ctx, name)
-	if err != nil {
-		if errors.Is(err, agents.ErrNotFound) {
-			log.Warn(ctx, "Artist not found in deezer", "artist", name)
-		} else {
-			log.Error(ctx, "Error calling deezer", "artist", name, err)
-		}
-		return nil, err
-	}
-
-	var res []agents.ExternalImage
-	possibleImages := []struct {
-		URL  string
-		Size int
-	}{
-		{artist.PictureXl, deezerApiPictureXlSize},
-		{artist.PictureBig, deezerApiPictureBigSize},
-		{artist.PictureMedium, deezerApiPictureMediumSize},
-		{artist.PictureSmall, deezerApiPictureSmallSize},
-	}
-	for _, imgData := range possibleImages {
-		if imgData.URL != "" {
-			res = append(res, agents.ExternalImage{
-				URL:  imgData.URL,
-				Size: imgData.Size,
-			})
-		}
-	}
-	return res, nil
-}
-
-func (s *deezerAgent) searchArtist(ctx context.Context, name string) (*Artist, error) {
-	artists, err := s.client.searchArtists(ctx, name, deezerArtistSearchLimit)
-	if errors.Is(err, ErrNotFound) || len(artists) == 0 {
-		return nil, agents.ErrNotFound
-	}
-	if err != nil {
-		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,
-		}
-	})
-	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
-	}
-
-	return s.client.getArtistBio(ctx, artist.ID)
-}
-
-func init() {
-	conf.AddHook(func() {
-		if conf.Server.Deezer.Enabled {
-			agents.Register(deezerAgentName, deezerConstructor)
-		}
-	})
-}

core/agents/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"`
-}

core/agents/deezer/responses_test.go

@@ -1,69 +0,0 @@
-package deezer
-
-import (
-	"encoding/json"
-	"os"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Responses", func() {
-	Describe("Search type=artist", func() {
-		It("parses the artist search result correctly ", func() {
-			var resp SearchArtistResults
-			body, err := os.ReadFile("tests/fixtures/deezer.search.artist.json")
-			Expect(err).To(BeNil())
-			err = json.Unmarshal(body, &resp)
-			Expect(err).To(BeNil())
-
-			Expect(resp.Data).To(HaveLen(17))
-			michael := resp.Data[0]
-			Expect(michael.Name).To(Equal("Michael Jackson"))
-			Expect(michael.PictureXl).To(Equal("https://cdn-images.dzcdn.net/images/artist/97fae13b2b30e4aec2e8c9e0c7839d92/1000x1000-000000-80-0-0.jpg"))
-		})
-	})
-
-	Describe("Error", func() {
-		It("parses the error response correctly", func() {
-			var errorResp Error
-			body := []byte(`{"error":{"type":"MissingParameterException","message":"Missing parameters: q","code":501}}`)
-			err := json.Unmarshal(body, &errorResp)
-			Expect(err).To(BeNil())
-
-			Expect(errorResp.Error.Code).To(Equal(501))
-			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

@@ -13,12 +13,12 @@ type Interface interface {
 	AgentName() string
 }
 
-// AlbumInfo contains album metadata (no images)
 type AlbumInfo struct {
 	Name        string
 	MBID        string
 	Description string
 	URL         string
+	Images      []ExternalImage
 }
 
 type Artist struct {
@@ -40,16 +40,11 @@ var (
 	ErrNotFound = errors.New("not found")
 )
 
-// AlbumInfoRetriever provides album info (no images)
+// TODO Break up this interface in more specific methods, like artists
 type AlbumInfoRetriever interface {
 	GetAlbumInfo(ctx context.Context, name, artist, mbid string) (*AlbumInfo, error)
 }
 
-// AlbumImageRetriever provides album images
-type AlbumImageRetriever interface {
-	GetAlbumImages(ctx context.Context, name, artist, mbid string) ([]ExternalImage, error)
-}
-
 type ArtistMBIDRetriever interface {
 	GetArtistMBID(ctx context.Context, id string, name string) (string, error)
 }

core/agents/lastfm/agent.go

@@ -38,7 +38,6 @@ type lastfmAgent struct {
 	secret       string
 	lang         string
 	client       *client
-	httpClient   httpDoer
 	getInfoMutex sync.Mutex
 }
 
@@ -57,7 +56,6 @@ 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)
 	return l
 }
@@ -74,23 +72,16 @@ func (l *lastfmAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid strin
 		return nil, err
 	}
 
-	return &agents.AlbumInfo{
+	response := agents.AlbumInfo{
 		Name:        a.Name,
 		MBID:        a.MBID,
 		Description: a.Description.Summary,
 		URL:         a.URL,
-	}, nil
-}
-
-func (l *lastfmAgent) GetAlbumImages(ctx context.Context, name, artist, mbid string) ([]agents.ExternalImage, error) {
-	a, err := l.callAlbumGetInfo(ctx, name, artist, mbid)
-	if err != nil {
-		return nil, err
+		Images:      make([]agents.ExternalImage, 0),
 	}
 
 	// Last.fm can return duplicate sizes.
 	seenSizes := map[int]bool{}
-	images := make([]agents.ExternalImage, 0)
 
 	// This assumes that Last.fm returns images with size small, medium, and large.
 	// This is true as of December 29, 2022
@@ -101,20 +92,23 @@ func (l *lastfmAgent) GetAlbumImages(ctx context.Context, name, artist, mbid str
 			log.Trace(ctx, "LastFM/albuminfo image URL does not match expected regex or is empty", "url", img.URL, "size", img.Size)
 			continue
 		}
+
 		numericSize, err := strconv.Atoi(size[0][2:])
 		if err != nil {
 			log.Error(ctx, "LastFM/albuminfo image URL does not match expected regex", "url", img.URL, "size", img.Size, err)
 			return nil, err
-		}
-		if _, exists := seenSizes[numericSize]; !exists {
-			images = append(images, agents.ExternalImage{
-				Size: numericSize,
-				URL:  img.URL,
-			})
-			seenSizes[numericSize] = true
+		} else {
+			if _, exists := seenSizes[numericSize]; !exists {
+				response.Images = append(response.Images, agents.ExternalImage{
+					Size: numericSize,
+					URL:  img.URL,
+				})
+				seenSizes[numericSize] = true
+			}
 		}
 	}
-	return images, nil
+
+	return &response, nil
 }
 
 func (l *lastfmAgent) GetArtistMBID(ctx context.Context, id string, name string) (string, error) {
@@ -192,13 +186,13 @@ func (l *lastfmAgent) GetArtistTopSongs(ctx context.Context, id, artistName, mbi
 	return res, nil
 }
 
-var (
-	artistOpenGraphQuery = cascadia.MustCompile(`html > head > meta[property="og:image"]`)
-	artistIgnoredImage   = "2a96cbd8b46e442fc41c2b86b821562f" // Last.fm artist placeholder image name
-)
+var artistOpenGraphQuery = cascadia.MustCompile(`html > head > meta[property="og:image"]`)
 
 func (l *lastfmAgent) GetArtistImages(ctx context.Context, _, name, mbid string) ([]agents.ExternalImage, error) {
 	log.Debug(ctx, "Getting artist images from Last.fm", "name", name)
+	hc := http.Client{
+		Timeout: consts.DefaultHttpClientTimeOut,
+	}
 	a, err := l.callArtistGetInfo(ctx, name)
 	if err != nil {
 		return nil, fmt.Errorf("get artist info: %w", err)
@@ -207,7 +201,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)
 	}
@@ -224,16 +218,11 @@ func (l *lastfmAgent) GetArtistImages(ctx context.Context, _, name, mbid string)
 		return res, nil
 	}
 	for _, attr := range n.Attr {
-		if attr.Key != "content" {
-			continue
-		}
-		if strings.Contains(attr.Val, artistIgnoredImage) {
-			log.Debug(ctx, "Artist image is ignored default image", "name", name, "url", attr.Val)
-			return res, nil
-		}
-
-		res = []agents.ExternalImage{
-			{URL: attr.Val},
+		if attr.Key == "content" {
+			res = []agents.ExternalImage{
+				{URL: attr.Val},
+			}
+			break
 		}
 	}
 	return res, nil
@@ -290,27 +279,20 @@ func (l *lastfmAgent) callArtistGetTopTracks(ctx context.Context, artistName str
 	return t.Track, nil
 }
 
-func (l *lastfmAgent) getArtistForScrobble(track *model.MediaFile, role model.Role, displayName string) string {
-	if conf.Server.LastFM.ScrobbleFirstArtistOnly && len(track.Participants[role]) > 0 {
-		return track.Participants[role][0].Name
-	}
-	return displayName
-}
-
-func (l *lastfmAgent) NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) error {
+func (l *lastfmAgent) NowPlaying(ctx context.Context, userId string, track *model.MediaFile) error {
 	sk, err := l.sessionKeys.Get(ctx, userId)
 	if err != nil || sk == "" {
 		return scrobbler.ErrNotAuthorized
 	}
 
 	err = l.client.updateNowPlaying(ctx, sk, ScrobbleInfo{
-		artist:      l.getArtistForScrobble(track, model.RoleArtist, track.Artist),
+		artist:      track.Artist,
 		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)
@@ -330,13 +312,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:      s.Artist,
 		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 {
@@ -362,8 +344,6 @@ func (l *lastfmAgent) IsAuthorized(ctx context.Context, userId string) bool {
 func init() {
 	conf.AddHook(func() {
 		agents.Register(lastFMAgentName, func(ds model.DataStore) agents.Interface {
-			// This is a workaround for the fact that a (Interface)(nil) is not the same as a (*lastfmAgent)(nil)
-			// See https://go.dev/doc/faq#nil_error
 			a := lastFMConstructor(ds)
 			if a != nil {
 				return a
@@ -371,8 +351,6 @@ func init() {
 			return nil
 		})
 		scrobbler.Register(lastFMAgentName, func(ds model.DataStore) scrobbler.Scrobbler {
-			// Same as above - this is a workaround for the fact that a (Scrobbler)(nil) is not the same as a (*lastfmAgent)(nil)
-			// See https://go.dev/doc/faq#nil_error
 			a := lastFMConstructor(ds)
 			if a != nil {
 				return a

core/agents/lastfm/agent_test.go

@@ -196,16 +196,6 @@ var _ = Describe("lastfmAgent", func() {
 				TrackNumber:    1,
 				Duration:       180,
 				MbzRecordingID: "mbz-123",
-				Participants: map[model.Role]model.ParticipantList{
-					model.RoleArtist: []model.Participant{
-						{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"}},
-					},
-				},
 			}
 		})
 
@@ -213,7 +203,7 @@ var _ = Describe("lastfmAgent", func() {
 			It("calls Last.fm with correct params", func() {
 				httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString("{}")), StatusCode: 200}
 
-				err := agent.NowPlaying(ctx, "user-1", track, 0)
+				err := agent.NowPlaying(ctx, "user-1", track)
 
 				Expect(err).ToNot(HaveOccurred())
 				Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodPost))
@@ -230,26 +220,9 @@ var _ = Describe("lastfmAgent", func() {
 			})
 
 			It("returns ErrNotAuthorized if user is not linked", func() {
-				err := agent.NowPlaying(ctx, "user-2", track, 0)
+				err := agent.NowPlaying(ctx, "user-2", track)
 				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())
-					sentParams := httpClient.SavedRequest.URL.Query()
-					Expect(sentParams.Get("artist")).To(Equal("First Artist"))
-					Expect(sentParams.Get("albumArtist")).To(Equal("First Album Artist"))
-				})
-			})
 		})
 
 		Describe("scrobble", func() {
@@ -274,24 +247,6 @@ var _ = Describe("lastfmAgent", func() {
 				Expect(sentParams.Get("timestamp")).To(Equal(strconv.FormatInt(ts.Unix(), 10)))
 			})
 
-			When("ScrobbleFirstArtistOnly is true", func() {
-				BeforeEach(func() {
-					conf.Server.LastFM.ScrobbleFirstArtistOnly = true
-				})
-
-				It("uses only the first artist", func() {
-					ts := time.Now()
-					httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString("{}")), StatusCode: 200}
-
-					err := agent.Scrobble(ctx, "user-1", scrobbler.Scrobble{MediaFile: *track, TimeStamp: ts})
-
-					Expect(err).ToNot(HaveOccurred())
-					sentParams := httpClient.SavedRequest.URL.Query()
-					Expect(sentParams.Get("artist")).To(Equal("First Artist"))
-					Expect(sentParams.Get("albumArtist")).To(Equal("First Album Artist"))
-				})
-			})
-
 			It("skips songs with less than 31 seconds", func() {
 				track.Duration = 29
 				httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString("{}")), StatusCode: 200}
@@ -367,6 +322,24 @@ var _ = Describe("lastfmAgent", func() {
 				MBID:        "03c91c40-49a6-44a7-90e7-a700edf97a62",
 				Description: "Believe is the twenty-third studio album by American singer-actress Cher, released on November 10, 1998 by Warner Bros. Records. The RIAA certified it Quadruple Platinum on December 23, 1999, recognizing four million shipments in the United States; Worldwide, the album has sold more than 20 million copies, making it the biggest-selling album of her career. In 1999 the album received three Grammy Awards nominations including \"Record of the Year\", \"Best Pop Album\" and winning \"Best Dance Recording\" for the single \"Believe\". It was released by Warner Bros. Records at the end of 1998. The album was executive produced by Rob <a href=\"https://www.last.fm/music/Cher/Believe\">Read more on Last.fm</a>.",
 				URL:         "https://www.last.fm/music/Cher/Believe",
+				Images: []agents.ExternalImage{
+					{
+						URL:  "https://lastfm.freetls.fastly.net/i/u/34s/3b54885952161aaea4ce2965b2db1638.png",
+						Size: 34,
+					},
+					{
+						URL:  "https://lastfm.freetls.fastly.net/i/u/64s/3b54885952161aaea4ce2965b2db1638.png",
+						Size: 64,
+					},
+					{
+						URL:  "https://lastfm.freetls.fastly.net/i/u/174s/3b54885952161aaea4ce2965b2db1638.png",
+						Size: 174,
+					},
+					{
+						URL:  "https://lastfm.freetls.fastly.net/i/u/300x300/3b54885952161aaea4ce2965b2db1638.png",
+						Size: 300,
+					},
+				},
 			}))
 			Expect(httpClient.RequestCount).To(Equal(1))
 			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("03c91c40-49a6-44a7-90e7-a700edf97a62"))
@@ -376,8 +349,9 @@ var _ = Describe("lastfmAgent", func() {
 			f, _ := os.Open("tests/fixtures/lastfm.album.getinfo.empty_urls.json")
 			httpClient.Res = http.Response{Body: f, StatusCode: 200}
 			Expect(agent.GetAlbumInfo(ctx, "The Definitive Less Damage And More Joy", "The Jesus and Mary Chain", "")).To(Equal(&agents.AlbumInfo{
-				Name: "The Definitive Less Damage And More Joy",
-				URL:  "https://www.last.fm/music/The+Jesus+and+Mary+Chain/The+Definitive+Less+Damage+And+More+Joy",
+				Name:   "The Definitive Less Damage And More Joy",
+				URL:    "https://www.last.fm/music/The+Jesus+and+Mary+Chain/The+Definitive+Less+Damage+And+More+Joy",
+				Images: []agents.ExternalImage{},
 			}))
 			Expect(httpClient.RequestCount).To(Equal(1))
 			Expect(httpClient.SavedRequest.URL.Query().Get("album")).To(Equal("The Definitive Less Damage And More Joy"))
@@ -415,73 +389,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", "pt", 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"))
-		})
-	})
 })

core/agents/listenbrainz/agent.go

@@ -73,7 +73,7 @@ func (l *listenBrainzAgent) formatListen(track *model.MediaFile) listenInfo {
 	return li
 }
 
-func (l *listenBrainzAgent) NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) error {
+func (l *listenBrainzAgent) NowPlaying(ctx context.Context, userId string, track *model.MediaFile) error {
 	sk, err := l.sessionKeys.Get(ctx, userId)
 	if err != nil || sk == "" {
 		return errors.Join(err, scrobbler.ErrNotAuthorized)

core/agents/listenbrainz/agent_test.go

@@ -79,12 +79,12 @@ var _ = Describe("listenBrainzAgent", func() {
 		It("updates NowPlaying successfully", func() {
 			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(`{"status": "ok"}`)), StatusCode: 200}
 
-			err := agent.NowPlaying(ctx, "user-1", track, 0)
+			err := agent.NowPlaying(ctx, "user-1", track)
 			Expect(err).ToNot(HaveOccurred())
 		})
 
 		It("returns ErrNotAuthorized if user is not linked", func() {
-			err := agent.NowPlaying(ctx, "user-2", track, 0)
+			err := agent.NowPlaying(ctx, "user-2", track)
 			Expect(err).To(MatchError(scrobbler.ErrNotAuthorized))
 		})
 	})

core/agents/mcp/mcp-server/.gitignore

@@ -0,0 +1,2 @@
+mcp-server
+*.wasm

core/agents/mcp/mcp-server/README.md

@@ -0,0 +1,17 @@
+# MCP Server (Proof of Concept)
+
+This directory contains the source code for the `mcp-server`, a simple server implementation used as a proof-of-concept (PoC) for the Navidrome Plugin/MCP agent system.
+
+This server is designed to be compiled into a WebAssembly (WASM) module (`.wasm`) using the `wasip1` target.
+
+## Compilation
+
+To compile the server into a WASM module (`mcp-server.wasm`), navigate to this directory in your terminal and run the following command:
+
+```bash
+CGO_ENABLED=0 GOOS=wasip1 GOARCH=wasm go build -o mcp-server.wasm .
+```
+
+**Note:** This command compiles the WASM module _without_ the `netgo` tag. Networking operations (like HTTP requests) are expected to be handled by host functions provided by the embedding application (Navidrome's `MCPAgent`) rather than directly within the WASM module itself.
+
+Place the resulting `mcp-server.wasm` file where the Navidrome `MCPAgent` expects it (currently configured via the `McpServerPath` constant in `core/agents/mcp/mcp_agent.go`).

core/agents/mcp/mcp-server/dbpedia.go

@@ -0,0 +1,172 @@
+package main
+
+import (
+	"context"
+	"encoding/json" // Reusing ErrNotFound from wikidata.go (implicitly via main)
+	"fmt"
+	"log"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+const dbpediaEndpoint = "https://dbpedia.org/sparql"
+
+// Default timeout for DBpedia requests
+const defaultDbpediaTimeout = 20 * time.Second
+
+// Can potentially reuse SparqlResult, SparqlBindings, SparqlValue from wikidata.go
+// if the structure is identical. Assuming it is for now.
+
+// GetArtistBioFromDBpedia queries DBpedia for an artist's abstract using their name.
+func GetArtistBioFromDBpedia(fetcher Fetcher, ctx context.Context, name string) (string, error) {
+	log.Printf("[MCP] Debug: GetArtistBioFromDBpedia called for name: %s", name)
+	if name == "" {
+		log.Printf("[MCP] Error: GetArtistBioFromDBpedia requires a name.")
+		return "", fmt.Errorf("name is required to query DBpedia by name")
+	}
+
+	// Escape name for SPARQL query literal
+	escapedName := strings.ReplaceAll(name, "\"", "\\\"")
+
+	// SPARQL query using DBpedia ontology (dbo)
+	// Prefixes are recommended but can be omitted if endpoint resolves them.
+	// Searching case-insensitively on the label.
+	// Filtering for dbo:MusicalArtist or dbo:Band.
+	// Selecting the English abstract.
+	sparqlQuery := fmt.Sprintf(`
+PREFIX dbo: <http://dbpedia.org/ontology/>
+PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+
+SELECT DISTINCT ?abstract WHERE {
+  ?artist rdfs:label ?nameLabel .
+  FILTER(LCASE(STR(?nameLabel)) = LCASE("%s") && LANG(?nameLabel) = "en")
+  
+  # Ensure it's a musical artist or band
+  { ?artist rdf:type dbo:MusicalArtist } UNION { ?artist rdf:type dbo:Band }
+  
+  ?artist dbo:abstract ?abstract .
+  FILTER(LANG(?abstract) = "en")
+} LIMIT 1`, escapedName)
+
+	// Prepare and execute HTTP request
+	queryValues := url.Values{}
+	queryValues.Set("query", sparqlQuery)
+	queryValues.Set("format", "application/sparql-results+json") // DBpedia standard format
+
+	reqURL := fmt.Sprintf("%s?%s", dbpediaEndpoint, queryValues.Encode())
+	log.Printf("[MCP] Debug: DBpedia Bio Request URL: %s", reqURL)
+
+	timeout := defaultDbpediaTimeout
+	if deadline, ok := ctx.Deadline(); ok {
+		timeout = time.Until(deadline)
+	}
+	log.Printf("[MCP] Debug: Fetching from DBpedia with timeout: %v", timeout)
+
+	statusCode, bodyBytes, err := fetcher.Fetch(ctx, "GET", reqURL, nil, timeout)
+	if err != nil {
+		log.Printf("[MCP] Error: Fetcher failed for DBpedia bio request (name: '%s'): %v", name, err)
+		return "", fmt.Errorf("failed to execute DBpedia request: %w", err)
+	}
+
+	if statusCode != http.StatusOK {
+		log.Printf("[MCP] Error: DBpedia bio query failed for name '%s' with status %d: %s", name, statusCode, string(bodyBytes))
+		return "", fmt.Errorf("DBpedia query failed with status %d: %s", statusCode, string(bodyBytes))
+	}
+	log.Printf("[MCP] Debug: DBpedia bio query successful (status %d), %d bytes received.", statusCode, len(bodyBytes))
+
+	var result SparqlResult
+	if err := json.Unmarshal(bodyBytes, &result); err != nil {
+		// Try reading the raw body for debugging if JSON parsing fails
+		// (Seek back to the beginning might be needed if already read for error)
+		// For simplicity, just return the parsing error now.
+		log.Printf("[MCP] Error: Failed to decode DBpedia bio response for name '%s': %v", name, err)
+		return "", fmt.Errorf("failed to decode DBpedia response: %w", err)
+	}
+
+	// Extract the abstract
+	if len(result.Results.Bindings) > 0 {
+		if abstractVal, ok := result.Results.Bindings[0]["abstract"]; ok {
+			log.Printf("[MCP] Debug: Found DBpedia abstract for '%s'.", name)
+			return abstractVal.Value, nil
+		}
+	}
+
+	// Use the shared ErrNotFound
+	log.Printf("[MCP] Warn: No abstract found on DBpedia for name '%s'.", name)
+	return "", ErrNotFound
+}
+
+// GetArtistWikipediaURLFromDBpedia queries DBpedia for an artist's Wikipedia URL using their name.
+func GetArtistWikipediaURLFromDBpedia(fetcher Fetcher, ctx context.Context, name string) (string, error) {
+	log.Printf("[MCP] Debug: GetArtistWikipediaURLFromDBpedia called for name: %s", name)
+	if name == "" {
+		log.Printf("[MCP] Error: GetArtistWikipediaURLFromDBpedia requires a name.")
+		return "", fmt.Errorf("name is required to query DBpedia by name for URL")
+	}
+
+	escapedName := strings.ReplaceAll(name, "\"", "\\\"")
+
+	// SPARQL query using foaf:isPrimaryTopicOf
+	sparqlQuery := fmt.Sprintf(`
+PREFIX dbo: <http://dbpedia.org/ontology/>
+PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+
+SELECT DISTINCT ?wikiPage WHERE {
+  ?artist rdfs:label ?nameLabel .
+  FILTER(LCASE(STR(?nameLabel)) = LCASE("%s") && LANG(?nameLabel) = "en")
+
+  { ?artist rdf:type dbo:MusicalArtist } UNION { ?artist rdf:type dbo:Band }
+
+  ?artist foaf:isPrimaryTopicOf ?wikiPage .
+  # Ensure it links to the English Wikipedia
+  FILTER(STRSTARTS(STR(?wikiPage), "https://en.wikipedia.org/"))
+} LIMIT 1`, escapedName)
+
+	// Prepare and execute HTTP request (similar structure to bio query)
+	queryValues := url.Values{}
+	queryValues.Set("query", sparqlQuery)
+	queryValues.Set("format", "application/sparql-results+json")
+
+	reqURL := fmt.Sprintf("%s?%s", dbpediaEndpoint, queryValues.Encode())
+	log.Printf("[MCP] Debug: DBpedia URL Request URL: %s", reqURL)
+
+	timeout := defaultDbpediaTimeout
+	if deadline, ok := ctx.Deadline(); ok {
+		timeout = time.Until(deadline)
+	}
+	log.Printf("[MCP] Debug: Fetching DBpedia URL with timeout: %v", timeout)
+
+	statusCode, bodyBytes, err := fetcher.Fetch(ctx, "GET", reqURL, nil, timeout)
+	if err != nil {
+		log.Printf("[MCP] Error: Fetcher failed for DBpedia URL request (name: '%s'): %v", name, err)
+		return "", fmt.Errorf("failed to execute DBpedia URL request: %w", err)
+	}
+
+	if statusCode != http.StatusOK {
+		log.Printf("[MCP] Error: DBpedia URL query failed for name '%s' with status %d: %s", name, statusCode, string(bodyBytes))
+		return "", fmt.Errorf("DBpedia URL query failed with status %d: %s", statusCode, string(bodyBytes))
+	}
+	log.Printf("[MCP] Debug: DBpedia URL query successful (status %d), %d bytes received.", statusCode, len(bodyBytes))
+
+	var result SparqlResult
+	if err := json.Unmarshal(bodyBytes, &result); err != nil {
+		log.Printf("[MCP] Error: Failed to decode DBpedia URL response for name '%s': %v", name, err)
+		return "", fmt.Errorf("failed to decode DBpedia URL response: %w", err)
+	}
+
+	// Extract the URL
+	if len(result.Results.Bindings) > 0 {
+		if pageVal, ok := result.Results.Bindings[0]["wikiPage"]; ok {
+			log.Printf("[MCP] Debug: Found DBpedia Wikipedia URL for '%s': %s", name, pageVal.Value)
+			return pageVal.Value, nil
+		}
+	}
+
+	log.Printf("[MCP] Warn: No Wikipedia URL found on DBpedia for name '%s'.", name)
+	return "", ErrNotFound
+}

core/agents/mcp/mcp-server/fetch.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"context"
+	"time"
+)
+
+// Fetcher defines an interface for making HTTP requests, abstracting
+// over native net/http and WASM host functions.
+type Fetcher interface {
+	// Fetch performs an HTTP request.
+	// Returns the status code, response body, and any error encountered.
+	// Note: Implementations should aim to return the body even on non-2xx status codes
+	// if the body was successfully read, allowing callers to potentially inspect it.
+	Fetch(ctx context.Context, method, url string, requestBody []byte, timeout time.Duration) (statusCode int, responseBody []byte, err error)
+}

core/agents/mcp/mcp-server/fetch_native.go

@@ -0,0 +1,83 @@
+//go:build !wasm
+
+package main
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"time"
+)
+
+type nativeFetcher struct {
+	// We could hold a shared client, but creating one per request
+	// with the specific timeout is simpler for this adapter.
+}
+
+// Ensure nativeFetcher implements Fetcher
+var _ Fetcher = (*nativeFetcher)(nil)
+
+// NewFetcher creates the default native HTTP fetcher.
+func NewFetcher() Fetcher {
+	log.Println("[MCP] Debug: Using Native HTTP fetcher")
+	return &nativeFetcher{}
+}
+
+func (nf *nativeFetcher) Fetch(ctx context.Context, method, urlStr string, requestBody []byte, timeout time.Duration) (statusCode int, responseBody []byte, err error) {
+	log.Printf("[MCP] Debug: Native Fetch: Method=%s, URL=%s, Timeout=%v", method, urlStr, timeout)
+	// Create a client with the specific timeout for this request
+	client := &http.Client{Timeout: timeout}
+
+	var bodyReader io.Reader
+	if requestBody != nil {
+		bodyReader = bytes.NewReader(requestBody)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, method, urlStr, bodyReader)
+	if err != nil {
+		log.Printf("[MCP] Error: Native Fetch failed to create request: %v", err)
+		return 0, nil, fmt.Errorf("failed to create native request: %w", err)
+	}
+
+	// Set headers consistent with previous direct client usage
+	req.Header.Set("Accept", "application/sparql-results+json, application/json")
+	// Note: Specific User-Agent was set per call site previously, might need adjustment
+	// if different user agents are desired per service.
+	req.Header.Set("User-Agent", "MCPGoServerExample/0.1 (Native Client)")
+
+	log.Printf("[MCP] Debug: Native Fetch executing request...")
+	resp, err := client.Do(req)
+	if err != nil {
+		// Let context cancellation errors pass through
+		if ctx.Err() != nil {
+			log.Printf("[MCP] Debug: Native Fetch context cancelled: %v", ctx.Err())
+			return 0, nil, ctx.Err()
+		}
+		log.Printf("[MCP] Error: Native Fetch HTTP request failed: %v", err)
+		return 0, nil, fmt.Errorf("native HTTP request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	statusCode = resp.StatusCode
+	log.Printf("[MCP] Debug: Native Fetch received status code: %d", statusCode)
+	responseBodyBytes, readErr := io.ReadAll(resp.Body)
+	if readErr != nil {
+		// Still return status code if body read fails
+		log.Printf("[MCP] Error: Native Fetch failed to read response body: %v", readErr)
+		return statusCode, nil, fmt.Errorf("failed to read native response body: %w", readErr)
+	}
+	responseBody = responseBodyBytes
+	log.Printf("[MCP] Debug: Native Fetch read %d bytes from response body", len(responseBodyBytes))
+
+	// Mimic behavior of returning body even on error status
+	if statusCode < 200 || statusCode >= 300 {
+		log.Printf("[MCP] Warn: Native Fetch request failed with status %d. Body: %s", statusCode, string(responseBody))
+		return statusCode, responseBody, fmt.Errorf("native request failed with status %d", statusCode)
+	}
+
+	log.Printf("[MCP] Debug: Native Fetch completed successfully.")
+	return statusCode, responseBody, nil
+}

core/agents/mcp/mcp-server/fetch_wasm.go

@@ -0,0 +1,171 @@
+//go:build wasm
+
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"time"
+	"unsafe"
+)
+
+// --- WASM Host Function Import --- (Copied from user prompt)
+
+//go:wasmimport env http_fetch
+//go:noescape
+func http_fetch(
+	// Request details
+	urlPtr, urlLen uint32,
+	methodPtr, methodLen uint32,
+	bodyPtr, bodyLen uint32,
+	timeoutMillis uint32,
+	// Result pointers
+	resultStatusPtr uint32,
+	resultBodyPtr uint32, resultBodyCapacity uint32, resultBodyLenPtr uint32,
+	resultErrorPtr uint32, resultErrorCapacity uint32, resultErrorLenPtr uint32,
+) uint32 // 0 on success, 1 on host error
+
+// --- Go Wrapper for Host Function --- (Copied from user prompt)
+
+const (
+	defaultResponseBodyCapacity  = 1024 * 10 // 10 KB for response body
+	defaultResponseErrorCapacity = 1024      // 1 KB for error messages
+)
+
+// callHostHTTPFetch provides a Go-friendly interface to the http_fetch host function.
+func callHostHTTPFetch(ctx context.Context, method, url string, requestBody []byte, timeout time.Duration) (statusCode int, responseBody []byte, err error) {
+	log.Printf("[MCP] Debug: WASM Fetch (Host Call): Method=%s, URL=%s, Timeout=%v", method, url, timeout)
+
+	// --- Prepare Input Pointers ---
+	urlPtr, urlLen := stringToPtr(url)
+	methodPtr, methodLen := stringToPtr(method)
+	bodyPtr, bodyLen := bytesToPtr(requestBody)
+
+	timeoutMillis := uint32(timeout.Milliseconds())
+	if timeoutMillis <= 0 {
+		timeoutMillis = 30000 // Default 30 seconds if 0 or negative
+	}
+	if timeout == 0 {
+		// Handle case where context might already be cancelled
+		select {
+		case <-ctx.Done():
+			log.Printf("[MCP] Debug: WASM Fetch context cancelled before host call: %v", ctx.Err())
+			return 0, nil, ctx.Err()
+		default:
+		}
+	}
+
+	// --- Prepare Output Buffers and Pointers ---
+	resultBodyBuffer := make([]byte, defaultResponseBodyCapacity)
+	resultErrorBuffer := make([]byte, defaultResponseErrorCapacity)
+
+	resultStatus := uint32(0)
+	resultBodyLen := uint32(0)
+	resultErrorLen := uint32(0)
+
+	resultStatusPtr := &resultStatus
+	resultBodyPtr, resultBodyCapacity := bytesToPtr(resultBodyBuffer)
+	resultBodyLenPtr := &resultBodyLen
+	resultErrorPtr, resultErrorCapacity := bytesToPtr(resultErrorBuffer)
+	resultErrorLenPtr := &resultErrorLen
+
+	// --- Call the Host Function ---
+	log.Printf("[MCP] Debug: WASM Fetch calling host function http_fetch...")
+	hostReturnCode := http_fetch(
+		urlPtr, urlLen,
+		methodPtr, methodLen,
+		bodyPtr, bodyLen,
+		timeoutMillis,
+		uint32(uintptr(unsafe.Pointer(resultStatusPtr))),
+		resultBodyPtr, resultBodyCapacity, uint32(uintptr(unsafe.Pointer(resultBodyLenPtr))),
+		resultErrorPtr, resultErrorCapacity, uint32(uintptr(unsafe.Pointer(resultErrorLenPtr))),
+	)
+	log.Printf("[MCP] Debug: WASM Fetch host function returned code: %d", hostReturnCode)
+
+	// --- Process Results ---
+	if hostReturnCode != 0 {
+		err = errors.New("host function http_fetch failed internally")
+		log.Printf("[MCP] Error: WASM Fetch host function failed: %v", err)
+		return 0, nil, err
+	}
+
+	statusCode = int(resultStatus)
+	log.Printf("[MCP] Debug: WASM Fetch received status code from host: %d", statusCode)
+
+	if resultErrorLen > 0 {
+		actualErrorLen := min(resultErrorLen, resultErrorCapacity)
+		errMsg := string(resultErrorBuffer[:actualErrorLen])
+		err = errors.New(errMsg)
+		log.Printf("[MCP] Error: WASM Fetch received error from host: %s", errMsg)
+		return statusCode, nil, err
+	}
+
+	if resultBodyLen > 0 {
+		actualBodyLen := min(resultBodyLen, resultBodyCapacity)
+		responseBody = make([]byte, actualBodyLen)
+		copy(responseBody, resultBodyBuffer[:actualBodyLen])
+		log.Printf("[MCP] Debug: WASM Fetch received %d bytes from host body (reported size: %d)", actualBodyLen, resultBodyLen)
+
+		if resultBodyLen > resultBodyCapacity {
+			err = fmt.Errorf("response body truncated: received %d bytes, but actual size was %d", actualBodyLen, resultBodyLen)
+			log.Printf("[MCP] Warn: WASM Fetch %v", err)
+			return statusCode, responseBody, err // Return truncated body with error
+		}
+		log.Printf("[MCP] Debug: WASM Fetch completed successfully.")
+		return statusCode, responseBody, nil
+	}
+
+	log.Printf("[MCP] Debug: WASM Fetch completed successfully (no body, no error).")
+	return statusCode, nil, nil
+}
+
+// --- Pointer Helper Functions --- (Copied from user prompt)
+
+func stringToPtr(s string) (ptr uint32, length uint32) {
+	if len(s) == 0 {
+		return 0, 0
+	}
+	// Use unsafe.StringData for potentially safer pointer access in modern Go
+	// Needs Go 1.20+
+	// return uint32(uintptr(unsafe.Pointer(unsafe.StringData(s)))), uint32(len(s))
+	// Fallback to slice conversion for broader compatibility / if StringData isn't available
+	buf := []byte(s)
+	return bytesToPtr(buf)
+}
+
+func bytesToPtr(b []byte) (ptr uint32, length uint32) {
+	if len(b) == 0 {
+		return 0, 0
+	}
+	// Use unsafe.SliceData for potentially safer pointer access in modern Go
+	// Needs Go 1.20+
+	// return uint32(uintptr(unsafe.Pointer(unsafe.SliceData(b)))), uint32(len(b))
+	// Fallback for broader compatibility
+	return uint32(uintptr(unsafe.Pointer(&b[0]))), uint32(len(b))
+}
+
+func min(a, b uint32) uint32 {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// --- WASM Fetcher Implementation ---
+type wasmFetcher struct{}
+
+// Ensure wasmFetcher implements Fetcher
+var _ Fetcher = (*wasmFetcher)(nil)
+
+// NewFetcher creates the WASM host function fetcher.
+func NewFetcher() Fetcher {
+	log.Println("[MCP] Debug: Using WASM host fetcher")
+	return &wasmFetcher{}
+}
+
+func (wf *wasmFetcher) Fetch(ctx context.Context, method, url string, requestBody []byte, timeout time.Duration) (statusCode int, responseBody []byte, err error) {
+	// Directly call the wrapper which now contains logging
+	return callHostHTTPFetch(ctx, method, url, requestBody, timeout)
+}

core/agents/mcp/mcp-server/go.mod

@@ -0,0 +1,19 @@
+module mcp-server
+
+go 1.24.2
+
+require github.com/metoro-io/mcp-golang v0.11.0
+
+require (
+	github.com/bahlo/generic-list-go v0.2.0 // indirect
+	github.com/buger/jsonparser v1.1.1 // indirect
+	github.com/invopop/jsonschema v0.12.0 // indirect
+	github.com/mailru/easyjson v0.7.7 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/tidwall/gjson v1.18.0 // indirect
+	github.com/tidwall/match v1.1.1 // indirect
+	github.com/tidwall/pretty v1.2.1 // indirect
+	github.com/tidwall/sjson v1.2.5 // indirect
+	github.com/wk8/go-ordered-map/v2 v2.1.8 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

core/agents/mcp/mcp-server/go.sum

@@ -0,0 +1,34 @@
+github.com/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPnH1Wvgk=
+github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg=
+github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs=
+github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/invopop/jsonschema v0.12.0 h1:6ovsNSuvn9wEQVOyc72aycBMVQFKz7cPdMJn10CvzRI=
+github.com/invopop/jsonschema v0.12.0/go.mod h1:ffZ5Km5SWWRAIN6wbDXItl95euhFz2uON45H2qjYt+0=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
+github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
+github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
+github.com/metoro-io/mcp-golang v0.11.0 h1:1k+VSE9QaeMTLn0gJ3FgE/DcjsCBsLFnz5eSFbgXUiI=
+github.com/metoro-io/mcp-golang v0.11.0/go.mod h1:ifLP9ZzKpN1UqFWNTpAHOqSvNkMK6b7d1FSZ5Lu0lN0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/tidwall/gjson v1.14.2/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
+github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
+github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
+github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
+github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY=
+github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28=
+github.com/wk8/go-ordered-map/v2 v2.1.8 h1:5h/BUHu93oj4gIdvHHHGsScSTMijfx5PeYkE/fJgbpc=
+github.com/wk8/go-ordered-map/v2 v2.1.8/go.mod h1:5nJHM5DyteebpVlHnWMV0rPz6Zp7+xBAnxjb1X5vnTw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

core/agents/mcp/mcp-server/main.go

@@ -0,0 +1,289 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"log"
+	"net/url"
+	"os"
+
+	mcp_golang "github.com/metoro-io/mcp-golang"
+	"github.com/metoro-io/mcp-golang/transport/stdio"
+)
+
+type Content struct {
+	Title       string  `json:"title" jsonschema:"required,description=The title to submit"`
+	Description *string `json:"description" jsonschema:"description=The description to submit"`
+}
+type MyFunctionsArguments struct {
+	Submitter string  `json:"submitter" jsonschema:"required,description=The name of the thing calling this tool (openai, google, claude, etc)"`
+	Content   Content `json:"content" jsonschema:"required,description=The content of the message"`
+}
+
+type ArtistBiography struct {
+	ID   string `json:"id" jsonschema:"required,description=The id of the artist"`
+	Name string `json:"name" jsonschema:"required,description=The name of the artist"`
+	MBID string `json:"mbid" jsonschema:"description=The mbid of the artist"`
+}
+
+type ArtistURLArgs struct {
+	ID   string `json:"id" jsonschema:"required,description=The id of the artist"`
+	Name string `json:"name" jsonschema:"required,description=The name of the artist"`
+	MBID string `json:"mbid" jsonschema:"description=The mbid of the artist"`
+}
+
+func main() {
+	log.Println("[MCP] Starting mcp-server...")
+	done := make(chan struct{})
+
+	// Create the appropriate fetcher (native or WASM based on build tags)
+	log.Printf("[MCP] Debug: Creating fetcher...")
+	fetcher := NewFetcher()
+	log.Printf("[MCP] Debug: Fetcher created successfully.")
+
+	// --- Command Line Flag Handling ---
+	nameFlag := flag.String("name", "", "Artist name to query directly")
+	mbidFlag := flag.String("mbid", "", "Artist MBID to query directly")
+	flag.Parse()
+
+	if *nameFlag != "" || *mbidFlag != "" {
+		log.Printf("[MCP] Debug: Running tools directly via CLI flags (Name: '%s', MBID: '%s')", *nameFlag, *mbidFlag)
+		fmt.Println("--- Running Tools Directly ---")
+
+		// Call getArtistBiography
+		fmt.Printf("Calling get_artist_biography (Name: '%s', MBID: '%s')...\n", *nameFlag, *mbidFlag)
+		if *mbidFlag == "" && *nameFlag == "" {
+			fmt.Println("  Error: --mbid or --name is required for get_artist_biography")
+		} else {
+			// Use context.Background for CLI calls
+			log.Printf("[MCP] Debug: CLI calling getArtistBiography...")
+			bio, bioErr := getArtistBiography(fetcher, context.Background(), "cli", *nameFlag, *mbidFlag)
+			if bioErr != nil {
+				fmt.Printf("  Error: %v\n", bioErr)
+				log.Printf("[MCP] Error: CLI getArtistBiography failed: %v", bioErr)
+			} else {
+				fmt.Printf("  Result: %s\n", bio)
+				log.Printf("[MCP] Debug: CLI getArtistBiography succeeded.")
+			}
+		}
+
+		// Call getArtistURL
+		fmt.Printf("Calling get_artist_url (Name: '%s', MBID: '%s')...\n", *nameFlag, *mbidFlag)
+		if *mbidFlag == "" && *nameFlag == "" {
+			fmt.Println("  Error: --mbid or --name is required for get_artist_url")
+		} else {
+			log.Printf("[MCP] Debug: CLI calling getArtistURL...")
+			urlResult, urlErr := getArtistURL(fetcher, context.Background(), "cli", *nameFlag, *mbidFlag)
+			if urlErr != nil {
+				fmt.Printf("  Error: %v\n", urlErr)
+				log.Printf("[MCP] Error: CLI getArtistURL failed: %v", urlErr)
+			} else {
+				fmt.Printf("  Result: %s\n", urlResult)
+				log.Printf("[MCP] Debug: CLI getArtistURL succeeded.")
+			}
+		}
+
+		fmt.Println("-----------------------------")
+		log.Printf("[MCP] Debug: CLI execution finished.")
+		return // Exit after direct execution
+	}
+	// --- End Command Line Flag Handling ---
+
+	log.Printf("[MCP] Debug: Initializing MCP server...")
+	server := mcp_golang.NewServer(stdio.NewStdioServerTransport())
+
+	log.Printf("[MCP] Debug: Registering tool 'hello'...")
+	err := server.RegisterTool("hello", "Say hello to a person", func(arguments MyFunctionsArguments) (*mcp_golang.ToolResponse, error) {
+		log.Printf("[MCP] Debug: Tool 'hello' called with args: %+v", arguments)
+		return mcp_golang.NewToolResponse(mcp_golang.NewTextContent(fmt.Sprintf("Hello, %server!", arguments.Submitter))), nil
+	})
+	if err != nil {
+		log.Fatalf("[MCP] Fatal: Failed to register tool 'hello': %v", err)
+	}
+
+	log.Printf("[MCP] Debug: Registering tool 'get_artist_biography'...")
+	err = server.RegisterTool("get_artist_biography", "Get the biography of an artist", func(arguments ArtistBiography) (*mcp_golang.ToolResponse, error) {
+		log.Printf("[MCP] Debug: Tool 'get_artist_biography' called with args: %+v", arguments)
+		// Using background context in handlers as request context isn't passed through MCP library currently
+		bio, err := getArtistBiography(fetcher, context.Background(), arguments.ID, arguments.Name, arguments.MBID)
+		if err != nil {
+			log.Printf("[MCP] Error: getArtistBiography handler failed: %v", err)
+			return nil, fmt.Errorf("handler returned an error: %w", err) // Return structured error
+		}
+		log.Printf("[MCP] Debug: Tool 'get_artist_biography' succeeded.")
+		return mcp_golang.NewToolResponse(mcp_golang.NewTextContent(bio)), nil
+	})
+	if err != nil {
+		log.Fatalf("[MCP] Fatal: Failed to register tool 'get_artist_biography': %v", err)
+	}
+
+	log.Printf("[MCP] Debug: Registering tool 'get_artist_url'...")
+	err = server.RegisterTool("get_artist_url", "Get the artist's specific Wikipedia URL via MBID, or a search URL using name as fallback", func(arguments ArtistURLArgs) (*mcp_golang.ToolResponse, error) {
+		log.Printf("[MCP] Debug: Tool 'get_artist_url' called with args: %+v", arguments)
+		urlResult, err := getArtistURL(fetcher, context.Background(), arguments.ID, arguments.Name, arguments.MBID)
+		if err != nil {
+			log.Printf("[MCP] Error: getArtistURL handler failed: %v", err)
+			return nil, fmt.Errorf("handler returned an error: %w", err)
+		}
+		log.Printf("[MCP] Debug: Tool 'get_artist_url' succeeded.")
+		return mcp_golang.NewToolResponse(mcp_golang.NewTextContent(urlResult)), nil
+	})
+	if err != nil {
+		log.Fatalf("[MCP] Fatal: Failed to register tool 'get_artist_url': %v", err)
+	}
+
+	log.Printf("[MCP] Debug: Registering prompt 'prompt_test'...")
+	err = server.RegisterPrompt("prompt_test", "This is a test prompt", func(arguments Content) (*mcp_golang.PromptResponse, error) {
+		log.Printf("[MCP] Debug: Prompt 'prompt_test' called with args: %+v", arguments)
+		return mcp_golang.NewPromptResponse("description", mcp_golang.NewPromptMessage(mcp_golang.NewTextContent(fmt.Sprintf("Hello, %server!", arguments.Title)), mcp_golang.RoleUser)), nil
+	})
+	if err != nil {
+		log.Fatalf("[MCP] Fatal: Failed to register prompt 'prompt_test': %v", err)
+	}
+
+	log.Printf("[MCP] Debug: Registering resource 'test://resource'...")
+	err = server.RegisterResource("test://resource", "resource_test", "This is a test resource", "application/json", func() (*mcp_golang.ResourceResponse, error) {
+		log.Printf("[MCP] Debug: Resource 'test://resource' called")
+		return mcp_golang.NewResourceResponse(mcp_golang.NewTextEmbeddedResource("test://resource", "This is a test resource", "application/json")), nil
+	})
+	if err != nil {
+		log.Fatalf("[MCP] Fatal: Failed to register resource 'test://resource': %v", err)
+	}
+
+	log.Printf("[MCP] Debug: Registering resource 'file://app_logs'...")
+	err = server.RegisterResource("file://app_logs", "app_logs", "The app logs", "text/plain", func() (*mcp_golang.ResourceResponse, error) {
+		log.Printf("[MCP] Debug: Resource 'file://app_logs' called")
+		return mcp_golang.NewResourceResponse(mcp_golang.NewTextEmbeddedResource("file://app_logs", "This is a test resource", "text/plain")), nil
+	})
+	if err != nil {
+		log.Fatalf("[MCP] Fatal: Failed to register resource 'file://app_logs': %v", err)
+	}
+
+	log.Println("[MCP] MCP server initialized and starting to serve...")
+	err = server.Serve()
+	if err != nil {
+		log.Fatalf("[MCP] Fatal: Server exited with error: %v", err)
+	}
+
+	log.Println("[MCP] Server exited cleanly.")
+	<-done // Keep running until interrupted (though server.Serve() is blocking)
+}
+
+func getArtistBiography(fetcher Fetcher, ctx context.Context, id, name, mbid string) (string, error) {
+	log.Printf("[MCP] Debug: getArtistBiography called (id: %s, name: %s, mbid: %s)", id, name, mbid)
+	if mbid == "" {
+		fmt.Fprintf(os.Stderr, "MBID not provided, attempting DBpedia lookup by name: %s\n", name)
+		log.Printf("[MCP] Debug: MBID not provided, attempting DBpedia lookup by name: %s", name)
+	} else {
+		// 1. Attempt Wikidata MBID lookup first
+		log.Printf("[MCP] Debug: Attempting Wikidata URL lookup for MBID: %s", mbid)
+		wikiURL, err := GetArtistWikipediaURL(fetcher, ctx, mbid)
+		if err == nil {
+			// 1a. Found Wikidata URL, now fetch from Wikipedia API
+			log.Printf("[MCP] Debug: Found Wikidata URL '%s', fetching bio from Wikipedia API...", wikiURL)
+			bio, errBio := GetBioFromWikipediaAPI(fetcher, ctx, wikiURL)
+			if errBio == nil {
+				log.Printf("[MCP] Debug: Successfully fetched bio from Wikipedia API for '%s'.", name)
+				return bio, nil // Success via Wikidata/Wikipedia!
+			} else {
+				// Failed to get bio even though URL was found
+				log.Printf("[MCP] Error: Found Wikipedia URL (%s) via MBID %s, but failed to fetch bio: %v", wikiURL, mbid, errBio)
+				fmt.Fprintf(os.Stderr, "Found Wikipedia URL (%s) via MBID %s, but failed to fetch bio: %v\n", wikiURL, mbid, errBio)
+				// Fall through to try DBpedia by name as a last resort?
+				// Let's fall through for now.
+			}
+		} else if !errors.Is(err, ErrNotFound) {
+			// Wikidata lookup failed for a reason other than not found (e.g., network)
+			log.Printf("[MCP] Error: Wikidata URL lookup failed for MBID %s (non-NotFound error): %v", mbid, err)
+			fmt.Fprintf(os.Stderr, "Wikidata URL lookup failed for MBID %s (non-NotFound error): %v\n", mbid, err)
+			// Don't proceed to DBpedia name lookup if Wikidata had a technical failure
+			return "", fmt.Errorf("Wikidata lookup failed: %w", err)
+		} else {
+			// Wikidata lookup returned ErrNotFound for MBID
+			log.Printf("[MCP] Debug: MBID %s not found on Wikidata, attempting DBpedia lookup by name: %s", mbid, name)
+			fmt.Fprintf(os.Stderr, "MBID %s not found on Wikidata, attempting DBpedia lookup by name: %s\n", mbid, name)
+		}
+	}
+
+	// 2. Attempt DBpedia lookup by name (if MBID was missing or failed with ErrNotFound)
+	if name == "" {
+		log.Printf("[MCP] Error: Cannot find artist bio: MBID lookup failed/missing, and no name provided.")
+		return "", fmt.Errorf("cannot find artist: MBID lookup failed or MBID not provided, and no name provided for DBpedia fallback")
+	}
+	log.Printf("[MCP] Debug: Attempting DBpedia bio lookup by name: %s", name)
+	dbpediaBio, errDb := GetArtistBioFromDBpedia(fetcher, ctx, name)
+	if errDb == nil {
+		log.Printf("[MCP] Debug: Successfully fetched bio from DBpedia for '%s'.", name)
+		return dbpediaBio, nil // Success via DBpedia!
+	}
+
+	// 3. If both Wikidata (MBID) and DBpedia (Name) failed
+	if errors.Is(errDb, ErrNotFound) {
+		log.Printf("[MCP] Error: Artist '%s' (MBID: %s) not found via Wikidata or DBpedia name lookup.", name, mbid)
+		return "", fmt.Errorf("artist '%s' (MBID: %s) not found via Wikidata MBID or DBpedia Name lookup", name, mbid)
+	}
+
+	// Return DBpedia's error if it wasn't ErrNotFound
+	log.Printf("[MCP] Error: DBpedia lookup failed for name '%s': %v", name, errDb)
+	return "", fmt.Errorf("DBpedia lookup failed for name '%s': %w", name, errDb)
+}
+
+// getArtistURL attempts to find the specific Wikipedia URL using MBID (via Wikidata),
+// then by Name (via DBpedia), falling back to a search URL using name.
+func getArtistURL(fetcher Fetcher, ctx context.Context, id, name, mbid string) (string, error) {
+	log.Printf("[MCP] Debug: getArtistURL called (id: %s, name: %s, mbid: %s)", id, name, mbid)
+	if mbid == "" {
+		fmt.Fprintf(os.Stderr, "getArtistURL: MBID not provided, attempting DBpedia lookup by name: %s\n", name)
+		log.Printf("[MCP] Debug: getArtistURL: MBID not provided, attempting DBpedia lookup by name: %s", name)
+	} else {
+		// Try to get the specific URL from Wikidata using MBID
+		log.Printf("[MCP] Debug: getArtistURL: Attempting Wikidata URL lookup for MBID: %s", mbid)
+		wikiURL, err := GetArtistWikipediaURL(fetcher, ctx, mbid)
+		if err == nil && wikiURL != "" {
+			log.Printf("[MCP] Debug: getArtistURL: Found specific URL '%s' via Wikidata MBID.", wikiURL)
+			return wikiURL, nil // Found specific URL via MBID
+		}
+		// Log error if Wikidata lookup failed for reasons other than not found
+		if err != nil && !errors.Is(err, ErrNotFound) {
+			log.Printf("[MCP] Error: getArtistURL: Wikidata URL lookup failed for MBID %s (non-NotFound error): %v", mbid, err)
+			fmt.Fprintf(os.Stderr, "getArtistURL: Wikidata URL lookup failed for MBID %s (non-NotFound error): %v\n", mbid, err)
+			// Fall through to try DBpedia if name is available
+		} else if errors.Is(err, ErrNotFound) {
+			log.Printf("[MCP] Debug: getArtistURL: MBID %s not found on Wikidata, attempting DBpedia lookup by name: %s", mbid, name)
+			fmt.Fprintf(os.Stderr, "getArtistURL: MBID %s not found on Wikidata, attempting DBpedia lookup by name: %s\n", mbid, name)
+		}
+	}
+
+	// Fallback 1: Try DBpedia lookup by name
+	if name != "" {
+		log.Printf("[MCP] Debug: getArtistURL: Attempting DBpedia URL lookup by name: %s", name)
+		dbpediaWikiURL, errDb := GetArtistWikipediaURLFromDBpedia(fetcher, ctx, name)
+		if errDb == nil && dbpediaWikiURL != "" {
+			log.Printf("[MCP] Debug: getArtistURL: Found specific URL '%s' via DBpedia Name lookup.", dbpediaWikiURL)
+			return dbpediaWikiURL, nil // Found specific URL via DBpedia Name lookup
+		}
+		// Log error if DBpedia lookup failed for reasons other than not found
+		if errDb != nil && !errors.Is(errDb, ErrNotFound) {
+			log.Printf("[MCP] Error: getArtistURL: DBpedia URL lookup failed for name '%s' (non-NotFound error): %v", name, errDb)
+			fmt.Fprintf(os.Stderr, "getArtistURL: DBpedia URL lookup failed for name '%s' (non-NotFound error): %v\n", name, errDb)
+			// Fall through to search URL fallback
+		} else if errors.Is(errDb, ErrNotFound) {
+			log.Printf("[MCP] Debug: getArtistURL: Name '%s' not found on DBpedia, attempting search fallback", name)
+			fmt.Fprintf(os.Stderr, "getArtistURL: Name '%s' not found on DBpedia, attempting search fallback\n", name)
+		}
+	}
+
+	// Fallback 2: Generate a search URL if name is provided
+	if name != "" {
+		searchURL := fmt.Sprintf("https://en.wikipedia.org/w/index.php?search=%s", url.QueryEscape(name))
+		log.Printf("[MCP] Debug: getArtistURL: Falling back to search URL: %s", searchURL)
+		fmt.Fprintf(os.Stderr, "getArtistURL: Falling back to search URL: %s\n", searchURL)
+		return searchURL, nil
+	}
+
+	// Final error: MBID lookup failed (or no MBID given) AND no name provided for fallback
+	log.Printf("[MCP] Error: getArtistURL: Cannot generate Wikipedia URL: Lookups failed and no name provided.")
+	return "", fmt.Errorf("cannot generate Wikipedia URL: Wikidata/DBpedia lookups failed and no artist name provided for search fallback")
+}

core/agents/mcp/mcp-server/wikidata.go

@@ -0,0 +1,205 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+	"os"
+	"time"
+)
+
+const wikidataEndpoint = "https://query.wikidata.org/sparql"
+
+// ErrNotFound indicates a specific item (like an artist or URL) was not found on Wikidata.
+var ErrNotFound = errors.New("item not found on Wikidata")
+
+// Wikidata SPARQL query result structures
+type SparqlResult struct {
+	Results SparqlBindings `json:"results"`
+}
+
+type SparqlBindings struct {
+	Bindings []map[string]SparqlValue `json:"bindings"`
+}
+
+type SparqlValue struct {
+	Type  string `json:"type"`
+	Value string `json:"value"`
+	Lang  string `json:"xml:lang,omitempty"` // Handle language tags like "en"
+}
+
+// GetArtistBioFromWikidata queries Wikidata for an artist's description using their MBID.
+// NOTE: This function is currently UNUSED as the main logic prefers Wikipedia/DBpedia.
+func GetArtistBioFromWikidata(client *http.Client, mbid string) (string, error) {
+	log.Printf("[MCP] Debug: GetArtistBioFromWikidata called for MBID: %s", mbid)
+	if mbid == "" {
+		log.Printf("[MCP] Error: GetArtistBioFromWikidata requires an MBID.")
+		return "", fmt.Errorf("MBID is required to query Wikidata")
+	}
+
+	// SPARQL query to find the English description for an entity with a specific MusicBrainz ID
+	sparqlQuery := fmt.Sprintf(`
+SELECT ?artistDescription WHERE {
+  ?artist wdt:P434 "%s" . # P434 is the property for MusicBrainz artist ID
+  OPTIONAL { 
+    ?artist schema:description ?artistDescription .
+    FILTER(LANG(?artistDescription) = "en")
+  }
+  SERVICE wikibase:label { bd:serviceParam wikibase:language "en". }
+}
+LIMIT 1`, mbid)
+
+	// Prepare the HTTP request
+	queryValues := url.Values{}
+	queryValues.Set("query", sparqlQuery)
+	queryValues.Set("format", "json")
+
+	reqURL := fmt.Sprintf("%s?%s", wikidataEndpoint, queryValues.Encode())
+	log.Printf("[MCP] Debug: Wikidata Bio Request URL: %s", reqURL)
+
+	req, err := http.NewRequest("GET", reqURL, nil)
+	if err != nil {
+		log.Printf("[MCP] Error: Failed to create Wikidata bio request: %v", err)
+		return "", fmt.Errorf("failed to create Wikidata request: %w", err)
+	}
+	req.Header.Set("Accept", "application/sparql-results+json")
+	req.Header.Set("User-Agent", "MCPGoServerExample/0.1 (https://example.com/contact)") // Good practice to identify your client
+
+	// Execute the request
+	log.Printf("[MCP] Debug: Executing Wikidata bio request...")
+	resp, err := client.Do(req)
+	if err != nil {
+		log.Printf("[MCP] Error: Failed to execute Wikidata bio request: %v", err)
+		return "", fmt.Errorf("failed to execute Wikidata request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		// Attempt to read body for more error info, but don't fail if it doesn't work
+		bodyBytes, readErr := io.ReadAll(resp.Body)
+		errorMsg := "Could not read error body"
+		if readErr == nil {
+			errorMsg = string(bodyBytes)
+		}
+		log.Printf("[MCP] Error: Wikidata bio query failed with status %d: %s", resp.StatusCode, errorMsg)
+		return "", fmt.Errorf("Wikidata query failed with status %d: %s", resp.StatusCode, errorMsg)
+	}
+	log.Printf("[MCP] Debug: Wikidata bio query successful (status %d).", resp.StatusCode)
+
+	// Parse the response
+	var result SparqlResult
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		log.Printf("[MCP] Error: Failed to decode Wikidata bio response: %v", err)
+		return "", fmt.Errorf("failed to decode Wikidata response: %w", err)
+	}
+
+	// Extract the description
+	if len(result.Results.Bindings) > 0 {
+		if descriptionVal, ok := result.Results.Bindings[0]["artistDescription"]; ok {
+			log.Printf("[MCP] Debug: Found description for MBID %s", mbid)
+			return descriptionVal.Value, nil
+		}
+	}
+
+	log.Printf("[MCP] Warn: No English description found on Wikidata for MBID %s", mbid)
+	return "", fmt.Errorf("no English description found on Wikidata for MBID %s", mbid)
+}
+
+// GetArtistWikipediaURL queries Wikidata for an artist's English Wikipedia page URL using MBID.
+// It tries searching by MBID first, then falls back to searching by name.
+func GetArtistWikipediaURL(fetcher Fetcher, ctx context.Context, mbid string) (string, error) {
+	log.Printf("[MCP] Debug: GetArtistWikipediaURL called for MBID: %s", mbid)
+	// 1. Try finding by MBID
+	if mbid == "" {
+		log.Printf("[MCP] Error: GetArtistWikipediaURL requires an MBID.")
+		return "", fmt.Errorf("MBID is required to find Wikipedia URL on Wikidata")
+	} else {
+		// SPARQL query to find the enwiki URL for an entity with a specific MusicBrainz ID
+		sparqlQuery := fmt.Sprintf(`
+SELECT ?article WHERE {
+  ?artist wdt:P434 "%s" . # P434 is MusicBrainz artist ID
+  ?article schema:about ?artist ;
+           schema:isPartOf <https://en.wikipedia.org/> .
+}
+LIMIT 1`, mbid)
+
+		log.Printf("[MCP] Debug: Executing Wikidata URL query for MBID: %s", mbid)
+		foundURL, err := executeWikidataURLQuery(fetcher, ctx, sparqlQuery)
+		if err == nil && foundURL != "" {
+			log.Printf("[MCP] Debug: Found Wikipedia URL '%s' via MBID %s", foundURL, mbid)
+			return foundURL, nil // Found via MBID
+		}
+		// Use the specific ErrNotFound
+		if errors.Is(err, ErrNotFound) {
+			log.Printf("[MCP] Debug: MBID %s not found on Wikidata for URL lookup.", mbid)
+			return "", ErrNotFound // Explicitly return ErrNotFound
+		}
+		// Log other errors
+		if err != nil {
+			log.Printf("[MCP] Error: Wikidata URL lookup via MBID %s failed: %v", mbid, err)
+			fmt.Fprintf(os.Stderr, "Wikidata URL lookup via MBID %s failed: %v\n", mbid, err)
+			return "", fmt.Errorf("Wikidata URL lookup via MBID failed: %w", err)
+		}
+	}
+
+	// Should ideally not be reached if MBID is required and lookup failed or was not found
+	log.Printf("[MCP] Warn: Reached end of GetArtistWikipediaURL unexpectedly for MBID %s", mbid)
+	return "", ErrNotFound // Return ErrNotFound if somehow reached
+}
+
+// executeWikidataURLQuery is a helper to run SPARQL and extract the first bound URL for '?article'.
+func executeWikidataURLQuery(fetcher Fetcher, ctx context.Context, sparqlQuery string) (string, error) {
+	log.Printf("[MCP] Debug: executeWikidataURLQuery called.")
+	queryValues := url.Values{}
+	queryValues.Set("query", sparqlQuery)
+	queryValues.Set("format", "json")
+
+	reqURL := fmt.Sprintf("%s?%s", wikidataEndpoint, queryValues.Encode())
+	log.Printf("[MCP] Debug: Wikidata Sparql Request URL: %s", reqURL)
+
+	// Directly use the fetcher
+	// Note: Headers (Accept, User-Agent) are now handled by the Fetcher implementation
+	// The WASM fetcher currently doesn't support setting them via the host func interface.
+	// Timeout is handled via context for native, and passed to host func for WASM.
+	// Let's use a default timeout here if not provided via context (e.g., 15s)
+	// TODO: Consider making timeout configurable or passed down
+	timeout := 15 * time.Second
+	if deadline, ok := ctx.Deadline(); ok {
+		timeout = time.Until(deadline)
+	}
+	log.Printf("[MCP] Debug: Fetching from Wikidata with timeout: %v", timeout)
+
+	statusCode, bodyBytes, err := fetcher.Fetch(ctx, "GET", reqURL, nil, timeout)
+	if err != nil {
+		log.Printf("[MCP] Error: Fetcher failed for Wikidata SPARQL request: %v", err)
+		return "", fmt.Errorf("failed to execute Wikidata request: %w", err)
+	}
+
+	// Check status code. Fetcher interface implies body might be returned even on error.
+	if statusCode != http.StatusOK {
+		log.Printf("[MCP] Error: Wikidata SPARQL query failed with status %d: %s", statusCode, string(bodyBytes))
+		return "", fmt.Errorf("Wikidata query failed with status %d: %s", statusCode, string(bodyBytes))
+	}
+	log.Printf("[MCP] Debug: Wikidata SPARQL query successful (status %d), %d bytes received.", statusCode, len(bodyBytes))
+
+	var result SparqlResult
+	if err := json.Unmarshal(bodyBytes, &result); err != nil { // Use Unmarshal for byte slice
+		log.Printf("[MCP] Error: Failed to decode Wikidata SPARQL response: %v", err)
+		return "", fmt.Errorf("failed to decode Wikidata response: %w", err)
+	}
+
+	if len(result.Results.Bindings) > 0 {
+		if articleVal, ok := result.Results.Bindings[0]["article"]; ok {
+			log.Printf("[MCP] Debug: Found Wikidata article URL: %s", articleVal.Value)
+			return articleVal.Value, nil
+		}
+	}
+
+	log.Printf("[MCP] Debug: No Wikidata article URL found in SPARQL response.")
+	return "", ErrNotFound
+}

core/agents/mcp/mcp-server/wikipedia.go

@@ -0,0 +1,121 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+const mediaWikiAPIEndpoint = "https://en.wikipedia.org/w/api.php"
+
+// Structures for parsing MediaWiki API response (query extracts)
+type MediaWikiQueryResult struct {
+	Query MediaWikiQuery `json:"query"`
+}
+
+type MediaWikiQuery struct {
+	Pages map[string]MediaWikiPage `json:"pages"`
+}
+
+type MediaWikiPage struct {
+	PageID  int    `json:"pageid"`
+	Ns      int    `json:"ns"`
+	Title   string `json:"title"`
+	Extract string `json:"extract"`
+}
+
+// Default timeout for Wikipedia API requests
+const defaultWikipediaTimeout = 15 * time.Second
+
+// GetBioFromWikipediaAPI fetches the introductory text of a Wikipedia page.
+func GetBioFromWikipediaAPI(fetcher Fetcher, ctx context.Context, wikipediaURL string) (string, error) {
+	log.Printf("[MCP] Debug: GetBioFromWikipediaAPI called for URL: %s", wikipediaURL)
+	pageTitle, err := extractPageTitleFromURL(wikipediaURL)
+	if err != nil {
+		log.Printf("[MCP] Error: Could not extract title from Wikipedia URL '%s': %v", wikipediaURL, err)
+		return "", fmt.Errorf("could not extract title from Wikipedia URL %s: %w", wikipediaURL, err)
+	}
+	log.Printf("[MCP] Debug: Extracted Wikipedia page title: %s", pageTitle)
+
+	// Prepare API request parameters
+	apiParams := url.Values{}
+	apiParams.Set("action", "query")
+	apiParams.Set("format", "json")
+	apiParams.Set("prop", "extracts")    // Request page extracts
+	apiParams.Set("exintro", "true")     // Get only the intro section
+	apiParams.Set("explaintext", "true") // Get plain text instead of HTML
+	apiParams.Set("titles", pageTitle)   // Specify the page title
+	apiParams.Set("redirects", "1")      // Follow redirects
+
+	reqURL := fmt.Sprintf("%s?%s", mediaWikiAPIEndpoint, apiParams.Encode())
+	log.Printf("[MCP] Debug: MediaWiki API Request URL: %s", reqURL)
+
+	timeout := defaultWikipediaTimeout
+	if deadline, ok := ctx.Deadline(); ok {
+		timeout = time.Until(deadline)
+	}
+	log.Printf("[MCP] Debug: Fetching from MediaWiki with timeout: %v", timeout)
+
+	statusCode, bodyBytes, err := fetcher.Fetch(ctx, "GET", reqURL, nil, timeout)
+	if err != nil {
+		log.Printf("[MCP] Error: Fetcher failed for MediaWiki request (title: '%s'): %v", pageTitle, err)
+		return "", fmt.Errorf("failed to execute MediaWiki request for title '%s': %w", pageTitle, err)
+	}
+
+	if statusCode != http.StatusOK {
+		log.Printf("[MCP] Error: MediaWiki query for '%s' failed with status %d: %s", pageTitle, statusCode, string(bodyBytes))
+		return "", fmt.Errorf("MediaWiki query for '%s' failed with status %d: %s", pageTitle, statusCode, string(bodyBytes))
+	}
+	log.Printf("[MCP] Debug: MediaWiki query successful (status %d), %d bytes received.", statusCode, len(bodyBytes))
+
+	// Parse the response
+	var result MediaWikiQueryResult
+	if err := json.Unmarshal(bodyBytes, &result); err != nil {
+		log.Printf("[MCP] Error: Failed to decode MediaWiki response for '%s': %v", pageTitle, err)
+		return "", fmt.Errorf("failed to decode MediaWiki response for '%s': %w", pageTitle, err)
+	}
+
+	// Extract the text - MediaWiki API returns pages keyed by page ID
+	for pageID, page := range result.Query.Pages {
+		log.Printf("[MCP] Debug: Processing MediaWiki page ID: %s, Title: %s", pageID, page.Title)
+		if page.Extract != "" {
+			// Often includes a newline at the end, trim it
+			log.Printf("[MCP] Debug: Found extract for '%s'. Length: %d", pageTitle, len(page.Extract))
+			return strings.TrimSpace(page.Extract), nil
+		}
+	}
+
+	log.Printf("[MCP] Warn: No extract found in MediaWiki response for title '%s'", pageTitle)
+	return "", fmt.Errorf("no extract found in MediaWiki response for title '%s' (page might not exist or be empty)", pageTitle)
+}
+
+// extractPageTitleFromURL attempts to get the page title from a standard Wikipedia URL.
+// Example: https://en.wikipedia.org/wiki/The_Beatles -> The_Beatles
+func extractPageTitleFromURL(wikiURL string) (string, error) {
+	parsedURL, err := url.Parse(wikiURL)
+	if err != nil {
+		return "", err
+	}
+	if parsedURL.Host != "en.wikipedia.org" {
+		return "", fmt.Errorf("URL host is not en.wikipedia.org: %s", parsedURL.Host)
+	}
+	pathParts := strings.Split(strings.TrimPrefix(parsedURL.Path, "/"), "/")
+	if len(pathParts) < 2 || pathParts[0] != "wiki" {
+		return "", fmt.Errorf("URL path does not match /wiki/<title> format: %s", parsedURL.Path)
+	}
+	title := pathParts[1]
+	if title == "" {
+		return "", fmt.Errorf("extracted title is empty")
+	}
+	// URL Decode the title (e.g., %27 -> ')
+	decodedTitle, err := url.PathUnescape(title)
+	if err != nil {
+		return "", fmt.Errorf("failed to decode title '%s': %w", title, err)
+	}
+	return decodedTitle, nil
+}

core/agents/mcp/mcp_agent.go

@@ -0,0 +1,207 @@
+package mcp
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	mcp "github.com/metoro-io/mcp-golang"
+	"github.com/tetratelabs/wazero"
+
+	"github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+)
+
+// Constants used by the MCP agent
+const (
+	McpAgentName          = "mcp"
+	initializationTimeout = 5 * time.Second
+	// McpServerPath defines the location of the MCP server executable or WASM module.
+	// McpServerPath     = "./core/agents/mcp/mcp-server/mcp-server"
+	McpServerPath     = "./core/agents/mcp/mcp-server/mcp-server.wasm"
+	McpToolNameGetBio = "get_artist_biography"
+	McpToolNameGetURL = "get_artist_url"
+)
+
+// mcpClient interface matching the methods used from mcp.Client.
+type mcpClient interface {
+	Initialize(ctx context.Context) (*mcp.InitializeResponse, error)
+	CallTool(ctx context.Context, toolName string, args any) (*mcp.ToolResponse, error)
+}
+
+// mcpImplementation defines the common interface for both native and WASM MCP agents.
+// This allows the main MCPAgent to delegate calls without knowing the underlying type.
+type mcpImplementation interface {
+	Close() error // For cleaning up resources associated with this specific implementation.
+
+	// callMCPTool is the core method implemented differently by native/wasm
+	callMCPTool(ctx context.Context, toolName string, args any) (string, error)
+}
+
+// MCPAgent is the public-facing agent registered with Navidrome.
+// It acts as a wrapper around the actual implementation (native or WASM).
+type MCPAgent struct {
+	// No mutex needed here if impl is set once at construction
+	// and the implementation handles its own internal state synchronization.
+	impl mcpImplementation
+
+	// Shared Wazero resources (runtime, cache) are managed externally
+	// and closed separately, likely during application shutdown.
+}
+
+// mcpConstructor creates the appropriate MCP implementation (native or WASM)
+// and wraps it in the MCPAgent.
+func mcpConstructor(ds model.DataStore) agents.Interface {
+	if _, err := os.Stat(McpServerPath); os.IsNotExist(err) {
+		log.Warn("MCP server executable/WASM not found, disabling agent", "path", McpServerPath, "error", err)
+		return nil
+	}
+
+	var agentImpl mcpImplementation
+	var err error
+
+	if strings.HasSuffix(McpServerPath, ".wasm") {
+		log.Info("Configuring MCP agent for WASM execution", "path", McpServerPath)
+		ctx := context.Background()
+
+		// Setup Shared Wazero Resources
+		var cache wazero.CompilationCache
+		cacheDir := filepath.Join(conf.Server.DataFolder, "cache", "wazero")
+		if errMkdir := os.MkdirAll(cacheDir, 0755); errMkdir != nil {
+			log.Error(ctx, "Failed to create Wazero cache directory, WASM caching disabled", "path", cacheDir, "error", errMkdir)
+		} else {
+			cache, err = wazero.NewCompilationCacheWithDir(cacheDir)
+			if err != nil {
+				log.Error(ctx, "Failed to create Wazero compilation cache, WASM caching disabled", "path", cacheDir, "error", err)
+				cache = nil
+			}
+		}
+
+		runtimeConfig := wazero.NewRuntimeConfig()
+		if cache != nil {
+			runtimeConfig = runtimeConfig.WithCompilationCache(cache)
+		}
+
+		runtime := wazero.NewRuntimeWithConfig(ctx, runtimeConfig)
+
+		if err = registerHostFunctions(ctx, runtime); err != nil {
+			_ = runtime.Close(ctx)
+			if cache != nil {
+				_ = cache.Close(ctx)
+			}
+			return nil // Fatal error: Host functions required
+		}
+
+		if _, err = wasi_snapshot_preview1.Instantiate(ctx, runtime); err != nil {
+			log.Error(ctx, "Failed to instantiate WASI on shared Wazero runtime, MCP WASM agent disabled", "error", err)
+			_ = runtime.Close(ctx)
+			if cache != nil {
+				_ = cache.Close(ctx)
+			}
+			return nil // Fatal error: WASI required
+		}
+
+		// Compile the module
+		log.Debug(ctx, "Pre-compiling WASM module...", "path", McpServerPath)
+		wasmBytes, err := os.ReadFile(McpServerPath)
+		if err != nil {
+			log.Error(ctx, "Failed to read WASM module file, disabling agent", "path", McpServerPath, "error", err)
+			_ = runtime.Close(ctx)
+			if cache != nil {
+				_ = cache.Close(ctx)
+			}
+			return nil
+		}
+		compiledModule, err := runtime.CompileModule(ctx, wasmBytes)
+		if err != nil {
+			log.Error(ctx, "Failed to pre-compile WASM module, disabling agent", "path", McpServerPath, "error", err)
+			_ = runtime.Close(ctx)
+			if cache != nil {
+				_ = cache.Close(ctx)
+			}
+			return nil
+		}
+
+		agentImpl = newMCPWasm(runtime, cache, compiledModule)
+		log.Info(ctx, "Shared Wazero runtime, WASI, cache, host functions initialized, and module pre-compiled for MCP agent")
+
+	} else {
+		log.Info("Configuring MCP agent for native execution", "path", McpServerPath)
+		agentImpl = newMCPNative()
+	}
+
+	log.Info("MCP Agent implementation created successfully")
+	return &MCPAgent{impl: agentImpl}
+}
+
+// NewAgentForTesting is a constructor specifically for tests.
+// It creates the appropriate implementation based on McpServerPath
+// and injects a mock mcpClient into its ClientOverride field.
+func NewAgentForTesting(mockClient mcpClient) agents.Interface {
+	// We need to replicate the logic from mcpConstructor to determine
+	// the implementation type, but without actually starting processes.
+
+	var agentImpl mcpImplementation
+
+	if strings.HasSuffix(McpServerPath, ".wasm") {
+		// For WASM testing, we might not need the full runtime setup,
+		// just the struct. Pass nil for shared resources for now.
+		// We rely on the mockClient being used before any real WASM interaction.
+		wasmImpl := newMCPWasm(nil, nil, nil)
+		wasmImpl.ClientOverride = mockClient
+		agentImpl = wasmImpl
+	} else {
+		nativeImpl := newMCPNative()
+		nativeImpl.ClientOverride = mockClient
+		agentImpl = nativeImpl
+	}
+
+	return &MCPAgent{impl: agentImpl}
+}
+
+func (a *MCPAgent) AgentName() string {
+	return McpAgentName
+}
+
+func (a *MCPAgent) GetArtistBiography(ctx context.Context, id, name, mbid string) (string, error) {
+	if a.impl == nil {
+		return "", errors.New("MCP agent implementation is nil")
+	}
+	// Construct args and call the implementation's specific tool caller
+	args := ArtistArgs{ID: id, Name: name, Mbid: mbid}
+	return a.impl.callMCPTool(ctx, McpToolNameGetBio, args)
+}
+
+func (a *MCPAgent) GetArtistURL(ctx context.Context, id, name, mbid string) (string, error) {
+	if a.impl == nil {
+		return "", errors.New("MCP agent implementation is nil")
+	}
+	// Construct args and call the implementation's specific tool caller
+	args := ArtistArgs{ID: id, Name: name, Mbid: mbid}
+	return a.impl.callMCPTool(ctx, McpToolNameGetURL, args)
+}
+
+// Note: A Close method on MCPAgent itself isn't part of agents.Interface.
+// Cleanup of the specific implementation happens via impl.Close().
+// Cleanup of shared Wazero resources needs separate handling (e.g., on app shutdown).
+
+// ArtistArgs defines the structure for MCP tool arguments requiring artist info.
+type ArtistArgs struct {
+	ID   string `json:"id"`
+	Name string `json:"name"`
+	Mbid string `json:"mbid,omitempty"`
+}
+
+var _ agents.ArtistBiographyRetriever = (*MCPAgent)(nil)
+var _ agents.ArtistURLRetriever = (*MCPAgent)(nil)
+
+func init() {
+	agents.Register(McpAgentName, mcpConstructor)
+}

core/agents/mcp/mcp_agent_test.go

@@ -0,0 +1,237 @@
+package mcp_test
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+
+	mcp_client "github.com/metoro-io/mcp-golang" // Renamed alias for clarity
+	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/core/agents/mcp"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+// Define the mcpClient interface locally for mocking, matching the one
+// used internally by MCPNative/MCPWasm.
+type mcpClient interface {
+	Initialize(ctx context.Context) (*mcp_client.InitializeResponse, error)
+	CallTool(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error)
+}
+
+// mockMCPClient is a mock implementation of mcpClient for testing.
+type mockMCPClient struct {
+	InitializeFunc func(ctx context.Context) (*mcp_client.InitializeResponse, error)
+	CallToolFunc   func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error)
+	callToolArgs   []any  // Store args for verification
+	callToolName   string // Store tool name for verification
+}
+
+func (m *mockMCPClient) Initialize(ctx context.Context) (*mcp_client.InitializeResponse, error) {
+	if m.InitializeFunc != nil {
+		return m.InitializeFunc(ctx)
+	}
+	return &mcp_client.InitializeResponse{}, nil // Default success
+}
+
+func (m *mockMCPClient) CallTool(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+	m.callToolName = toolName
+	m.callToolArgs = append(m.callToolArgs, args)
+	if m.CallToolFunc != nil {
+		return m.CallToolFunc(ctx, toolName, args)
+	}
+	return &mcp_client.ToolResponse{}, nil
+}
+
+// Ensure mock implements the local interface (compile-time check)
+var _ mcpClient = (*mockMCPClient)(nil)
+
+var _ = Describe("MCPAgent", func() {
+	var (
+		ctx context.Context
+		// We test the public MCPAgent wrapper, which uses the implementations internally.
+		// The actual agent instance might be native or wasm depending on McpServerPath
+		agent      agents.Interface // Use the public agents.Interface
+		mockClient *mockMCPClient
+	)
+
+	BeforeEach(func() {
+		ctx = context.Background()
+		mockClient = &mockMCPClient{
+			callToolArgs: make([]any, 0), // Reset args on each test
+		}
+
+		// Instantiate the real agent using a testing constructor
+		// This constructor needs to be added to the mcp package.
+		agent = mcp.NewAgentForTesting(mockClient)
+		Expect(agent).NotTo(BeNil(), "Agent should be created")
+	})
+
+	// Helper to get the concrete agent type for calling specific methods
+	getConcreteAgent := func() *mcp.MCPAgent {
+		concreteAgent, ok := agent.(*mcp.MCPAgent)
+		Expect(ok).To(BeTrue(), "Agent should be of type *mcp.MCPAgent")
+		return concreteAgent
+	}
+
+	Describe("GetArtistBiography", func() {
+		It("should call the correct tool and return the biography", func() {
+			expectedBio := "This is the artist bio."
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				Expect(toolName).To(Equal(mcp.McpToolNameGetBio))
+				Expect(args).To(BeAssignableToTypeOf(mcp.ArtistArgs{}))
+				typedArgs := args.(mcp.ArtistArgs)
+				Expect(typedArgs.ID).To(Equal("id1"))
+				Expect(typedArgs.Name).To(Equal("Artist Name"))
+				Expect(typedArgs.Mbid).To(Equal("mbid1"))
+				return mcp_client.NewToolResponse(mcp_client.NewTextContent(expectedBio)), nil
+			}
+
+			bio, err := getConcreteAgent().GetArtistBiography(ctx, "id1", "Artist Name", "mbid1")
+			Expect(err).NotTo(HaveOccurred())
+			Expect(bio).To(Equal(expectedBio))
+		})
+
+		It("should return error if CallTool fails", func() {
+			expectedErr := errors.New("mcp tool error")
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				return nil, expectedErr
+			}
+
+			bio, err := getConcreteAgent().GetArtistBiography(ctx, "id1", "Artist Name", "mbid1")
+			Expect(err).To(HaveOccurred())
+			// The error originates from the implementation now, check for specific part
+			Expect(err.Error()).To(SatisfyAny(
+				ContainSubstring("native MCP agent not ready"), // Error from native
+				ContainSubstring("WASM MCP agent not ready"),   // Error from WASM
+				ContainSubstring("failed to call native MCP tool"),
+				ContainSubstring("failed to call WASM MCP tool"),
+			))
+			Expect(errors.Is(err, expectedErr)).To(BeTrue())
+			Expect(bio).To(BeEmpty())
+		})
+
+		It("should return ErrNotFound if CallTool response is empty", func() {
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				// Return a response created with no content parts
+				return mcp_client.NewToolResponse(), nil
+			}
+
+			bio, err := getConcreteAgent().GetArtistBiography(ctx, "id1", "Artist Name", "mbid1")
+			Expect(err).To(MatchError(agents.ErrNotFound))
+			Expect(bio).To(BeEmpty())
+		})
+
+		It("should return ErrNotFound if CallTool response has nil TextContent (simulated by empty string)", func() {
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				// Simulate nil/empty text content by creating response with empty string text
+				return mcp_client.NewToolResponse(mcp_client.NewTextContent("")), nil
+			}
+
+			bio, err := getConcreteAgent().GetArtistBiography(ctx, "id1", "Artist Name", "mbid1")
+			Expect(err).To(MatchError(agents.ErrNotFound))
+			Expect(bio).To(BeEmpty())
+		})
+
+		It("should return comm error if CallTool returns pipe error", func() {
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				return nil, io.ErrClosedPipe
+			}
+
+			bio, err := getConcreteAgent().GetArtistBiography(ctx, "id1", "Artist Name", "mbid1")
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(SatisfyAny(
+				ContainSubstring("native MCP agent process communication error"),
+				ContainSubstring("WASM MCP agent module communication error"),
+			))
+			Expect(errors.Is(err, io.ErrClosedPipe)).To(BeTrue())
+			Expect(bio).To(BeEmpty())
+		})
+
+		It("should return ErrNotFound if MCP tool returns an error string", func() {
+			mcpErrorString := "handler returned an error: something went wrong on the server"
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				return mcp_client.NewToolResponse(mcp_client.NewTextContent(mcpErrorString)), nil
+			}
+
+			bio, err := getConcreteAgent().GetArtistBiography(ctx, "id1", "Artist Name", "mbid1")
+			Expect(err).To(MatchError(agents.ErrNotFound))
+			Expect(bio).To(BeEmpty())
+		})
+	})
+
+	Describe("GetArtistURL", func() {
+		It("should call the correct tool and return the URL", func() {
+			expectedURL := "http://example.com/artist"
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				Expect(toolName).To(Equal(mcp.McpToolNameGetURL))
+				Expect(args).To(BeAssignableToTypeOf(mcp.ArtistArgs{}))
+				typedArgs := args.(mcp.ArtistArgs)
+				Expect(typedArgs.ID).To(Equal("id2"))
+				Expect(typedArgs.Name).To(Equal("Another Artist"))
+				Expect(typedArgs.Mbid).To(Equal("mbid2"))
+				return mcp_client.NewToolResponse(mcp_client.NewTextContent(expectedURL)), nil
+			}
+
+			url, err := getConcreteAgent().GetArtistURL(ctx, "id2", "Another Artist", "mbid2")
+			Expect(err).NotTo(HaveOccurred())
+			Expect(url).To(Equal(expectedURL))
+		})
+
+		It("should return error if CallTool fails", func() {
+			expectedErr := errors.New("mcp tool error url")
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				return nil, expectedErr
+			}
+
+			url, err := getConcreteAgent().GetArtistURL(ctx, "id2", "Another Artist", "mbid2")
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(SatisfyAny(
+				ContainSubstring("native MCP agent not ready"), // Error from native
+				ContainSubstring("WASM MCP agent not ready"),   // Error from WASM
+				ContainSubstring("failed to call native MCP tool"),
+				ContainSubstring("failed to call WASM MCP tool"),
+			))
+			Expect(errors.Is(err, expectedErr)).To(BeTrue())
+			Expect(url).To(BeEmpty())
+		})
+
+		It("should return ErrNotFound if CallTool response is empty", func() {
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				// Return a response created with no content parts
+				return mcp_client.NewToolResponse(), nil
+			}
+
+			url, err := getConcreteAgent().GetArtistURL(ctx, "id2", "Another Artist", "mbid2")
+			Expect(err).To(MatchError(agents.ErrNotFound))
+			Expect(url).To(BeEmpty())
+		})
+
+		It("should return comm error if CallTool returns pipe error", func() {
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				return nil, fmt.Errorf("write: %w", io.ErrClosedPipe)
+			}
+
+			url, err := getConcreteAgent().GetArtistURL(ctx, "id2", "Another Artist", "mbid2")
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(SatisfyAny(
+				ContainSubstring("native MCP agent process communication error"),
+				ContainSubstring("WASM MCP agent module communication error"),
+			))
+			Expect(errors.Is(err, io.ErrClosedPipe)).To(BeTrue())
+			Expect(url).To(BeEmpty())
+		})
+
+		It("should return ErrNotFound if MCP tool returns an error string", func() {
+			mcpErrorString := "handler returned an error: could not find url"
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				return mcp_client.NewToolResponse(mcp_client.NewTextContent(mcpErrorString)), nil
+			}
+
+			url, err := getConcreteAgent().GetArtistURL(ctx, "id2", "Another Artist", "mbid2")
+			Expect(err).To(MatchError(agents.ErrNotFound))
+			Expect(url).To(BeEmpty())
+		})
+	})
+})

core/agents/mcp/mcp_host_functions.go

@@ -0,0 +1,189 @@
+package mcp
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/tetratelabs/wazero"
+	"github.com/tetratelabs/wazero/api"
+)
+
+// httpClient is a shared HTTP client for host function reuse.
+var httpClient = &http.Client{
+	// Consider adding a default timeout
+	Timeout: 30 * time.Second,
+}
+
+// registerHostFunctions defines and registers the host functions (e.g., http_fetch)
+// into the provided Wazero runtime.
+func registerHostFunctions(ctx context.Context, runtime wazero.Runtime) error {
+	// Define and Instantiate Host Module "env"
+	_, err := runtime.NewHostModuleBuilder("env"). // "env" is the conventional module name
+							NewFunctionBuilder().
+							WithFunc(httpFetch).  // Register our Go function
+							Export("http_fetch"). // Export it with the name WASM will use
+							Instantiate(ctx)
+	if err != nil {
+		log.Error(ctx, "Failed to instantiate 'env' host module with httpFetch", "error", err)
+		return fmt.Errorf("instantiate host module 'env': %w", err)
+	}
+	log.Info(ctx, "Instantiated 'env' host module with http_fetch function")
+	return nil
+}
+
+// httpFetch is the host function exposed to WASM.
+// ... (full implementation as provided previously) ...
+// Returns:
+// - 0 on success (request completed, results written).
+// - 1 on host-side failure (e.g., memory access error, invalid input).
+func httpFetch(
+	ctx context.Context, mod api.Module, // Standard Wazero host function params
+	// Request details
+	urlPtr, urlLen uint32,
+	methodPtr, methodLen uint32,
+	bodyPtr, bodyLen uint32,
+	timeoutMillis uint32,
+	// Result pointers
+	resultStatusPtr uint32,
+	resultBodyPtr uint32, resultBodyCapacity uint32, resultBodyLenPtr uint32,
+	resultErrorPtr uint32, resultErrorCapacity uint32, resultErrorLenPtr uint32,
+) uint32 { // Using uint32 for status code convention (0=success, 1=failure)
+	mem := mod.Memory()
+
+	// --- Read Inputs ---
+	urlBytes, ok := mem.Read(urlPtr, urlLen)
+	if !ok {
+		log.Error(ctx, "httpFetch host error: failed to read URL from WASM memory")
+		// Cannot write error back as we don't have the pointers validated yet
+		return 1
+	}
+	url := string(urlBytes)
+
+	methodBytes, ok := mem.Read(methodPtr, methodLen)
+	if !ok {
+		log.Error(ctx, "httpFetch host error: failed to read method from WASM memory", "url", url)
+		return 1 // Bail out
+	}
+	method := string(methodBytes)
+	if method == "" {
+		method = "GET" // Default to GET
+	}
+
+	var reqBody io.Reader
+	if bodyLen > 0 {
+		bodyBytes, ok := mem.Read(bodyPtr, bodyLen)
+		if !ok {
+			log.Error(ctx, "httpFetch host error: failed to read body from WASM memory", "url", url, "method", method)
+			return 1 // Bail out
+		}
+		reqBody = bytes.NewReader(bodyBytes)
+	}
+
+	timeout := time.Duration(timeoutMillis) * time.Millisecond
+	if timeout <= 0 {
+		timeout = 30 * time.Second // Default timeout matching httpClient
+	}
+
+	// --- Prepare and Execute Request ---
+	log.Debug(ctx, "httpFetch executing request", "method", method, "url", url, "timeout", timeout)
+
+	// Use a specific context for the request, derived from the host function's context
+	// but with the specific timeout for this call.
+	reqCtx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(reqCtx, method, url, reqBody)
+	if err != nil {
+		errMsg := fmt.Sprintf("failed to create request: %v", err)
+		log.Error(ctx, "httpFetch host error", "url", url, "method", method, "error", errMsg)
+		writeStringResult(mem, resultErrorPtr, resultErrorCapacity, resultErrorLenPtr, errMsg)
+		mem.WriteUint32Le(resultStatusPtr, 0)  // Write 0 status on creation error
+		mem.WriteUint32Le(resultBodyLenPtr, 0) // No body
+		return 0                               // Indicate results (including error) were written
+	}
+
+	// TODO: Consider adding a User-Agent?
+	// req.Header.Set("User-Agent", "Navidrome/MCP-Agent-Host")
+
+	resp, err := httpClient.Do(req)
+	if err != nil {
+		// Handle client-side errors (network, DNS, timeout)
+		errMsg := fmt.Sprintf("failed to execute request: %v", err)
+		log.Error(ctx, "httpFetch host error", "url", url, "method", method, "error", errMsg)
+		writeStringResult(mem, resultErrorPtr, resultErrorCapacity, resultErrorLenPtr, errMsg)
+		mem.WriteUint32Le(resultStatusPtr, 0) // Write 0 status on transport error
+		mem.WriteUint32Le(resultBodyLenPtr, 0)
+		return 0 // Indicate results written
+	}
+	defer resp.Body.Close()
+
+	// --- Process Response ---
+	statusCode := uint32(resp.StatusCode)
+	responseBodyBytes, readErr := io.ReadAll(resp.Body)
+	if readErr != nil {
+		errMsg := fmt.Sprintf("failed to read response body: %v", readErr)
+		log.Error(ctx, "httpFetch host error", "url", url, "method", method, "status", statusCode, "error", errMsg)
+		writeStringResult(mem, resultErrorPtr, resultErrorCapacity, resultErrorLenPtr, errMsg)
+		mem.WriteUint32Le(resultStatusPtr, statusCode) // Write actual status code
+		mem.WriteUint32Le(resultBodyLenPtr, 0)
+		return 0 // Indicate results written
+	}
+
+	// --- Write Results Back to WASM Memory ---
+	log.Debug(ctx, "httpFetch writing results", "url", url, "method", method, "status", statusCode, "bodyLen", len(responseBodyBytes))
+
+	// Write status code
+	if !mem.WriteUint32Le(resultStatusPtr, statusCode) {
+		log.Error(ctx, "httpFetch host error: failed to write status code to WASM memory")
+		return 1 // Host error
+	}
+
+	// Write response body (checking capacity)
+	if !writeBytesResult(mem, resultBodyPtr, resultBodyCapacity, resultBodyLenPtr, responseBodyBytes) {
+		// If body write fails (likely due to capacity), write an error message instead.
+		errMsg := fmt.Sprintf("response body size (%d) exceeds buffer capacity (%d)", len(responseBodyBytes), resultBodyCapacity)
+		log.Error(ctx, "httpFetch host error", "url", url, "method", method, "status", statusCode, "error", errMsg)
+		writeStringResult(mem, resultErrorPtr, resultErrorCapacity, resultErrorLenPtr, errMsg)
+		mem.WriteUint32Le(resultBodyLenPtr, 0) // Ensure body length is 0 if we wrote an error
+	} else {
+		// Write empty error string if body write was successful
+		mem.WriteUint32Le(resultErrorLenPtr, 0)
+	}
+
+	return 0 // Success
+}
+
+// Helper to write string results, respecting capacity. Returns true on success.
+func writeStringResult(mem api.Memory, ptr, capacity, lenPtr uint32, result string) bool {
+	bytes := []byte(result)
+	return writeBytesResult(mem, ptr, capacity, lenPtr, bytes)
+}
+
+// Helper to write byte results, respecting capacity. Returns true on success.
+func writeBytesResult(mem api.Memory, ptr, capacity, lenPtr uint32, result []byte) bool {
+	resultLen := uint32(len(result))
+	writeLen := resultLen
+	if writeLen > capacity {
+		log.Warn(context.Background(), "WASM host write truncated", "requested", resultLen, "capacity", capacity)
+		writeLen = capacity // Truncate if too large for buffer
+	}
+
+	if writeLen > 0 {
+		if !mem.Write(ptr, result[:writeLen]) {
+			log.Error(context.Background(), "WASM host memory write failed", "ptr", ptr, "len", writeLen)
+			return false // Memory write failed
+		}
+	}
+
+	// Write the *original* length of the data (even if truncated) so the WASM side knows.
+	if !mem.WriteUint32Le(lenPtr, resultLen) {
+		log.Error(context.Background(), "WASM host memory length write failed", "lenPtr", lenPtr, "len", resultLen)
+		return false // Memory write failed
+	}
+	return true
+}

core/agents/mcp/mcp_process_native.go

@@ -0,0 +1,252 @@
+package mcp
+
+import (
+	"bufio"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strings"
+	"sync"
+
+	mcp "github.com/metoro-io/mcp-golang"
+	"github.com/metoro-io/mcp-golang/transport/stdio"
+	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/log"
+)
+
+// MCPNative implements the mcpImplementation interface for running the MCP server as a native process.
+type MCPNative struct {
+	mu     sync.Mutex
+	cmd    *exec.Cmd // Stores the running command
+	stdin  io.WriteCloser
+	client mcpClient
+
+	// ClientOverride allows injecting a mock client for testing this specific implementation.
+	ClientOverride mcpClient // TODO: Consider if this is the best way to test
+}
+
+// newMCPNative creates a new instance of the native MCP agent implementation.
+func newMCPNative() *MCPNative {
+	return &MCPNative{}
+}
+
+// --- mcpImplementation interface methods ---
+
+func (n *MCPNative) Close() error {
+	n.mu.Lock()
+	defer n.mu.Unlock()
+	n.cleanupResources_locked()
+	return nil // Currently, cleanup doesn't return errors
+}
+
+// --- Internal Helper Methods ---
+
+// ensureClientInitialized starts the MCP server process and initializes the client if needed.
+// MUST be called with the mutex HELD.
+func (n *MCPNative) ensureClientInitialized_locked(ctx context.Context) error {
+	// Use override if provided (for testing)
+	if n.ClientOverride != nil {
+		if n.client == nil {
+			n.client = n.ClientOverride
+			log.Debug(ctx, "Using provided MCP client override for native testing")
+		}
+		return nil
+	}
+
+	// Check if already initialized
+	if n.client != nil {
+		return nil
+	}
+
+	log.Info(ctx, "Initializing Native MCP client and starting/restarting server process...", "serverPath", McpServerPath)
+
+	// Clean up any old resources *before* starting new ones
+	n.cleanupResources_locked()
+
+	hostStdinWriter, hostStdoutReader, nativeCmd, startErr := n.startProcess_locked(ctx)
+	if startErr != nil {
+		log.Error(ctx, "Failed to start Native MCP server process", "error", startErr)
+		// Ensure pipes are closed if start failed (startProcess might handle this, but be sure)
+		if hostStdinWriter != nil {
+			_ = hostStdinWriter.Close()
+		}
+		if hostStdoutReader != nil {
+			_ = hostStdoutReader.Close()
+		}
+		return fmt.Errorf("failed to start native MCP server: %w", startErr)
+	}
+
+	// --- Initialize MCP client ---
+	transport := stdio.NewStdioServerTransportWithIO(hostStdoutReader, hostStdinWriter)
+	clientImpl := mcp.NewClient(transport)
+
+	initCtx, cancel := context.WithTimeout(context.Background(), initializationTimeout)
+	defer cancel()
+	if _, initErr := clientImpl.Initialize(initCtx); initErr != nil {
+		err := fmt.Errorf("failed to initialize native MCP client: %w", initErr)
+		log.Error(ctx, "Native MCP client initialization failed", "error", err)
+		// Cleanup the newly started process and close pipes
+		n.cmd = nativeCmd // Temporarily set cmd so cleanup can kill it
+		n.cleanupResources_locked()
+		if hostStdinWriter != nil {
+			_ = hostStdinWriter.Close()
+		}
+		if hostStdoutReader != nil {
+			_ = hostStdoutReader.Close()
+		}
+		return err
+	}
+
+	// --- Initialization successful, update agent state ---
+	n.cmd = nativeCmd
+	n.stdin = hostStdinWriter // This is the pipe the agent writes to
+	n.client = clientImpl
+
+	log.Info(ctx, "Native MCP client initialized successfully", "pid", n.cmd.Process.Pid)
+	return nil // Success
+}
+
+// callMCPTool handles ensuring initialization and calling the MCP tool.
+func (n *MCPNative) callMCPTool(ctx context.Context, toolName string, args any) (string, error) {
+	// Ensure the client is initialized and the server is running (attempts restart if needed)
+	n.mu.Lock()
+	err := n.ensureClientInitialized_locked(ctx)
+	if err != nil {
+		n.mu.Unlock()
+		log.Error(ctx, "Native MCP agent initialization/restart failed", "tool", toolName, "error", err)
+		return "", fmt.Errorf("native MCP agent not ready: %w", err)
+	}
+
+	// Keep a reference to the client while locked
+	currentClient := n.client
+	// Unlock mutex *before* making the potentially blocking MCP call
+	n.mu.Unlock()
+
+	// Call the tool using the client reference
+	log.Debug(ctx, "Calling Native MCP tool", "tool", toolName, "args", args)
+	response, callErr := currentClient.CallTool(ctx, toolName, args)
+	if callErr != nil {
+		// Handle potential pipe closures or other communication errors
+		log.Error(ctx, "Failed to call Native MCP tool", "tool", toolName, "error", callErr)
+		// Check if the error indicates a broken pipe, suggesting the server died
+		// The monitoring goroutine will handle cleanup, just return error here.
+		if errors.Is(callErr, io.ErrClosedPipe) || strings.Contains(callErr.Error(), "broken pipe") || strings.Contains(callErr.Error(), "EOF") {
+			log.Warn(ctx, "Native MCP tool call failed, possibly due to server process exit.", "tool", toolName)
+			// No need to explicitly call cleanup, monitoring goroutine handles it.
+			return "", fmt.Errorf("native MCP agent process communication error: %w", callErr)
+		}
+		return "", fmt.Errorf("failed to call native MCP tool '%s': %w", toolName, callErr)
+	}
+
+	// Process the response (same logic as before)
+	if response == nil || len(response.Content) == 0 || response.Content[0].TextContent == nil || response.Content[0].TextContent.Text == "" {
+		log.Warn(ctx, "Native MCP tool returned empty/invalid response", "tool", toolName)
+		// Treat as not found for agent interface consistency
+		return "", agents.ErrNotFound // Import agents package if needed, or define locally
+	}
+	resultText := response.Content[0].TextContent.Text
+	if strings.HasPrefix(resultText, "handler returned an error:") {
+		log.Warn(ctx, "Native MCP tool returned an error message", "tool", toolName, "mcpError", resultText)
+		return "", agents.ErrNotFound // Treat MCP tool errors as "not found"
+	}
+
+	log.Debug(ctx, "Received response from Native MCP agent", "tool", toolName, "length", len(resultText))
+	return resultText, nil
+}
+
+// cleanupResources closes existing resources (stdin, server process).
+// MUST be called with the mutex HELD.
+func (n *MCPNative) cleanupResources_locked() {
+	log.Debug(context.Background(), "Cleaning up Native MCP instance resources...")
+	if n.stdin != nil {
+		_ = n.stdin.Close()
+		n.stdin = nil
+	}
+	if n.cmd != nil && n.cmd.Process != nil {
+		pid := n.cmd.Process.Pid
+		log.Debug(context.Background(), "Killing native MCP process", "pid", pid)
+		// Kill the process. Ignore error if it's already done.
+		if err := n.cmd.Process.Kill(); err != nil && !errors.Is(err, os.ErrProcessDone) {
+			log.Error(context.Background(), "Failed to kill native process", "pid", pid, "error", err)
+		}
+		// Wait for the process to release resources. Ignore error.
+		_ = n.cmd.Wait()
+		n.cmd = nil
+	}
+	// Mark client as invalid
+	n.client = nil
+}
+
+// startProcess starts the MCP server as a native executable and sets up monitoring.
+// MUST be called with the mutex HELD.
+func (n *MCPNative) startProcess_locked(ctx context.Context) (stdin io.WriteCloser, stdout io.ReadCloser, cmd *exec.Cmd, err error) {
+	log.Debug(ctx, "Starting native MCP server process", "path", McpServerPath)
+	// Use Background context for the command itself, as it should outlive the request context (ctx)
+	cmd = exec.CommandContext(context.Background(), McpServerPath)
+
+	stdinPipe, err := cmd.StdinPipe()
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("native stdin pipe: %w", err)
+	}
+
+	stdoutPipe, err := cmd.StdoutPipe()
+	if err != nil {
+		_ = stdinPipe.Close()
+		return nil, nil, nil, fmt.Errorf("native stdout pipe: %w", err)
+	}
+
+	// Get stderr pipe to stream logs
+	stderrPipe, err := cmd.StderrPipe()
+	if err != nil {
+		_ = stdinPipe.Close()
+		_ = stdoutPipe.Close()
+		return nil, nil, nil, fmt.Errorf("native stderr pipe: %w", err)
+	}
+
+	if err = cmd.Start(); err != nil {
+		_ = stdinPipe.Close()
+		_ = stdoutPipe.Close()
+		// stderrPipe gets closed implicitly if cmd.Start() fails
+		return nil, nil, nil, fmt.Errorf("native start: %w", err)
+	}
+
+	currentPid := cmd.Process.Pid
+	currentCmd := cmd // Capture the current cmd pointer for the goroutine
+	log.Info(ctx, "Native MCP server process started", "pid", currentPid)
+
+	// Start monitoring goroutine for process exit
+	go func() {
+		// Start separate goroutine to stream stderr
+		go func() {
+			scanner := bufio.NewScanner(stderrPipe)
+			for scanner.Scan() {
+				log.Info("[MCP-SERVER] " + scanner.Text())
+			}
+			if err := scanner.Err(); err != nil {
+				log.Error("Error reading MCP server stderr", "pid", currentPid, "error", err)
+			}
+			log.Debug("MCP server stderr pipe closed", "pid", currentPid)
+		}()
+
+		waitErr := currentCmd.Wait() // Wait for the specific process this goroutine monitors
+		n.mu.Lock()
+		// Stderr is now streamed, so we don't capture it here anymore.
+		log.Warn("Native MCP server process exited", "pid", currentPid, "error", waitErr)
+
+		// Critical: Check if the agent's current command is STILL the one we were monitoring.
+		// If it's different, it means cleanup/restart already happened, so we shouldn't cleanup again.
+		if n.cmd == currentCmd {
+			n.cleanupResources_locked() // Use the locked version as we hold the lock
+			log.Info("MCP Native agent state cleaned up after process exit", "pid", currentPid)
+		} else {
+			log.Debug("Native MCP process exited, but state already updated/cmd mismatch", "exitedPid", currentPid)
+		}
+		n.mu.Unlock()
+	}()
+
+	// Return the pipes connected to the process and the Cmd object
+	return stdinPipe, stdoutPipe, cmd, nil
+}

core/agents/mcp/mcp_process_wazero.go

@@ -0,0 +1,305 @@
+package mcp
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	mcp "github.com/metoro-io/mcp-golang"
+	"github.com/metoro-io/mcp-golang/transport/stdio"
+	"github.com/navidrome/navidrome/core/agents" // Needed for ErrNotFound
+	"github.com/navidrome/navidrome/log"
+	"github.com/tetratelabs/wazero"     // Needed for types
+	"github.com/tetratelabs/wazero/api" // Needed for types
+)
+
+// MCPWasm implements the mcpImplementation interface for running the MCP server as a WASM module.
+type MCPWasm struct {
+	mu           sync.Mutex
+	wasmModule   api.Module // Stores the instantiated module
+	wasmCompiled api.Closer // Stores the compiled module reference for this instance
+	stdin        io.WriteCloser
+	client       mcpClient
+
+	// Shared resources (passed in, not owned by this struct)
+	wasmRuntime       api.Closer              // Shared Wazero Runtime
+	wasmCache         wazero.CompilationCache // Shared Compilation Cache (can be nil)
+	preCompiledModule wazero.CompiledModule   // Pre-compiled module from constructor
+
+	// ClientOverride allows injecting a mock client for testing this specific implementation.
+	ClientOverride mcpClient // TODO: Consider if this is the best way to test
+}
+
+// newMCPWasm creates a new instance of the WASM MCP agent implementation.
+// It stores the shared runtime, cache, and the pre-compiled module.
+func newMCPWasm(runtime api.Closer, cache wazero.CompilationCache, compiledModule wazero.CompiledModule) *MCPWasm {
+	return &MCPWasm{
+		wasmRuntime:       runtime,
+		wasmCache:         cache,
+		preCompiledModule: compiledModule,
+	}
+}
+
+// --- mcpImplementation interface methods ---
+
+// Close cleans up instance-specific WASM resources.
+// It does NOT close the shared runtime or cache.
+func (w *MCPWasm) Close() error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	w.cleanupResources_locked()
+	return nil
+}
+
+// --- Internal Helper Methods ---
+
+// ensureClientInitialized starts the MCP WASM module and initializes the client if needed.
+// MUST be called with the mutex HELD.
+func (w *MCPWasm) ensureClientInitialized_locked(ctx context.Context) error {
+	// Use override if provided (for testing)
+	if w.ClientOverride != nil {
+		if w.client == nil {
+			w.client = w.ClientOverride
+			log.Debug(ctx, "Using provided MCP client override for WASM testing")
+		}
+		return nil
+	}
+
+	// Check if already initialized
+	if w.client != nil {
+		return nil
+	}
+
+	log.Info(ctx, "Initializing WASM MCP client and starting/restarting server module...", "serverPath", McpServerPath)
+
+	w.cleanupResources_locked()
+
+	// Check if shared runtime exists
+	if w.wasmRuntime == nil {
+		return errors.New("shared Wazero runtime not initialized for MCPWasm")
+	}
+
+	hostStdinWriter, hostStdoutReader, mod, err := w.startModule_locked(ctx)
+	if err != nil {
+		log.Error(ctx, "Failed to start WASM MCP server module", "error", err)
+		// Ensure pipes are closed if start failed
+		if hostStdinWriter != nil {
+			_ = hostStdinWriter.Close()
+		}
+		if hostStdoutReader != nil {
+			_ = hostStdoutReader.Close()
+		}
+		// startModule_locked handles cleanup of mod/compiled on error
+		return fmt.Errorf("failed to start WASM MCP server: %w", err)
+	}
+
+	transport := stdio.NewStdioServerTransportWithIO(hostStdoutReader, hostStdinWriter)
+	clientImpl := mcp.NewClient(transport)
+
+	initCtx, cancel := context.WithTimeout(context.Background(), initializationTimeout)
+	defer cancel()
+	if _, initErr := clientImpl.Initialize(initCtx); initErr != nil {
+		err := fmt.Errorf("failed to initialize WASM MCP client: %w", initErr)
+		log.Error(ctx, "WASM MCP client initialization failed", "error", err)
+		// Cleanup the newly started module and close pipes
+		w.wasmModule = mod   // Temporarily set so cleanup can close it
+		w.wasmCompiled = nil // We don't store the compiled instance ref anymore, just the module instance
+		w.cleanupResources_locked()
+		if hostStdinWriter != nil {
+			_ = hostStdinWriter.Close()
+		}
+		if hostStdoutReader != nil {
+			_ = hostStdoutReader.Close()
+		}
+		return err
+	}
+
+	w.wasmModule = mod
+	w.wasmCompiled = nil // We don't store the compiled instance ref anymore, just the module instance
+	w.stdin = hostStdinWriter
+	w.client = clientImpl
+
+	log.Info(ctx, "WASM MCP client initialized successfully")
+	return nil
+}
+
+// callMCPTool handles ensuring initialization and calling the MCP tool.
+func (w *MCPWasm) callMCPTool(ctx context.Context, toolName string, args any) (string, error) {
+	w.mu.Lock()
+	err := w.ensureClientInitialized_locked(ctx)
+	if err != nil {
+		w.mu.Unlock()
+		log.Error(ctx, "WASM MCP agent initialization/restart failed", "tool", toolName, "error", err)
+		return "", fmt.Errorf("WASM MCP agent not ready: %w", err)
+	}
+
+	// Keep a reference to the client while locked
+	currentClient := w.client
+	// Unlock mutex *before* making the potentially blocking MCP call
+	w.mu.Unlock()
+
+	// Call the tool using the client reference
+	log.Debug(ctx, "Calling WASM MCP tool", "tool", toolName, "args", args)
+	response, callErr := currentClient.CallTool(ctx, toolName, args)
+	if callErr != nil {
+		// Handle potential pipe closures or other communication errors
+		log.Error(ctx, "Failed to call WASM MCP tool", "tool", toolName, "error", callErr)
+		// Check if the error indicates a broken pipe, suggesting the server died
+		// The monitoring goroutine will handle cleanup, just return error here.
+		if errors.Is(callErr, io.ErrClosedPipe) || strings.Contains(callErr.Error(), "broken pipe") || strings.Contains(callErr.Error(), "EOF") {
+			log.Warn(ctx, "WASM MCP tool call failed, possibly due to server module exit.", "tool", toolName)
+			// No need to explicitly call cleanup, monitoring goroutine handles it.
+			return "", fmt.Errorf("WASM MCP agent module communication error: %w", callErr)
+		}
+		return "", fmt.Errorf("failed to call WASM MCP tool '%s': %w", toolName, callErr)
+	}
+
+	// Process the response (same logic as native)
+	if response == nil || len(response.Content) == 0 || response.Content[0].TextContent == nil || response.Content[0].TextContent.Text == "" {
+		log.Warn(ctx, "WASM MCP tool returned empty/invalid response", "tool", toolName)
+		return "", agents.ErrNotFound
+	}
+	resultText := response.Content[0].TextContent.Text
+	if strings.HasPrefix(resultText, "handler returned an error:") {
+		log.Warn(ctx, "WASM MCP tool returned an error message", "tool", toolName, "mcpError", resultText)
+		return "", agents.ErrNotFound // Treat MCP tool errors as "not found"
+	}
+
+	log.Debug(ctx, "Received response from WASM MCP agent", "tool", toolName, "length", len(resultText))
+	return resultText, nil
+}
+
+// cleanupResources closes instance-specific WASM resources (stdin, module, compiled ref).
+// It specifically avoids closing the shared runtime or cache.
+// MUST be called with the mutex HELD.
+func (w *MCPWasm) cleanupResources_locked() {
+	log.Debug(context.Background(), "Cleaning up WASM MCP instance resources...")
+	if w.stdin != nil {
+		_ = w.stdin.Close()
+		w.stdin = nil
+	}
+	// Close the module instance
+	if w.wasmModule != nil {
+		log.Debug(context.Background(), "Closing WASM module instance")
+		ctxClose, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+		if err := w.wasmModule.Close(ctxClose); err != nil && !errors.Is(err, context.DeadlineExceeded) {
+			log.Error(context.Background(), "Failed to close WASM module instance", "error", err)
+		}
+		cancel()
+		w.wasmModule = nil
+	}
+	// DO NOT close w.wasmCompiled (instance ref)
+	// DO NOT close w.preCompiledModule (shared pre-compiled code)
+	// DO NOT CLOSE w.wasmRuntime or w.wasmCache here!
+	w.client = nil
+}
+
+// startModule loads and starts the MCP server as a WASM module.
+// It now uses the pre-compiled module.
+// MUST be called with the mutex HELD.
+func (w *MCPWasm) startModule_locked(ctx context.Context) (hostStdinWriter io.WriteCloser, hostStdoutReader io.ReadCloser, mod api.Module, err error) {
+	// Check for pre-compiled module
+	if w.preCompiledModule == nil {
+		return nil, nil, nil, errors.New("pre-compiled WASM module is nil")
+	}
+
+	// Create pipes for stdio redirection
+	wasmStdinReader, hostStdinWriter, err := os.Pipe()
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("wasm stdin pipe: %w", err)
+	}
+	// Defer close pipes on error exit
+	shouldClosePipesOnError := true
+	defer func() {
+		if shouldClosePipesOnError {
+			if wasmStdinReader != nil {
+				_ = wasmStdinReader.Close()
+			}
+			if hostStdinWriter != nil {
+				_ = hostStdinWriter.Close()
+			}
+			// hostStdoutReader and wasmStdoutWriter handled below
+		}
+	}()
+
+	hostStdoutReader, wasmStdoutWriter, err := os.Pipe()
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("wasm stdout pipe: %w", err)
+	}
+	// Defer close pipes on error exit
+	defer func() {
+		if shouldClosePipesOnError {
+			if hostStdoutReader != nil {
+				_ = hostStdoutReader.Close()
+			}
+			if wasmStdoutWriter != nil {
+				_ = wasmStdoutWriter.Close()
+			}
+		}
+	}()
+
+	// Use the SHARDED runtime from the agent struct
+	runtime, ok := w.wasmRuntime.(wazero.Runtime)
+	if !ok || runtime == nil {
+		return nil, nil, nil, errors.New("wasmRuntime is not initialized or not a wazero.Runtime")
+	}
+
+	// Prepare module configuration (host funcs/WASI already instantiated on runtime)
+	config := wazero.NewModuleConfig().
+		WithStdin(wasmStdinReader).
+		WithStdout(wasmStdoutWriter).
+		WithStderr(os.Stderr).
+		WithArgs(McpServerPath).
+		WithFS(os.DirFS("/")) // Keep FS access for now
+
+	log.Info(ctx, "Instantiating pre-compiled WASM module (will run _start)...")
+	var moduleInstance api.Module
+	instanceErrChan := make(chan error, 1)
+	go func() {
+		var instantiateErr error
+		// Use context.Background() for the module's main execution context
+		moduleInstance, instantiateErr = runtime.InstantiateModule(context.Background(), w.preCompiledModule, config)
+		instanceErrChan <- instantiateErr
+	}()
+
+	// Wait briefly for immediate instantiation errors
+	select {
+	case instantiateErr := <-instanceErrChan:
+		if instantiateErr != nil {
+			log.Error(ctx, "Failed to instantiate pre-compiled WASM module", "error", instantiateErr)
+			// Pipes closed by defer
+			return nil, nil, nil, fmt.Errorf("instantiate wasm module: %w", instantiateErr)
+		}
+		log.Warn(ctx, "WASM module instantiation returned (exited?) immediately without error.")
+	case <-time.After(1 * time.Second): // Shorter wait now, instantiation should be faster
+		log.Debug(ctx, "WASM module instantiation likely blocking (server running), proceeding...")
+	}
+
+	// Start a monitoring goroutine for WASM module exit/error
+	go func(instanceToMonitor api.Module, errChan chan error) {
+		// This blocks until the instance created by InstantiateModule exits or errors.
+		instantiateErr := <-errChan
+
+		w.mu.Lock() // Lock the specific MCPWasm instance
+		log.Warn("WASM module exited/errored", "error", instantiateErr)
+
+		// Critical: Check if the agent's current module is STILL the one we were monitoring.
+		if w.wasmModule == instanceToMonitor {
+			w.cleanupResources_locked() // Use the locked version
+			log.Info("MCP WASM agent state cleaned up after module exit/error")
+		} else {
+			log.Debug("WASM module exited, but state already updated/module mismatch. No cleanup needed by this goroutine.")
+			// No need to close anything here, the pre-compiled module is shared
+		}
+		w.mu.Unlock()
+	}(moduleInstance, instanceErrChan)
+
+	// Success: prevent deferred cleanup of pipes
+	shouldClosePipesOnError = false
+	return hostStdinWriter, hostStdoutReader, moduleInstance, nil
+}

core/agents/mcp/mcp_suite_test.go

@@ -1,4 +1,4 @@
-package deezer
+package mcp_test
 
 import (
 	"testing"
@@ -9,9 +9,9 @@ import (
 	. "github.com/onsi/gomega"
 )
 
-func TestDeezer(t *testing.T) {
+func TestMCPAgent(t *testing.T) {
 	tests.Init(t, false)
 	log.SetLevel(log.LevelFatal)
 	RegisterFailHandler(Fail)
-	RunSpecs(t, "Deezer Test Suite")
+	RunSpecs(t, "MCP Agent Test Suite")
 }

core/archiver.go

@@ -98,7 +98,7 @@ func (a *archiver) ZipShare(ctx context.Context, id string, out io.Writer) error
 		return model.ErrNotAuthorized
 	}
 	log.Debug(ctx, "Zipping share", "name", s.ID, "format", s.Format, "bitrate", s.MaxBitRate, "numTracks", len(s.Tracks))
-	return a.zipMediaFiles(ctx, id, s.ID, s.Format, s.MaxBitRate, out, s.Tracks, false)
+	return a.zipMediaFiles(ctx, id, s.Format, s.MaxBitRate, out, s.Tracks)
 }
 
 func (a *archiver) ZipPlaylist(ctx context.Context, id string, format string, bitrate int, out io.Writer) error {
@@ -109,40 +109,15 @@ func (a *archiver) ZipPlaylist(ctx context.Context, id string, format string, bi
 	}
 	mfs := pls.MediaFiles()
 	log.Debug(ctx, "Zipping playlist", "name", pls.Name, "format", format, "bitrate", bitrate, "numTracks", len(mfs))
-	return a.zipMediaFiles(ctx, id, pls.Name, format, bitrate, out, mfs, true)
+	return a.zipMediaFiles(ctx, id, format, bitrate, out, mfs)
 }
 
-func (a *archiver) zipMediaFiles(ctx context.Context, id, name string, format string, bitrate int, out io.Writer, mfs model.MediaFiles, addM3U bool) error {
+func (a *archiver) zipMediaFiles(ctx context.Context, id string, format string, bitrate int, out io.Writer, mfs model.MediaFiles) error {
 	z := createZipWriter(out, format, bitrate)
-
-	zippedMfs := make(model.MediaFiles, len(mfs))
 	for idx, mf := range mfs {
 		file := a.playlistFilename(mf, format, idx)
 		_ = a.addFileToZip(ctx, z, mf, format, bitrate, file)
-		mf.Path = file
-		zippedMfs[idx] = mf
 	}
-
-	// Add M3U file if requested
-	if addM3U && len(zippedMfs) > 0 {
-		plsName := sanitizeName(name)
-		w, err := z.CreateHeader(&zip.FileHeader{
-			Name:     plsName + ".m3u",
-			Modified: mfs[0].UpdatedAt,
-			Method:   zip.Store,
-		})
-		if err != nil {
-			log.Error(ctx, "Error creating playlist zip entry", err)
-			return err
-		}
-
-		_, err = w.Write([]byte(zippedMfs.ToM3U8(plsName, false)))
-		if err != nil {
-			log.Error(ctx, "Error writing m3u in zip", err)
-			return err
-		}
-	}
-
 	err := z.Close()
 	if err != nil {
 		log.Error(ctx, "Error closing zip file", "id", id, err)

core/archiver_test.go

@@ -145,21 +145,9 @@ var _ = Describe("Archiver", func() {
 			zr, err := zip.NewReader(bytes.NewReader(out.Bytes()), int64(out.Len()))
 			Expect(err).To(BeNil())
 
-			Expect(len(zr.File)).To(Equal(3))
+			Expect(len(zr.File)).To(Equal(2))
 			Expect(zr.File[0].Name).To(Equal("01 - AC_DC - track1.mp3"))
 			Expect(zr.File[1].Name).To(Equal("02 - Artist 2 - track2.mp3"))
-			Expect(zr.File[2].Name).To(Equal("Test Playlist.m3u"))
-
-			// Verify M3U content
-			m3uFile, err := zr.File[2].Open()
-			Expect(err).To(BeNil())
-			defer m3uFile.Close()
-
-			m3uContent, err := io.ReadAll(m3uFile)
-			Expect(err).To(BeNil())
-
-			expectedM3U := "#EXTM3U\n#PLAYLIST:Test Playlist\n#EXTINF:0,AC/DC - track1\n01 - AC_DC - track1.mp3\n#EXTINF:0,Artist 2 - track2\n02 - Artist 2 - track2.mp3\n"
-			Expect(string(m3uContent)).To(Equal(expectedM3U))
 		})
 	})
 })

core/artwork/artwork.go

@@ -115,7 +115,7 @@ func (a *artwork) getArtworkReader(ctx context.Context, artID model.ArtworkID, s
 	} else {
 		switch artID.Kind {
 		case model.KindArtistArtwork:
-			artReader, err = newArtistArtworkReader(ctx, a, artID, a.provider)
+			artReader, err = newArtistReader(ctx, a, artID, a.provider)
 		case model.KindAlbumArtwork:
 			artReader, err = newAlbumArtworkReader(ctx, a, artID, a.provider)
 		case model.KindMediaFileArtwork:

core/artwork/artwork_internal_test.go

@@ -4,11 +4,7 @@ import (
 	"context"
 	"errors"
 	"image"
-	"image/jpeg"
-	"image/png"
 	"io"
-	"os"
-	"path/filepath"
 
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/conf/configtest"
@@ -19,11 +15,11 @@ import (
 	. "github.com/onsi/gomega"
 )
 
-var _ = Describe("Artwork", func() {
+// TODO Fix tests
+var _ = XDescribe("Artwork", func() {
 	var aw *artwork
 	var ds model.DataStore
 	var ffmpeg *tests.MockFFmpeg
-	var folderRepo *fakeFolderRepo
 	ctx := log.NewContext(context.TODO())
 	var alOnlyEmbed, alEmbedNotFound, alOnlyExternal, alExternalNotFound, alMultipleCovers model.Album
 	var arMultipleCovers model.Artist
@@ -34,21 +30,20 @@ var _ = Describe("Artwork", func() {
 		conf.Server.ImageCacheSize = "0" // Disable cache
 		conf.Server.CoverArtPriority = "folder.*, cover.*, embedded , front.*"
 
-		folderRepo = &fakeFolderRepo{}
-		ds = &tests.MockDataStore{
-			MockedTranscoding: &tests.MockTranscodingRepo{},
-			MockedFolder:      folderRepo,
-		}
-		alOnlyEmbed = model.Album{ID: "222", Name: "Only embed", EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3", FolderIDs: []string{"f1"}}
-		alEmbedNotFound = model.Album{ID: "333", Name: "Embed not found", EmbedArtPath: "tests/fixtures/NON_EXISTENT.mp3", FolderIDs: []string{"f1"}}
-		alOnlyExternal = model.Album{ID: "444", Name: "Only external", FolderIDs: []string{"f1"}}
-		alExternalNotFound = model.Album{ID: "555", Name: "External not found", FolderIDs: []string{"f2"}}
+		ds = &tests.MockDataStore{MockedTranscoding: &tests.MockTranscodingRepo{}}
+		alOnlyEmbed = model.Album{ID: "222", Name: "Only embed", EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3"}
+		alEmbedNotFound = model.Album{ID: "333", Name: "Embed not found", EmbedArtPath: "tests/fixtures/NON_EXISTENT.mp3"}
+		//alOnlyExternal = model.Album{ID: "444", Name: "Only external", ImageFiles: "tests/fixtures/artist/an-album/front.png"}
+		//alExternalNotFound = model.Album{ID: "555", Name: "External not found", ImageFiles: "tests/fixtures/NON_EXISTENT.png"}
 		arMultipleCovers = model.Artist{ID: "777", Name: "All options"}
 		alMultipleCovers = model.Album{
-			ID:            "666",
-			Name:          "All options",
-			EmbedArtPath:  "tests/fixtures/artist/an-album/test.mp3",
-			FolderIDs:     []string{"f1"},
+			ID:           "666",
+			Name:         "All options",
+			EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3",
+			//Paths:        []string{"tests/fixtures/artist/an-album"},
+			//ImageFiles: "tests/fixtures/artist/an-album/cover.jpg" + consts.Zwsp +
+			//	"tests/fixtures/artist/an-album/front.png" + consts.Zwsp +
+			//	"tests/fixtures/artist/an-album/artist.png",
 			AlbumArtistID: "777",
 		}
 		mfWithEmbed = model.MediaFile{ID: "22", Path: "tests/fixtures/test.mp3", HasCoverArt: true, AlbumID: "222"}
@@ -70,7 +65,6 @@ var _ = Describe("Artwork", func() {
 		})
 		Context("Embed images", func() {
 			BeforeEach(func() {
-				folderRepo.result = nil
 				ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
 					alOnlyEmbed,
 					alEmbedNotFound,
@@ -93,17 +87,12 @@ var _ = Describe("Artwork", func() {
 		})
 		Context("External images", func() {
 			BeforeEach(func() {
-				folderRepo.result = []model.Folder{}
 				ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
 					alOnlyExternal,
 					alExternalNotFound,
 				})
 			})
 			It("returns external cover", func() {
-				folderRepo.result = []model.Folder{{
-					Path:       "tests/fixtures/artist/an-album",
-					ImageFiles: []string{"front.png"},
-				}}
 				aw, err := newAlbumArtworkReader(ctx, aw, alOnlyExternal.CoverArtID(), nil)
 				Expect(err).ToNot(HaveOccurred())
 				_, path, err := aw.Reader(ctx)
@@ -111,7 +100,6 @@ var _ = Describe("Artwork", func() {
 				Expect(path).To(Equal("tests/fixtures/artist/an-album/front.png"))
 			})
 			It("returns ErrUnavailable if external file is not available", func() {
-				folderRepo.result = []model.Folder{}
 				aw, err := newAlbumArtworkReader(ctx, aw, alExternalNotFound.CoverArtID(), nil)
 				Expect(err).ToNot(HaveOccurred())
 				_, _, err = aw.Reader(ctx)
@@ -120,10 +108,6 @@ var _ = Describe("Artwork", func() {
 		})
 		Context("Multiple covers", func() {
 			BeforeEach(func() {
-				folderRepo.result = []model.Folder{{
-					Path:       "tests/fixtures/artist/an-album",
-					ImageFiles: []string{"cover.jpg", "front.png", "artist.png"},
-				}}
 				ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
 					alMultipleCovers,
 				})
@@ -146,10 +130,6 @@ var _ = Describe("Artwork", func() {
 	Describe("artistArtworkReader", func() {
 		Context("Multiple covers", func() {
 			BeforeEach(func() {
-				folderRepo.result = []model.Folder{{
-					Path:       "tests/fixtures/artist/an-album",
-					ImageFiles: []string{"artist.png"},
-				}}
 				ds.Artist(ctx).(*tests.MockArtistRepo).SetData(model.Artists{
 					arMultipleCovers,
 				})
@@ -163,7 +143,7 @@ var _ = Describe("Artwork", func() {
 			DescribeTable("ArtistArtPriority",
 				func(priority string, expected string) {
 					conf.Server.ArtistArtPriority = priority
-					aw, err := newArtistArtworkReader(ctx, aw, arMultipleCovers.CoverArtID(), nil)
+					aw, err := newArtistReader(ctx, aw, arMultipleCovers.CoverArtID(), nil)
 					Expect(err).ToNot(HaveOccurred())
 					_, path, err := aw.Reader(ctx)
 					Expect(err).ToNot(HaveOccurred())
@@ -177,16 +157,12 @@ var _ = Describe("Artwork", func() {
 	Describe("mediafileArtworkReader", func() {
 		Context("ID not found", func() {
 			It("returns ErrNotFound if mediafile is not in the DB", func() {
-				_, err := newMediafileArtworkReader(ctx, aw, model.MustParseArtworkID("mf-NOT-FOUND"))
+				_, err := newAlbumArtworkReader(ctx, aw, alMultipleCovers.CoverArtID(), nil)
 				Expect(err).To(MatchError(model.ErrNotFound))
 			})
 		})
 		Context("Embed images", func() {
 			BeforeEach(func() {
-				folderRepo.result = []model.Folder{{
-					Path:       "tests/fixtures/artist/an-album",
-					ImageFiles: []string{"front.png"},
-				}}
 				ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
 					alOnlyEmbed,
 					alOnlyExternal,
@@ -209,17 +185,11 @@ var _ = Describe("Artwork", func() {
 				Expect(err).ToNot(HaveOccurred())
 				r, path, err := aw.Reader(ctx)
 				Expect(err).ToNot(HaveOccurred())
-				data, _ := io.ReadAll(r)
-				Expect(data).ToNot(BeEmpty())
+				Expect(io.ReadAll(r)).To(Equal([]byte("content from ffmpeg")))
 				Expect(path).To(Equal("tests/fixtures/test.ogg"))
 			})
 			It("returns album cover if cannot read embed artwork", func() {
-				// Force fromTag to fail
-				mfCorruptedCover.Path = "tests/fixtures/DOES_NOT_EXIST.ogg"
-				Expect(ds.MediaFile(ctx).(*tests.MockMediaFileRepo).Put(&mfCorruptedCover)).To(Succeed())
-				// Simulate ffmpeg error
 				ffmpeg.Error = errors.New("not available")
-
 				aw, err := newMediafileArtworkReader(ctx, aw, mfCorruptedCover.CoverArtID())
 				Expect(err).ToNot(HaveOccurred())
 				_, path, err := aw.Reader(ctx)
@@ -237,10 +207,6 @@ var _ = Describe("Artwork", func() {
 	})
 	Describe("resizedArtworkReader", func() {
 		BeforeEach(func() {
-			folderRepo.result = []model.Folder{{
-				Path:       "tests/fixtures/artist/an-album",
-				ImageFiles: []string{"cover.jpg", "front.png"},
-			}}
 			ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
 				alMultipleCovers,
 			})
@@ -275,13 +241,12 @@ var _ = Describe("Artwork", func() {
 			DescribeTable("resize",
 				func(format string, landscape bool, size int) {
 					coverFileName := "cover." + format
-					dirName := createImage(format, landscape, size)
+					//dirName := createImage(format, landscape, size)
 					alCover = model.Album{
-						ID:        "444",
-						Name:      "Only external",
-						FolderIDs: []string{"tmp"},
+						ID:   "444",
+						Name: "Only external",
+						//ImageFiles: filepath.Join(dirName, coverFileName),
 					}
-					folderRepo.result = []model.Folder{{Path: dirName, ImageFiles: []string{coverFileName}}}
 					ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
 						alCover,
 					})
@@ -305,24 +270,24 @@ var _ = Describe("Artwork", func() {
 	})
 })
 
-func createImage(format string, landscape bool, size int) string {
-	var img image.Image
-
-	if landscape {
-		img = image.NewRGBA(image.Rect(0, 0, size, size/2))
-	} else {
-		img = image.NewRGBA(image.Rect(0, 0, size/2, size))
-	}
-
-	tmpDir := GinkgoT().TempDir()
-	f, _ := os.Create(filepath.Join(tmpDir, "cover."+format))
-	defer f.Close()
-	switch format {
-	case "png":
-		_ = png.Encode(f, img)
-	case "jpg":
-		_ = jpeg.Encode(f, img, &jpeg.Options{Quality: 75})
-	}
-
-	return tmpDir
-}
+//func createImage(format string, landscape bool, size int) string {
+//	var img image.Image
+//
+//	if landscape {
+//		img = image.NewRGBA(image.Rect(0, 0, size, size/2))
+//	} else {
+//		img = image.NewRGBA(image.Rect(0, 0, size/2, size))
+//	}
+//
+//	tmpDir := GinkgoT().TempDir()
+//	f, _ := os.Create(filepath.Join(tmpDir, "cover."+format))
+//	defer f.Close()
+//	switch format {
+//	case "png":
+//		_ = png.Encode(f, img)
+//	case "jpg":
+//		_ = jpeg.Encode(f, img, &jpeg.Options{Quality: 75})
+//	}
+//
+//	return tmpDir
+//}

core/artwork/cache_warmer.go

@@ -31,12 +31,6 @@ func NewCacheWarmer(artwork Artwork, cache cache.FileCache) CacheWarmer {
 		return &noopCacheWarmer{}
 	}
 
-	// If the file cache is disabled, return a NOOP implementation
-	if cache.Disabled(context.Background()) {
-		log.Debug("Image cache disabled. Cache warmer will not run")
-		return &noopCacheWarmer{}
-	}
-
 	a := &cacheWarmer{
 		artwork:    artwork,
 		cache:      cache,
@@ -59,9 +53,6 @@ type cacheWarmer struct {
 }
 
 func (a *cacheWarmer) PreCache(artID model.ArtworkID) {
-	if a.cache.Disabled(context.Background()) {
-		return
-	}
 	a.mutex.Lock()
 	defer a.mutex.Unlock()
 	a.buffer[artID] = struct{}{}
@@ -83,24 +74,10 @@ func (a *cacheWarmer) run(ctx context.Context) {
 			break
 		}
 
-		if a.cache.Disabled(ctx) {
-			a.mutex.Lock()
-			pending := len(a.buffer)
-			a.buffer = make(map[model.ArtworkID]struct{})
-			a.mutex.Unlock()
-			if pending > 0 {
-				log.Trace(ctx, "Cache disabled, discarding precache buffer", "bufferLen", pending)
-			}
-			return
-		}
-
 		// If cache not available, keep waiting
 		if !a.cache.Available(ctx) {
-			a.mutex.Lock()
-			bufferLen := len(a.buffer)
-			a.mutex.Unlock()
-			if bufferLen > 0 {
-				log.Trace(ctx, "Cache not available, buffering precache request", "bufferLen", bufferLen)
+			if len(a.buffer) > 0 {
+				log.Trace(ctx, "Cache not available, buffering precache request", "bufferLen", len(a.buffer))
 			}
 			continue
 		}

core/artwork/cache_warmer_test.go

@@ -1,222 +0,0 @@
-package artwork
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"strings"
-	"sync/atomic"
-	"time"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/conf/configtest"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/utils/cache"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("CacheWarmer", func() {
-	var (
-		fc *mockFileCache
-		aw *mockArtwork
-	)
-
-	BeforeEach(func() {
-		DeferCleanup(configtest.SetupConfig())
-		fc = &mockFileCache{}
-		aw = &mockArtwork{}
-	})
-
-	Context("initialization", func() {
-		It("returns noop when cache is disabled", func() {
-			fc.SetDisabled(true)
-			cw := NewCacheWarmer(aw, fc)
-			_, ok := cw.(*noopCacheWarmer)
-			Expect(ok).To(BeTrue())
-		})
-
-		It("returns noop when ImageCacheSize is 0", func() {
-			conf.Server.ImageCacheSize = "0"
-			cw := NewCacheWarmer(aw, fc)
-			_, ok := cw.(*noopCacheWarmer)
-			Expect(ok).To(BeTrue())
-		})
-
-		It("returns noop when EnableArtworkPrecache is false", func() {
-			conf.Server.EnableArtworkPrecache = false
-			cw := NewCacheWarmer(aw, fc)
-			_, ok := cw.(*noopCacheWarmer)
-			Expect(ok).To(BeTrue())
-		})
-
-		It("returns real implementation when properly configured", func() {
-			conf.Server.ImageCacheSize = "100MB"
-			conf.Server.EnableArtworkPrecache = true
-			fc.SetDisabled(false)
-			cw := NewCacheWarmer(aw, fc)
-			_, ok := cw.(*cacheWarmer)
-			Expect(ok).To(BeTrue())
-		})
-	})
-
-	Context("buffer management", func() {
-		BeforeEach(func() {
-			conf.Server.ImageCacheSize = "100MB"
-			conf.Server.EnableArtworkPrecache = true
-			fc.SetDisabled(false)
-		})
-
-		It("drops buffered items when cache becomes disabled", func() {
-			cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
-			cw.PreCache(model.MustParseArtworkID("al-test"))
-			fc.SetDisabled(true)
-			Eventually(func() int {
-				cw.mutex.Lock()
-				defer cw.mutex.Unlock()
-				return len(cw.buffer)
-			}).Should(Equal(0))
-		})
-
-		It("adds multiple items to 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-2"))
-			cw.mutex.Lock()
-			defer cw.mutex.Unlock()
-			Expect(len(cw.buffer)).To(Equal(2))
-		})
-
-		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"))
-			cw.mutex.Lock()
-			defer cw.mutex.Unlock()
-			Expect(len(cw.buffer)).To(Equal(1))
-		})
-	})
-
-	Context("error handling", func() {
-		BeforeEach(func() {
-			conf.Server.ImageCacheSize = "100MB"
-			conf.Server.EnableArtworkPrecache = true
-			fc.SetDisabled(false)
-		})
-
-		It("continues processing after artwork retrieval error", func() {
-			aw.err = errors.New("artwork error")
-			cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
-			cw.PreCache(model.MustParseArtworkID("al-error"))
-			cw.PreCache(model.MustParseArtworkID("al-1"))
-
-			Eventually(func() int {
-				cw.mutex.Lock()
-				defer cw.mutex.Unlock()
-				return len(cw.buffer)
-			}).Should(Equal(0))
-		})
-
-		It("continues processing after cache error", func() {
-			fc.err = errors.New("cache error")
-			cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
-			cw.PreCache(model.MustParseArtworkID("al-error"))
-			cw.PreCache(model.MustParseArtworkID("al-1"))
-
-			Eventually(func() int {
-				cw.mutex.Lock()
-				defer cw.mutex.Unlock()
-				return len(cw.buffer)
-			}).Should(Equal(0))
-		})
-	})
-
-	Context("background processing", func() {
-		BeforeEach(func() {
-			conf.Server.ImageCacheSize = "100MB"
-			conf.Server.EnableArtworkPrecache = true
-			fc.SetDisabled(false)
-		})
-
-		It("processes items in batches", func() {
-			cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
-			for i := 0; i < 5; i++ {
-				cw.PreCache(model.MustParseArtworkID(fmt.Sprintf("al-%d", i)))
-			}
-
-			Eventually(func() int {
-				cw.mutex.Lock()
-				defer cw.mutex.Unlock()
-				return len(cw.buffer)
-			}).Should(Equal(0))
-		})
-
-		It("wakes up on new items", func() {
-			cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
-
-			// Add first batch
-			cw.PreCache(model.MustParseArtworkID("al-1"))
-			Eventually(func() int {
-				cw.mutex.Lock()
-				defer cw.mutex.Unlock()
-				return len(cw.buffer)
-			}).Should(Equal(0))
-
-			// Add second batch
-			cw.PreCache(model.MustParseArtworkID("al-2"))
-			Eventually(func() int {
-				cw.mutex.Lock()
-				defer cw.mutex.Unlock()
-				return len(cw.buffer)
-			}).Should(Equal(0))
-		})
-	})
-})
-
-type mockArtwork struct {
-	err error
-}
-
-func (m *mockArtwork) Get(ctx context.Context, artID model.ArtworkID, size int, square bool) (io.ReadCloser, time.Time, error) {
-	if m.err != nil {
-		return nil, time.Time{}, m.err
-	}
-	return io.NopCloser(strings.NewReader("test")), time.Now(), nil
-}
-
-func (m *mockArtwork) GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (io.ReadCloser, time.Time, error) {
-	return m.Get(ctx, model.ArtworkID{}, size, square)
-}
-
-type mockFileCache struct {
-	disabled atomic.Bool
-	ready    atomic.Bool
-	err      error
-}
-
-func (f *mockFileCache) Get(ctx context.Context, item cache.Item) (*cache.CachedStream, error) {
-	if f.err != nil {
-		return nil, f.err
-	}
-	return &cache.CachedStream{Reader: io.NopCloser(strings.NewReader("cached"))}, nil
-}
-
-func (f *mockFileCache) Available(ctx context.Context) bool {
-	return f.ready.Load() && !f.disabled.Load()
-}
-
-func (f *mockFileCache) Disabled(ctx context.Context) bool {
-	return f.disabled.Load()
-}
-
-func (f *mockFileCache) SetDisabled(v bool) {
-	f.disabled.Store(v)
-	f.ready.Store(true)
-}
-
-func (f *mockFileCache) SetReady(v bool) {
-	f.ready.Store(v)
-}

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)
-	// by comparing base filenames without extensions
-	slices.SortFunc(imgFiles, compareImageFiles)
+	// This prioritizes files from lower-numbered disc folders by sorting the paths
+	slices.Sort(imgFiles)
 
 	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)
-			Expect(imgFiles).To(HaveLen(5))
+			// Check that image files are sorted alphabetically
+			Expect(imgFiles).To(HaveLen(4))
 
-			// Files should be sorted by base filename without extension, then by full path
-			// "back" < "cover", so back.jpg comes first
-			// Then all cover.jpg files, sorted by path
+			// The files should be sorted by full 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[3]).To(Equal(filepath.FromSlash("Artist/Album/Disc10/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")))
+			Expect(imgFiles[2]).To(Equal(filepath.FromSlash("Artist/Album/Disc10/cover.jpg")))
+			Expect(imgFiles[3]).To(Equal(filepath.FromSlash("Artist/Album/Disc2/cover.jpg")))
 		})
 	})
 })

core/artwork/reader_artist.go

@@ -8,7 +8,6 @@ import (
 	"io/fs"
 	"os"
 	"path/filepath"
-	"slices"
 	"strings"
 	"time"
 
@@ -21,12 +20,6 @@ import (
 	"github.com/navidrome/navidrome/utils/str"
 )
 
-const (
-	// maxArtistFolderTraversalDepth defines how many directory levels to search
-	// when looking for artist images (artist folder + parent directories)
-	maxArtistFolderTraversalDepth = 3
-)
-
 type artistReader struct {
 	cacheKey
 	a            *artwork
@@ -36,7 +29,7 @@ type artistReader struct {
 	imgFiles     []string
 }
 
-func newArtistArtworkReader(ctx context.Context, artwork *artwork, artID model.ArtworkID, provider external.Provider) (*artistReader, error) {
+func newArtistReader(ctx context.Context, artwork *artwork, artID model.ArtworkID, provider external.Provider) (*artistReader, error) {
 	ar, err := artwork.ds.Artist(ctx).Get(artID.ID)
 	if err != nil {
 		return nil, err
@@ -115,63 +108,36 @@ func (a *artistReader) fromArtistArtPriority(ctx context.Context, priority strin
 
 func fromArtistFolder(ctx context.Context, artistFolder string, pattern string) sourceFunc {
 	return func() (io.ReadCloser, string, error) {
-		current := artistFolder
-		for i := 0; i < maxArtistFolderTraversalDepth; i++ {
-			if reader, path, err := findImageInFolder(ctx, current, pattern); err == nil {
-				return reader, path, nil
-			}
-
-			parent := filepath.Dir(current)
-			if parent == current {
-				break
-			}
-			current = parent
-		}
-		return nil, "", fmt.Errorf(`no matches for '%s' in '%s' or its parent directories`, pattern, artistFolder)
-	}
-}
-
-func findImageInFolder(ctx context.Context, folder, pattern string) (io.ReadCloser, string, error) {
-	log.Trace(ctx, "looking for artist image", "pattern", pattern, "folder", folder)
-	fsys := os.DirFS(folder)
-	matches, err := fs.Glob(fsys, pattern)
-	if err != nil {
-		log.Warn(ctx, "Error matching artist image pattern", "pattern", pattern, "folder", folder, err)
-		return nil, "", err
-	}
-
-	// Filter to valid image files
-	var imagePaths []string
-	for _, m := range matches {
-		if !model.IsImageFile(m) {
-			continue
-		}
-		imagePaths = append(imagePaths, 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)
+		fsys := os.DirFS(artistFolder)
+		matches, err := fs.Glob(fsys, pattern)
 		if err != nil {
-			log.Warn(ctx, "Could not open cover art file", "file", filePath, err)
-			continue
+			log.Warn(ctx, "Error matching artist image pattern", "pattern", pattern, "folder", artistFolder)
+			return nil, "", err
 		}
-		return f, filePath, nil
+		if len(matches) == 0 {
+			return nil, "", fmt.Errorf(`no matches for '%s' in '%s'`, pattern, artistFolder)
+		}
+		for _, m := range matches {
+			filePath := filepath.Join(artistFolder, m)
+			if !model.IsImageFile(m) {
+				continue
+			}
+			f, err := os.Open(filePath)
+			if err != nil {
+				log.Warn(ctx, "Could not open cover art file", "file", filePath, err)
+				return nil, "", err
+			}
+			return f, filePath, nil
+		}
+		return nil, "", nil
 	}
-
-	return nil, "", fmt.Errorf(`no matches for '%s' in '%s'`, pattern, folder)
 }
 
 func loadArtistFolder(ctx context.Context, ds model.DataStore, albums model.Albums, paths []string) (string, time.Time, error) {
 	if len(albums) == 0 {
 		return "", time.Time{}, nil
 	}
-	libID := albums[0].LibraryID // Just need one of the albums, as they should all be in the same Library - for now! TODO: Support multiple libraries
+	libID := albums[0].LibraryID // Just need one of the albums, as they should all be in the same Library
 
 	folderPath := str.LongestCommonPrefix(paths)
 	if !strings.HasSuffix(folderPath, string(filepath.Separator)) {

core/artwork/reader_artist_test.go

@@ -3,8 +3,6 @@ package artwork
 import (
 	"context"
 	"errors"
-	"io"
-	"os"
 	"path/filepath"
 	"time"
 
@@ -14,7 +12,7 @@ import (
 	. "github.com/onsi/gomega"
 )
 
-var _ = Describe("artistArtworkReader", func() {
+var _ = Describe("artistReader", func() {
 	var _ = Describe("loadArtistFolder", func() {
 		var (
 			ctx             context.Context
@@ -110,309 +108,6 @@ var _ = Describe("artistArtworkReader", func() {
 			})
 		})
 	})
-
-	var _ = Describe("fromArtistFolder", func() {
-		var (
-			ctx      context.Context
-			tempDir  string
-			testFunc sourceFunc
-		)
-
-		BeforeEach(func() {
-			ctx = context.Background()
-			tempDir = GinkgoT().TempDir()
-		})
-
-		When("artist folder contains matching image", func() {
-			BeforeEach(func() {
-				// Create test structure: /temp/artist/artist.jpg
-				artistDir := filepath.Join(tempDir, "artist")
-				Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
-				artistImagePath := filepath.Join(artistDir, "artist.jpg")
-				Expect(os.WriteFile(artistImagePath, []byte("fake image data"), 0600)).To(Succeed())
-
-				testFunc = fromArtistFolder(ctx, artistDir, "artist.*")
-			})
-
-			It("finds and returns the image", func() {
-				reader, path, err := testFunc()
-				Expect(err).ToNot(HaveOccurred())
-				Expect(reader).ToNot(BeNil())
-				Expect(path).To(ContainSubstring("artist.jpg"))
-
-				// Verify we can read the content
-				data, err := io.ReadAll(reader)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(string(data)).To(Equal("fake image data"))
-				reader.Close()
-			})
-		})
-
-		When("artist folder is empty but parent contains image", func() {
-			BeforeEach(func() {
-				// Create test structure: /temp/parent/artist.jpg and /temp/parent/artist/album/
-				parentDir := filepath.Join(tempDir, "parent")
-				artistDir := filepath.Join(parentDir, "artist")
-				albumDir := filepath.Join(artistDir, "album")
-				Expect(os.MkdirAll(albumDir, 0755)).To(Succeed())
-
-				// Put artist image in parent directory
-				artistImagePath := filepath.Join(parentDir, "artist.jpg")
-				Expect(os.WriteFile(artistImagePath, []byte("parent image"), 0600)).To(Succeed())
-
-				testFunc = fromArtistFolder(ctx, artistDir, "artist.*")
-			})
-
-			It("finds image in parent directory", func() {
-				reader, path, err := testFunc()
-				Expect(err).ToNot(HaveOccurred())
-				Expect(reader).ToNot(BeNil())
-				Expect(path).To(ContainSubstring("parent" + string(filepath.Separator) + "artist.jpg"))
-
-				data, err := io.ReadAll(reader)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(string(data)).To(Equal("parent image"))
-				reader.Close()
-			})
-		})
-
-		When("image is two levels up", func() {
-			BeforeEach(func() {
-				// Create test structure: /temp/grandparent/artist.jpg and /temp/grandparent/parent/artist/
-				grandparentDir := filepath.Join(tempDir, "grandparent")
-				parentDir := filepath.Join(grandparentDir, "parent")
-				artistDir := filepath.Join(parentDir, "artist")
-				Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
-				// Put artist image in grandparent directory
-				artistImagePath := filepath.Join(grandparentDir, "artist.jpg")
-				Expect(os.WriteFile(artistImagePath, []byte("grandparent image"), 0600)).To(Succeed())
-
-				testFunc = fromArtistFolder(ctx, artistDir, "artist.*")
-			})
-
-			It("finds image in grandparent directory", func() {
-				reader, path, err := testFunc()
-				Expect(err).ToNot(HaveOccurred())
-				Expect(reader).ToNot(BeNil())
-				Expect(path).To(ContainSubstring("grandparent" + string(filepath.Separator) + "artist.jpg"))
-
-				data, err := io.ReadAll(reader)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(string(data)).To(Equal("grandparent image"))
-				reader.Close()
-			})
-		})
-
-		When("images exist at multiple levels", func() {
-			BeforeEach(func() {
-				// Create test structure with images at multiple levels
-				grandparentDir := filepath.Join(tempDir, "grandparent")
-				parentDir := filepath.Join(grandparentDir, "parent")
-				artistDir := filepath.Join(parentDir, "artist")
-				Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
-				// Put artist images at all levels
-				Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("artist level"), 0600)).To(Succeed())
-				Expect(os.WriteFile(filepath.Join(parentDir, "artist.jpg"), []byte("parent level"), 0600)).To(Succeed())
-				Expect(os.WriteFile(filepath.Join(grandparentDir, "artist.jpg"), []byte("grandparent level"), 0600)).To(Succeed())
-
-				testFunc = fromArtistFolder(ctx, artistDir, "artist.*")
-			})
-
-			It("prioritizes the closest (artist folder) image", func() {
-				reader, path, err := testFunc()
-				Expect(err).ToNot(HaveOccurred())
-				Expect(reader).ToNot(BeNil())
-				Expect(path).To(ContainSubstring("artist" + string(filepath.Separator) + "artist.jpg"))
-
-				data, err := io.ReadAll(reader)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(string(data)).To(Equal("artist level"))
-				reader.Close()
-			})
-		})
-
-		When("pattern matches multiple files", func() {
-			BeforeEach(func() {
-				artistDir := filepath.Join(tempDir, "artist")
-				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())
-
-				testFunc = fromArtistFolder(ctx, artistDir, "artist.*")
-			})
-
-			It("returns the first valid image file in sorted order", func() {
-				reader, path, err := testFunc()
-				Expect(err).ToNot(HaveOccurred())
-				Expect(reader).ToNot(BeNil())
-
-				// Should return an image file,
-				// Files are sorted: jpg comes before png alphabetically.
-				// .abc comes first, but it's not an image.
-				Expect(path).To(ContainSubstring("artist.jpg"))
-				reader.Close()
-			})
-		})
-
-		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()
-			})
-		})
-
-		When("no matching files exist anywhere", func() {
-			BeforeEach(func() {
-				artistDir := filepath.Join(tempDir, "artist")
-				Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
-				// Create non-matching files
-				Expect(os.WriteFile(filepath.Join(artistDir, "cover.jpg"), []byte("cover image"), 0600)).To(Succeed())
-
-				testFunc = fromArtistFolder(ctx, artistDir, "artist.*")
-			})
-
-			It("returns an error", func() {
-				reader, path, err := testFunc()
-				Expect(err).To(HaveOccurred())
-				Expect(reader).To(BeNil())
-				Expect(path).To(BeEmpty())
-				Expect(err.Error()).To(ContainSubstring("no matches for 'artist.*'"))
-				Expect(err.Error()).To(ContainSubstring("parent directories"))
-			})
-		})
-
-		When("directory traversal reaches filesystem root", func() {
-			BeforeEach(func() {
-				// Start from a shallow directory to test root boundary
-				artistDir := filepath.Join(tempDir, "artist")
-				Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
-				testFunc = fromArtistFolder(ctx, artistDir, "artist.*")
-			})
-
-			It("handles root boundary gracefully", func() {
-				reader, path, err := testFunc()
-				Expect(err).To(HaveOccurred())
-				Expect(reader).To(BeNil())
-				Expect(path).To(BeEmpty())
-				// Should not panic or cause infinite loop
-			})
-		})
-
-		When("file exists but cannot be opened", func() {
-			BeforeEach(func() {
-				artistDir := filepath.Join(tempDir, "artist")
-				Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
-				// Create a file that cannot be opened (permission denied)
-				restrictedFile := filepath.Join(artistDir, "artist.jpg")
-				Expect(os.WriteFile(restrictedFile, []byte("restricted"), 0600)).To(Succeed())
-
-				testFunc = fromArtistFolder(ctx, artistDir, "artist.*")
-			})
-
-			It("logs warning and continues searching", func() {
-				// This test depends on the ability to restrict file permissions
-				// For now, we'll just ensure it doesn't panic and returns appropriate error
-				reader, _, err := testFunc()
-				// The file should be readable in test environment, so this will succeed
-				// In a real scenario with permission issues, it would continue searching
-				if err == nil {
-					Expect(reader).ToNot(BeNil())
-					reader.Close()
-				}
-			})
-		})
-
-		When("single album artist scenario (original issue)", func() {
-			BeforeEach(func() {
-				// Simulate the exact folder structure from the issue:
-				// /music/artist/album1/ (single album)
-				// /music/artist/artist.jpg (artist image that should be found)
-				artistDir := filepath.Join(tempDir, "music", "artist")
-				albumDir := filepath.Join(artistDir, "album1")
-				Expect(os.MkdirAll(albumDir, 0755)).To(Succeed())
-
-				// Create artist.jpg in the artist folder (this was not being found before)
-				artistImagePath := filepath.Join(artistDir, "artist.jpg")
-				Expect(os.WriteFile(artistImagePath, []byte("single album artist image"), 0600)).To(Succeed())
-
-				// The fromArtistFolder is called with the artist folder path
-				testFunc = fromArtistFolder(ctx, artistDir, "artist.*")
-			})
-
-			It("finds artist.jpg in artist folder for single album artist", func() {
-				reader, path, err := testFunc()
-				Expect(err).ToNot(HaveOccurred())
-				Expect(reader).ToNot(BeNil())
-				Expect(path).To(ContainSubstring("artist.jpg"))
-				Expect(path).To(ContainSubstring("artist"))
-
-				// Verify the content
-				data, err := io.ReadAll(reader)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(string(data)).To(Equal("single album artist image"))
-				reader.Close()
-			})
-		})
-	})
 })
 
 type fakeFolderRepo struct {

core/artwork/sources.go

@@ -182,14 +182,13 @@ 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
 	}
 	if resp.StatusCode != http.StatusOK {
 		resp.Body.Close()
-		return nil, "", fmt.Errorf("error retrieving artwork from %s: %s", imageUrl, resp.Status)
+		return nil, "", fmt.Errorf("error retrieveing artwork from %s: %s", imageUrl, resp.Status)
 	}
 	return resp.Body, imageUrl.String(), nil
 }

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

@@ -190,13 +190,10 @@ type mockAgents struct {
 	topSongsAgent  agents.ArtistTopSongsRetriever
 	similarAgent   agents.ArtistSimilarRetriever
 	imageAgent     agents.ArtistImageRetriever
-	albumInfoAgent interface {
-		agents.AlbumInfoRetriever
-		agents.AlbumImageRetriever
-	}
-	bioAgent  agents.ArtistBiographyRetriever
-	mbidAgent agents.ArtistMBIDRetriever
-	urlAgent  agents.ArtistURLRetriever
+	albumInfoAgent agents.AlbumInfoRetriever
+	bioAgent       agents.ArtistBiographyRetriever
+	mbidAgent      agents.ArtistMBIDRetriever
+	urlAgent       agents.ArtistURLRetriever
 	agents.Interface
 }
 
@@ -271,14 +268,3 @@ func (m *mockAgents) GetArtistImages(ctx context.Context, id, name, mbid string)
 	}
 	return nil, args.Error(1)
 }
-
-func (m *mockAgents) GetAlbumImages(ctx context.Context, name, artist, mbid string) ([]agents.ExternalImage, error) {
-	if m.albumInfoAgent != nil {
-		return m.albumInfoAgent.GetAlbumImages(ctx, name, artist, mbid)
-	}
-	args := m.Called(ctx, name, artist, mbid)
-	if args.Get(0) != nil {
-		return args.Get(0).([]agents.ExternalImage), args.Error(1)
-	}
-	return nil, args.Error(1)
-}

core/external/provider.go

@@ -3,7 +3,6 @@ package external
 import (
 	"context"
 	"errors"
-	"fmt"
 	"net/url"
 	"sort"
 	"strings"
@@ -12,9 +11,9 @@ 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/mcp"
 	_ "github.com/navidrome/navidrome/core/agents/spotify"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
@@ -36,7 +35,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)
-	ArtistRadio(ctx context.Context, id string, count int) (model.MediaFiles, error)
+	SimilarSongs(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)
@@ -51,33 +50,16 @@ type provider struct {
 
 type auxAlbum struct {
 	model.Album
-}
-
-// Name returns the appropriate album name for external API calls
-// based on the DevPreserveUnicodeInExternalCalls configuration option
-func (a *auxAlbum) Name() string {
-	if conf.Server.DevPreserveUnicodeInExternalCalls {
-		return a.Album.Name
-	}
-	return str.Clear(a.Album.Name)
+	Name string
 }
 
 type auxArtist struct {
 	model.Artist
-}
-
-// Name returns the appropriate artist name for external API calls
-// based on the DevPreserveUnicodeInExternalCalls configuration option
-func (a *auxArtist) Name() string {
-	if conf.Server.DevPreserveUnicodeInExternalCalls {
-		return a.Artist.Name
-	}
-	return str.Clear(a.Artist.Name)
+	Name string
 }
 
 type Agents interface {
 	agents.AlbumInfoRetriever
-	agents.AlbumImageRetriever
 	agents.ArtistBiographyRetriever
 	agents.ArtistMBIDRetriever
 	agents.ArtistImageRetriever
@@ -104,6 +86,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:
@@ -121,9 +104,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
@@ -132,7 +114,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)
 	}
 
@@ -141,13 +123,12 @@ func (e *provider) UpdateAlbumInfo(ctx context.Context, id string) (*model.Album
 
 func (e *provider) populateAlbumInfo(ctx context.Context, album auxAlbum) (auxAlbum, error) {
 	start := time.Now()
-	albumName := album.Name()
-	info, err := e.ag.GetAlbumInfo(ctx, albumName, album.AlbumArtist, album.MbzAlbumID)
+	info, err := e.ag.GetAlbumInfo(ctx, album.Name, album.AlbumArtist, album.MbzAlbumID)
 	if errors.Is(err, agents.ErrNotFound) {
 		return album, nil
 	}
 	if err != nil {
-		log.Error("Error refreshing AlbumInfo", "id", album.ID, "name", albumName, "artist", album.AlbumArtist,
+		log.Error("Error refreshing AlbumInfo", "id", album.ID, "name", album.Name, "artist", album.AlbumArtist,
 			"elapsed", time.Since(start), err)
 		return album, err
 	}
@@ -159,26 +140,25 @@ 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)
-	if err == nil && len(images) > 0 {
-		sort.Slice(images, func(i, j int) bool {
-			return images[i].Size > images[j].Size
+	if len(info.Images) > 0 {
+		sort.Slice(info.Images, func(i, j int) bool {
+			return info.Images[i].Size > info.Images[j].Size
 		})
 
-		album.LargeImageUrl = images[0].URL
+		album.LargeImageUrl = info.Images[0].URL
 
-		if len(images) >= 2 {
-			album.MediumImageUrl = images[1].URL
+		if len(info.Images) >= 2 {
+			album.MediumImageUrl = info.Images[1].URL
 		}
 
-		if len(images) >= 3 {
-			album.SmallImageUrl = images[2].URL
+		if len(info.Images) >= 3 {
+			album.SmallImageUrl = info.Images[2].URL
 		}
 	}
 
 	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))
@@ -198,6 +178,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:
@@ -226,9 +207,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
@@ -237,7 +217,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
@@ -246,9 +226,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
 		}
@@ -264,14 +243,14 @@ func (e *provider) populateArtistInfo(ctx context.Context, artist auxArtist) (au
 	_ = 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))
@@ -279,7 +258,7 @@ func (e *provider) populateArtistInfo(ctx context.Context, artist auxArtist) (au
 	return artist, nil
 }
 
-func (e *provider) ArtistRadio(ctx context.Context, id string, count int) (model.MediaFiles, error) {
+func (e *provider) SimilarSongs(ctx context.Context, id string, count int) (model.MediaFiles, error) {
 	artist, err := e.getArtist(ctx, id)
 	if err != nil {
 		return nil, err
@@ -287,19 +266,19 @@ func (e *provider) ArtistRadio(ctx context.Context, id string, count int) (model
 
 	e.callGetSimilar(ctx, e.ag, &artist, 15, false)
 	if utils.IsCtxDone(ctx) {
-		log.Warn(ctx, "ArtistRadio call canceled", ctx.Err())
+		log.Warn(ctx, "SimilarSongs 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, "ArtistRadio call canceled", ctx.Err())
+			log.Warn(ctx, "SimilarSongs 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
@@ -362,29 +341,29 @@ func (e *provider) AlbumImage(ctx context.Context, id string) (*url.URL, error)
 		return nil, err
 	}
 
-	albumName := album.Name()
-	images, err := e.ag.GetAlbumImages(ctx, albumName, album.AlbumArtist, album.MbzAlbumID)
+	info, err := e.ag.GetAlbumInfo(ctx, album.Name, album.AlbumArtist, album.MbzAlbumID)
 	if err != nil {
 		switch {
 		case errors.Is(err, agents.ErrNotFound):
-			log.Trace(ctx, "Album not found in agent", "albumID", id, "name", albumName, "artist", album.AlbumArtist)
+			log.Trace(ctx, "Album not found in agent", "albumID", id, "name", album.Name, "artist", album.AlbumArtist)
 			return nil, model.ErrNotFound
 		case errors.Is(err, context.Canceled):
-			log.Debug(ctx, "GetAlbumImages call canceled", err)
+			log.Debug(ctx, "GetAlbumInfo 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 info 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)
+	if info == nil {
+		log.Warn(ctx, "Agent returned nil info without error", "albumID", id, "name", album.Name, "artist", album.AlbumArtist)
 		return nil, model.ErrNotFound
 	}
 
 	// Return the biggest image
 	var img agents.ExternalImage
-	for _, i := range images {
+	for _, i := range info.Images {
 		if img.Size <= i.Size {
 			img = i
 		}
@@ -420,125 +399,64 @@ func (e *provider) TopSongs(ctx context.Context, artistName string, count int) (
 }
 
 func (e *provider) getMatchingTopSongs(ctx context.Context, agent agents.ArtistTopSongsRetriever, artist *auxArtist, count int) (model.MediaFiles, error) {
-	artistName := artist.Name()
-	songs, err := agent.GetArtistTopSongs(ctx, artist.ID, artistName, artist.MbzArtistID, count)
+	songs, err := agent.GetArtistTopSongs(ctx, artist.ID, artist.Name, artist.MbzArtistID, count)
 	if err != nil {
-		return nil, fmt.Errorf("failed to get top songs for artist %s: %w", artistName, err)
+		return nil, err
 	}
 
-	mbidMatches, err := e.loadTracksByMBID(ctx, songs)
-	if err != nil {
-		return nil, fmt.Errorf("failed to load tracks by MBID: %w", err)
+	var mfs model.MediaFiles
+	for _, t := range songs {
+		mf, err := e.findMatchingTrack(ctx, t.MBID, artist.ID, t.Name)
+		if err != nil {
+			continue
+		}
+		mfs = append(mfs, *mf)
+		if len(mfs) == count {
+			break
+		}
 	}
-	titleMatches, err := e.loadTracksByTitle(ctx, songs, artist, mbidMatches)
-	if err != nil {
-		return nil, fmt.Errorf("failed to load tracks by title: %w", err)
-	}
-
-	log.Trace(ctx, "Top Songs loaded", "name", artistName, "numSongs", len(songs), "numMBIDMatches", len(mbidMatches), "numTitleMatches", len(titleMatches))
-	mfs := e.selectTopSongs(songs, mbidMatches, titleMatches, count)
-
 	if len(mfs) == 0 {
-		log.Debug(ctx, "No matching top songs found", "name", artistName)
+		log.Debug(ctx, "No matching top songs found", "name", artist.Name)
 	} else {
-		log.Debug(ctx, "Found matching top songs", "name", artistName, "numSongs", len(mfs))
+		log.Debug(ctx, "Found matching top songs", "name", artist.Name, "numSongs", len(mfs))
 	}
 
 	return mfs, nil
 }
 
-func (e *provider) loadTracksByMBID(ctx context.Context, songs []agents.Song) (map[string]model.MediaFile, error) {
-	var mbids []string
-	for _, s := range songs {
-		if s.MBID != "" {
-			mbids = append(mbids, s.MBID)
+func (e *provider) findMatchingTrack(ctx context.Context, mbid string, artistID, title string) (*model.MediaFile, error) {
+	if mbid != "" {
+		mfs, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+			Filters: squirrel.And{
+				squirrel.Eq{"mbz_recording_id": mbid},
+				squirrel.Eq{"missing": false},
+			},
+		})
+		if err == nil && len(mfs) > 0 {
+			return &mfs[0], nil
 		}
+		return e.findMatchingTrack(ctx, "", artistID, title)
 	}
-	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{
+	mfs, 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},
+				squirrel.Eq{"artist_id": artistID},
+				squirrel.Eq{"album_artist_id": artistID},
 			},
-			titleFilters,
+			squirrel.Like{"order_title": str.SanitizeFieldForSorting(title)},
 			squirrel.Eq{"missing": false},
 		},
 		Sort: "starred desc, rating desc, year asc, compilation asc ",
+		Max:  1,
 	})
-	if err != nil {
-		return matches, err
+	if err != nil || len(mfs) == 0 {
+		return nil, model.ErrNotFound
 	}
-	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
+	return &mfs[0], nil
 }
 
 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
 	}
@@ -546,7 +464,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
 	}
@@ -556,7 +474,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
 	}
@@ -575,21 +493,20 @@ func (e *provider) callGetImage(ctx context.Context, agent agents.ArtistImageRet
 
 func (e *provider) callGetSimilar(ctx context.Context, agent agents.ArtistSimilarRetriever, artist *auxArtist,
 	limit int, includeNotPresent bool) {
-	artistName := artist.Name()
-	similar, err := agent.GetSimilarArtists(ctx, artist.ID, artistName, artist.MbzArtistID, limit)
+	similar, err := agent.GetSimilarArtists(ctx, artist.ID, artist.Name, artist.MbzArtistID, limit)
 	if len(similar) == 0 || err != nil {
 		return
 	}
 	start := time.Now()
-	sa, err := e.mapSimilarArtists(ctx, similar, limit, includeNotPresent)
-	log.Debug(ctx, "Mapped Similar Artists", "artist", artistName, "numSimilar", len(sa), "elapsed", time.Since(start))
+	sa, err := e.mapSimilarArtists(ctx, similar, includeNotPresent)
+	log.Debug(ctx, "Mapped Similar Artists", "artist", artist.Name, "numSimilar", len(sa), "elapsed", time.Since(start))
 	if err != nil {
 		return
 	}
 	artist.SimilarArtists = sa
 }
 
-func (e *provider) mapSimilarArtists(ctx context.Context, similar []agents.Artist, limit int, includeNotPresent bool) (model.Artists, error) {
+func (e *provider) mapSimilarArtists(ctx context.Context, similar []agents.Artist, includeNotPresent bool) (model.Artists, error) {
 	var result model.Artists
 	var notPresent []string
 
@@ -612,33 +529,21 @@ func (e *provider) mapSimilarArtists(ctx context.Context, similar []agents.Artis
 		artistMap[artist.Name] = artist
 	}
 
-	count := 0
-
 	// Process the similar artists
 	for _, s := range similar {
 		if artist, found := artistMap[s.Name]; found {
 			result = append(result, artist)
-			count++
-
-			if count >= limit {
-				break
-			}
 		} else {
 			notPresent = append(notPresent, s.Name)
 		}
 	}
 
 	// Then fill up with non-present artists
-	if includeNotPresent && count < limit {
+	if includeNotPresent {
 		for _, s := range notPresent {
 			// Let the ID empty to indicate that the artist is not present in the DB
 			sa := model.Artist{Name: s}
 			result = append(result, sa)
-
-			count++
-			if count >= limit {
-				break
-			}
 		}
 	}
 
@@ -656,7 +561,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 {
@@ -672,7 +581,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

@@ -23,6 +23,7 @@ var _ = Describe("Provider - AlbumImage", func() {
 	var mockAlbumRepo *mockAlbumRepo
 	var mockMediaFileRepo *mockMediaFileRepo
 	var mockAlbumAgent *mockAlbumInfoAgent
+	var agentsCombined *mockAgents
 	var ctx context.Context
 
 	BeforeEach(func() {
@@ -42,7 +43,10 @@ var _ = Describe("Provider - AlbumImage", func() {
 
 		mockAlbumAgent = newMockAlbumInfoAgent()
 
-		agentsCombined := &mockAgents{albumInfoAgent: mockAlbumAgent}
+		agentsCombined = &mockAgents{
+			albumInfoAgent: mockAlbumAgent,
+		}
+
 		provider = NewProvider(ds, agentsCombined)
 
 		// Default mocks
@@ -62,11 +66,13 @@ var _ = Describe("Provider - AlbumImage", func() {
 		mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once() // Expect GetEntityByID sequence
 		mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()
 		// Explicitly mock agent call for this test
-		mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").
-			Return([]agents.ExternalImage{
-				{URL: "http://example.com/large.jpg", Size: 1000},
-				{URL: "http://example.com/medium.jpg", Size: 500},
-				{URL: "http://example.com/small.jpg", Size: 200},
+		mockAlbumAgent.On("GetAlbumInfo", ctx, "Album One", "", "").
+			Return(&agents.AlbumInfo{
+				Images: []agents.ExternalImage{
+					{URL: "http://example.com/large.jpg", Size: 1000},
+					{URL: "http://example.com/medium.jpg", Size: 500},
+					{URL: "http://example.com/small.jpg", Size: 200},
+				},
 			}, nil).Once()
 
 		expectedURL, _ := url.Parse("http://example.com/large.jpg")
@@ -76,8 +82,8 @@ var _ = Describe("Provider - AlbumImage", func() {
 		Expect(imgURL).To(Equal(expectedURL))
 		mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1") // From GetEntityByID
 		mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")
-		mockArtistRepo.AssertNotCalled(GinkgoT(), "Get", "artist-1")                       // Artist lookup no longer happens in getAlbum
-		mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "") // Expect empty artist name
+		mockArtistRepo.AssertNotCalled(GinkgoT(), "Get", "artist-1")                     // Artist lookup no longer happens in getAlbum
+		mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumInfo", ctx, "Album One", "", "") // Expect empty artist name
 	})
 
 	It("returns ErrNotFound if the album is not found in the DB", func() {
@@ -93,7 +99,7 @@ var _ = Describe("Provider - AlbumImage", func() {
 		mockArtistRepo.AssertCalled(GinkgoT(), "Get", "not-found")
 		mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "not-found")
 		mockMediaFileRepo.AssertCalled(GinkgoT(), "Get", "not-found")
-		mockAlbumAgent.AssertNotCalled(GinkgoT(), "GetAlbumImages", mock.Anything, mock.Anything, mock.Anything)
+		mockAlbumAgent.AssertNotCalled(GinkgoT(), "GetAlbumInfo", mock.Anything, mock.Anything, mock.Anything, mock.Anything)
 	})
 
 	It("returns the agent error if the agent fails", func() {
@@ -103,7 +109,7 @@ var _ = Describe("Provider - AlbumImage", func() {
 
 		agentErr := errors.New("agent failure")
 		// Explicitly mock agent call for this test
-		mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").Return(nil, agentErr).Once() // Expect empty artist
+		mockAlbumAgent.On("GetAlbumInfo", ctx, "Album One", "", "").Return(nil, agentErr).Once() // Expect empty artist
 
 		imgURL, err := provider.AlbumImage(ctx, "album-1")
 
@@ -112,7 +118,7 @@ var _ = Describe("Provider - AlbumImage", func() {
 		mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1")
 		mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")
 		mockArtistRepo.AssertNotCalled(GinkgoT(), "Get", "artist-1")
-		mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "") // Expect empty artist
+		mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumInfo", ctx, "Album One", "", "") // Expect empty artist
 	})
 
 	It("returns ErrNotFound if the agent returns ErrNotFound", func() {
@@ -121,7 +127,7 @@ var _ = Describe("Provider - AlbumImage", func() {
 		mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()
 
 		// Explicitly mock agent call for this test
-		mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").Return(nil, agents.ErrNotFound).Once() // Expect empty artist
+		mockAlbumAgent.On("GetAlbumInfo", ctx, "Album One", "", "").Return(nil, agents.ErrNotFound).Once() // Expect empty artist
 
 		imgURL, err := provider.AlbumImage(ctx, "album-1")
 
@@ -129,7 +135,7 @@ var _ = Describe("Provider - AlbumImage", func() {
 		Expect(imgURL).To(BeNil())
 		mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1")
 		mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")
-		mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "") // Expect empty artist
+		mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumInfo", ctx, "Album One", "", "") // Expect empty artist
 	})
 
 	It("returns ErrNotFound if the agent returns no images", func() {
@@ -138,8 +144,8 @@ var _ = Describe("Provider - AlbumImage", func() {
 		mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()
 
 		// Explicitly mock agent call for this test
-		mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").
-			Return([]agents.ExternalImage{}, nil).Once() // Expect empty artist
+		mockAlbumAgent.On("GetAlbumInfo", ctx, "Album One", "", "").
+			Return(&agents.AlbumInfo{Images: []agents.ExternalImage{}}, nil).Once() // Expect empty artist
 
 		imgURL, err := provider.AlbumImage(ctx, "album-1")
 
@@ -147,7 +153,7 @@ var _ = Describe("Provider - AlbumImage", func() {
 		Expect(imgURL).To(BeNil())
 		mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1")
 		mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")
-		mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "") // Expect empty artist
+		mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumInfo", ctx, "Album One", "", "") // Expect empty artist
 	})
 
 	It("returns context error if context is canceled", func() {
@@ -157,7 +163,7 @@ var _ = Describe("Provider - AlbumImage", func() {
 		mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once()
 		mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()
 		// Expect the agent call even if context is cancelled, returning the context error
-		mockAlbumAgent.On("GetAlbumImages", cctx, "Album One", "", "").Return(nil, context.Canceled).Once()
+		mockAlbumAgent.On("GetAlbumInfo", cctx, "Album One", "", "").Return(nil, context.Canceled).Once()
 		// Cancel the context *before* calling the function under test
 		cancelCtx()
 
@@ -168,7 +174,7 @@ var _ = Describe("Provider - AlbumImage", func() {
 		mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1")
 		mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")
 		// Agent should now be called, verify this expectation
-		mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", cctx, "Album One", "", "")
+		mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumInfo", cctx, "Album One", "", "")
 	})
 
 	It("derives album ID from MediaFile ID", func() {
@@ -180,11 +186,13 @@ var _ = Describe("Provider - AlbumImage", func() {
 		mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()
 
 		// Explicitly mock agent call for this test
-		mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").
-			Return([]agents.ExternalImage{
-				{URL: "http://example.com/large.jpg", Size: 1000},
-				{URL: "http://example.com/medium.jpg", Size: 500},
-				{URL: "http://example.com/small.jpg", Size: 200},
+		mockAlbumAgent.On("GetAlbumInfo", ctx, "Album One", "", "").
+			Return(&agents.AlbumInfo{
+				Images: []agents.ExternalImage{
+					{URL: "http://example.com/large.jpg", Size: 1000},
+					{URL: "http://example.com/medium.jpg", Size: 500},
+					{URL: "http://example.com/small.jpg", Size: 200},
+				},
 			}, nil).Once()
 
 		expectedURL, _ := url.Parse("http://example.com/large.jpg")
@@ -198,7 +206,7 @@ var _ = Describe("Provider - AlbumImage", func() {
 		mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1")
 		mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")
 		mockArtistRepo.AssertNotCalled(GinkgoT(), "Get", "artist-1")
-		mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "")
+		mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumInfo", ctx, "Album One", "", "")
 	})
 
 	It("handles different image orders from agent", func() {
@@ -206,11 +214,13 @@ var _ = Describe("Provider - AlbumImage", func() {
 		mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once() // Expect GetEntityByID sequence
 		mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()
 		// Explicitly mock agent call for this test
-		mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").
-			Return([]agents.ExternalImage{
-				{URL: "http://example.com/small.jpg", Size: 200},
-				{URL: "http://example.com/large.jpg", Size: 1000},
-				{URL: "http://example.com/medium.jpg", Size: 500},
+		mockAlbumAgent.On("GetAlbumInfo", ctx, "Album One", "", "").
+			Return(&agents.AlbumInfo{
+				Images: []agents.ExternalImage{
+					{URL: "http://example.com/small.jpg", Size: 200},
+					{URL: "http://example.com/large.jpg", Size: 1000},
+					{URL: "http://example.com/medium.jpg", Size: 500},
+				},
 			}, nil).Once()
 
 		expectedURL, _ := url.Parse("http://example.com/large.jpg")
@@ -218,7 +228,7 @@ var _ = Describe("Provider - AlbumImage", func() {
 
 		Expect(err).ToNot(HaveOccurred())
 		Expect(imgURL).To(Equal(expectedURL)) // Should still pick the largest
-		mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "")
+		mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumInfo", ctx, "Album One", "", "")
 	})
 
 	It("handles agent returning only one image", func() {
@@ -226,9 +236,11 @@ var _ = Describe("Provider - AlbumImage", func() {
 		mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once() // Expect GetEntityByID sequence
 		mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()
 		// Explicitly mock agent call for this test
-		mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").
-			Return([]agents.ExternalImage{
-				{URL: "http://example.com/single.jpg", Size: 700},
+		mockAlbumAgent.On("GetAlbumInfo", ctx, "Album One", "", "").
+			Return(&agents.AlbumInfo{
+				Images: []agents.ExternalImage{
+					{URL: "http://example.com/single.jpg", Size: 700},
+				},
 			}, nil).Once()
 
 		expectedURL, _ := url.Parse("http://example.com/single.jpg")
@@ -236,7 +248,7 @@ var _ = Describe("Provider - AlbumImage", func() {
 
 		Expect(err).ToNot(HaveOccurred())
 		Expect(imgURL).To(Equal(expectedURL))
-		mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "")
+		mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumInfo", ctx, "Album One", "", "")
 	})
 
 	It("returns ErrNotFound if deriving album ID fails", func() {
@@ -258,78 +270,14 @@ var _ = Describe("Provider - AlbumImage", func() {
 		mockArtistRepo.AssertCalled(GinkgoT(), "Get", "not-found")
 		mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "not-found")
 		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, "", "")
-			})
-		})
+		mockAlbumAgent.AssertNotCalled(GinkgoT(), "GetAlbumInfo", mock.Anything, mock.Anything, mock.Anything, mock.Anything)
 	})
 })
 
 // mockAlbumInfoAgent implementation
 type mockAlbumInfoAgent struct {
 	mock.Mock
-	agents.AlbumInfoRetriever
-	agents.AlbumImageRetriever
+	agents.AlbumInfoRetriever // Embed interface
 }
 
 func newMockAlbumInfoAgent() *mockAlbumInfoAgent {
@@ -351,14 +299,5 @@ func (m *mockAlbumInfoAgent) GetAlbumInfo(ctx context.Context, name, artist, mbi
 	return args.Get(0).(*agents.AlbumInfo), args.Error(1)
 }
 
-func (m *mockAlbumInfoAgent) GetAlbumImages(ctx context.Context, name, artist, mbid string) ([]agents.ExternalImage, error) {
-	args := m.Called(ctx, name, artist, mbid)
-	if args.Get(0) == nil {
-		return nil, args.Error(1)
-	}
-	return args.Get(0).([]agents.ExternalImage), args.Error(1)
-}
-
-// Ensure mockAgent implements the interfaces
+// Ensure mockAgent implements the interface
 var _ agents.AlbumInfoRetriever = (*mockAlbumInfoAgent)(nil)
-var _ agents.AlbumImageRetriever = (*mockAlbumInfoAgent)(nil)

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_similarsongs_test.go

@@ -13,7 +13,7 @@ import (
 	"github.com/stretchr/testify/mock"
 )
 
-var _ = Describe("Provider - ArtistRadio", func() {
+var _ = Describe("Provider - SimilarSongs", func() {
 	var ds model.DataStore
 	var provider Provider
 	var mockAgent *mockSimilarArtistAgent
@@ -50,9 +50,9 @@ var _ = Describe("Provider - ArtistRadio", func() {
 	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"}
+		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1"}
+		song2 := model.MediaFile{ID: "song-2", Title: "Song Two", ArtistID: "artist-1"}
+		song3 := model.MediaFile{ID: "song-3", Title: "Song Three", ArtistID: "artist-3"}
 
 		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
 		artistRepo.On("Get", "artist-3").Return(&similarArtist, nil).Maybe()
@@ -82,10 +82,11 @@ var _ = Describe("Provider - ArtistRadio", func() {
 				{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()
+		mediaFileRepo.FindByMBID("mbid-1", song1)
+		mediaFileRepo.FindByMBID("mbid-2", song2)
+		mediaFileRepo.FindByMBID("mbid-3", song3)
 
-		songs, err := provider.ArtistRadio(ctx, "artist-1", 3)
+		songs, err := provider.SimilarSongs(ctx, "artist-1", 3)
 
 		Expect(err).ToNot(HaveOccurred())
 		Expect(songs).To(HaveLen(3))
@@ -102,7 +103,7 @@ var _ = Describe("Provider - ArtistRadio", func() {
 			return opt.Max == 1 && opt.Filters != nil
 		})).Return(model.Artists{}, nil).Maybe()
 
-		songs, err := provider.ArtistRadio(ctx, "artist-unknown-artist", 5)
+		songs, err := provider.SimilarSongs(ctx, "artist-unknown-artist", 5)
 
 		Expect(err).To(Equal(model.ErrNotFound))
 		Expect(songs).To(BeNil())
@@ -110,7 +111,7 @@ var _ = Describe("Provider - ArtistRadio", func() {
 
 	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"}
+		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1"}
 
 		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
 		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
@@ -129,9 +130,9 @@ var _ = Describe("Provider - ArtistRadio", func() {
 				{Name: "Song One", MBID: "mbid-1"},
 			}, nil).Once()
 
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1}, nil).Once()
+		mediaFileRepo.FindByMBID("mbid-1", song1)
 
-		songs, err := provider.ArtistRadio(ctx, "artist-1", 5)
+		songs, err := provider.SimilarSongs(ctx, "artist-1", 5)
 
 		Expect(err).ToNot(HaveOccurred())
 		Expect(songs).To(HaveLen(1))
@@ -156,7 +157,7 @@ var _ = Describe("Provider - ArtistRadio", func() {
 		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)
+		songs, err := provider.SimilarSongs(ctx, "artist-1", 5)
 
 		Expect(err).ToNot(HaveOccurred())
 		Expect(songs).To(BeEmpty())
@@ -164,8 +165,8 @@ var _ = Describe("Provider - ArtistRadio", func() {
 
 	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"}
+		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1"}
+		song2 := model.MediaFile{ID: "song-2", Title: "Song Two", ArtistID: "artist-1"}
 
 		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
 		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
@@ -185,9 +186,10 @@ var _ = Describe("Provider - ArtistRadio", func() {
 				{Name: "Song Two", MBID: "mbid-2"},
 			}, nil).Once()
 
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1, song2}, nil).Once()
+		mediaFileRepo.FindByMBID("mbid-1", song1)
+		mediaFileRepo.FindByMBID("mbid-2", song2)
 
-		songs, err := provider.ArtistRadio(ctx, "artist-1", 1)
+		songs, err := provider.SimilarSongs(ctx, "artist-1", 1)
 
 		Expect(err).ToNot(HaveOccurred())
 		Expect(songs).To(HaveLen(1))

core/external/provider_topsongs_test.go

@@ -42,6 +42,10 @@ var _ = Describe("Provider - TopSongs", func() {
 		p = NewProvider(ds, ag)
 	})
 
+	BeforeEach(func() {
+		// Setup expectations in individual tests
+	})
+
 	It("returns top songs for a known artist", func() {
 		// Mock finding the artist
 		artist1 := model.Artist{ID: "artist-1", Name: "Artist One", MbzArtistID: "mbid-artist-1"}
@@ -54,10 +58,11 @@ var _ = Describe("Provider - TopSongs", func() {
 		}
 		ag.On("GetArtistTopSongs", ctx, "artist-1", "Artist One", "mbid-artist-1", 2).Return(agentSongs, nil).Once()
 
-		// Mock finding matching tracks (both returned in a single query)
+		// Mock finding matching tracks
 		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-song-1"}
 		song2 := model.MediaFile{ID: "song-2", Title: "Song Two", ArtistID: "artist-1", MbzRecordingID: "mbid-song-2"}
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1, song2}, nil).Once()
+		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1}, nil).Once()
+		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song2}, nil).Once()
 
 		songs, err := p.TopSongs(ctx, "Artist One", 2)
 
@@ -150,10 +155,11 @@ var _ = Describe("Provider - TopSongs", func() {
 		}
 		ag.On("GetArtistTopSongs", ctx, "artist-1", "Artist One", "mbid-artist-1", 2).Return(agentSongs, nil).Once()
 
-		// Mock finding matching tracks (only find song 1 on bulk query)
+		// Mock finding matching tracks (only find song 1)
 		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() // bulk MBID query
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{}, nil).Once()      // title fallback for song2
+		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1}, nil).Once()
+		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{}, nil).Once() // For mbid-song-2 (fails)
+		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{}, nil).Once() // For title fallback (fails)
 
 		songs, err := p.TopSongs(ctx, "Artist One", 2)
 
@@ -184,91 +190,4 @@ var _ = Describe("Provider - TopSongs", func() {
 		artistRepo.AssertExpectations(GinkgoT())
 		ag.AssertExpectations(GinkgoT())
 	})
-
-	It("falls back to title matching when MbzRecordingID is missing", 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 songs that have NO MBID (empty string)
-		agentSongs := []agents.Song{
-			{Name: "Song One", MBID: ""}, // No MBID, should fall back to title matching
-			{Name: "Song Two", MBID: ""}, // No MBID, should fall back to title matching
-		}
-		ag.On("GetArtistTopSongs", ctx, "artist-1", "Artist One", "mbid-artist-1", 2).Return(agentSongs, nil).Once()
-
-		// Since there are no MBIDs, loadTracksByMBID should not make any database call
-		// loadTracksByTitle should make a database call for title matching
-		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "", OrderTitle: "song one"}
-		song2 := model.MediaFile{ID: "song-2", Title: "Song Two", ArtistID: "artist-1", MbzRecordingID: "", OrderTitle: "song two"}
-		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("combines MBID and title matching when some songs have missing MbzRecordingID", 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 mixed MBID availability
-		agentSongs := []agents.Song{
-			{Name: "Song One", MBID: "mbid-song-1"}, // Has MBID, should match by MBID
-			{Name: "Song Two", MBID: ""},            // No MBID, should fall back to title matching
-		}
-		ag.On("GetArtistTopSongs", ctx, "artist-1", "Artist One", "mbid-artist-1", 2).Return(agentSongs, nil).Once()
-
-		// Mock the MBID query (finds song1 by MBID)
-		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-song-1", OrderTitle: "song one"}
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1}, nil).Once()
-
-		// Mock the title fallback query (finds song2 by title)
-		song2 := model.MediaFile{ID: "song-2", Title: "Song Two", ArtistID: "artist-1", MbzRecordingID: "", OrderTitle: "song two"}
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{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")) // Found by MBID
-		Expect(songs[1].ID).To(Equal("song-2")) // Found by title
-		artistRepo.AssertExpectations(GinkgoT())
-		ag.AssertExpectations(GinkgoT())
-		mediaFileRepo.AssertExpectations(GinkgoT())
-	})
-
-	It("only returns requested count when provider returns additional items", 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
-		agentSongs := []agents.Song{
-			{Name: "Song One", MBID: "mbid-song-1"},
-			{Name: "Song Two", MBID: "mbid-song-2"},
-		}
-		ag.On("GetArtistTopSongs", ctx, "artist-1", "Artist One", "mbid-artist-1", 1).Return(agentSongs, nil).Once()
-
-		// Mock finding matching tracks (both returned in a single query)
-		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-song-1"}
-		song2 := model.MediaFile{ID: "song-2", Title: "Song Two", ArtistID: "artist-1", MbzRecordingID: "mbid-song-2"}
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1, song2}, 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_updatealbuminfo_test.go

@@ -59,13 +59,13 @@ var _ = Describe("Provider - UpdateAlbumInfo", func() {
 		expectedInfo := &agents.AlbumInfo{
 			URL:         "http://example.com/album",
 			Description: "Album Description",
+			Images: []agents.ExternalImage{
+				{URL: "http://example.com/large.jpg", Size: 300},
+				{URL: "http://example.com/medium.jpg", Size: 200},
+				{URL: "http://example.com/small.jpg", Size: 100},
+			},
 		}
 		ag.On("GetAlbumInfo", ctx, "Test Album", "Test Artist", "mbid-album").Return(expectedInfo, nil)
-		ag.On("GetAlbumImages", ctx, "Test Album", "Test Artist", "mbid-album").Return([]agents.ExternalImage{
-			{URL: "http://example.com/large.jpg", Size: 300},
-			{URL: "http://example.com/medium.jpg", Size: 200},
-			{URL: "http://example.com/small.jpg", Size: 100},
-		}, nil)
 
 		updatedAlbum, err := p.UpdateAlbumInfo(ctx, "al-existing")
 
@@ -74,6 +74,9 @@ var _ = Describe("Provider - UpdateAlbumInfo", func() {
 		Expect(updatedAlbum.ID).To(Equal("al-existing"))
 		Expect(updatedAlbum.ExternalUrl).To(Equal("http://example.com/album"))
 		Expect(updatedAlbum.Description).To(Equal("Album Description"))
+		Expect(updatedAlbum.LargeImageUrl).To(Equal("http://example.com/large.jpg"))
+		Expect(updatedAlbum.MediumImageUrl).To(Equal("http://example.com/medium.jpg"))
+		Expect(updatedAlbum.SmallImageUrl).To(Equal("http://example.com/small.jpg"))
 		Expect(updatedAlbum.ExternalInfoUpdatedAt).NotTo(BeNil())
 		Expect(*updatedAlbum.ExternalInfoUpdatedAt).To(BeTemporally("~", time.Now(), time.Second))
 

core/ffmpeg/ffmpeg.go

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

core/ffmpeg/ffmpeg_test.go

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

core/library.go

@@ -1,407 +0,0 @@
-package core
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/Masterminds/squirrel"
-	"github.com/deluan/rest"
-	"github.com/navidrome/navidrome/core/storage"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/model/request"
-	"github.com/navidrome/navidrome/server/events"
-	"github.com/navidrome/navidrome/utils/slice"
-)
-
-// Watcher interface for managing file system watchers
-type Watcher interface {
-	Watch(ctx context.Context, lib *model.Library) error
-	StopWatching(ctx context.Context, libraryID int) error
-}
-
-// Library provides business logic for library management and user-library associations
-type Library interface {
-	GetUserLibraries(ctx context.Context, userID string) (model.Libraries, error)
-	SetUserLibraries(ctx context.Context, userID string, libraryIDs []int) error
-	ValidateLibraryAccess(ctx context.Context, userID string, libraryID int) error
-
-	NewRepository(ctx context.Context) rest.Repository
-}
-
-type libraryService struct {
-	ds      model.DataStore
-	scanner model.Scanner
-	watcher Watcher
-	broker  events.Broker
-}
-
-// NewLibrary creates a new Library service
-func NewLibrary(ds model.DataStore, scanner model.Scanner, watcher Watcher, broker events.Broker) Library {
-	return &libraryService{
-		ds:      ds,
-		scanner: scanner,
-		watcher: watcher,
-		broker:  broker,
-	}
-}
-
-// User-library association operations
-
-func (s *libraryService) GetUserLibraries(ctx context.Context, userID string) (model.Libraries, error) {
-	// Verify user exists
-	if _, err := s.ds.User(ctx).Get(userID); err != nil {
-		return nil, err
-	}
-
-	return s.ds.User(ctx).GetUserLibraries(userID)
-}
-
-func (s *libraryService) SetUserLibraries(ctx context.Context, userID string, libraryIDs []int) error {
-	// Verify user exists
-	user, err := s.ds.User(ctx).Get(userID)
-	if err != nil {
-		return err
-	}
-
-	// Admin users get all libraries automatically - don't allow manual assignment
-	if user.IsAdmin {
-		return fmt.Errorf("%w: cannot manually assign libraries to admin users", model.ErrValidation)
-	}
-
-	// Regular users must have at least one library
-	if len(libraryIDs) == 0 {
-		return fmt.Errorf("%w: at least one library must be assigned to non-admin users", model.ErrValidation)
-	}
-
-	// Validate all library IDs exist
-	if len(libraryIDs) > 0 {
-		if err := s.validateLibraryIDs(ctx, libraryIDs); err != nil {
-			return err
-		}
-	}
-
-	// Set user libraries
-	err = s.ds.User(ctx).SetUserLibraries(userID, libraryIDs)
-	if err != nil {
-		return fmt.Errorf("error setting user libraries: %w", err)
-	}
-
-	// Send refresh event to all clients
-	event := &events.RefreshResource{}
-	libIDs := slice.Map(libraryIDs, func(id int) string { return strconv.Itoa(id) })
-	event = event.With("user", userID).With("library", libIDs...)
-	s.broker.SendBroadcastMessage(ctx, event)
-	return nil
-}
-
-func (s *libraryService) ValidateLibraryAccess(ctx context.Context, userID string, libraryID int) error {
-	user, ok := request.UserFrom(ctx)
-	if !ok {
-		return fmt.Errorf("user not found in context")
-	}
-
-	// Admin users have access to all libraries
-	if user.IsAdmin {
-		return nil
-	}
-
-	// Check if user has explicit access to this library
-	libraries, err := s.ds.User(ctx).GetUserLibraries(userID)
-	if err != nil {
-		log.Error(ctx, "Error checking library access", "userID", userID, "libraryID", libraryID, err)
-		return fmt.Errorf("error checking library access: %w", err)
-	}
-
-	for _, lib := range libraries {
-		if lib.ID == libraryID {
-			return nil
-		}
-	}
-
-	return fmt.Errorf("%w: user does not have access to library %d", model.ErrNotAuthorized, libraryID)
-}
-
-// REST repository wrapper
-
-func (s *libraryService) NewRepository(ctx context.Context) rest.Repository {
-	repo := s.ds.Library(ctx)
-	wrapper := &libraryRepositoryWrapper{
-		ctx:               ctx,
-		LibraryRepository: repo,
-		Repository:        repo.(rest.Repository),
-		ds:                s.ds,
-		scanner:           s.scanner,
-		watcher:           s.watcher,
-		broker:            s.broker,
-	}
-	return wrapper
-}
-
-type libraryRepositoryWrapper struct {
-	rest.Repository
-	model.LibraryRepository
-	ctx     context.Context
-	ds      model.DataStore
-	scanner model.Scanner
-	watcher Watcher
-	broker  events.Broker
-}
-
-func (r *libraryRepositoryWrapper) Save(entity interface{}) (string, error) {
-	lib := entity.(*model.Library)
-	if err := r.validateLibrary(lib); err != nil {
-		return "", err
-	}
-
-	err := r.LibraryRepository.Put(lib)
-	if err != nil {
-		return "", r.mapError(err)
-	}
-
-	// Start watcher and trigger scan after successful library creation
-	if r.watcher != nil {
-		if err := r.watcher.Watch(r.ctx, lib); err != nil {
-			log.Warn(r.ctx, "Failed to start watcher for new library", "libraryID", lib.ID, "name", lib.Name, "path", lib.Path, err)
-		}
-	}
-
-	if r.scanner != nil {
-		go r.triggerScan(lib, "new")
-	}
-
-	// Send library refresh event to all clients
-	if r.broker != nil {
-		event := &events.RefreshResource{}
-		r.broker.SendBroadcastMessage(r.ctx, event.With("library", strconv.Itoa(lib.ID)))
-		log.Debug(r.ctx, "Library created - sent refresh event", "libraryID", lib.ID, "name", lib.Name)
-	}
-
-	return strconv.Itoa(lib.ID), nil
-}
-
-func (r *libraryRepositoryWrapper) Update(id string, entity interface{}, _ ...string) error {
-	lib := entity.(*model.Library)
-	libID, err := strconv.Atoi(id)
-	if err != nil {
-		return fmt.Errorf("invalid library ID: %s", id)
-	}
-
-	lib.ID = libID
-	if err := r.validateLibrary(lib); err != nil {
-		return err
-	}
-
-	// Get the original library to check if path changed
-	originalLib, err := r.Get(libID)
-	if err != nil {
-		return r.mapError(err)
-	}
-
-	pathChanged := originalLib.Path != lib.Path
-
-	err = r.LibraryRepository.Put(lib)
-	if err != nil {
-		return r.mapError(err)
-	}
-
-	// Restart watcher and trigger scan if path was updated
-	if pathChanged {
-		if r.watcher != nil {
-			if err := r.watcher.Watch(r.ctx, lib); err != nil {
-				log.Warn(r.ctx, "Failed to restart watcher for updated library", "libraryID", lib.ID, "name", lib.Name, "path", lib.Path, err)
-			}
-		}
-
-		if r.scanner != nil {
-			go r.triggerScan(lib, "updated")
-		}
-	}
-
-	// Send library refresh event to all clients
-	if r.broker != nil {
-		event := &events.RefreshResource{}
-		r.broker.SendBroadcastMessage(r.ctx, event.With("library", id))
-		log.Debug(r.ctx, "Library updated - sent refresh event", "libraryID", libID, "name", lib.Name)
-	}
-
-	return nil
-}
-
-func (r *libraryRepositoryWrapper) Delete(id string) error {
-	libID, err := strconv.Atoi(id)
-	if err != nil {
-		return &rest.ValidationError{Errors: map[string]string{
-			"id": "invalid library ID format",
-		}}
-	}
-
-	// Get library info before deletion for logging
-	lib, err := r.Get(libID)
-	if err != nil {
-		return r.mapError(err)
-	}
-
-	err = r.LibraryRepository.Delete(libID)
-	if err != nil {
-		return r.mapError(err)
-	}
-
-	// Stop watcher and trigger scan after successful library deletion to clean up orphaned data
-	if r.watcher != nil {
-		if err := r.watcher.StopWatching(r.ctx, libID); err != nil {
-			log.Warn(r.ctx, "Failed to stop watcher for deleted library", "libraryID", libID, "name", lib.Name, "path", lib.Path, err)
-		}
-	}
-
-	if r.scanner != nil {
-		go r.triggerScan(lib, "deleted")
-	}
-
-	// Send library refresh event to all clients
-	if r.broker != nil {
-		event := &events.RefreshResource{}
-		r.broker.SendBroadcastMessage(r.ctx, event.With("library", id))
-		log.Debug(r.ctx, "Library deleted - sent refresh event", "libraryID", libID, "name", lib.Name)
-	}
-
-	return nil
-}
-
-// Helper methods
-
-func (r *libraryRepositoryWrapper) mapError(err error) error {
-	if err == nil {
-		return nil
-	}
-
-	errStr := err.Error()
-
-	// Handle database constraint violations.
-	// TODO: Being tied to react-admin translations is not ideal, but this will probably go away with the new UI/API
-	if strings.Contains(errStr, "UNIQUE constraint failed") {
-		if strings.Contains(errStr, "library.name") {
-			return &rest.ValidationError{Errors: map[string]string{"name": "ra.validation.unique"}}
-		}
-		if strings.Contains(errStr, "library.path") {
-			return &rest.ValidationError{Errors: map[string]string{"path": "ra.validation.unique"}}
-		}
-	}
-
-	switch {
-	case errors.Is(err, model.ErrNotFound):
-		return rest.ErrNotFound
-	case errors.Is(err, model.ErrNotAuthorized):
-		return rest.ErrPermissionDenied
-	default:
-		return err
-	}
-}
-
-func (r *libraryRepositoryWrapper) validateLibrary(library *model.Library) error {
-	validationErrors := make(map[string]string)
-
-	if library.Name == "" {
-		validationErrors["name"] = "ra.validation.required"
-	}
-
-	if library.Path == "" {
-		validationErrors["path"] = "ra.validation.required"
-	} else {
-		// Validate path format and accessibility
-		if err := r.validateLibraryPath(library); err != nil {
-			validationErrors["path"] = err.Error()
-		}
-	}
-
-	if len(validationErrors) > 0 {
-		return &rest.ValidationError{Errors: validationErrors}
-	}
-
-	return nil
-}
-
-func (r *libraryRepositoryWrapper) validateLibraryPath(library *model.Library) error {
-	// Validate path format
-	if !filepath.IsAbs(library.Path) {
-		return fmt.Errorf("library path must be absolute")
-	}
-
-	// Clean the path to normalize it
-	cleanPath := filepath.Clean(library.Path)
-	library.Path = cleanPath
-
-	// Check if path exists and is accessible using storage abstraction
-	fileStore, err := storage.For(library.Path)
-	if err != nil {
-		return fmt.Errorf("invalid storage scheme: %w", err)
-	}
-
-	fsys, err := fileStore.FS()
-	if err != nil {
-		log.Warn(r.ctx, "Error validating library.path", "path", library.Path, err)
-		return fmt.Errorf("resources.library.validation.pathInvalid")
-	}
-
-	// Check if root directory exists
-	info, err := fs.Stat(fsys, ".")
-	if err != nil {
-		// Parse the error message to check for "not a directory"
-		log.Warn(r.ctx, "Error stating library.path", "path", library.Path, err)
-		errStr := err.Error()
-		if strings.Contains(errStr, "not a directory") ||
-			strings.Contains(errStr, "The directory name is invalid.") {
-			return fmt.Errorf("resources.library.validation.pathNotDirectory")
-		} else if os.IsNotExist(err) {
-			return fmt.Errorf("resources.library.validation.pathNotFound")
-		} else if os.IsPermission(err) {
-			return fmt.Errorf("resources.library.validation.pathNotAccessible")
-		} else {
-			return fmt.Errorf("resources.library.validation.pathInvalid")
-		}
-	}
-
-	if !info.IsDir() {
-		return fmt.Errorf("resources.library.validation.pathNotDirectory")
-	}
-
-	return nil
-}
-
-func (s *libraryService) validateLibraryIDs(ctx context.Context, libraryIDs []int) error {
-	if len(libraryIDs) == 0 {
-		return nil
-	}
-
-	// Use CountAll to efficiently validate library IDs exist
-	count, err := s.ds.Library(ctx).CountAll(model.QueryOptions{
-		Filters: squirrel.Eq{"id": libraryIDs},
-	})
-	if err != nil {
-		return fmt.Errorf("error validating library IDs: %w", err)
-	}
-
-	if int(count) != len(libraryIDs) {
-		return fmt.Errorf("%w: one or more library IDs are invalid", model.ErrValidation)
-	}
-
-	return nil
-}
-
-func (r *libraryRepositoryWrapper) triggerScan(lib *model.Library, action string) {
-	log.Info(r.ctx, fmt.Sprintf("Triggering scan for %s library", action), "libraryID", lib.ID, "name", lib.Name, "path", lib.Path)
-	start := time.Now()
-	warnings, err := r.scanner.ScanAll(r.ctx, false) // Quick scan for new library
-	if err != nil {
-		log.Error(r.ctx, fmt.Sprintf("Error scanning %s library", action), "libraryID", lib.ID, "name", lib.Name, err)
-	} else {
-		log.Info(r.ctx, fmt.Sprintf("Scan completed for %s library", action), "libraryID", lib.ID, "name", lib.Name, "warnings", len(warnings), "elapsed", time.Since(start))
-	}
-}

core/library_test.go

@@ -1,958 +0,0 @@
-package core_test
-
-import (
-	"context"
-	"errors"
-	"net/http"
-	"os"
-	"path/filepath"
-	"sync"
-
-	"github.com/deluan/rest"
-	_ "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
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/model/request"
-	"github.com/navidrome/navidrome/server/events"
-	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-// These tests require the local storage adapter and the taglib extractor to be registered.
-var _ = Describe("Library Service", func() {
-	var service core.Library
-	var ds *tests.MockDataStore
-	var libraryRepo *tests.MockLibraryRepo
-	var userRepo *tests.MockedUserRepo
-	var ctx context.Context
-	var tempDir string
-	var scanner *tests.MockScanner
-	var watcherManager *mockWatcherManager
-	var broker *mockEventBroker
-
-	BeforeEach(func() {
-		DeferCleanup(configtest.SetupConfig())
-
-		ds = &tests.MockDataStore{}
-		libraryRepo = &tests.MockLibraryRepo{}
-		userRepo = tests.CreateMockUserRepo()
-		ds.MockedLibrary = libraryRepo
-		ds.MockedUser = userRepo
-
-		// Create a mock scanner that tracks calls
-		scanner = tests.NewMockScanner()
-		// Create a mock watcher manager
-		watcherManager = &mockWatcherManager{
-			libraryStates: make(map[int]model.Library),
-		}
-		// Create a mock event broker
-		broker = &mockEventBroker{}
-		service = core.NewLibrary(ds, scanner, watcherManager, broker)
-		ctx = context.Background()
-
-		// Create a temporary directory for testing valid paths
-		var err error
-		tempDir, err = os.MkdirTemp("", "navidrome-library-test-")
-		Expect(err).NotTo(HaveOccurred())
-		DeferCleanup(func() {
-			os.RemoveAll(tempDir)
-		})
-	})
-
-	Describe("Library CRUD Operations", func() {
-		var repo rest.Persistable
-
-		BeforeEach(func() {
-			r := service.NewRepository(ctx)
-			repo = r.(rest.Persistable)
-		})
-
-		Describe("Create", func() {
-			It("creates a new library successfully", func() {
-				library := &model.Library{ID: 1, Name: "New Library", Path: tempDir}
-
-				_, err := repo.Save(library)
-
-				Expect(err).NotTo(HaveOccurred())
-				Expect(libraryRepo.Data[1].Name).To(Equal("New Library"))
-				Expect(libraryRepo.Data[1].Path).To(Equal(tempDir))
-			})
-
-			It("fails when library name is empty", func() {
-				library := &model.Library{Path: tempDir}
-
-				_, err := repo.Save(library)
-
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("ra.validation.required"))
-			})
-
-			It("fails when library path is empty", func() {
-				library := &model.Library{Name: "Test"}
-
-				_, err := repo.Save(library)
-
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("ra.validation.required"))
-			})
-
-			It("fails when library path is not absolute", func() {
-				library := &model.Library{Name: "Test", Path: "relative/path"}
-
-				_, err := repo.Save(library)
-
-				Expect(err).To(HaveOccurred())
-				var validationErr *rest.ValidationError
-				Expect(errors.As(err, &validationErr)).To(BeTrue())
-				Expect(validationErr.Errors["path"]).To(Equal("library path must be absolute"))
-			})
-
-			Context("Database constraint violations", func() {
-				BeforeEach(func() {
-					// Set up an existing library that will cause constraint violations
-					libraryRepo.SetData(model.Libraries{
-						{ID: 1, Name: "Existing Library", Path: tempDir},
-					})
-				})
-
-				AfterEach(func() {
-					// Reset custom PutFn after each test
-					libraryRepo.PutFn = nil
-				})
-
-				It("handles name uniqueness constraint violation from database", func() {
-					// Create the directory that will be used for the test
-					otherTempDir, err := os.MkdirTemp("", "navidrome-other-")
-					Expect(err).NotTo(HaveOccurred())
-					DeferCleanup(func() { os.RemoveAll(otherTempDir) })
-
-					// Try to create another library with the same name
-					library := &model.Library{ID: 2, Name: "Existing Library", Path: otherTempDir}
-
-					// Mock the repository to return a UNIQUE constraint error
-					libraryRepo.PutFn = func(library *model.Library) error {
-						return errors.New("UNIQUE constraint failed: library.name")
-					}
-
-					_, err = repo.Save(library)
-
-					Expect(err).To(HaveOccurred())
-					var validationErr *rest.ValidationError
-					Expect(errors.As(err, &validationErr)).To(BeTrue())
-					Expect(validationErr.Errors["name"]).To(Equal("ra.validation.unique"))
-				})
-
-				It("handles path uniqueness constraint violation from database", func() {
-					// Try to create another library with the same path
-					library := &model.Library{ID: 2, Name: "Different Library", Path: tempDir}
-
-					// Mock the repository to return a UNIQUE constraint error
-					libraryRepo.PutFn = func(library *model.Library) error {
-						return errors.New("UNIQUE constraint failed: library.path")
-					}
-
-					_, err := repo.Save(library)
-
-					Expect(err).To(HaveOccurred())
-					var validationErr *rest.ValidationError
-					Expect(errors.As(err, &validationErr)).To(BeTrue())
-					Expect(validationErr.Errors["path"]).To(Equal("ra.validation.unique"))
-				})
-			})
-		})
-
-		Describe("Update", func() {
-			BeforeEach(func() {
-				libraryRepo.SetData(model.Libraries{
-					{ID: 1, Name: "Original Library", Path: tempDir},
-				})
-			})
-
-			It("updates an existing library successfully", func() {
-				newTempDir, err := os.MkdirTemp("", "navidrome-library-update-")
-				Expect(err).NotTo(HaveOccurred())
-				DeferCleanup(func() { os.RemoveAll(newTempDir) })
-
-				library := &model.Library{ID: 1, Name: "Updated Library", Path: newTempDir}
-
-				err = repo.Update("1", library)
-
-				Expect(err).NotTo(HaveOccurred())
-				Expect(libraryRepo.Data[1].Name).To(Equal("Updated Library"))
-				Expect(libraryRepo.Data[1].Path).To(Equal(newTempDir))
-			})
-
-			It("fails when library doesn't exist", func() {
-				// Create a unique temporary directory to avoid path conflicts
-				uniqueTempDir, err := os.MkdirTemp("", "navidrome-nonexistent-")
-				Expect(err).NotTo(HaveOccurred())
-				DeferCleanup(func() { os.RemoveAll(uniqueTempDir) })
-
-				library := &model.Library{ID: 999, Name: "Non-existent", Path: uniqueTempDir}
-
-				err = repo.Update("999", library)
-
-				Expect(err).To(HaveOccurred())
-				Expect(err).To(Equal(model.ErrNotFound))
-			})
-
-			It("fails when library name is empty", func() {
-				library := &model.Library{ID: 1, Path: tempDir}
-
-				err := repo.Update("1", library)
-
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("ra.validation.required"))
-			})
-
-			It("cleans and normalizes the path on update", func() {
-				unnormalizedPath := tempDir + "//../" + filepath.Base(tempDir)
-				library := &model.Library{ID: 1, Name: "Updated Library", Path: unnormalizedPath}
-
-				err := repo.Update("1", library)
-
-				Expect(err).NotTo(HaveOccurred())
-				Expect(libraryRepo.Data[1].Path).To(Equal(filepath.Clean(unnormalizedPath)))
-			})
-
-			It("allows updating library with same name (no change)", func() {
-				// Set up a library
-				libraryRepo.SetData(model.Libraries{
-					{ID: 1, Name: "Test Library", Path: tempDir},
-				})
-
-				// Update the library keeping the same name (should be allowed)
-				library := &model.Library{ID: 1, Name: "Test Library", Path: tempDir}
-
-				err := repo.Update("1", library)
-
-				Expect(err).NotTo(HaveOccurred())
-			})
-
-			It("allows updating library with same path (no change)", func() {
-				// Set up a library
-				libraryRepo.SetData(model.Libraries{
-					{ID: 1, Name: "Test Library", Path: tempDir},
-				})
-
-				// Update the library keeping the same path (should be allowed)
-				library := &model.Library{ID: 1, Name: "Test Library", Path: tempDir}
-
-				err := repo.Update("1", library)
-
-				Expect(err).NotTo(HaveOccurred())
-			})
-
-			Context("Database constraint violations during update", func() {
-				BeforeEach(func() {
-					// Reset any custom PutFn from previous tests
-					libraryRepo.PutFn = nil
-				})
-
-				It("handles name uniqueness constraint violation during update", func() {
-					// Create additional temp directory for the test
-					otherTempDir, err := os.MkdirTemp("", "navidrome-other-")
-					Expect(err).NotTo(HaveOccurred())
-					DeferCleanup(func() { os.RemoveAll(otherTempDir) })
-
-					// Set up two libraries
-					libraryRepo.SetData(model.Libraries{
-						{ID: 1, Name: "Library One", Path: tempDir},
-						{ID: 2, Name: "Library Two", Path: otherTempDir},
-					})
-
-					// Mock database constraint violation
-					libraryRepo.PutFn = func(library *model.Library) error {
-						return errors.New("UNIQUE constraint failed: library.name")
-					}
-
-					// Try to update library 2 to have the same name as library 1
-					library := &model.Library{ID: 2, Name: "Library One", Path: otherTempDir}
-
-					err = repo.Update("2", library)
-
-					Expect(err).To(HaveOccurred())
-					var validationErr *rest.ValidationError
-					Expect(errors.As(err, &validationErr)).To(BeTrue())
-					Expect(validationErr.Errors["name"]).To(Equal("ra.validation.unique"))
-				})
-
-				It("handles path uniqueness constraint violation during update", func() {
-					// Create additional temp directory for the test
-					otherTempDir, err := os.MkdirTemp("", "navidrome-other-")
-					Expect(err).NotTo(HaveOccurred())
-					DeferCleanup(func() { os.RemoveAll(otherTempDir) })
-
-					// Set up two libraries
-					libraryRepo.SetData(model.Libraries{
-						{ID: 1, Name: "Library One", Path: tempDir},
-						{ID: 2, Name: "Library Two", Path: otherTempDir},
-					})
-
-					// Mock database constraint violation
-					libraryRepo.PutFn = func(library *model.Library) error {
-						return errors.New("UNIQUE constraint failed: library.path")
-					}
-
-					// Try to update library 2 to have the same path as library 1
-					library := &model.Library{ID: 2, Name: "Library Two", Path: tempDir}
-
-					err = repo.Update("2", library)
-
-					Expect(err).To(HaveOccurred())
-					var validationErr *rest.ValidationError
-					Expect(errors.As(err, &validationErr)).To(BeTrue())
-					Expect(validationErr.Errors["path"]).To(Equal("ra.validation.unique"))
-				})
-			})
-		})
-
-		Describe("Path Validation", func() {
-			Context("Create operation", func() {
-				It("fails when path is not absolute", func() {
-					library := &model.Library{Name: "Test", Path: "relative/path"}
-
-					_, err := repo.Save(library)
-
-					Expect(err).To(HaveOccurred())
-					var validationErr *rest.ValidationError
-					Expect(errors.As(err, &validationErr)).To(BeTrue())
-					Expect(validationErr.Errors["path"]).To(Equal("library path must be absolute"))
-				})
-
-				It("fails when path does not exist", func() {
-					nonExistentPath := filepath.Join(tempDir, "nonexistent")
-					library := &model.Library{Name: "Test", Path: nonExistentPath}
-
-					_, err := repo.Save(library)
-
-					Expect(err).To(HaveOccurred())
-					var validationErr *rest.ValidationError
-					Expect(errors.As(err, &validationErr)).To(BeTrue())
-					Expect(validationErr.Errors["path"]).To(Equal("resources.library.validation.pathInvalid"))
-				})
-
-				It("fails when path is a file instead of directory", func() {
-					testFile := filepath.Join(tempDir, "testfile.txt")
-					err := os.WriteFile(testFile, []byte("test"), 0600)
-					Expect(err).NotTo(HaveOccurred())
-
-					library := &model.Library{Name: "Test", Path: testFile}
-
-					_, err = repo.Save(library)
-
-					Expect(err).To(HaveOccurred())
-					var validationErr *rest.ValidationError
-					Expect(errors.As(err, &validationErr)).To(BeTrue())
-					Expect(validationErr.Errors["path"]).To(Equal("resources.library.validation.pathNotDirectory"))
-				})
-
-				It("fails when path is not accessible due to permissions", func() {
-					Skip("Permission tests are environment-dependent and may fail in CI")
-					// This test is skipped because creating a directory with no read permissions
-					// is complex and may not work consistently across different environments
-				})
-
-				It("handles multiple validation errors", func() {
-					library := &model.Library{Name: "", Path: "relative/path"}
-
-					_, err := repo.Save(library)
-
-					Expect(err).To(HaveOccurred())
-					var validationErr *rest.ValidationError
-					Expect(errors.As(err, &validationErr)).To(BeTrue())
-					Expect(validationErr.Errors).To(HaveKey("name"))
-					Expect(validationErr.Errors).To(HaveKey("path"))
-					Expect(validationErr.Errors["name"]).To(Equal("ra.validation.required"))
-					Expect(validationErr.Errors["path"]).To(Equal("library path must be absolute"))
-				})
-			})
-
-			Context("Update operation", func() {
-				BeforeEach(func() {
-					libraryRepo.SetData(model.Libraries{
-						{ID: 1, Name: "Test Library", Path: tempDir},
-					})
-				})
-
-				It("fails when updated path is not absolute", func() {
-					library := &model.Library{ID: 1, Name: "Test", Path: "relative/path"}
-
-					err := repo.Update("1", library)
-
-					Expect(err).To(HaveOccurred())
-					var validationErr *rest.ValidationError
-					Expect(errors.As(err, &validationErr)).To(BeTrue())
-					Expect(validationErr.Errors["path"]).To(Equal("library path must be absolute"))
-				})
-
-				It("allows updating library with same name (no change)", func() {
-					// Set up a library
-					libraryRepo.SetData(model.Libraries{
-						{ID: 1, Name: "Test Library", Path: tempDir},
-					})
-
-					// Update the library keeping the same name (should be allowed)
-					library := &model.Library{ID: 1, Name: "Test Library", Path: tempDir}
-
-					err := repo.Update("1", library)
-
-					Expect(err).NotTo(HaveOccurred())
-				})
-
-				It("fails when updated path does not exist", func() {
-					nonExistentPath := filepath.Join(tempDir, "nonexistent")
-					library := &model.Library{ID: 1, Name: "Test", Path: nonExistentPath}
-
-					err := repo.Update("1", library)
-
-					Expect(err).To(HaveOccurred())
-					var validationErr *rest.ValidationError
-					Expect(errors.As(err, &validationErr)).To(BeTrue())
-					Expect(validationErr.Errors["path"]).To(Equal("resources.library.validation.pathInvalid"))
-				})
-
-				It("fails when updated path is a file instead of directory", func() {
-					testFile := filepath.Join(tempDir, "updatefile.txt")
-					err := os.WriteFile(testFile, []byte("test"), 0600)
-					Expect(err).NotTo(HaveOccurred())
-
-					library := &model.Library{ID: 1, Name: "Test", Path: testFile}
-
-					err = repo.Update("1", library)
-
-					Expect(err).To(HaveOccurred())
-					var validationErr *rest.ValidationError
-					Expect(errors.As(err, &validationErr)).To(BeTrue())
-					Expect(validationErr.Errors["path"]).To(Equal("resources.library.validation.pathNotDirectory"))
-				})
-
-				It("handles multiple validation errors on update", func() {
-					// Try to update with empty name and invalid path
-					library := &model.Library{ID: 1, Name: "", Path: "relative/path"}
-
-					err := repo.Update("1", library)
-
-					Expect(err).To(HaveOccurred())
-					var validationErr *rest.ValidationError
-					Expect(errors.As(err, &validationErr)).To(BeTrue())
-					Expect(validationErr.Errors).To(HaveKey("name"))
-					Expect(validationErr.Errors).To(HaveKey("path"))
-					Expect(validationErr.Errors["name"]).To(Equal("ra.validation.required"))
-					Expect(validationErr.Errors["path"]).To(Equal("library path must be absolute"))
-				})
-			})
-		})
-
-		Describe("Delete", func() {
-			BeforeEach(func() {
-				libraryRepo.SetData(model.Libraries{
-					{ID: 1, Name: "Library to Delete", Path: tempDir},
-				})
-			})
-
-			It("deletes an existing library successfully", func() {
-				err := repo.Delete("1")
-
-				Expect(err).NotTo(HaveOccurred())
-				Expect(libraryRepo.Data).To(HaveLen(0))
-			})
-
-			It("fails when library doesn't exist", func() {
-				err := repo.Delete("999")
-
-				Expect(err).To(HaveOccurred())
-				Expect(err).To(Equal(model.ErrNotFound))
-			})
-		})
-	})
-
-	Describe("User-Library Association Operations", func() {
-		var regularUser, adminUser *model.User
-
-		BeforeEach(func() {
-			regularUser = &model.User{ID: "user1", UserName: "regular", IsAdmin: false}
-			adminUser = &model.User{ID: "admin1", UserName: "admin", IsAdmin: true}
-
-			userRepo.Data = map[string]*model.User{
-				"regular": regularUser,
-				"admin":   adminUser,
-			}
-			libraryRepo.SetData(model.Libraries{
-				{ID: 1, Name: "Library 1", Path: "/music1"},
-				{ID: 2, Name: "Library 2", Path: "/music2"},
-				{ID: 3, Name: "Library 3", Path: "/music3"},
-			})
-		})
-
-		Describe("GetUserLibraries", func() {
-			It("returns user's libraries", func() {
-				userRepo.UserLibraries = map[string][]int{
-					"user1": {1},
-				}
-
-				result, err := service.GetUserLibraries(ctx, "user1")
-
-				Expect(err).NotTo(HaveOccurred())
-				Expect(result).To(HaveLen(1))
-				Expect(result[0].ID).To(Equal(1))
-			})
-
-			It("fails when user doesn't exist", func() {
-				_, err := service.GetUserLibraries(ctx, "nonexistent")
-
-				Expect(err).To(HaveOccurred())
-				Expect(err).To(Equal(model.ErrNotFound))
-			})
-		})
-
-		Describe("SetUserLibraries", func() {
-			It("sets libraries for regular user successfully", func() {
-				err := service.SetUserLibraries(ctx, "user1", []int{1, 2})
-
-				Expect(err).NotTo(HaveOccurred())
-				libraries := userRepo.UserLibraries["user1"]
-				Expect(libraries).To(HaveLen(2))
-			})
-
-			It("fails when user doesn't exist", func() {
-				err := service.SetUserLibraries(ctx, "nonexistent", []int{1})
-
-				Expect(err).To(HaveOccurred())
-				Expect(err).To(Equal(model.ErrNotFound))
-			})
-
-			It("fails when trying to set libraries for admin user", func() {
-				err := service.SetUserLibraries(ctx, "admin1", []int{1})
-
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("cannot manually assign libraries to admin users"))
-			})
-
-			It("fails when no libraries provided for regular user", func() {
-				err := service.SetUserLibraries(ctx, "user1", []int{})
-
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("at least one library must be assigned to non-admin users"))
-			})
-
-			It("fails when library doesn't exist", func() {
-				err := service.SetUserLibraries(ctx, "user1", []int{999})
-
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("one or more library IDs are invalid"))
-			})
-
-			It("fails when some libraries don't exist", func() {
-				err := service.SetUserLibraries(ctx, "user1", []int{1, 999, 2})
-
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("one or more library IDs are invalid"))
-			})
-		})
-
-		Describe("ValidateLibraryAccess", func() {
-			Context("admin user", func() {
-				BeforeEach(func() {
-					ctx = request.WithUser(ctx, *adminUser)
-				})
-
-				It("allows access to any library", func() {
-					err := service.ValidateLibraryAccess(ctx, "admin1", 1)
-
-					Expect(err).NotTo(HaveOccurred())
-				})
-			})
-
-			Context("regular user", func() {
-				BeforeEach(func() {
-					ctx = request.WithUser(ctx, *regularUser)
-					userRepo.UserLibraries = map[string][]int{
-						"user1": {1},
-					}
-				})
-
-				It("allows access to user's libraries", func() {
-					err := service.ValidateLibraryAccess(ctx, "user1", 1)
-
-					Expect(err).NotTo(HaveOccurred())
-				})
-
-				It("denies access to libraries user doesn't have", func() {
-					err := service.ValidateLibraryAccess(ctx, "user1", 2)
-
-					Expect(err).To(HaveOccurred())
-					Expect(err.Error()).To(ContainSubstring("user does not have access to library 2"))
-				})
-			})
-
-			Context("no user in context", func() {
-				It("fails with user not found error", func() {
-					err := service.ValidateLibraryAccess(ctx, "user1", 1)
-
-					Expect(err).To(HaveOccurred())
-					Expect(err.Error()).To(ContainSubstring("user not found in context"))
-				})
-			})
-		})
-	})
-
-	Describe("Scan Triggering", func() {
-		var repo rest.Persistable
-
-		BeforeEach(func() {
-			r := service.NewRepository(ctx)
-			repo = r.(rest.Persistable)
-		})
-
-		It("triggers scan when creating a new library", func() {
-			library := &model.Library{ID: 1, Name: "New Library", Path: tempDir}
-
-			_, err := repo.Save(library)
-			Expect(err).NotTo(HaveOccurred())
-
-			// Wait briefly for the goroutine to complete
-			Eventually(func() int {
-				return scanner.GetScanAllCallCount()
-			}, "1s", "10ms").Should(Equal(1))
-
-			// Verify scan was called with correct parameters
-			calls := scanner.GetScanAllCalls()
-			Expect(calls[0].FullScan).To(BeFalse()) // Should be quick scan
-		})
-
-		It("triggers scan when updating library path", func() {
-			// First create a library
-			libraryRepo.SetData(model.Libraries{
-				{ID: 1, Name: "Original Library", Path: tempDir},
-			})
-
-			// Create a new temporary directory for the update
-			newTempDir, err := os.MkdirTemp("", "navidrome-library-update-")
-			Expect(err).NotTo(HaveOccurred())
-			DeferCleanup(func() { os.RemoveAll(newTempDir) })
-
-			// Update the library with a new path
-			library := &model.Library{ID: 1, Name: "Updated Library", Path: newTempDir}
-			err = repo.Update("1", library)
-			Expect(err).NotTo(HaveOccurred())
-
-			// Wait briefly for the goroutine to complete
-			Eventually(func() int {
-				return scanner.GetScanAllCallCount()
-			}, "1s", "10ms").Should(Equal(1))
-
-			// Verify scan was called with correct parameters
-			calls := scanner.GetScanAllCalls()
-			Expect(calls[0].FullScan).To(BeFalse()) // Should be quick scan
-		})
-
-		It("does not trigger scan when updating library without path change", func() {
-			// First create a library
-			libraryRepo.SetData(model.Libraries{
-				{ID: 1, Name: "Original Library", Path: tempDir},
-			})
-
-			// Update the library name only (same path)
-			library := &model.Library{ID: 1, Name: "Updated Name", Path: tempDir}
-			err := repo.Update("1", library)
-			Expect(err).NotTo(HaveOccurred())
-
-			// Wait a bit to ensure no scan was triggered
-			Consistently(func() int {
-				return scanner.GetScanAllCallCount()
-			}, "100ms", "10ms").Should(Equal(0))
-		})
-
-		It("does not trigger scan when library creation fails", func() {
-			// Try to create library with invalid data (empty name)
-			library := &model.Library{Path: tempDir}
-
-			_, err := repo.Save(library)
-			Expect(err).To(HaveOccurred())
-
-			// Ensure no scan was triggered since creation failed
-			Consistently(func() int {
-				return scanner.GetScanAllCallCount()
-			}, "100ms", "10ms").Should(Equal(0))
-		})
-
-		It("does not trigger scan when library update fails", func() {
-			// First create a library
-			libraryRepo.SetData(model.Libraries{
-				{ID: 1, Name: "Original Library", Path: tempDir},
-			})
-
-			// Try to update with invalid data (empty name)
-			library := &model.Library{ID: 1, Name: "", Path: tempDir}
-			err := repo.Update("1", library)
-			Expect(err).To(HaveOccurred())
-
-			// Ensure no scan was triggered since update failed
-			Consistently(func() int {
-				return scanner.GetScanAllCallCount()
-			}, "100ms", "10ms").Should(Equal(0))
-		})
-
-		It("triggers scan when deleting a library", func() {
-			// First create a library
-			libraryRepo.SetData(model.Libraries{
-				{ID: 1, Name: "Library to Delete", Path: tempDir},
-			})
-
-			// Delete the library
-			err := repo.Delete("1")
-			Expect(err).NotTo(HaveOccurred())
-
-			// Wait briefly for the goroutine to complete
-			Eventually(func() int {
-				return scanner.GetScanAllCallCount()
-			}, "1s", "10ms").Should(Equal(1))
-
-			// Verify scan was called with correct parameters
-			calls := scanner.GetScanAllCalls()
-			Expect(calls[0].FullScan).To(BeFalse()) // Should be quick scan
-		})
-
-		It("does not trigger scan when library deletion fails", func() {
-			// Try to delete a non-existent library
-			err := repo.Delete("999")
-			Expect(err).To(HaveOccurred())
-
-			// Ensure no scan was triggered since deletion failed
-			Consistently(func() int {
-				return scanner.GetScanAllCallCount()
-			}, "100ms", "10ms").Should(Equal(0))
-		})
-
-		Context("Watcher Integration", func() {
-			It("starts watcher when creating a new library", func() {
-				library := &model.Library{ID: 1, Name: "New Library", Path: tempDir}
-
-				_, err := repo.Save(library)
-				Expect(err).NotTo(HaveOccurred())
-
-				// Verify watcher was started
-				Eventually(func() int {
-					return watcherManager.lenStarted()
-				}, "1s", "10ms").Should(Equal(1))
-
-				Expect(watcherManager.StartedWatchers[0].ID).To(Equal(1))
-				Expect(watcherManager.StartedWatchers[0].Name).To(Equal("New Library"))
-				Expect(watcherManager.StartedWatchers[0].Path).To(Equal(tempDir))
-			})
-
-			It("restarts watcher when library path is updated", func() {
-				// First create a library
-				libraryRepo.SetData(model.Libraries{
-					{ID: 1, Name: "Original Library", Path: tempDir},
-				})
-
-				// Simulate that this library already has a watcher
-				watcherManager.simulateExistingLibrary(model.Library{ID: 1, Name: "Original Library", Path: tempDir})
-
-				// Create a new temp directory for the update
-				newTempDir, err := os.MkdirTemp("", "navidrome-library-update-")
-				Expect(err).NotTo(HaveOccurred())
-				DeferCleanup(func() { os.RemoveAll(newTempDir) })
-
-				// Update library with new path
-				library := &model.Library{ID: 1, Name: "Updated Library", Path: newTempDir}
-				err = repo.Update("1", library)
-				Expect(err).NotTo(HaveOccurred())
-
-				// Verify watcher was restarted
-				Eventually(func() int {
-					return watcherManager.lenRestarted()
-				}, "1s", "10ms").Should(Equal(1))
-
-				Expect(watcherManager.RestartedWatchers[0].ID).To(Equal(1))
-				Expect(watcherManager.RestartedWatchers[0].Path).To(Equal(newTempDir))
-			})
-
-			It("does not restart watcher when only library name is updated", func() {
-				// First create a library
-				libraryRepo.SetData(model.Libraries{
-					{ID: 1, Name: "Original Library", Path: tempDir},
-				})
-
-				// Update library with same path but different name
-				library := &model.Library{ID: 1, Name: "Updated Name", Path: tempDir}
-				err := repo.Update("1", library)
-				Expect(err).NotTo(HaveOccurred())
-
-				// Verify watcher was NOT restarted (since path didn't change)
-				Consistently(func() int {
-					return watcherManager.lenRestarted()
-				}, "100ms", "10ms").Should(Equal(0))
-			})
-
-			It("stops watcher when library is deleted", func() {
-				// Set up a library
-				libraryRepo.SetData(model.Libraries{
-					{ID: 1, Name: "Test Library", Path: tempDir},
-				})
-
-				err := repo.Delete("1")
-				Expect(err).NotTo(HaveOccurred())
-
-				// Verify watcher was stopped
-				Eventually(func() int {
-					return watcherManager.lenStopped()
-				}, "1s", "10ms").Should(Equal(1))
-
-				Expect(watcherManager.StoppedWatchers[0]).To(Equal(1))
-			})
-
-			It("does not stop watcher when library deletion fails", func() {
-				// Set up a library
-				libraryRepo.SetData(model.Libraries{
-					{ID: 1, Name: "Test Library", Path: tempDir},
-				})
-
-				// Mock deletion to fail by trying to delete non-existent library
-				err := repo.Delete("999")
-				Expect(err).To(HaveOccurred())
-
-				// Verify watcher was NOT stopped since deletion failed
-				Consistently(func() int {
-					return watcherManager.lenStopped()
-				}, "100ms", "10ms").Should(Equal(0))
-			})
-		})
-	})
-
-	Describe("Event Broadcasting", func() {
-		var repo rest.Persistable
-
-		BeforeEach(func() {
-			r := service.NewRepository(ctx)
-			repo = r.(rest.Persistable)
-			// Clear any events from broker
-			broker.Events = []events.Event{}
-		})
-
-		It("sends refresh event when creating a library", func() {
-			library := &model.Library{ID: 1, Name: "New Library", Path: tempDir}
-
-			_, err := repo.Save(library)
-
-			Expect(err).NotTo(HaveOccurred())
-			Expect(broker.Events).To(HaveLen(1))
-		})
-
-		It("sends refresh event when updating a library", func() {
-			// First create a library
-			libraryRepo.SetData(model.Libraries{
-				{ID: 1, Name: "Original Library", Path: tempDir},
-			})
-
-			library := &model.Library{ID: 1, Name: "Updated Library", Path: tempDir}
-			err := repo.Update("1", library)
-
-			Expect(err).NotTo(HaveOccurred())
-			Expect(broker.Events).To(HaveLen(1))
-		})
-
-		It("sends refresh event when deleting a library", func() {
-			// First create a library
-			libraryRepo.SetData(model.Libraries{
-				{ID: 2, Name: "Library to Delete", Path: tempDir},
-			})
-
-			err := repo.Delete("2")
-
-			Expect(err).NotTo(HaveOccurred())
-			Expect(broker.Events).To(HaveLen(1))
-		})
-	})
-})
-
-// mockWatcherManager provides a simple mock implementation of core.Watcher for testing
-type mockWatcherManager struct {
-	StartedWatchers   []model.Library
-	StoppedWatchers   []int
-	RestartedWatchers []model.Library
-	libraryStates     map[int]model.Library // Track which libraries we know about
-	mu                sync.RWMutex
-}
-
-func (m *mockWatcherManager) Watch(ctx context.Context, lib *model.Library) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	// Check if we already know about this library ID
-	if _, exists := m.libraryStates[lib.ID]; exists {
-		// This is a restart - the library already existed
-		// Update our tracking and record the restart
-		for i, startedLib := range m.StartedWatchers {
-			if startedLib.ID == lib.ID {
-				m.StartedWatchers[i] = *lib
-				break
-			}
-		}
-		m.RestartedWatchers = append(m.RestartedWatchers, *lib)
-		m.libraryStates[lib.ID] = *lib
-		return nil
-	}
-
-	// This is a new library - first time we're seeing it
-	m.StartedWatchers = append(m.StartedWatchers, *lib)
-	m.libraryStates[lib.ID] = *lib
-	return nil
-}
-
-func (m *mockWatcherManager) StopWatching(ctx context.Context, libraryID int) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.StoppedWatchers = append(m.StoppedWatchers, libraryID)
-	return nil
-}
-
-func (m *mockWatcherManager) lenStarted() int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return len(m.StartedWatchers)
-}
-
-func (m *mockWatcherManager) lenStopped() int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return len(m.StoppedWatchers)
-}
-
-func (m *mockWatcherManager) lenRestarted() int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return len(m.RestartedWatchers)
-}
-
-// simulateExistingLibrary simulates the scenario where a library already exists
-// and has a watcher running (used by tests to set up the initial state)
-func (m *mockWatcherManager) simulateExistingLibrary(lib model.Library) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.libraryStates[lib.ID] = lib
-}
-
-// mockEventBroker provides a mock implementation of events.Broker for testing
-type mockEventBroker struct {
-	http.Handler
-	Events []events.Event
-	mu     sync.RWMutex
-}
-
-func (m *mockEventBroker) SendMessage(ctx context.Context, event events.Event) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.Events = append(m.Events, event)
-}
-
-func (m *mockEventBroker) SendBroadcastMessage(ctx context.Context, event events.Event) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.Events = append(m.Events, event)
-}

core/lyrics/lyrics.go

@@ -1,37 +0,0 @@
-package lyrics
-
-import (
-	"context"
-	"strings"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
-)
-
-func GetLyrics(ctx context.Context, mf *model.MediaFile) (model.LyricList, error) {
-	var lyricsList model.LyricList
-	var err error
-
-	for pattern := range strings.SplitSeq(strings.ToLower(conf.Server.LyricsPriority), ",") {
-		pattern = strings.TrimSpace(pattern)
-		switch {
-		case pattern == "embedded":
-			lyricsList, err = fromEmbedded(ctx, mf)
-		case strings.HasPrefix(pattern, "."):
-			lyricsList, err = fromExternalFile(ctx, mf, pattern)
-		default:
-			log.Error(ctx, "Invalid lyric pattern", "pattern", pattern)
-		}
-
-		if err != nil {
-			log.Error(ctx, "error parsing lyrics", "source", pattern, err)
-		}
-
-		if len(lyricsList) > 0 {
-			return lyricsList, nil
-		}
-	}
-
-	return nil, nil
-}

core/lyrics/lyrics_suite_test.go

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

core/lyrics/lyrics_test.go

@@ -1,124 +0,0 @@
-package lyrics_test
-
-import (
-	"context"
-	"encoding/json"
-	"os"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/conf/configtest"
-	"github.com/navidrome/navidrome/core/lyrics"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/utils"
-	"github.com/navidrome/navidrome/utils/gg"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("sources", func() {
-	var mf model.MediaFile
-	var ctx context.Context
-
-	const badLyrics = "This is a set of lyrics\nThat is not good"
-	unsynced, _ := model.ToLyrics("xxx", badLyrics)
-	embeddedLyrics := model.LyricList{*unsynced}
-
-	syncedLyrics := model.LyricList{
-		model.Lyrics{
-			DisplayArtist: "Rick Astley",
-			DisplayTitle:  "That one song",
-			Lang:          "eng",
-			Line: []model.Line{
-				{
-					Start: gg.P(int64(18800)),
-					Value: "We're no strangers to love",
-				},
-				{
-					Start: gg.P(int64(22801)),
-					Value: "You know the rules and so do I",
-				},
-			},
-			Offset: gg.P(int64(-100)),
-			Synced: true,
-		},
-	}
-
-	unsyncedLyrics := model.LyricList{
-		model.Lyrics{
-			Lang: "xxx",
-			Line: []model.Line{
-				{
-					Value: "We're no strangers to love",
-				},
-				{
-					Value: "You know the rules and so do I",
-				},
-			},
-			Synced: false,
-		},
-	}
-
-	BeforeEach(func() {
-		DeferCleanup(configtest.SetupConfig())
-
-		lyricsJson, _ := json.Marshal(embeddedLyrics)
-
-		mf = model.MediaFile{
-			Lyrics: string(lyricsJson),
-			Path:   "tests/fixtures/test.mp3",
-		}
-		ctx = context.Background()
-	})
-
-	DescribeTable("Lyrics Priority", func(priority string, expected model.LyricList) {
-		conf.Server.LyricsPriority = priority
-		list, err := lyrics.GetLyrics(ctx, &mf)
-		Expect(err).To(BeNil())
-		Expect(list).To(Equal(expected))
-	},
-		Entry("embedded > lrc > txt", "embedded,.lrc,.txt", embeddedLyrics),
-		Entry("lrc > embedded > txt", ".lrc,embedded,.txt", syncedLyrics),
-		Entry("txt > lrc > embedded", ".txt,.lrc,embedded", unsyncedLyrics))
-
-	Context("Errors", func() {
-		var RegularUserContext = XContext
-		var isRegularUser = os.Getuid() != 0
-		if isRegularUser {
-			RegularUserContext = Context
-		}
-
-		RegularUserContext("run without root permissions", func() {
-			var accessForbiddenFile string
-
-			BeforeEach(func() {
-				accessForbiddenFile = utils.TempFileName("access_forbidden-", ".mp3")
-
-				f, err := os.OpenFile(accessForbiddenFile, os.O_WRONLY|os.O_CREATE, 0222)
-				Expect(err).ToNot(HaveOccurred())
-
-				mf.Path = accessForbiddenFile
-
-				DeferCleanup(func() {
-					Expect(f.Close()).To(Succeed())
-					Expect(os.Remove(accessForbiddenFile)).To(Succeed())
-				})
-			})
-
-			It("should fallback to embedded if an error happens when parsing file", func() {
-				conf.Server.LyricsPriority = ".mp3,embedded"
-
-				list, err := lyrics.GetLyrics(ctx, &mf)
-				Expect(err).To(BeNil())
-				Expect(list).To(Equal(embeddedLyrics))
-			})
-
-			It("should return nothing if error happens when trying to parse file", func() {
-				conf.Server.LyricsPriority = ".mp3"
-
-				list, err := lyrics.GetLyrics(ctx, &mf)
-				Expect(err).To(BeNil())
-				Expect(list).To(BeEmpty())
-			})
-		})
-	})
-})

core/lyrics/sources.go

@@ -1,51 +0,0 @@
-package lyrics
-
-import (
-	"context"
-	"errors"
-	"os"
-	"path"
-
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/utils/ioutils"
-)
-
-func fromEmbedded(ctx context.Context, mf *model.MediaFile) (model.LyricList, error) {
-	if mf.Lyrics != "" {
-		log.Trace(ctx, "embedded lyrics found in file", "title", mf.Title)
-		return mf.StructuredLyrics()
-	}
-
-	log.Trace(ctx, "no embedded lyrics for file", "path", mf.Title)
-
-	return nil, nil
-}
-
-func fromExternalFile(ctx context.Context, mf *model.MediaFile, suffix string) (model.LyricList, error) {
-	basePath := mf.AbsolutePath()
-	ext := path.Ext(basePath)
-
-	externalLyric := basePath[0:len(basePath)-len(ext)] + suffix
-
-	contents, err := ioutils.UTF8ReadFile(externalLyric)
-	if errors.Is(err, os.ErrNotExist) {
-		log.Trace(ctx, "no lyrics found at path", "path", externalLyric)
-		return nil, nil
-	} else if err != nil {
-		return nil, err
-	}
-
-	lyrics, err := model.ToLyrics("xxx", string(contents))
-	if err != nil {
-		log.Error(ctx, "error parsing lyric external file", "path", externalLyric, err)
-		return nil, err
-	} else if lyrics == nil {
-		log.Trace(ctx, "empty lyrics from external file", "path", externalLyric)
-		return nil, nil
-	}
-
-	log.Trace(ctx, "retrieved lyrics from external file", "path", externalLyric)
-
-	return model.LyricList{*lyrics}, nil
-}

core/lyrics/sources_test.go

@@ -1,146 +0,0 @@
-package lyrics
-
-import (
-	"context"
-	"encoding/json"
-
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/utils/gg"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("sources", func() {
-	ctx := context.Background()
-
-	Describe("fromEmbedded", func() {
-		It("should return nothing for a media file with no lyrics", func() {
-			mf := model.MediaFile{}
-			lyrics, err := fromEmbedded(ctx, &mf)
-
-			Expect(err).To(BeNil())
-			Expect(lyrics).To(HaveLen(0))
-		})
-
-		It("should return lyrics for a media file with well-formatted lyrics", func() {
-			const syncedLyrics = "[00:18.80]We're no strangers to love\n[00:22.801]You know the rules and so do I"
-			const unsyncedLyrics = "We're no strangers to love\nYou know the rules and so do I"
-
-			synced, _ := model.ToLyrics("eng", syncedLyrics)
-			unsynced, _ := model.ToLyrics("xxx", unsyncedLyrics)
-
-			expectedList := model.LyricList{*synced, *unsynced}
-			lyricsJson, err := json.Marshal(expectedList)
-
-			Expect(err).ToNot(HaveOccurred())
-
-			mf := model.MediaFile{
-				Lyrics: string(lyricsJson),
-			}
-
-			lyrics, err := fromEmbedded(ctx, &mf)
-			Expect(err).To(BeNil())
-			Expect(lyrics).ToNot(BeNil())
-			Expect(lyrics).To(Equal(expectedList))
-		})
-
-		It("should return an error if somehow the JSON is bad", func() {
-			mf := model.MediaFile{Lyrics: "["}
-			lyrics, err := fromEmbedded(ctx, &mf)
-
-			Expect(lyrics).To(HaveLen(0))
-			Expect(err).ToNot(BeNil())
-		})
-	})
-
-	Describe("fromExternalFile", func() {
-		It("should return nil for lyrics that don't exist", func() {
-			mf := model.MediaFile{Path: "tests/fixtures/01 Invisible (RED) Edit Version.mp3"}
-			lyrics, err := fromExternalFile(ctx, &mf, ".lrc")
-
-			Expect(err).To(BeNil())
-			Expect(lyrics).To(HaveLen(0))
-		})
-
-		It("should return synchronized lyrics from a file", func() {
-			mf := model.MediaFile{Path: "tests/fixtures/test.mp3"}
-			lyrics, err := fromExternalFile(ctx, &mf, ".lrc")
-
-			Expect(err).To(BeNil())
-			Expect(lyrics).To(Equal(model.LyricList{
-				model.Lyrics{
-					DisplayArtist: "Rick Astley",
-					DisplayTitle:  "That one song",
-					Lang:          "eng",
-					Line: []model.Line{
-						{
-							Start: gg.P(int64(18800)),
-							Value: "We're no strangers to love",
-						},
-						{
-							Start: gg.P(int64(22801)),
-							Value: "You know the rules and so do I",
-						},
-					},
-					Offset: gg.P(int64(-100)),
-					Synced: true,
-				},
-			}))
-		})
-
-		It("should return unsynchronized lyrics from a file", func() {
-			mf := model.MediaFile{Path: "tests/fixtures/test.mp3"}
-			lyrics, err := fromExternalFile(ctx, &mf, ".txt")
-
-			Expect(err).To(BeNil())
-			Expect(lyrics).To(Equal(model.LyricList{
-				model.Lyrics{
-					Lang: "xxx",
-					Line: []model.Line{
-						{
-							Value: "We're no strangers to love",
-						},
-						{
-							Value: "You know the rules and so do I",
-						},
-					},
-					Synced: false,
-				},
-			}))
-		})
-
-		It("should handle LRC files with UTF-8 BOM marker (issue #4631)", func() {
-			// The function looks for <basePath-without-ext><suffix>, so we need to pass
-			// a MediaFile with .mp3 path and look for .lrc suffix
-			mf := model.MediaFile{Path: "tests/fixtures/bom-test.mp3"}
-			lyrics, err := fromExternalFile(ctx, &mf, ".lrc")
-
-			Expect(err).To(BeNil())
-			Expect(lyrics).ToNot(BeNil())
-			Expect(lyrics).To(HaveLen(1))
-
-			// The critical assertion: even with BOM, synced should be true
-			Expect(lyrics[0].Synced).To(BeTrue(), "Lyrics with BOM marker should be recognized as synced")
-			Expect(lyrics[0].Line).To(HaveLen(1))
-			Expect(lyrics[0].Line[0].Start).To(Equal(gg.P(int64(0))))
-			Expect(lyrics[0].Line[0].Value).To(ContainSubstring("作曲"))
-		})
-
-		It("should handle UTF-16 LE encoded LRC files", func() {
-			mf := model.MediaFile{Path: "tests/fixtures/bom-utf16-test.mp3"}
-			lyrics, err := fromExternalFile(ctx, &mf, ".lrc")
-
-			Expect(err).To(BeNil())
-			Expect(lyrics).ToNot(BeNil())
-			Expect(lyrics).To(HaveLen(1))
-
-			// UTF-16 should be properly converted to UTF-8
-			Expect(lyrics[0].Synced).To(BeTrue(), "UTF-16 encoded lyrics should be recognized as synced")
-			Expect(lyrics[0].Line).To(HaveLen(2))
-			Expect(lyrics[0].Line[0].Start).To(Equal(gg.P(int64(18800))))
-			Expect(lyrics[0].Line[0].Value).To(Equal("We're no strangers to love"))
-			Expect(lyrics[0].Line[1].Start).To(Equal(gg.P(int64(22801))))
-			Expect(lyrics[0].Line[1].Value).To(Equal("You know the rules and so do I"))
-		})
-	})
-})

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

core/metrics/insights.go

@@ -6,7 +6,6 @@ import (
 	"encoding/json"
 	"math"
 	"net/http"
-	"os"
 	"path/filepath"
 	"runtime"
 	"runtime/debug"
@@ -22,9 +21,6 @@ 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"
-	"github.com/navidrome/navidrome/server/events"
 	"github.com/navidrome/navidrome/utils/singleton"
 )
 
@@ -60,16 +56,9 @@ func GetInstance(ds model.DataStore) Insights {
 }
 
 func (c *insightsCollector) Run(ctx context.Context) {
+	ctx = auth.WithAdminUser(ctx, c.ds)
 	for {
-		// Refresh admin context on each iteration to handle cases where
-		// 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)
-		}
+		c.sendInsights(ctx)
 		select {
 		case <-time.After(consts.InsightsUpdateInterval):
 			continue
@@ -164,13 +153,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
@@ -194,15 +176,13 @@ var staticData = sync.OnceValue(func() insights.Data {
 	data.Config.DefaultBackgroundURLSet = conf.Server.UILoginBackgroundURL == consts.DefaultUILoginBackgroundURL
 	data.Config.EnableArtworkPrecache = conf.Server.EnableArtworkPrecache
 	data.Config.EnableCoverAnimation = conf.Server.EnableCoverAnimation
-	data.Config.EnableNowPlaying = conf.Server.EnableNowPlaying
 	data.Config.EnableDownloads = conf.Server.EnableDownloads
 	data.Config.EnableSharing = conf.Server.EnableSharing
 	data.Config.EnableStarRating = conf.Server.EnableStarRating
-	data.Config.EnableLastFM = conf.Server.LastFM.Enabled && conf.Server.LastFM.ApiKey != "" && conf.Server.LastFM.Secret != ""
-	data.Config.EnableSpotify = conf.Server.Spotify.ID != "" && conf.Server.Spotify.Secret != ""
+	data.Config.EnableLastFM = conf.Server.LastFM.Enabled
 	data.Config.EnableListenBrainz = conf.Server.ListenBrainz.Enabled
-	data.Config.EnableDeezer = conf.Server.Deezer.Enabled
 	data.Config.EnableMediaFileCoverArt = conf.Server.EnableMediaFileCoverArt
+	data.Config.EnableSpotify = conf.Server.Spotify.ID != ""
 	data.Config.EnableJukebox = conf.Server.Jukebox.Enabled
 	data.Config.EnablePrometheus = conf.Server.Prometheus.Enabled
 	data.Config.TranscodingCacheSize = conf.Server.TranscodingCacheSize
@@ -218,9 +198,6 @@ var staticData = sync.OnceValue(func() insights.Data {
 	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.HasCustomPID = conf.Server.PID.Track != "" || conf.Server.PID.Album != ""
-	data.Config.HasCustomTags = len(conf.Server.Tags) > 0
 
 	return data
 })
@@ -255,29 +232,12 @@ func (c *insightsCollector) collect(ctx context.Context) []byte {
 	if err != nil {
 		log.Trace(ctx, "Error reading radios count", err)
 	}
-	data.Library.Libraries, err = c.ds.Library(ctx).CountAll()
-	if err != nil {
-		log.Trace(ctx, "Error reading libraries count", err)
-	}
 	data.Library.ActiveUsers, err = c.ds.User(ctx).CountAll(model.QueryOptions{
 		Filters: squirrel.Gt{"last_access_at": time.Now().Add(-7 * 24 * time.Hour)},
 	})
 	if err != nil {
 		log.Trace(ctx, "Error reading active users count", err)
 	}
-
-	// Check for smart playlists
-	data.Config.HasSmartPlaylists, err = c.hasSmartPlaylists(ctx)
-	if err != nil {
-		log.Trace(ctx, "Error checking for smart playlists", err)
-	}
-
-	// Collect plugins if permitted and enabled
-	if conf.Server.DevEnablePluginsInsights && conf.Server.Plugins.Enabled {
-		data.Plugins = c.collectPlugins(ctx)
-	}
-
-	// Collect active players if permitted
 	if conf.Server.DevEnablePlayerInsights {
 		data.Library.ActivePlayers, err = c.ds.Player(ctx).CountByClient(model.QueryOptions{
 			Filters: squirrel.Gt{"last_seen": time.Now().Add(-7 * 24 * time.Hour)},
@@ -303,27 +263,3 @@ func (c *insightsCollector) collect(ctx context.Context) []byte {
 	}
 	return resp
 }
-
-// hasSmartPlaylists checks if there are any smart playlists (playlists with rules)
-func (c *insightsCollector) hasSmartPlaylists(ctx context.Context) (bool, error) {
-	count, err := c.ds.Playlist(ctx).CountAll(model.QueryOptions{
-		Filters: squirrel.And{squirrel.NotEq{"rules": ""}, squirrel.NotEq{"rules": nil}},
-	})
-	return count > 0, err
-}
-
-// collectPlugins collects information about installed plugins
-func (c *insightsCollector) collectPlugins(_ context.Context) map[string]insights.PluginInfo {
-	// TODO Fix import/inject cycles
-	manager := plugins.GetManager(c.ds, events.GetBroker())
-	info := manager.GetPluginInfo()
-
-	result := make(map[string]insights.PluginInfo, len(info))
-	for name, p := range info {
-		result[name] = insights.PluginInfo{
-			Name:    p.Name,
-			Version: p.Version,
-		}
-	}
-	return result
-}

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"`
@@ -37,7 +36,6 @@ type Data struct {
 		Playlists     int64            `json:"playlists"`
 		Shares        int64            `json:"shares"`
 		Radios        int64            `json:"radios"`
-		Libraries     int64            `json:"libraries"`
 		ActiveUsers   int64            `json:"activeUsers"`
 		ActivePlayers map[string]int64 `json:"activePlayers,omitempty"`
 	} `json:"library"`
@@ -57,13 +55,11 @@ type Data struct {
 		EnableStarRating        bool   `json:"enableStarRating,omitempty"`
 		EnableLastFM            bool   `json:"enableLastFM,omitempty"`
 		EnableListenBrainz      bool   `json:"enableListenBrainz,omitempty"`
-		EnableDeezer            bool   `json:"enableDeezer,omitempty"`
 		EnableMediaFileCoverArt bool   `json:"enableMediaFileCoverArt,omitempty"`
 		EnableSpotify           bool   `json:"enableSpotify,omitempty"`
 		EnableJukebox           bool   `json:"enableJukebox,omitempty"`
 		EnablePrometheus        bool   `json:"enablePrometheus,omitempty"`
 		EnableCoverAnimation    bool   `json:"enableCoverAnimation,omitempty"`
-		EnableNowPlaying        bool   `json:"enableNowPlaying,omitempty"`
 		SessionTimeout          uint64 `json:"sessionTimeout,omitempty"`
 		SearchFullString        bool   `json:"searchFullString,omitempty"`
 		RecentlyAddedByModTime  bool   `json:"recentlyAddedByModTime,omitempty"`
@@ -72,17 +68,7 @@ type Data struct {
 		BackupCount             int    `json:"backupCount,omitempty"`
 		DevActivityPanel        bool   `json:"devActivityPanel,omitempty"`
 		DefaultBackgroundURLSet bool   `json:"defaultBackgroundURL,omitempty"`
-		HasSmartPlaylists       bool   `json:"hasSmartPlaylists,omitempty"`
-		ReverseProxyConfigured  bool   `json:"reverseProxyConfigured,omitempty"`
-		HasCustomPID            bool   `json:"hasCustomPID,omitempty"`
-		HasCustomTags           bool   `json:"hasCustomTags,omitempty"`
 	} `json:"config"`
-	Plugins map[string]PluginInfo `json:"plugins,omitempty"`
-}
-
-type PluginInfo struct {
-	Name    string `json:"name"`
-	Version string `json:"version"`
 }
 
 type FSInfo struct {

core/metrics/insights_linux.go

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

core/metrics/prometheus.go

@@ -2,6 +2,7 @@ package metrics
 
 import (
 	"context"
+	"fmt"
 	"net/http"
 	"strconv"
 	"sync"
@@ -12,7 +13,6 @@ import (
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/utils/singleton"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 )
@@ -20,8 +20,6 @@ import (
 type Metrics interface {
 	WriteInitialMetrics(ctx context.Context)
 	WriteAfterScanMetrics(ctx context.Context, success bool)
-	RecordRequest(ctx context.Context, endpoint, method, client string, status int32, elapsed int64)
-	RecordPluginRequest(ctx context.Context, plugin, method string, ok bool, elapsed int64)
 	GetHandler() http.Handler
 }
 
@@ -29,14 +27,11 @@ type metrics struct {
 	ds model.DataStore
 }
 
-func GetPrometheusInstance(ds model.DataStore) Metrics {
-	if !conf.Server.Prometheus.Enabled {
-		return noopMetrics{}
-	}
-
-	return singleton.GetInstance(func() *metrics {
+func NewPrometheusInstance(ds model.DataStore) Metrics {
+	if conf.Server.Prometheus.Enabled {
 		return &metrics{ds: ds}
-	})
+	}
+	return noopMetrics{}
 }
 
 func NewNoopInstance() Metrics {
@@ -56,38 +51,6 @@ func (m *metrics) WriteAfterScanMetrics(ctx context.Context, success bool) {
 	getPrometheusMetrics().mediaScansCounter.With(scanLabels).Inc()
 }
 
-func (m *metrics) RecordRequest(_ context.Context, endpoint, method, client string, status int32, elapsed int64) {
-	httpLabel := prometheus.Labels{
-		"endpoint": endpoint,
-		"method":   method,
-		"client":   client,
-		"status":   strconv.FormatInt(int64(status), 10),
-	}
-	getPrometheusMetrics().httpRequestCounter.With(httpLabel).Inc()
-
-	httpLatencyLabel := prometheus.Labels{
-		"endpoint": endpoint,
-		"method":   method,
-		"client":   client,
-	}
-	getPrometheusMetrics().httpRequestDuration.With(httpLatencyLabel).Observe(float64(elapsed))
-}
-
-func (m *metrics) RecordPluginRequest(_ context.Context, plugin, method string, ok bool, elapsed int64) {
-	pluginLabel := prometheus.Labels{
-		"plugin": plugin,
-		"method": method,
-		"ok":     strconv.FormatBool(ok),
-	}
-	getPrometheusMetrics().pluginRequestCounter.With(pluginLabel).Inc()
-
-	pluginLatencyLabel := prometheus.Labels{
-		"plugin": plugin,
-		"method": method,
-	}
-	getPrometheusMetrics().pluginRequestDuration.With(pluginLatencyLabel).Observe(float64(elapsed))
-}
-
 func (m *metrics) GetHandler() http.Handler {
 	r := chi.NewRouter()
 
@@ -96,31 +59,20 @@ func (m *metrics) GetHandler() http.Handler {
 			consts.PrometheusAuthUser: conf.Server.Prometheus.Password,
 		}))
 	}
+	r.Handle("/", promhttp.Handler())
 
-	// Enable created at timestamp to handle zero counter on create.
-	// This requires --enable-feature=created-timestamp-zero-ingestion to be passed in Prometheus
-	r.Handle("/", promhttp.HandlerFor(prometheus.DefaultGatherer, promhttp.HandlerOpts{
-		EnableOpenMetrics:                   true,
-		EnableOpenMetricsTextCreatedSamples: true,
-	}))
 	return r
 }
 
 type prometheusMetrics struct {
-	dbTotal               *prometheus.GaugeVec
-	versionInfo           *prometheus.GaugeVec
-	lastMediaScan         *prometheus.GaugeVec
-	mediaScansCounter     *prometheus.CounterVec
-	httpRequestCounter    *prometheus.CounterVec
-	httpRequestDuration   *prometheus.SummaryVec
-	pluginRequestCounter  *prometheus.CounterVec
-	pluginRequestDuration *prometheus.SummaryVec
+	dbTotal           *prometheus.GaugeVec
+	versionInfo       *prometheus.GaugeVec
+	lastMediaScan     *prometheus.GaugeVec
+	mediaScansCounter *prometheus.CounterVec
 }
 
 // Prometheus' metrics requires initialization. But not more than once
 var getPrometheusMetrics = sync.OnceValue(func() *prometheusMetrics {
-	quartilesToEstimate := map[float64]float64{0.5: 0.05, 0.75: 0.025, 0.9: 0.01, 0.99: 0.001}
-
 	instance := &prometheusMetrics{
 		dbTotal: prometheus.NewGaugeVec(
 			prometheus.GaugeOpts{
@@ -150,49 +102,23 @@ var getPrometheusMetrics = sync.OnceValue(func() *prometheusMetrics {
 			},
 			[]string{"success"},
 		),
-		httpRequestCounter: prometheus.NewCounterVec(
-			prometheus.CounterOpts{
-				Name: "http_request_count",
-				Help: "Request types by status",
-			},
-			[]string{"endpoint", "method", "client", "status"},
-		),
-		httpRequestDuration: prometheus.NewSummaryVec(
-			prometheus.SummaryOpts{
-				Name:       "http_request_latency",
-				Help:       "Latency (in ms) of HTTP requests",
-				Objectives: quartilesToEstimate,
-			},
-			[]string{"endpoint", "method", "client"},
-		),
-		pluginRequestCounter: prometheus.NewCounterVec(
-			prometheus.CounterOpts{
-				Name: "plugin_request_count",
-				Help: "Plugin requests by method/status",
-			},
-			[]string{"plugin", "method", "ok"},
-		),
-		pluginRequestDuration: prometheus.NewSummaryVec(
-			prometheus.SummaryOpts{
-				Name:       "plugin_request_latency",
-				Help:       "Latency (in ms) of plugin requests",
-				Objectives: quartilesToEstimate,
-			},
-			[]string{"plugin", "method"},
-		),
 	}
-
-	prometheus.DefaultRegisterer.MustRegister(
-		instance.dbTotal,
-		instance.versionInfo,
-		instance.lastMediaScan,
-		instance.mediaScansCounter,
-		instance.httpRequestCounter,
-		instance.httpRequestDuration,
-		instance.pluginRequestCounter,
-		instance.pluginRequestDuration,
-	)
-
+	err := prometheus.DefaultRegisterer.Register(instance.dbTotal)
+	if err != nil {
+		log.Fatal("Unable to create Prometheus metric instance", fmt.Errorf("unable to register db_model_totals metrics: %w", err))
+	}
+	err = prometheus.DefaultRegisterer.Register(instance.versionInfo)
+	if err != nil {
+		log.Fatal("Unable to create Prometheus metric instance", fmt.Errorf("unable to register navidrome_info metrics: %w", err))
+	}
+	err = prometheus.DefaultRegisterer.Register(instance.lastMediaScan)
+	if err != nil {
+		log.Fatal("Unable to create Prometheus metric instance", fmt.Errorf("unable to register media_scan_last metrics: %w", err))
+	}
+	err = prometheus.DefaultRegisterer.Register(instance.mediaScansCounter)
+	if err != nil {
+		log.Fatal("Unable to create Prometheus metric instance", fmt.Errorf("unable to register media_scans metrics: %w", err))
+	}
 	return instance
 })
 
@@ -233,8 +159,4 @@ func (n noopMetrics) WriteInitialMetrics(context.Context) {}
 
 func (n noopMetrics) WriteAfterScanMetrics(context.Context, bool) {}
 
-func (n noopMetrics) RecordRequest(context.Context, string, string, string, int32, int64) {}
-
-func (n noopMetrics) RecordPluginRequest(context.Context, string, string, bool, int64) {}
-
 func (n noopMetrics) GetHandler() http.Handler { return nil }

core/mock_library_service.go

@@ -1,46 +0,0 @@
-package core
-
-import (
-	"context"
-
-	"github.com/deluan/rest"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
-)
-
-// MockLibraryWrapper provides a simple wrapper around MockLibraryRepo
-// that implements the core.Library interface for testing
-type MockLibraryWrapper struct {
-	*tests.MockLibraryRepo
-}
-
-// MockLibraryRestAdapter adapts MockLibraryRepo to rest.Repository interface
-type MockLibraryRestAdapter struct {
-	*tests.MockLibraryRepo
-}
-
-// NewMockLibraryService creates a new mock library service for testing
-func NewMockLibraryService() Library {
-	repo := &tests.MockLibraryRepo{
-		Data: make(map[int]model.Library),
-	}
-	// Set up default test data
-	repo.SetData(model.Libraries{
-		{ID: 1, Name: "Test Library 1", Path: "/music/library1"},
-		{ID: 2, Name: "Test Library 2", Path: "/music/library2"},
-	})
-	return &MockLibraryWrapper{MockLibraryRepo: repo}
-}
-
-func (m *MockLibraryWrapper) NewRepository(ctx context.Context) rest.Repository {
-	return &MockLibraryRestAdapter{MockLibraryRepo: m.MockLibraryRepo}
-}
-
-// rest.Repository interface implementation
-
-func (a *MockLibraryRestAdapter) Delete(id string) error {
-	return a.DeleteByStringID(id)
-}
-
-var _ Library = (*MockLibraryWrapper)(nil)
-var _ rest.Repository = (*MockLibraryRestAdapter)(nil)