Merge branch 'master' into fix/default-language-app-startup

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/copilot-instructions.md

@@ -0,0 +1,53 @@
+# Navidrome Code Guidelines
+
+This is a music streaming server written in Go with a React frontend. The application manages music libraries, provides streaming capabilities, and offers various features like artist information, artwork handling, and external service integrations.
+
+## Code Standards
+
+### Backend (Go)
+- Follow standard Go conventions and idioms
+- Use context propagation for cancellation signals
+- Write unit tests for new functionality using Ginkgo/Gomega
+- Use mutex appropriately for concurrent operations
+- Implement interfaces for dependencies to facilitate testing
+
+### Frontend (React)
+- Use functional components with hooks
+- Follow React best practices for state management
+- Implement PropTypes for component properties
+- Prefer using React-Admin and Material-UI components
+- Icons should be imported from `react-icons` only
+- Follow existing patterns for API interaction
+
+## Repository Structure
+- `core/`: Server-side business logic (artwork handling, playback, etc.)
+- `ui/`: React frontend components
+- `model/`: Data models and repository interfaces
+- `server/`: API endpoints and server implementation
+- `utils/`: Shared utility functions
+- `persistence/`: Database access layer
+- `scanner/`: Music library scanning functionality
+
+## Key Guidelines
+1. Maintain cache management patterns for performance
+2. Follow the existing concurrency patterns (mutex, atomic)
+3. Use the testing framework appropriately (Ginkgo/Gomega for Go)
+4. Keep UI components focused and reusable
+5. Document configuration options in code
+6. Consider performance implications when working with music libraries
+7. Follow existing error handling patterns
+8. Ensure compatibility with external services (LastFM, Spotify)
+
+## Development Workflow
+- Test changes thoroughly, especially around concurrent operations
+- Validate both backend and frontend interactions
+- Consider how changes will affect user experience and performance
+- Test with different music library sizes and configurations
+- Before committing, ALWAYS run `make format lint test`, and make sure there are no issues
+
+## Important commands
+- `make build`: Build the application
+- `make test`: Run Go tests
+- To run tests for a specific package, use `make test PKG=./pkgname/...`
+- `make lintall`: Run linters
+- `make format`: Format code

.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@v8
         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,7 @@ music
 docker-compose.yml
 !contrib/docker-compose.yml
 binaries
-navidrome-*
-/ndpgen
+navidrome-master
 AGENTS.md
-.github/prompts
-.github/instructions
-.github/git-commit-instructions.md
 *.exe
-*.test
-*.wasm
-*.ndp
-openspec/
+bin/

.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,29 @@ 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
+test: ##@Development Run Go tests
 	go test -tags netgo $(PKG)
 .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)
 .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
+	@PATH=$$PATH:./bin which golangci-lint > /dev/null || (echo "Installing golangci-lint..." && curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/HEAD/install.sh | sh -s v2.1.6)
 .PHONY: install-golangci-lint
 
 lint: install-golangci-lint ##@Development Lint Go code
-	PATH=$$PATH:./bin golangci-lint run --timeout 5m
+	PATH=$$PATH:./bin golangci-lint run -v --timeout 5m
 .PHONY: lint
 
 lintall: lint ##@Development Lint Go and JS code
@@ -95,7 +64,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 +72,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 +153,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

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

@@ -179,7 +179,7 @@ var _ = Describe("Extractor", func() {
 			Entry("correctly parses wma/asf tags", "test.wma", "1.02s", 1, 44100, 16, "3.27 dB", "0.132914", "3.27 dB", "0.132914", false, true),
 
 			// ffmpeg -f lavfi -i "sine=frequency=800:duration=1" test.wv
-			Entry("correctly parses wv (wavpak) tags", "test.wv", "1s", 1, 44100, 16, "3.43 dB", "0.125061", "3.43 dB", "0.125061", false, true),
+			Entry("correctly parses wv (wavpak) tags", "test.wv", "1s", 1, 44100, 16, "3.43 dB", "0.125061", "3.43 dB", "0.125061", false, 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),

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);
     }
   }
@@ -280,19 +242,7 @@ char has_cover(const TagLib::FileRef f) {
   // ----- 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();
-    }
+    hasCover = tag && asfFile->tag()->attributeListMap().contains("WM/Picture");
   }
 
   return hasCover;

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,7 +66,6 @@ type configOptions struct {
 	CoverArtPriority                string
 	CoverJpegQuality                int
 	ArtistArtPriority               string
-	LyricsPriority                  string
 	EnableGravatar                  bool
 	EnableFavourites                bool
 	EnableStarRating                bool
@@ -81,58 +79,49 @@ type configOptions struct {
 	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
+	LyricsPriority                  string
+
+	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
+	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 {
@@ -156,20 +145,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 +165,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 +207,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 +225,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 +246,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,7 +274,7 @@ func Load(noConfigDump bool) {
 	log.SetLogSourceLine(Server.DevLogSourceLine)
 	log.SetRedacting(Server.EnableLogRedacting)
 
-	err = run.Sequentially(
+	err = chain.RunSequentially(
 		validateScanSchedule,
 		validateBackupSchedule,
 		validatePlaylistsPath,
@@ -343,18 +297,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 +314,9 @@ 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")
+	logDeprecatedOptions("DevEnableBufferedScrobble") // Deprecated: Buffered scrobbling is now always enabled and this option is ignored
 
 	// Call init hooks
 	for _, hook := range hooks {
@@ -382,29 +324,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 +366,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 {
@@ -467,7 +394,7 @@ func validatePurgeMissingOption() error {
 		}
 	}
 	if !valid {
-		err := fmt.Errorf("invalid Scanner.PurgeMissing value: '%s'. Must be one of: %v", Server.Scanner.PurgeMissing, allowedValues)
+		err := fmt.Errorf("Invalid Scanner.PurgeMissing value: '%s'. Must be one of: %v", Server.Scanner.PurgeMissing, allowedValues)
 		log.Error(err.Error())
 		Server.Scanner.PurgeMissing = consts.PurgeMissingNever
 		return err
@@ -514,16 +441,6 @@ func AddHook(hook func()) {
 	hooks = append(hooks, hook)
 }
 
-// hasNDEnvVars checks if any ND_ prefixed environment variables are set (excluding ND_CONFIGFILE)
-func hasNDEnvVars() bool {
-	for _, env := range os.Environ() {
-		if strings.HasPrefix(env, "ND_") && !strings.HasPrefix(env, "ND_CONFIGFILE=") {
-			return true
-		}
-	}
-	return false
-}
-
 func setViperDefaults() {
 	viper.SetDefault("musicfolder", filepath.Join(".", "music"))
 	viper.SetDefault("cachefolder", "")
@@ -541,7 +458,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 +477,10 @@ 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,7 +490,6 @@ 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)
@@ -586,8 +500,8 @@ func setViperDefaults() {
 	viper.SetDefault("authrequestlimit", 5)
 	viper.SetDefault("authwindowlength", 20*time.Second)
 	viper.SetDefault("passwordencryptionkey", "")
-	viper.SetDefault("extauth.userheader", "Remote-User")
-	viper.SetDefault("extauth.trustedsources", "")
+	viper.SetDefault("reverseproxyuserheader", "Remote-User")
+	viper.SetDefault("reverseproxywhitelist", "")
 	viper.SetDefault("prometheus.enabled", false)
 	viper.SetDefault("prometheus.metricspath", consts.PrometheusDefaultPath)
 	viper.SetDefault("prometheus.password", "")
@@ -604,25 +518,21 @@ func setViperDefaults() {
 	viper.SetDefault("scanner.genreseparators", "")
 	viper.SetDefault("scanner.groupalbumreleases", false)
 	viper.SetDefault("scanner.followsymlinks", true)
-	viper.SetDefault("scanner.purgemissing", consts.PurgeMissingNever)
+	viper.SetDefault("scanner.purgemissing", "never")
 	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)
@@ -632,12 +542,7 @@ func setViperDefaults() {
 	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("lyricspriority", ".lrc,.txt,embedded")
 	viper.SetDefault("devlogsourceline", false)
 	viper.SetDefault("devenableprofiler", false)
 	viper.SetDefault("devautocreateadminpassword", "")
@@ -646,8 +551,6 @@ func setViperDefaults() {
 	viper.SetDefault("devactivitypanelupdaterate", 300*time.Millisecond)
 	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 +559,17 @@ 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 +583,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

@@ -31,7 +31,7 @@ var _ = Describe("Configuration", func() {
 			filename := filepath.Join("testdata", "cfg."+format)
 
 			// Initialize config with the test file
-			conf.InitConfig(filename, false)
+			conf.InitConfig(filename)
 			// Load the configuration (with noConfigDump=true)
 			conf.Load(true)
 
@@ -39,10 +39,6 @@ var _ = Describe("Configuration", func() {
 			Expect(conf.Server.MusicFolder).To(Equal(fmt.Sprintf("/%s/music", format)))
 			Expect(conf.Server.UIWelcomeMessage).To(Equal("Welcome " + format))
 			Expect(conf.Server.Tags["custom"].Aliases).To(Equal([]string{format, "test"}))
-			Expect(conf.Server.Tags["artist"].Split).To(Equal([]string{";"}))
-
-			// Check deprecated option mapping
-			Expect(conf.Server.ExtAuth.UserHeader).To(Equal("X-Auth-User"))
 
 			// The config file used should be the one we created
 			Expect(conf.Server.ConfigFile).To(Equal(filename))

conf/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

@@ -150,8 +150,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, init(ds))
 	}
+	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/deezer_suite_test.go

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

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 {

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

@@ -96,11 +96,8 @@ func (a *cacheWarmer) run(ctx context.Context) {
 
 		// 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

@@ -80,7 +80,6 @@ var _ = Describe("CacheWarmer", func() {
 		})
 
 		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"))
@@ -90,7 +89,6 @@ var _ = Describe("CacheWarmer", func() {
 		})
 
 		It("deduplicates items in buffer", func() {
-			fc.SetReady(false) // Make cache unavailable so items stay in buffer
 			cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
 			cw.PreCache(model.MustParseArtworkID("al-1"))
 			cw.PreCache(model.MustParseArtworkID("al-1"))
@@ -216,7 +214,3 @@ 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
@@ -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"
 
@@ -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,7 +11,6 @@ import (
 	"github.com/Masterminds/squirrel"
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/core/agents"
-	_ "github.com/navidrome/navidrome/core/agents/deezer"
 	_ "github.com/navidrome/navidrome/core/agents/lastfm"
 	_ "github.com/navidrome/navidrome/core/agents/listenbrainz"
 	_ "github.com/navidrome/navidrome/core/agents/spotify"
@@ -36,7 +34,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 +49,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 +85,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 +103,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 +113,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 +122,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 +139,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 +177,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 +206,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 +216,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 +225,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 +242,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 +257,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 +265,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 +340,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 +398,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 +463,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 +473,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 +492,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 +528,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 +560,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 +580,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/sources.go

@@ -8,7 +8,6 @@ import (
 
 	"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) {
@@ -28,7 +27,8 @@ func fromExternalFile(ctx context.Context, mf *model.MediaFile, suffix string) (
 
 	externalLyric := basePath[0:len(basePath)-len(ext)] + suffix
 
-	contents, err := ioutils.UTF8ReadFile(externalLyric)
+	contents, err := os.ReadFile(externalLyric)
+
 	if errors.Is(err, os.ErrNotExist) {
 		log.Trace(ctx, "no lyrics found at path", "path", externalLyric)
 		return nil, nil

core/lyrics/sources_test.go

@@ -108,39 +108,5 @@ var _ = Describe("sources", func() {
 				},
 			}))
 		})
-
-		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)

core/playback/mpv/mpv.go

@@ -10,15 +10,11 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/kballard/go-shellquote"
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/log"
 )
 
 func start(ctx context.Context, args []string) (Executor, error) {
-	if len(args) == 0 {
-		return Executor{}, fmt.Errorf("no command arguments provided")
-	}
 	log.Debug("Executing mpv command", "cmd", args)
 	j := Executor{args: args}
 	j.PipeReader, j.out = io.Pipe()
@@ -75,32 +71,28 @@ func (j *Executor) wait() {
 
 // Path will always be an absolute path
 func createMPVCommand(deviceName string, filename string, socketName string) []string {
-	// Parse the template structure using shell parsing to handle quoted arguments
-	templateArgs, err := shellquote.Split(conf.Server.MPVCmdTemplate)
-	if err != nil {
-		log.Error("Failed to parse MPV command template", "template", conf.Server.MPVCmdTemplate, err)
-		return nil
+	split := strings.Split(fixCmd(conf.Server.MPVCmdTemplate), " ")
+	for i, s := range split {
+		s = strings.ReplaceAll(s, "%d", deviceName)
+		s = strings.ReplaceAll(s, "%f", filename)
+		s = strings.ReplaceAll(s, "%s", socketName)
+		split[i] = s
 	}
+	return split
+}
 
-	// Replace placeholders in each parsed argument to preserve spaces in substituted values
-	for i, arg := range templateArgs {
-		arg = strings.ReplaceAll(arg, "%d", deviceName)
-		arg = strings.ReplaceAll(arg, "%f", filename)
-		arg = strings.ReplaceAll(arg, "%s", socketName)
-		templateArgs[i] = arg
-	}
-
-	// Replace mpv executable references with the configured path
-	if len(templateArgs) > 0 {
-		cmdPath, err := mpvCommand()
-		if err == nil {
-			if templateArgs[0] == "mpv" || templateArgs[0] == "mpv.exe" {
-				templateArgs[0] = cmdPath
-			}
+func fixCmd(cmd string) string {
+	split := strings.Split(cmd, " ")
+	var result []string
+	cmdPath, _ := mpvCommand()
+	for _, s := range split {
+		if s == "mpv" || s == "mpv.exe" {
+			result = append(result, cmdPath)
+		} else {
+			result = append(result, s)
 		}
 	}
-
-	return templateArgs
+	return strings.Join(result, " ")
 }
 
 // This is a 1:1 copy of the stuff in ffmpeg.go, need to be unified.

core/playback/mpv/mpv_suite_test.go

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

core/playback/mpv/mpv_test.go

@@ -1,390 +0,0 @@
-package mpv
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/conf/configtest"
-	"github.com/navidrome/navidrome/model"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("MPV", func() {
-	var (
-		testScript string
-		tempDir    string
-	)
-
-	BeforeEach(func() {
-		DeferCleanup(configtest.SetupConfig())
-
-		// Reset MPV cache
-		mpvOnce = sync.Once{}
-		mpvPath = ""
-		mpvErr = nil
-
-		// Create temporary directory for test files
-		var err error
-		tempDir, err = os.MkdirTemp("", "mpv_test_*")
-		Expect(err).ToNot(HaveOccurred())
-		DeferCleanup(func() { os.RemoveAll(tempDir) })
-
-		// Create mock MPV script that outputs arguments to stdout
-		testScript = createMockMPVScript(tempDir)
-
-		// Configure test MPV path
-		conf.Server.MPVPath = testScript
-	})
-
-	Describe("createMPVCommand", func() {
-		Context("with default template", func() {
-			BeforeEach(func() {
-				conf.Server.MPVCmdTemplate = "mpv --audio-device=%d --no-audio-display --pause %f --input-ipc-server=%s"
-			})
-
-			It("creates correct command with simple paths", func() {
-				args := createMPVCommand("auto", "/music/test.mp3", "/tmp/socket")
-				Expect(args).To(Equal([]string{
-					testScript,
-					"--audio-device=auto",
-					"--no-audio-display",
-					"--pause",
-					"/music/test.mp3",
-					"--input-ipc-server=/tmp/socket",
-				}))
-			})
-
-			It("handles paths with spaces", func() {
-				args := createMPVCommand("auto", "/music/My Album/01 - Song.mp3", "/tmp/socket")
-				Expect(args).To(Equal([]string{
-					testScript,
-					"--audio-device=auto",
-					"--no-audio-display",
-					"--pause",
-					"/music/My Album/01 - Song.mp3",
-					"--input-ipc-server=/tmp/socket",
-				}))
-			})
-
-			It("handles complex device names", func() {
-				deviceName := "coreaudio/AppleUSBAudioEngine:Cambridge Audio :Cambridge Audio USB Audio 1.0:0000:1"
-				args := createMPVCommand(deviceName, "/music/test.mp3", "/tmp/socket")
-				Expect(args).To(Equal([]string{
-					testScript,
-					"--audio-device=" + deviceName,
-					"--no-audio-display",
-					"--pause",
-					"/music/test.mp3",
-					"--input-ipc-server=/tmp/socket",
-				}))
-			})
-		})
-
-		Context("with snapcast template (issue #3619)", func() {
-			BeforeEach(func() {
-				// This is the template that fails with naive space splitting
-				conf.Server.MPVCmdTemplate = "mpv --no-audio-display --pause %f --input-ipc-server=%s --audio-channels=stereo --audio-samplerate=48000 --audio-format=s16 --ao=pcm --ao-pcm-file=/audio/snapcast_fifo"
-			})
-
-			It("creates correct command for snapcast integration", func() {
-				args := createMPVCommand("auto", "/music/test.mp3", "/tmp/socket")
-				Expect(args).To(Equal([]string{
-					testScript,
-					"--no-audio-display",
-					"--pause",
-					"/music/test.mp3",
-					"--input-ipc-server=/tmp/socket",
-					"--audio-channels=stereo",
-					"--audio-samplerate=48000",
-					"--audio-format=s16",
-					"--ao=pcm",
-					"--ao-pcm-file=/audio/snapcast_fifo",
-				}))
-			})
-		})
-
-		Context("with wrapper script template", func() {
-			BeforeEach(func() {
-				// Test case that would break with naive splitting due to quoted arguments
-				conf.Server.MPVCmdTemplate = `/tmp/mpv.sh --no-audio-display --pause %f --input-ipc-server=%s --audio-channels=stereo`
-			})
-
-			It("handles wrapper script paths", func() {
-				args := createMPVCommand("auto", "/music/test.mp3", "/tmp/socket")
-				Expect(args).To(Equal([]string{
-					"/tmp/mpv.sh",
-					"--no-audio-display",
-					"--pause",
-					"/music/test.mp3",
-					"--input-ipc-server=/tmp/socket",
-					"--audio-channels=stereo",
-				}))
-			})
-		})
-
-		Context("with extra spaces in template", func() {
-			BeforeEach(func() {
-				conf.Server.MPVCmdTemplate = "mpv    --audio-device=%d   --no-audio-display     --pause %f --input-ipc-server=%s"
-			})
-
-			It("handles extra spaces correctly", func() {
-				args := createMPVCommand("auto", "/music/test.mp3", "/tmp/socket")
-				Expect(args).To(Equal([]string{
-					testScript,
-					"--audio-device=auto",
-					"--no-audio-display",
-					"--pause",
-					"/music/test.mp3",
-					"--input-ipc-server=/tmp/socket",
-				}))
-			})
-		})
-		Context("with paths containing spaces in template arguments", func() {
-			BeforeEach(func() {
-				// Template with spaces in the path arguments themselves
-				conf.Server.MPVCmdTemplate = `mpv --no-audio-display --pause %f --ao-pcm-file="/audio/my folder/snapcast_fifo" --input-ipc-server=%s`
-			})
-
-			It("handles spaces in quoted template argument paths", func() {
-				args := createMPVCommand("auto", "/music/test.mp3", "/tmp/socket")
-				// This test reveals the limitation of strings.Fields() - it will split on all spaces
-				// Expected behavior would be to keep the path as one argument
-				Expect(args).To(Equal([]string{
-					testScript,
-					"--no-audio-display",
-					"--pause",
-					"/music/test.mp3",
-					"--ao-pcm-file=/audio/my folder/snapcast_fifo", // This should be one argument
-					"--input-ipc-server=/tmp/socket",
-				}))
-			})
-		})
-
-		Context("with malformed template", func() {
-			BeforeEach(func() {
-				// Template with unmatched quotes that will cause shell parsing to fail
-				conf.Server.MPVCmdTemplate = `mpv --no-audio-display --pause %f --input-ipc-server=%s --ao-pcm-file="/unclosed/quote`
-			})
-
-			It("returns nil when shell parsing fails", func() {
-				args := createMPVCommand("auto", "/music/test.mp3", "/tmp/socket")
-				Expect(args).To(BeNil())
-			})
-		})
-
-		Context("with empty template", func() {
-			BeforeEach(func() {
-				conf.Server.MPVCmdTemplate = ""
-			})
-
-			It("returns empty slice for empty template", func() {
-				args := createMPVCommand("auto", "/music/test.mp3", "/tmp/socket")
-				Expect(args).To(Equal([]string{}))
-			})
-		})
-	})
-
-	Describe("start", func() {
-		BeforeEach(func() {
-			conf.Server.MPVCmdTemplate = "mpv --audio-device=%d --no-audio-display --pause %f --input-ipc-server=%s"
-		})
-
-		It("executes MPV command and captures arguments correctly", func() {
-			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-			defer cancel()
-
-			deviceName := "auto"
-			filename := "/music/test.mp3"
-			socketName := "/tmp/test_socket"
-
-			args := createMPVCommand(deviceName, filename, socketName)
-			executor, err := start(ctx, args)
-			Expect(err).ToNot(HaveOccurred())
-
-			// Read all the output from stdout (this will block until the process finishes or is canceled)
-			output, err := io.ReadAll(executor)
-			Expect(err).ToNot(HaveOccurred())
-
-			// Parse the captured arguments
-			lines := strings.Split(strings.TrimSpace(string(output)), "\n")
-			Expect(lines).To(HaveLen(6))
-			Expect(lines[0]).To(Equal(testScript))
-			Expect(lines[1]).To(Equal("--audio-device=auto"))
-			Expect(lines[2]).To(Equal("--no-audio-display"))
-			Expect(lines[3]).To(Equal("--pause"))
-			Expect(lines[4]).To(Equal("/music/test.mp3"))
-			Expect(lines[5]).To(Equal("--input-ipc-server=/tmp/test_socket"))
-		})
-
-		It("handles file paths with spaces", func() {
-			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-			defer cancel()
-
-			deviceName := "auto"
-			filename := "/music/My Album/01 - My Song.mp3"
-			socketName := "/tmp/test socket"
-
-			args := createMPVCommand(deviceName, filename, socketName)
-			executor, err := start(ctx, args)
-			Expect(err).ToNot(HaveOccurred())
-
-			// Read all the output from stdout (this will block until the process finishes or is canceled)
-			output, err := io.ReadAll(executor)
-			Expect(err).ToNot(HaveOccurred())
-
-			// Parse the captured arguments
-			lines := strings.Split(strings.TrimSpace(string(output)), "\n")
-			Expect(lines).To(ContainElement("/music/My Album/01 - My Song.mp3"))
-			Expect(lines).To(ContainElement("--input-ipc-server=/tmp/test socket"))
-		})
-
-		Context("with complex snapcast configuration", func() {
-			BeforeEach(func() {
-				conf.Server.MPVCmdTemplate = "mpv --no-audio-display --pause %f --input-ipc-server=%s --audio-channels=stereo --audio-samplerate=48000 --audio-format=s16 --ao=pcm --ao-pcm-file=/audio/snapcast_fifo"
-			})
-
-			It("passes all snapcast arguments correctly", func() {
-				ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-				defer cancel()
-
-				deviceName := "auto"
-				filename := "/music/album/track.flac"
-				socketName := "/tmp/mpv-ctrl-test.socket"
-
-				args := createMPVCommand(deviceName, filename, socketName)
-				executor, err := start(ctx, args)
-				Expect(err).ToNot(HaveOccurred())
-
-				// Read all the output from stdout (this will block until the process finishes or is canceled)
-				output, err := io.ReadAll(executor)
-				Expect(err).ToNot(HaveOccurred())
-
-				// Parse the captured arguments
-				lines := strings.Split(strings.TrimSpace(string(output)), "\n")
-
-				// Verify all expected arguments are present
-				Expect(lines).To(ContainElement("--no-audio-display"))
-				Expect(lines).To(ContainElement("--pause"))
-				Expect(lines).To(ContainElement("/music/album/track.flac"))
-				Expect(lines).To(ContainElement("--input-ipc-server=/tmp/mpv-ctrl-test.socket"))
-				Expect(lines).To(ContainElement("--audio-channels=stereo"))
-				Expect(lines).To(ContainElement("--audio-samplerate=48000"))
-				Expect(lines).To(ContainElement("--audio-format=s16"))
-				Expect(lines).To(ContainElement("--ao=pcm"))
-				Expect(lines).To(ContainElement("--ao-pcm-file=/audio/snapcast_fifo"))
-			})
-		})
-
-		Context("with nil args", func() {
-			It("returns error when args is nil", func() {
-				ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-				defer cancel()
-
-				_, err := start(ctx, nil)
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(Equal("no command arguments provided"))
-			})
-
-			It("returns error when args is empty", func() {
-				ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-				defer cancel()
-
-				_, err := start(ctx, []string{})
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(Equal("no command arguments provided"))
-			})
-		})
-	})
-
-	Describe("mpvCommand", func() {
-		BeforeEach(func() {
-			// Reset the mpv command cache
-			mpvOnce = sync.Once{}
-			mpvPath = ""
-			mpvErr = nil
-		})
-
-		It("finds the configured MPV path", func() {
-			conf.Server.MPVPath = testScript
-			path, err := mpvCommand()
-			Expect(err).ToNot(HaveOccurred())
-			Expect(path).To(Equal(testScript))
-		})
-	})
-
-	Describe("NewTrack integration", func() {
-		var testMediaFile model.MediaFile
-
-		BeforeEach(func() {
-			DeferCleanup(configtest.SetupConfig())
-			conf.Server.MPVPath = testScript
-
-			// Create a test media file
-			testMediaFile = model.MediaFile{
-				ID:   "test-id",
-				Path: "/music/test.mp3",
-			}
-		})
-
-		Context("with malformed template", func() {
-			BeforeEach(func() {
-				// Template with unmatched quotes that will cause shell parsing to fail
-				conf.Server.MPVCmdTemplate = `mpv --no-audio-display --pause %f --input-ipc-server=%s --ao-pcm-file="/unclosed/quote`
-			})
-
-			It("returns error when createMPVCommand fails", func() {
-				ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-				defer cancel()
-
-				playbackDone := make(chan bool, 1)
-				_, err := NewTrack(ctx, playbackDone, "auto", testMediaFile)
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(Equal("no mpv command arguments provided"))
-			})
-		})
-	})
-})
-
-// createMockMPVScript creates a mock script that outputs arguments to stdout
-func createMockMPVScript(tempDir string) string {
-	var scriptContent string
-	var scriptExt string
-
-	if runtime.GOOS == "windows" {
-		scriptExt = ".bat"
-		scriptContent = `@echo off
-echo %0
-:loop
-if "%~1"=="" goto end
-echo %~1
-shift
-goto loop
-:end
-`
-	} else {
-		scriptExt = ".sh"
-		scriptContent = `#!/bin/sh
-echo "$0"
-for arg in "$@"; do
-    echo "$arg"
-done
-`
-	}
-
-	scriptPath := filepath.Join(tempDir, "mock_mpv"+scriptExt)
-	err := os.WriteFile(scriptPath, []byte(scriptContent), 0755) // nolint:gosec
-	if err != nil {
-		panic(fmt.Sprintf("Failed to create mock script: %v", err))
-	}
-
-	return scriptPath
-}

core/playback/mpv/track.go

@@ -34,10 +34,7 @@ func NewTrack(ctx context.Context, playbackDoneChannel chan bool, deviceName str
 
 	tmpSocketName := socketName("mpv-ctrl-", ".socket")
 
-	args := createMPVCommand(deviceName, mf.AbsolutePath(), tmpSocketName)
-	if len(args) == 0 {
-		return nil, fmt.Errorf("no mpv command arguments provided")
-	}
+	args := createMPVCommand(deviceName, mf.Path, tmpSocketName)
 	exe, err := start(ctx, args)
 	if err != nil {
 		log.Error("Error starting mpv process", err)

core/playlists.go

@@ -1,7 +1,6 @@
 package core
 
 import (
-	"cmp"
 	"context"
 	"encoding/json"
 	"errors"
@@ -10,7 +9,7 @@ import (
 	"net/url"
 	"os"
 	"path/filepath"
-	"slices"
+	"regexp"
 	"strings"
 	"time"
 
@@ -21,9 +20,7 @@ import (
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/model/criteria"
 	"github.com/navidrome/navidrome/model/request"
-	"github.com/navidrome/navidrome/utils/ioutils"
 	"github.com/navidrome/navidrome/utils/slice"
-	"golang.org/x/text/unicode/norm"
 )
 
 type Playlists interface {
@@ -99,13 +96,12 @@ func (s *playlists) parsePlaylist(ctx context.Context, playlistFile string, fold
 	}
 	defer file.Close()
 
-	reader := ioutils.UTF8Reader(file)
 	extension := strings.ToLower(filepath.Ext(playlistFile))
 	switch extension {
 	case ".nsp":
-		err = s.parseNSP(ctx, pls, reader)
+		err = s.parseNSP(ctx, pls, file)
 	default:
-		err = s.parseM3U(ctx, pls, folder, reader)
+		err = s.parseM3U(ctx, pls, folder, file)
 	}
 	return pls, err
 }
@@ -195,35 +191,22 @@ func (s *playlists) parseM3U(ctx context.Context, pls *model.Playlist, folder *m
 			}
 			filteredLines = append(filteredLines, line)
 		}
-		resolvedPaths, err := s.resolvePaths(ctx, folder, filteredLines)
+		paths, err := s.normalizePaths(ctx, pls, folder, filteredLines)
 		if err != nil {
-			log.Warn(ctx, "Error resolving paths in playlist", "playlist", pls.Name, err)
+			log.Warn(ctx, "Error normalizing paths in playlist", "playlist", pls.Name, err)
 			continue
 		}
-
-		// Normalize to NFD for filesystem compatibility (macOS). Database stores paths in NFD.
-		// See https://github.com/navidrome/navidrome/issues/4663
-		resolvedPaths = slice.Map(resolvedPaths, func(path string) string {
-			return strings.ToLower(norm.NFD.String(path))
-		})
-
-		found, err := mediaFileRepository.FindByPaths(resolvedPaths)
+		found, err := mediaFileRepository.FindByPaths(paths)
 		if err != nil {
 			log.Warn(ctx, "Error reading files from DB", "playlist", pls.Name, err)
 			continue
 		}
-		// Build lookup map with library-qualified keys, normalized for comparison
 		existing := make(map[string]int, len(found))
 		for idx := range found {
-			// Normalize to lowercase for case-insensitive comparison
-			// Key format: "libraryID:path"
-			key := fmt.Sprintf("%d:%s", found[idx].LibraryID, strings.ToLower(found[idx].Path))
-			existing[key] = idx
+			existing[strings.ToLower(found[idx].Path)] = idx
 		}
-
-		// Find media files in the order of the resolved paths, to keep playlist order
-		for _, path := range resolvedPaths {
-			idx, ok := existing[path]
+		for _, path := range paths {
+			idx, ok := existing[strings.ToLower(path)]
 			if ok {
 				mfs = append(mfs, found[idx])
 			} else {
@@ -240,150 +223,62 @@ func (s *playlists) parseM3U(ctx context.Context, pls *model.Playlist, folder *m
 	return nil
 }
 
-// pathResolution holds the result of resolving a playlist path to a library-relative path.
-type pathResolution struct {
-	absolutePath string
-	libraryPath  string
-	libraryID    int
-	valid        bool
-}
-
-// ToQualifiedString converts the path resolution to a library-qualified string with forward slashes.
-// Format: "libraryID:relativePath" with forward slashes for path separators.
-func (r pathResolution) ToQualifiedString() (string, error) {
-	if !r.valid {
-		return "", fmt.Errorf("invalid path resolution")
-	}
-	relativePath, err := filepath.Rel(r.libraryPath, r.absolutePath)
+// TODO This won't work for multiple libraries
+func (s *playlists) normalizePaths(ctx context.Context, pls *model.Playlist, folder *model.Folder, lines []string) ([]string, error) {
+	libRegex, err := s.compileLibraryPaths(ctx)
 	if err != nil {
-		return "", err
+		return nil, err
 	}
-	// Convert path separators to forward slashes
-	return fmt.Sprintf("%d:%s", r.libraryID, filepath.ToSlash(relativePath)), nil
-}
 
-// libraryMatcher holds sorted libraries with cleaned paths for efficient path matching.
-type libraryMatcher struct {
-	libraries    model.Libraries
-	cleanedPaths []string
-}
+	res := make([]string, 0, len(lines))
+	for idx, line := range lines {
+		var libPath string
+		var filePath string
 
-// findLibraryForPath finds which library contains the given absolute path.
-// Returns library ID and path, or 0 and empty string if not found.
-func (lm *libraryMatcher) findLibraryForPath(absolutePath string) (int, string) {
-	// Check sorted libraries (longest path first) to find the best match
-	for i, cleanLibPath := range lm.cleanedPaths {
-		// Check if absolutePath is under this library path
-		if strings.HasPrefix(absolutePath, cleanLibPath) {
-			// Ensure it's a proper path boundary (not just a prefix)
-			if len(absolutePath) == len(cleanLibPath) || absolutePath[len(cleanLibPath)] == filepath.Separator {
-				return lm.libraries[i].ID, cleanLibPath
+		if folder != nil && !filepath.IsAbs(line) {
+			libPath = folder.LibraryPath
+			filePath = filepath.Join(folder.AbsolutePath(), line)
+		} else {
+			cleanLine := filepath.Clean(line)
+			if libPath = libRegex.FindString(cleanLine); libPath != "" {
+				filePath = cleanLine
 			}
 		}
-	}
-	return 0, ""
-}
 
-// newLibraryMatcher creates a libraryMatcher with libraries sorted by path length (longest first).
-// This ensures correct matching when library paths are prefixes of each other.
-// Example: /music-classical must be checked before /music
-// Otherwise, /music-classical/track.mp3 would match /music instead of /music-classical
-func newLibraryMatcher(libs model.Libraries) *libraryMatcher {
-	// Sort libraries by path length (descending) to ensure longest paths match first.
-	slices.SortFunc(libs, func(i, j model.Library) int {
-		return cmp.Compare(len(j.Path), len(i.Path)) // Reverse order for descending
-	})
-
-	// Pre-clean all library paths once for efficient matching
-	cleanedPaths := make([]string, len(libs))
-	for i, lib := range libs {
-		cleanedPaths[i] = filepath.Clean(lib.Path)
-	}
-	return &libraryMatcher{
-		libraries:    libs,
-		cleanedPaths: cleanedPaths,
-	}
-}
-
-// pathResolver handles path resolution logic for playlist imports.
-type pathResolver struct {
-	matcher *libraryMatcher
-}
-
-// newPathResolver creates a pathResolver with libraries loaded from the datastore.
-func newPathResolver(ctx context.Context, ds model.DataStore) (*pathResolver, error) {
-	libs, err := ds.Library(ctx).GetAll()
-	if err != nil {
-		return nil, err
-	}
-	matcher := newLibraryMatcher(libs)
-	return &pathResolver{matcher: matcher}, nil
-}
-
-// resolvePath determines the absolute path and library path for a playlist entry.
-// For absolute paths, it uses them directly.
-// For relative paths, it resolves them relative to the playlist's folder location.
-// Example: playlist at /music/playlists/test.m3u with line "../songs/abc.mp3"
-//
-//	resolves to /music/songs/abc.mp3
-func (r *pathResolver) resolvePath(line string, folder *model.Folder) pathResolution {
-	var absolutePath string
-	if folder != nil && !filepath.IsAbs(line) {
-		// Resolve relative path to absolute path based on playlist location
-		absolutePath = filepath.Clean(filepath.Join(folder.AbsolutePath(), line))
-	} else {
-		// Use absolute path directly after cleaning
-		absolutePath = filepath.Clean(line)
-	}
-
-	return r.findInLibraries(absolutePath)
-}
-
-// findInLibraries matches an absolute path against all known libraries and returns
-// a pathResolution with the library information. Returns an invalid resolution if
-// the path is not found in any library.
-func (r *pathResolver) findInLibraries(absolutePath string) pathResolution {
-	libID, libPath := r.matcher.findLibraryForPath(absolutePath)
-	if libID == 0 {
-		return pathResolution{valid: false}
-	}
-	return pathResolution{
-		absolutePath: absolutePath,
-		libraryPath:  libPath,
-		libraryID:    libID,
-		valid:        true,
-	}
-}
-
-// resolvePaths converts playlist file paths to library-qualified paths (format: "libraryID:relativePath").
-// For relative paths, it resolves them to absolute paths first, then determines which
-// library they belong to. This allows playlists to reference files across library boundaries.
-func (s *playlists) resolvePaths(ctx context.Context, folder *model.Folder, lines []string) ([]string, error) {
-	resolver, err := newPathResolver(ctx, s.ds)
-	if err != nil {
-		return nil, err
-	}
-
-	results := make([]string, 0, len(lines))
-	for idx, line := range lines {
-		resolution := resolver.resolvePath(line, folder)
-
-		if !resolution.valid {
+		if libPath != "" {
+			if rel, err := filepath.Rel(libPath, filePath); err == nil {
+				res = append(res, rel)
+			} else {
+				log.Debug(ctx, "Error getting relative path", "playlist", pls.Name, "path", line, "libPath", libPath,
+					"filePath", filePath, err)
+			}
+		} else {
 			log.Warn(ctx, "Path in playlist not found in any library", "path", line, "line", idx)
-			continue
 		}
+	}
+	return slice.Map(res, filepath.ToSlash), nil
+}
 
-		qualifiedPath, err := resolution.ToQualifiedString()
-		if err != nil {
-			log.Debug(ctx, "Error getting library-qualified path", "path", line,
-				"libPath", resolution.libraryPath, "filePath", resolution.absolutePath, err)
-			continue
-		}
-
-		results = append(results, qualifiedPath)
+func (s *playlists) compileLibraryPaths(ctx context.Context) (*regexp.Regexp, error) {
+	libs, err := s.ds.Library(ctx).GetAll()
+	if err != nil {
+		return nil, err
 	}
 
-	return results, nil
+	// Create regex patterns for each library path
+	patterns := make([]string, len(libs))
+	for i, lib := range libs {
+		cleanPath := filepath.Clean(lib.Path)
+		escapedPath := regexp.QuoteMeta(cleanPath)
+		patterns[i] = fmt.Sprintf("^%s(?:/|$)", escapedPath)
+	}
+	// Combine all patterns into a single regex
+	combinedPattern := strings.Join(patterns, "|")
+	re, err := regexp.Compile(combinedPattern)
+	if err != nil {
+		return nil, fmt.Errorf("compiling library paths `%s`: %w", combinedPattern, err)
+	}
+	return re, nil
 }
 
 func (s *playlists) updatePlaylist(ctx context.Context, newPls *model.Playlist) error {
@@ -431,7 +326,7 @@ func (s *playlists) Update(ctx context.Context, playlistID string,
 		if needsTrackRefresh {
 			pls, err = repo.GetWithTracks(playlistID, true, false)
 			pls.RemoveTracks(idxToRemove)
-			pls.AddMediaFilesByID(idsToAdd)
+			pls.AddTracks(idsToAdd)
 		} else {
 			if len(idsToAdd) > 0 {
 				_, err = tracks.Add(idsToAdd)

core/playlists_internal_test.go

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

core/playlists_test.go

@@ -1,4 +1,4 @@
-package core_test
+package core
 
 import (
 	"context"
@@ -9,19 +9,17 @@ import (
 
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/conf/configtest"
-	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/model/criteria"
 	"github.com/navidrome/navidrome/model/request"
 	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	"golang.org/x/text/unicode/norm"
 )
 
 var _ = Describe("Playlists", func() {
 	var ds *tests.MockDataStore
-	var ps core.Playlists
+	var ps Playlists
 	var mockPlsRepo mockedPlaylistRepo
 	var mockLibRepo *tests.MockLibraryRepo
 	ctx := context.Background()
@@ -34,16 +32,16 @@ var _ = Describe("Playlists", func() {
 			MockedLibrary:  mockLibRepo,
 		}
 		ctx = request.WithUser(ctx, model.User{ID: "123"})
+		// Path should be libPath, but we want to match the root folder referenced in the m3u, which is `/`
+		mockLibRepo.SetData([]model.Library{{ID: 1, Path: "/"}})
 	})
 
 	Describe("ImportFile", func() {
 		var folder *model.Folder
 		BeforeEach(func() {
-			ps = core.NewPlaylists(ds)
+			ps = NewPlaylists(ds)
 			ds.MockedMediaFile = &mockedMediaFileRepo{}
 			libPath, _ := os.Getwd()
-			// Set up library with the actual library path that matches the folder
-			mockLibRepo.SetData([]model.Library{{ID: 1, Path: libPath}})
 			folder = &model.Folder{
 				ID:          "1",
 				LibraryID:   1,
@@ -75,24 +73,6 @@ var _ = Describe("Playlists", func() {
 				Expect(err).ToNot(HaveOccurred())
 				Expect(pls.Tracks).To(HaveLen(2))
 			})
-
-			It("parses playlists with UTF-8 BOM marker", func() {
-				pls, err := ps.ImportFile(ctx, folder, "bom-test.m3u")
-				Expect(err).ToNot(HaveOccurred())
-				Expect(pls.OwnerID).To(Equal("123"))
-				Expect(pls.Name).To(Equal("Test Playlist"))
-				Expect(pls.Tracks).To(HaveLen(1))
-				Expect(pls.Tracks[0].Path).To(Equal("tests/fixtures/playlists/test.mp3"))
-			})
-
-			It("parses UTF-16 LE encoded playlists with BOM and converts to UTF-8", func() {
-				pls, err := ps.ImportFile(ctx, folder, "bom-test-utf16.m3u")
-				Expect(err).ToNot(HaveOccurred())
-				Expect(pls.OwnerID).To(Equal("123"))
-				Expect(pls.Name).To(Equal("UTF-16 Test Playlist"))
-				Expect(pls.Tracks).To(HaveLen(1))
-				Expect(pls.Tracks[0].Path).To(Equal("tests/fixtures/playlists/test.mp3"))
-			})
 		})
 
 		Describe("NSP", func() {
@@ -113,224 +93,6 @@ var _ = Describe("Playlists", func() {
 				Expect(err.Error()).To(ContainSubstring("line 19, column 1: invalid character '\\n'"))
 			})
 		})
-
-		Describe("Cross-library relative paths", func() {
-			var tmpDir, plsDir, songsDir string
-
-			BeforeEach(func() {
-				// Create temp directory structure
-				tmpDir = GinkgoT().TempDir()
-				plsDir = tmpDir + "/playlists"
-				songsDir = tmpDir + "/songs"
-				Expect(os.Mkdir(plsDir, 0755)).To(Succeed())
-				Expect(os.Mkdir(songsDir, 0755)).To(Succeed())
-
-				// Setup two different libraries with paths matching our temp structure
-				mockLibRepo.SetData([]model.Library{
-					{ID: 1, Path: songsDir},
-					{ID: 2, Path: plsDir},
-				})
-
-				// Create a mock media file repository that returns files for both libraries
-				// Note: The paths are relative to their respective library roots
-				ds.MockedMediaFile = &mockedMediaFileFromListRepo{
-					data: []string{
-						"abc.mp3", // This is songs/abc.mp3 relative to songsDir
-						"def.mp3", // This is playlists/def.mp3 relative to plsDir
-					},
-				}
-				ps = core.NewPlaylists(ds)
-			})
-
-			It("handles relative paths that reference files in other libraries", func() {
-				// Create a temporary playlist file with relative path
-				plsContent := "#PLAYLIST:Cross Library Test\n../songs/abc.mp3\ndef.mp3"
-				plsFile := plsDir + "/test.m3u"
-				Expect(os.WriteFile(plsFile, []byte(plsContent), 0600)).To(Succeed())
-
-				// Playlist is in the Playlists library folder
-				// Important: Path should be relative to LibraryPath, and Name is the folder name
-				plsFolder := &model.Folder{
-					ID:          "2",
-					LibraryID:   2,
-					LibraryPath: plsDir,
-					Path:        "",
-					Name:        "",
-				}
-
-				pls, err := ps.ImportFile(ctx, plsFolder, "test.m3u")
-				Expect(err).ToNot(HaveOccurred())
-				Expect(pls.Tracks).To(HaveLen(2))
-				Expect(pls.Tracks[0].Path).To(Equal("abc.mp3")) // From songsDir library
-				Expect(pls.Tracks[1].Path).To(Equal("def.mp3")) // From plsDir library
-			})
-
-			It("ignores paths that point outside all libraries", func() {
-				// Create a temporary playlist file with path outside libraries
-				plsContent := "#PLAYLIST:Outside Test\n../../outside.mp3\nabc.mp3"
-				plsFile := plsDir + "/test.m3u"
-				Expect(os.WriteFile(plsFile, []byte(plsContent), 0600)).To(Succeed())
-
-				plsFolder := &model.Folder{
-					ID:          "2",
-					LibraryID:   2,
-					LibraryPath: plsDir,
-					Path:        "",
-					Name:        "",
-				}
-
-				pls, err := ps.ImportFile(ctx, plsFolder, "test.m3u")
-				Expect(err).ToNot(HaveOccurred())
-				// Should only find abc.mp3, not outside.mp3
-				Expect(pls.Tracks).To(HaveLen(1))
-				Expect(pls.Tracks[0].Path).To(Equal("abc.mp3"))
-			})
-
-			It("handles relative paths with multiple '../' components", func() {
-				// Create a nested structure: tmpDir/playlists/subfolder/test.m3u
-				subFolder := plsDir + "/subfolder"
-				Expect(os.Mkdir(subFolder, 0755)).To(Succeed())
-
-				// Create the media file in the subfolder directory
-				// The mock will return it as "def.mp3" relative to plsDir
-				ds.MockedMediaFile = &mockedMediaFileFromListRepo{
-					data: []string{
-						"abc.mp3", // From songsDir library
-						"def.mp3", // From plsDir library root
-					},
-				}
-
-				// From subfolder, ../../songs/abc.mp3 should resolve to songs library
-				// ../def.mp3 should resolve to plsDir/def.mp3
-				plsContent := "#PLAYLIST:Nested Test\n../../songs/abc.mp3\n../def.mp3"
-				plsFile := subFolder + "/test.m3u"
-				Expect(os.WriteFile(plsFile, []byte(plsContent), 0600)).To(Succeed())
-
-				// The folder: AbsolutePath = LibraryPath + Path + Name
-				// So for /playlists/subfolder: LibraryPath=/playlists, Path="", Name="subfolder"
-				plsFolder := &model.Folder{
-					ID:          "2",
-					LibraryID:   2,
-					LibraryPath: plsDir,
-					Path:        "",          // Empty because subfolder is directly under library root
-					Name:        "subfolder", // The folder name
-				}
-
-				pls, err := ps.ImportFile(ctx, plsFolder, "test.m3u")
-				Expect(err).ToNot(HaveOccurred())
-				Expect(pls.Tracks).To(HaveLen(2))
-				Expect(pls.Tracks[0].Path).To(Equal("abc.mp3")) // From songsDir library
-				Expect(pls.Tracks[1].Path).To(Equal("def.mp3")) // From plsDir library root
-			})
-
-			It("correctly resolves libraries when one path is a prefix of another", func() {
-				// This tests the bug where /music would match before /music-classical
-				// Create temp directory structure with prefix conflict
-				tmpDir := GinkgoT().TempDir()
-				musicDir := tmpDir + "/music"
-				musicClassicalDir := tmpDir + "/music-classical"
-				Expect(os.Mkdir(musicDir, 0755)).To(Succeed())
-				Expect(os.Mkdir(musicClassicalDir, 0755)).To(Succeed())
-
-				// Setup two libraries where one is a prefix of the other
-				mockLibRepo.SetData([]model.Library{
-					{ID: 1, Path: musicDir},          // /tmp/xxx/music
-					{ID: 2, Path: musicClassicalDir}, // /tmp/xxx/music-classical
-				})
-
-				// Mock will return tracks from both libraries
-				ds.MockedMediaFile = &mockedMediaFileFromListRepo{
-					data: []string{
-						"rock.mp3", // From music library
-						"bach.mp3", // From music-classical library
-					},
-				}
-
-				// Create playlist in music library that references music-classical
-				plsContent := "#PLAYLIST:Cross Prefix Test\nrock.mp3\n../music-classical/bach.mp3"
-				plsFile := musicDir + "/test.m3u"
-				Expect(os.WriteFile(plsFile, []byte(plsContent), 0600)).To(Succeed())
-
-				plsFolder := &model.Folder{
-					ID:          "1",
-					LibraryID:   1,
-					LibraryPath: musicDir,
-					Path:        "",
-					Name:        "",
-				}
-
-				pls, err := ps.ImportFile(ctx, plsFolder, "test.m3u")
-				Expect(err).ToNot(HaveOccurred())
-				Expect(pls.Tracks).To(HaveLen(2))
-				Expect(pls.Tracks[0].Path).To(Equal("rock.mp3")) // From music library
-				Expect(pls.Tracks[1].Path).To(Equal("bach.mp3")) // From music-classical library (not music!)
-			})
-
-			It("correctly handles identical relative paths from different libraries", func() {
-				// This tests the bug where two libraries have files at the same relative path
-				// and only one appears in the playlist
-				tmpDir := GinkgoT().TempDir()
-				musicDir := tmpDir + "/music"
-				classicalDir := tmpDir + "/classical"
-				Expect(os.Mkdir(musicDir, 0755)).To(Succeed())
-				Expect(os.Mkdir(classicalDir, 0755)).To(Succeed())
-				Expect(os.MkdirAll(musicDir+"/album", 0755)).To(Succeed())
-				Expect(os.MkdirAll(classicalDir+"/album", 0755)).To(Succeed())
-				// Create placeholder files so paths resolve correctly
-				Expect(os.WriteFile(musicDir+"/album/track.mp3", []byte{}, 0600)).To(Succeed())
-				Expect(os.WriteFile(classicalDir+"/album/track.mp3", []byte{}, 0600)).To(Succeed())
-
-				// Both libraries have a file at "album/track.mp3"
-				mockLibRepo.SetData([]model.Library{
-					{ID: 1, Path: musicDir},
-					{ID: 2, Path: classicalDir},
-				})
-
-				// Mock returns files with same relative path but different IDs and library IDs
-				// Keys use the library-qualified format: "libraryID:path"
-				ds.MockedMediaFile = &mockedMediaFileRepo{
-					data: map[string]model.MediaFile{
-						"1:album/track.mp3": {ID: "music-track", Path: "album/track.mp3", LibraryID: 1, Title: "Rock Song"},
-						"2:album/track.mp3": {ID: "classical-track", Path: "album/track.mp3", LibraryID: 2, Title: "Classical Piece"},
-					},
-				}
-				// Recreate playlists service to pick up new mock
-				ps = core.NewPlaylists(ds)
-
-				// Create playlist in music library that references both tracks
-				plsContent := "#PLAYLIST:Same Path Test\nalbum/track.mp3\n../classical/album/track.mp3"
-				plsFile := musicDir + "/test.m3u"
-				Expect(os.WriteFile(plsFile, []byte(plsContent), 0600)).To(Succeed())
-
-				plsFolder := &model.Folder{
-					ID:          "1",
-					LibraryID:   1,
-					LibraryPath: musicDir,
-					Path:        "",
-					Name:        "",
-				}
-
-				pls, err := ps.ImportFile(ctx, plsFolder, "test.m3u")
-				Expect(err).ToNot(HaveOccurred())
-
-				// Should have BOTH tracks, not just one
-				Expect(pls.Tracks).To(HaveLen(2), "Playlist should contain both tracks with same relative path")
-
-				// Verify we got tracks from DIFFERENT libraries (the key fix!)
-				// Collect the library IDs
-				libIDs := make(map[int]bool)
-				for _, track := range pls.Tracks {
-					libIDs[track.LibraryID] = true
-				}
-				Expect(libIDs).To(HaveLen(2), "Tracks should come from two different libraries")
-				Expect(libIDs[1]).To(BeTrue(), "Should have track from library 1")
-				Expect(libIDs[2]).To(BeTrue(), "Should have track from library 2")
-
-				// Both tracks should have the same relative path
-				Expect(pls.Tracks[0].Path).To(Equal("album/track.mp3"))
-				Expect(pls.Tracks[1].Path).To(Equal("album/track.mp3"))
-			})
-		})
 	})
 
 	Describe("ImportM3U", func() {
@@ -338,7 +100,7 @@ var _ = Describe("Playlists", func() {
 		BeforeEach(func() {
 			repo = &mockedMediaFileFromListRepo{}
 			ds.MockedMediaFile = repo
-			ps = core.NewPlaylists(ds)
+			ps = NewPlaylists(ds)
 			mockLibRepo.SetData([]model.Library{{ID: 1, Path: "/music"}, {ID: 2, Path: "/new"}})
 			ctx = request.WithUser(ctx, model.User{ID: "123"})
 		})
@@ -424,24 +186,6 @@ var _ = Describe("Playlists", func() {
 			Expect(pls.Tracks).To(HaveLen(1))
 			Expect(pls.Tracks[0].Path).To(Equal("abc/tEsT1.Mp3"))
 		})
-
-		It("handles Unicode normalization when comparing paths (NFD vs NFC)", func() {
-			// Simulate macOS filesystem: stores paths in NFD (decomposed) form
-			// "è" (U+00E8) in NFC becomes "e" + "◌̀" (U+0065 + U+0300) in NFD
-			nfdPath := "artist/Mich" + string([]rune{'e', '\u0300'}) + "le/song.mp3" // NFD: e + combining grave
-			repo.data = []string{nfdPath}
-
-			// Simulate Apple Music M3U: uses NFC (composed) form
-			nfcPath := "/music/artist/Mich\u00E8le/song.mp3" // NFC: single è character
-			m3u := nfcPath + "\n"
-			f := strings.NewReader(m3u)
-			pls, err := ps.ImportM3U(ctx, f)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(pls.Tracks).To(HaveLen(1))
-			// Should match despite different Unicode normalization forms
-			Expect(pls.Tracks[0].Path).To(Equal(nfdPath))
-		})
-
 	})
 
 	Describe("InPlaylistsPath", func() {
@@ -458,27 +202,27 @@ var _ = Describe("Playlists", func() {
 
 		It("returns true if PlaylistsPath is empty", func() {
 			conf.Server.PlaylistsPath = ""
-			Expect(core.InPlaylistsPath(folder)).To(BeTrue())
+			Expect(InPlaylistsPath(folder)).To(BeTrue())
 		})
 
 		It("returns true if PlaylistsPath is any (**/**)", func() {
 			conf.Server.PlaylistsPath = "**/**"
-			Expect(core.InPlaylistsPath(folder)).To(BeTrue())
+			Expect(InPlaylistsPath(folder)).To(BeTrue())
 		})
 
 		It("returns true if folder is in PlaylistsPath", func() {
 			conf.Server.PlaylistsPath = "other/**:playlists/**"
-			Expect(core.InPlaylistsPath(folder)).To(BeTrue())
+			Expect(InPlaylistsPath(folder)).To(BeTrue())
 		})
 
 		It("returns false if folder is not in PlaylistsPath", func() {
 			conf.Server.PlaylistsPath = "other"
-			Expect(core.InPlaylistsPath(folder)).To(BeFalse())
+			Expect(InPlaylistsPath(folder)).To(BeFalse())
 		})
 
 		It("returns true if for a playlist in root of MusicFolder if PlaylistsPath is '.'", func() {
 			conf.Server.PlaylistsPath = "."
-			Expect(core.InPlaylistsPath(folder)).To(BeFalse())
+			Expect(InPlaylistsPath(folder)).To(BeFalse())
 
 			folder2 := model.Folder{
 				LibraryPath: "/music",
@@ -486,47 +230,22 @@ var _ = Describe("Playlists", func() {
 				Name:        ".",
 			}
 
-			Expect(core.InPlaylistsPath(folder2)).To(BeTrue())
+			Expect(InPlaylistsPath(folder2)).To(BeTrue())
 		})
 	})
 })
 
-// mockedMediaFileRepo's FindByPaths method returns MediaFiles for the given paths.
-// If data map is provided, looks up files by key; otherwise creates them from paths.
+// mockedMediaFileRepo's FindByPaths method returns a list of MediaFiles with the same paths as the input
 type mockedMediaFileRepo struct {
 	model.MediaFileRepository
-	data map[string]model.MediaFile
 }
 
 func (r *mockedMediaFileRepo) FindByPaths(paths []string) (model.MediaFiles, error) {
 	var mfs model.MediaFiles
-
-	// If data map provided, look up files
-	if r.data != nil {
-		for _, path := range paths {
-			if mf, ok := r.data[path]; ok {
-				mfs = append(mfs, mf)
-			}
-		}
-		return mfs, nil
-	}
-
-	// Otherwise, create MediaFiles from paths
 	for idx, path := range paths {
-		// Strip library qualifier if present (format: "libraryID:path")
-		actualPath := path
-		libraryID := 1
-		if parts := strings.SplitN(path, ":", 2); len(parts) == 2 {
-			if id, err := strconv.Atoi(parts[0]); err == nil {
-				libraryID = id
-				actualPath = parts[1]
-			}
-		}
-
 		mfs = append(mfs, model.MediaFile{
-			ID:        strconv.Itoa(idx),
-			Path:      actualPath,
-			LibraryID: libraryID,
+			ID:   strconv.Itoa(idx),
+			Path: path,
 		})
 	}
 	return mfs, nil
@@ -538,38 +257,13 @@ type mockedMediaFileFromListRepo struct {
 	data []string
 }
 
-func (r *mockedMediaFileFromListRepo) FindByPaths(paths []string) (model.MediaFiles, error) {
+func (r *mockedMediaFileFromListRepo) FindByPaths([]string) (model.MediaFiles, error) {
 	var mfs model.MediaFiles
-
-	for idx, dataPath := range r.data {
-		// Normalize the data path to NFD (simulates macOS filesystem storage)
-		normalizedDataPath := norm.NFD.String(dataPath)
-
-		for _, requestPath := range paths {
-			// Strip library qualifier if present (format: "libraryID:path")
-			actualPath := requestPath
-			libraryID := 1
-			if parts := strings.SplitN(requestPath, ":", 2); len(parts) == 2 {
-				if id, err := strconv.Atoi(parts[0]); err == nil {
-					libraryID = id
-					actualPath = parts[1]
-				}
-			}
-
-			// The request path should already be normalized to NFD by production code
-			// before calling FindByPaths (to match DB storage)
-			normalizedRequestPath := norm.NFD.String(actualPath)
-
-			// Case-insensitive comparison (like SQL's "collate nocase")
-			if strings.EqualFold(normalizedRequestPath, normalizedDataPath) {
-				mfs = append(mfs, model.MediaFile{
-					ID:        strconv.Itoa(idx),
-					Path:      dataPath, // Return original path from DB
-					LibraryID: libraryID,
-				})
-				break
-			}
-		}
+	for idx, path := range r.data {
+		mfs = append(mfs, model.MediaFile{
+			ID:   strconv.Itoa(idx),
+			Path: path,
+		})
 	}
 	return mfs, nil
 }

core/publicurl/publicurl.go

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

core/publicurl/publicurl_test.go

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

core/scrobbler/buffered_scrobbler.go

@@ -10,16 +10,9 @@ import (
 )
 
 func newBufferedScrobbler(ds model.DataStore, s Scrobbler, service string) *bufferedScrobbler {
-	ctx, cancel := context.WithCancel(context.Background())
-	b := &bufferedScrobbler{
-		ds:         ds,
-		wrapped:    s,
-		service:    service,
-		wakeSignal: make(chan struct{}, 1),
-		ctx:        ctx,
-		cancel:     cancel,
-	}
-	go b.run(ctx)
+	b := &bufferedScrobbler{ds: ds, wrapped: s, service: service}
+	b.wakeSignal = make(chan struct{}, 1)
+	go b.run(context.TODO())
 	return b
 }
 
@@ -28,22 +21,14 @@ type bufferedScrobbler struct {
 	wrapped    Scrobbler
 	service    string
 	wakeSignal chan struct{}
-	ctx        context.Context
-	cancel     context.CancelFunc
-}
-
-func (b *bufferedScrobbler) Stop() {
-	if b.cancel != nil {
-		b.cancel()
-	}
 }
 
 func (b *bufferedScrobbler) IsAuthorized(ctx context.Context, userId string) bool {
 	return b.wrapped.IsAuthorized(ctx, userId)
 }
 
-func (b *bufferedScrobbler) NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) error {
-	return b.wrapped.NowPlaying(ctx, userId, track, position)
+func (b *bufferedScrobbler) NowPlaying(ctx context.Context, userId string, track *model.MediaFile) error {
+	return b.wrapped.NowPlaying(ctx, userId, track)
 }
 
 func (b *bufferedScrobbler) Scrobble(ctx context.Context, userId string, s Scrobble) error {

core/scrobbler/buffered_scrobbler_test.go

@@ -1,89 +0,0 @@
-package scrobbler
-
-import (
-	"context"
-	"time"
-
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("BufferedScrobbler", func() {
-	var ds model.DataStore
-	var scr *fakeScrobbler
-	var bs *bufferedScrobbler
-	var ctx context.Context
-	var buffer *tests.MockedScrobbleBufferRepo
-
-	BeforeEach(func() {
-		ctx = context.Background()
-		buffer = tests.CreateMockedScrobbleBufferRepo()
-		ds = &tests.MockDataStore{
-			MockedScrobbleBuffer: buffer,
-		}
-		scr = &fakeScrobbler{Authorized: true}
-		bs = newBufferedScrobbler(ds, scr, "test")
-	})
-
-	It("forwards IsAuthorized calls", func() {
-		scr.Authorized = true
-		Expect(bs.IsAuthorized(ctx, "user1")).To(BeTrue())
-
-		scr.Authorized = false
-		Expect(bs.IsAuthorized(ctx, "user1")).To(BeFalse())
-	})
-
-	It("forwards NowPlaying calls", func() {
-		track := &model.MediaFile{ID: "123", Title: "Test Track"}
-		Expect(bs.NowPlaying(ctx, "user1", track, 0)).To(Succeed())
-		Expect(scr.GetNowPlayingCalled()).To(BeTrue())
-		Expect(scr.GetUserID()).To(Equal("user1"))
-		Expect(scr.GetTrack()).To(Equal(track))
-	})
-
-	It("enqueues scrobbles to buffer", func() {
-		track := model.MediaFile{ID: "123", Title: "Test Track"}
-		now := time.Now()
-		scrobble := Scrobble{MediaFile: track, TimeStamp: now}
-		Expect(buffer.Length()).To(Equal(int64(0)))
-		Expect(scr.ScrobbleCalled.Load()).To(BeFalse())
-
-		Expect(bs.Scrobble(ctx, "user1", scrobble)).To(Succeed())
-
-		// Wait for the background goroutine to process the scrobble.
-		// We don't check buffer.Length() here because the background goroutine
-		// may dequeue the entry before we can observe it.
-		Eventually(scr.ScrobbleCalled.Load).Should(BeTrue())
-
-		lastScrobble := scr.LastScrobble.Load()
-		Expect(lastScrobble.MediaFile.ID).To(Equal("123"))
-		Expect(lastScrobble.TimeStamp).To(BeTemporally("==", now))
-	})
-
-	It("stops the background goroutine when Stop is called", func() {
-		// Replace the real run method with one that signals when it exits
-		done := make(chan struct{})
-
-		// Start our instrumented run function that will signal when it exits
-		go func() {
-			defer close(done)
-			bs.run(bs.ctx)
-		}()
-
-		// Wait a bit to ensure the goroutine is running
-		time.Sleep(10 * time.Millisecond)
-
-		// Call the real Stop method
-		bs.Stop()
-
-		// Wait for the goroutine to exit or timeout
-		select {
-		case <-done:
-			// Success, goroutine exited
-		case <-time.After(100 * time.Millisecond):
-			Fail("Goroutine did not exit in time after Stop was called")
-		}
-	})
-})

core/scrobbler/interfaces.go

@@ -21,7 +21,7 @@ var (
 
 type Scrobbler interface {
 	IsAuthorized(ctx context.Context, userId string) bool
-	NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) error
+	NowPlaying(ctx context.Context, userId string, track *model.MediaFile) error
 	Scrobble(ctx context.Context, userId string, s Scrobble) error
 }
 

core/scrobbler/play_tracker.go

@@ -2,12 +2,9 @@ package scrobbler
 
 import (
 	"context"
-	"maps"
 	"sort"
-	"sync"
 	"time"
 
-	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
@@ -20,7 +17,6 @@ import (
 type NowPlayingInfo struct {
 	MediaFile  model.MediaFile
 	Start      time.Time
-	Position   int
 	Username   string
 	PlayerId   string
 	PlayerName string
@@ -31,69 +27,31 @@ type Submission struct {
 	Timestamp time.Time
 }
 
-type nowPlayingEntry struct {
-	ctx      context.Context
-	userId   string
-	track    *model.MediaFile
-	position int
-}
-
 type PlayTracker interface {
-	NowPlaying(ctx context.Context, playerId string, playerName string, trackId string, position int) error
+	NowPlaying(ctx context.Context, playerId string, playerName string, trackId string) error
 	GetNowPlaying(ctx context.Context) ([]NowPlayingInfo, error)
 	Submit(ctx context.Context, submissions []Submission) error
 }
 
-// PluginLoader is a minimal interface for plugin manager usage in PlayTracker
-// (avoids import cycles)
-type PluginLoader interface {
-	PluginNames(capability string) []string
-	LoadScrobbler(name string) (Scrobbler, bool)
-}
-
 type playTracker struct {
-	ds                model.DataStore
-	broker            events.Broker
-	playMap           cache.SimpleCache[string, NowPlayingInfo]
-	builtinScrobblers map[string]Scrobbler
-	pluginScrobblers  map[string]Scrobbler
-	pluginLoader      PluginLoader
-	mu                sync.RWMutex
-	npQueue           map[string]nowPlayingEntry
-	npMu              sync.Mutex
-	npSignal          chan struct{}
-	shutdown          chan struct{}
-	workerDone        chan struct{}
+	ds         model.DataStore
+	broker     events.Broker
+	playMap    cache.SimpleCache[string, NowPlayingInfo]
+	scrobblers map[string]Scrobbler
 }
 
-func GetPlayTracker(ds model.DataStore, broker events.Broker, pluginManager PluginLoader) PlayTracker {
+func GetPlayTracker(ds model.DataStore, broker events.Broker) PlayTracker {
 	return singleton.GetInstance(func() *playTracker {
-		return newPlayTracker(ds, broker, pluginManager)
+		return newPlayTracker(ds, broker)
 	})
 }
 
 // This constructor only exists for testing. For normal usage, the PlayTracker has to be a singleton, returned by
 // the GetPlayTracker function above
-func newPlayTracker(ds model.DataStore, broker events.Broker, pluginManager PluginLoader) *playTracker {
+func newPlayTracker(ds model.DataStore, broker events.Broker) *playTracker {
 	m := cache.NewSimpleCache[string, NowPlayingInfo]()
-	p := &playTracker{
-		ds:                ds,
-		playMap:           m,
-		broker:            broker,
-		builtinScrobblers: make(map[string]Scrobbler),
-		pluginScrobblers:  make(map[string]Scrobbler),
-		pluginLoader:      pluginManager,
-		npQueue:           make(map[string]nowPlayingEntry),
-		npSignal:          make(chan struct{}, 1),
-		shutdown:          make(chan struct{}),
-		workerDone:        make(chan struct{}),
-	}
-	if conf.Server.EnableNowPlaying {
-		m.OnExpiration(func(_ string, _ NowPlayingInfo) {
-			broker.SendBroadcastMessage(context.Background(), &events.NowPlayingCount{Count: m.Len()})
-		})
-	}
-
+	p := &playTracker{ds: ds, playMap: m, broker: broker}
+	p.scrobblers = make(map[string]Scrobbler)
 	var enabled []string
 	for name, constructor := range constructors {
 		s := constructor(ds)
@@ -103,94 +61,13 @@ func newPlayTracker(ds model.DataStore, broker events.Broker, pluginManager Plug
 		}
 		enabled = append(enabled, name)
 		s = newBufferedScrobbler(ds, s, name)
-		p.builtinScrobblers[name] = s
+		p.scrobblers[name] = s
 	}
-	log.Debug("List of builtin scrobblers enabled", "names", enabled)
-	go p.nowPlayingWorker()
+	log.Debug("List of scrobblers enabled", "names", enabled)
 	return p
 }
 
-// stopNowPlayingWorker stops the background worker. This is primarily for testing.
-func (p *playTracker) stopNowPlayingWorker() {
-	close(p.shutdown)
-	<-p.workerDone // Wait for worker to finish
-}
-
-// pluginNamesMatchScrobblers returns true if the set of pluginNames matches the keys in pluginScrobblers
-func pluginNamesMatchScrobblers(pluginNames []string, scrobblers map[string]Scrobbler) bool {
-	if len(pluginNames) != len(scrobblers) {
-		return false
-	}
-	for _, name := range pluginNames {
-		if _, ok := scrobblers[name]; !ok {
-			return false
-		}
-	}
-	return true
-}
-
-// refreshPluginScrobblers updates the pluginScrobblers map to match the current set of plugin scrobblers
-func (p *playTracker) refreshPluginScrobblers() {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	if p.pluginLoader == nil {
-		return
-	}
-
-	// Get the list of available plugin names
-	pluginNames := p.pluginLoader.PluginNames("Scrobbler")
-
-	// Early return if plugin names match existing scrobblers (no change)
-	if pluginNamesMatchScrobblers(pluginNames, p.pluginScrobblers) {
-		return
-	}
-
-	// Build a set of current plugins for faster lookups
-	current := make(map[string]struct{}, len(pluginNames))
-
-	// Process additions - add new plugins
-	for _, name := range pluginNames {
-		current[name] = struct{}{}
-		// Only create a new scrobbler if it doesn't exist
-		if _, exists := p.pluginScrobblers[name]; !exists {
-			s, ok := p.pluginLoader.LoadScrobbler(name)
-			if ok && s != nil {
-				p.pluginScrobblers[name] = newBufferedScrobbler(p.ds, s, name)
-			}
-		}
-	}
-
-	type stoppableScrobbler interface {
-		Scrobbler
-		Stop()
-	}
-
-	// Process removals - remove plugins that no longer exist
-	for name, scrobbler := range p.pluginScrobblers {
-		if _, exists := current[name]; !exists {
-			// If the scrobbler implements stoppableScrobbler, call Stop() before removing it
-			if stoppable, ok := scrobbler.(stoppableScrobbler); ok {
-				log.Debug("Stopping scrobbler", "name", name)
-				stoppable.Stop()
-			}
-			delete(p.pluginScrobblers, name)
-		}
-	}
-}
-
-// getActiveScrobblers refreshes plugin scrobblers, acquires a read lock,
-// combines builtin and plugin scrobblers into a new map, releases the lock,
-// and returns the combined map.
-func (p *playTracker) getActiveScrobblers() map[string]Scrobbler {
-	p.refreshPluginScrobblers()
-	p.mu.RLock()
-	defer p.mu.RUnlock()
-	combined := maps.Clone(p.builtinScrobblers)
-	maps.Copy(combined, p.pluginScrobblers)
-	return combined
-}
-
-func (p *playTracker) NowPlaying(ctx context.Context, playerId string, playerName string, trackId string, position int) error {
+func (p *playTracker) NowPlaying(ctx context.Context, playerId string, playerName string, trackId string) error {
 	mf, err := p.ds.MediaFile(ctx).GetWithParticipants(trackId)
 	if err != nil {
 		log.Error(ctx, "Error retrieving mediaFile", "id", trackId, err)
@@ -201,92 +78,31 @@ func (p *playTracker) NowPlaying(ctx context.Context, playerId string, playerNam
 	info := NowPlayingInfo{
 		MediaFile:  *mf,
 		Start:      time.Now(),
-		Position:   position,
 		Username:   user.UserName,
 		PlayerId:   playerId,
 		PlayerName: playerName,
 	}
 
-	// Calculate TTL based on remaining track duration. If position exceeds track duration,
-	// remaining is set to 0 to avoid negative TTL.
-	remaining := int(mf.Duration) - position
-	if remaining < 0 {
-		remaining = 0
-	}
-	// Add 5 seconds buffer to ensure the NowPlaying info is available slightly longer than the track duration.
-	ttl := time.Duration(remaining+5) * time.Second
+	ttl := time.Duration(int(mf.Duration)+5) * time.Second
 	_ = p.playMap.AddWithTTL(playerId, info, ttl)
-	if conf.Server.EnableNowPlaying {
-		p.broker.SendBroadcastMessage(ctx, &events.NowPlayingCount{Count: p.playMap.Len()})
-	}
 	player, _ := request.PlayerFrom(ctx)
 	if player.ScrobbleEnabled {
-		p.enqueueNowPlaying(ctx, playerId, user.ID, mf, position)
+		p.dispatchNowPlaying(ctx, user.ID, mf)
 	}
 	return nil
 }
 
-func (p *playTracker) enqueueNowPlaying(ctx context.Context, playerId string, userId string, track *model.MediaFile, position int) {
-	p.npMu.Lock()
-	defer p.npMu.Unlock()
-	ctx = context.WithoutCancel(ctx) // Prevent cancellation from affecting background processing
-	p.npQueue[playerId] = nowPlayingEntry{
-		ctx:      ctx,
-		userId:   userId,
-		track:    track,
-		position: position,
-	}
-	p.sendNowPlayingSignal()
-}
-
-func (p *playTracker) sendNowPlayingSignal() {
-	// Don't block if the previous signal was not read yet
-	select {
-	case p.npSignal <- struct{}{}:
-	default:
-	}
-}
-
-func (p *playTracker) nowPlayingWorker() {
-	defer close(p.workerDone)
-	for {
-		select {
-		case <-p.shutdown:
-			return
-		case <-time.After(time.Second):
-		case <-p.npSignal:
-		}
-
-		p.npMu.Lock()
-		if len(p.npQueue) == 0 {
-			p.npMu.Unlock()
-			continue
-		}
-
-		// Keep a copy of the entries to process and clear the queue
-		entries := p.npQueue
-		p.npQueue = make(map[string]nowPlayingEntry)
-		p.npMu.Unlock()
-
-		// Process entries without holding lock
-		for _, entry := range entries {
-			p.dispatchNowPlaying(entry.ctx, entry.userId, entry.track, entry.position)
-		}
-	}
-}
-
-func (p *playTracker) dispatchNowPlaying(ctx context.Context, userId string, t *model.MediaFile, position int) {
+func (p *playTracker) dispatchNowPlaying(ctx context.Context, userId string, t *model.MediaFile) {
 	if t.Artist == consts.UnknownArtist {
 		log.Debug(ctx, "Ignoring external NowPlaying update for track with unknown artist", "track", t.Title, "artist", t.Artist)
 		return
 	}
-	allScrobblers := p.getActiveScrobblers()
-	for name, s := range allScrobblers {
+	for name, s := range p.scrobblers {
 		if !s.IsAuthorized(ctx, userId) {
 			continue
 		}
-		log.Debug(ctx, "Sending NowPlaying update", "scrobbler", name, "track", t.Title, "artist", t.Artist, "position", position)
-		err := s.NowPlaying(ctx, userId, t, position)
+		log.Debug(ctx, "Sending NowPlaying update", "scrobbler", name, "track", t.Title, "artist", t.Artist)
+		err := s.NowPlaying(ctx, userId, t)
 		if err != nil {
 			log.Error(ctx, "Error sending NowPlayingInfo", "scrobbler", name, "track", t.Title, "artist", t.Artist, err)
 			continue
@@ -348,14 +164,8 @@ func (p *playTracker) incPlay(ctx context.Context, track *model.MediaFile, times
 		}
 		for _, artist := range track.Participants[model.RoleArtist] {
 			err = tx.Artist(ctx).IncPlayCount(artist.ID, timestamp)
-			if err != nil {
-				return err
-			}
 		}
-		if conf.Server.EnableScrobbleHistory {
-			return tx.Scrobble(ctx).RecordScrobble(track.ID, timestamp)
-		}
-		return nil
+		return err
 	})
 }
 
@@ -364,11 +174,9 @@ func (p *playTracker) dispatchScrobble(ctx context.Context, t *model.MediaFile,
 		log.Debug(ctx, "Ignoring external Scrobble for track with unknown artist", "track", t.Title, "artist", t.Artist)
 		return
 	}
-
-	allScrobblers := p.getActiveScrobblers()
 	u, _ := request.UserFrom(ctx)
 	scrobble := Scrobble{MediaFile: *t, TimeStamp: playTime}
-	for name, s := range allScrobblers {
+	for name, s := range p.scrobblers {
 		if !s.IsAuthorized(ctx, u.ID) {
 			continue
 		}

core/scrobbler/play_tracker_test.go

@@ -3,13 +3,8 @@ package scrobbler
 import (
 	"context"
 	"errors"
-	"net/http"
-	"sync"
-	"sync/atomic"
 	"time"
 
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/consts"
 
 	"github.com/navidrome/navidrome/model"
@@ -20,61 +15,30 @@ import (
 	. "github.com/onsi/gomega"
 )
 
-// mockPluginLoader is a test implementation of PluginLoader for plugin scrobbler tests
-// Moved to top-level scope to avoid linter issues
-
-type mockPluginLoader struct {
-	mu         sync.RWMutex
-	names      []string
-	scrobblers map[string]Scrobbler
-}
-
-func (m *mockPluginLoader) PluginNames(service string) []string {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.names
-}
-
-func (m *mockPluginLoader) SetNames(names []string) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.names = names
-}
-
-func (m *mockPluginLoader) LoadScrobbler(name string) (Scrobbler, bool) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	s, ok := m.scrobblers[name]
-	return s, ok
-}
-
 var _ = Describe("PlayTracker", func() {
 	var ctx context.Context
 	var ds model.DataStore
 	var tracker PlayTracker
-	var eventBroker *fakeEventBroker
 	var track model.MediaFile
 	var album model.Album
 	var artist1 model.Artist
 	var artist2 model.Artist
-	var fake *fakeScrobbler
+	var fake fakeScrobbler
 
 	BeforeEach(func() {
-		DeferCleanup(configtest.SetupConfig())
-		ctx = GinkgoT().Context()
+		ctx = context.Background()
 		ctx = request.WithUser(ctx, model.User{ID: "u-1"})
 		ctx = request.WithPlayer(ctx, model.Player{ScrobbleEnabled: true})
 		ds = &tests.MockDataStore{}
-		fake = &fakeScrobbler{Authorized: true}
+		fake = fakeScrobbler{Authorized: true}
 		Register("fake", func(model.DataStore) Scrobbler {
-			return fake
+			return &fake
 		})
 		Register("disabled", func(model.DataStore) Scrobbler {
 			return nil
 		})
-		eventBroker = &fakeEventBroker{}
-		tracker = newPlayTracker(ds, eventBroker, nil)
-		tracker.(*playTracker).builtinScrobblers["fake"] = fake // Bypass buffering for tests
+		tracker = newPlayTracker(ds, events.GetBroker())
+		tracker.(*playTracker).scrobblers["fake"] = &fake // Bypass buffering for tests
 
 		track = model.MediaFile{
 			ID:             "123",
@@ -97,89 +61,43 @@ var _ = Describe("PlayTracker", func() {
 		_ = ds.Album(ctx).(*tests.MockAlbumRepo).Put(&album)
 	})
 
-	AfterEach(func() {
-		// Stop the worker goroutine to prevent data races between tests
-		tracker.(*playTracker).stopNowPlayingWorker()
-	})
-
 	It("does not register disabled scrobblers", func() {
-		Expect(tracker.(*playTracker).builtinScrobblers).To(HaveKey("fake"))
-		Expect(tracker.(*playTracker).builtinScrobblers).ToNot(HaveKey("disabled"))
+		Expect(tracker.(*playTracker).scrobblers).To(HaveKey("fake"))
+		Expect(tracker.(*playTracker).scrobblers).ToNot(HaveKey("disabled"))
 	})
 
 	Describe("NowPlaying", func() {
 		It("sends track to agent", func() {
-			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123")
 			Expect(err).ToNot(HaveOccurred())
-			Eventually(func() bool { return fake.GetNowPlayingCalled() }).Should(BeTrue())
-			Expect(fake.GetUserID()).To(Equal("u-1"))
-			Expect(fake.GetTrack().ID).To(Equal("123"))
-			Expect(fake.GetTrack().Participants).To(Equal(track.Participants))
+			Expect(fake.NowPlayingCalled).To(BeTrue())
+			Expect(fake.UserID).To(Equal("u-1"))
+			Expect(fake.Track.ID).To(Equal("123"))
+			Expect(fake.Track.Participants).To(Equal(track.Participants))
 		})
 		It("does not send track to agent if user has not authorized", func() {
 			fake.Authorized = false
 
-			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123")
 
 			Expect(err).ToNot(HaveOccurred())
-			Expect(fake.GetNowPlayingCalled()).To(BeFalse())
+			Expect(fake.NowPlayingCalled).To(BeFalse())
 		})
 		It("does not send track to agent if player is not enabled to send scrobbles", func() {
 			ctx = request.WithPlayer(ctx, model.Player{ScrobbleEnabled: false})
 
-			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123")
 
 			Expect(err).ToNot(HaveOccurred())
-			Expect(fake.GetNowPlayingCalled()).To(BeFalse())
+			Expect(fake.NowPlayingCalled).To(BeFalse())
 		})
 		It("does not send track to agent if artist is unknown", func() {
 			track.Artist = consts.UnknownArtist
 
-			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123")
 
 			Expect(err).ToNot(HaveOccurred())
-			Expect(fake.GetNowPlayingCalled()).To(BeFalse())
-		})
-
-		It("stores position when greater than zero", func() {
-			pos := 42
-			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", pos)
-			Expect(err).ToNot(HaveOccurred())
-
-			Eventually(func() int { return fake.GetPosition() }).Should(Equal(pos))
-
-			playing, err := tracker.GetNowPlaying(ctx)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(playing).To(HaveLen(1))
-			Expect(playing[0].Position).To(Equal(pos))
-		})
-
-		It("sends event with count", func() {
-			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
-			Expect(err).ToNot(HaveOccurred())
-			eventList := eventBroker.getEvents()
-			Expect(eventList).ToNot(BeEmpty())
-			evt, ok := eventList[0].(*events.NowPlayingCount)
-			Expect(ok).To(BeTrue())
-			Expect(evt.Count).To(Equal(1))
-		})
-
-		It("does not send event when disabled", func() {
-			conf.Server.EnableNowPlaying = false
-			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(eventBroker.getEvents()).To(BeEmpty())
-		})
-
-		It("passes user to scrobbler via context (fix for issue #4787)", func() {
-			ctx = request.WithUser(ctx, model.User{ID: "u-1", UserName: "testuser"})
-			ctx = request.WithPlayer(ctx, model.Player{ScrobbleEnabled: true})
-
-			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
-			Expect(err).ToNot(HaveOccurred())
-			Eventually(func() bool { return fake.GetNowPlayingCalled() }).Should(BeTrue())
-			// Verify the username was passed through async dispatch via context
-			Eventually(func() string { return fake.GetUsername() }).Should(Equal("testuser"))
+			Expect(fake.NowPlayingCalled).To(BeFalse())
 		})
 	})
 
@@ -188,10 +106,10 @@ var _ = Describe("PlayTracker", func() {
 			track2 := track
 			track2.ID = "456"
 			_ = ds.MediaFile(ctx).Put(&track2)
-			ctx = request.WithUser(GinkgoT().Context(), model.User{UserName: "user-1"})
-			_ = tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
-			ctx = request.WithUser(GinkgoT().Context(), model.User{UserName: "user-2"})
-			_ = tracker.NowPlaying(ctx, "player-2", "player-two", "456", 0)
+			ctx = request.WithUser(context.Background(), model.User{UserName: "user-1"})
+			_ = tracker.NowPlaying(ctx, "player-1", "player-one", "123")
+			ctx = request.WithUser(context.Background(), model.User{UserName: "user-2"})
+			_ = tracker.NowPlaying(ctx, "player-2", "player-two", "456")
 
 			playing, err := tracker.GetNowPlaying(ctx)
 
@@ -209,26 +127,6 @@ var _ = Describe("PlayTracker", func() {
 		})
 	})
 
-	Describe("Expiration events", func() {
-		It("sends event when entry expires", func() {
-			info := NowPlayingInfo{MediaFile: track, Start: time.Now(), Username: "user"}
-			_ = tracker.(*playTracker).playMap.AddWithTTL("player-1", info, 10*time.Millisecond)
-			Eventually(func() int { return len(eventBroker.getEvents()) }).Should(BeNumerically(">", 0))
-			eventList := eventBroker.getEvents()
-			evt, ok := eventList[len(eventList)-1].(*events.NowPlayingCount)
-			Expect(ok).To(BeTrue())
-			Expect(evt.Count).To(Equal(0))
-		})
-
-		It("does not send event when disabled", func() {
-			conf.Server.EnableNowPlaying = false
-			tracker = newPlayTracker(ds, eventBroker, nil)
-			info := NowPlayingInfo{MediaFile: track, Start: time.Now(), Username: "user"}
-			_ = tracker.(*playTracker).playMap.AddWithTTL("player-2", info, 10*time.Millisecond)
-			Consistently(func() int { return len(eventBroker.getEvents()) }).Should(Equal(0))
-		})
-	})
-
 	Describe("Submit", func() {
 		It("sends track to agent", func() {
 			ctx = request.WithUser(ctx, model.User{ID: "u-1", UserName: "user-1"})
@@ -237,12 +135,10 @@ var _ = Describe("PlayTracker", func() {
 			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: ts}})
 
 			Expect(err).ToNot(HaveOccurred())
-			Expect(fake.ScrobbleCalled.Load()).To(BeTrue())
-			Expect(fake.GetUserID()).To(Equal("u-1"))
-			lastScrobble := fake.LastScrobble.Load()
-			Expect(lastScrobble.TimeStamp).To(BeTemporally("~", ts, 1*time.Second))
-			Expect(lastScrobble.ID).To(Equal("123"))
-			Expect(lastScrobble.Participants).To(Equal(track.Participants))
+			Expect(fake.ScrobbleCalled).To(BeTrue())
+			Expect(fake.UserID).To(Equal("u-1"))
+			Expect(fake.LastScrobble.ID).To(Equal("123"))
+			Expect(fake.LastScrobble.Participants).To(Equal(track.Participants))
 		})
 
 		It("increments play counts in the DB", func() {
@@ -266,7 +162,7 @@ var _ = Describe("PlayTracker", func() {
 			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: time.Now()}})
 
 			Expect(err).ToNot(HaveOccurred())
-			Expect(fake.ScrobbleCalled.Load()).To(BeFalse())
+			Expect(fake.ScrobbleCalled).To(BeFalse())
 		})
 
 		It("does not send track to agent if player is not enabled to send scrobbles", func() {
@@ -275,7 +171,7 @@ var _ = Describe("PlayTracker", func() {
 			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: time.Now()}})
 
 			Expect(err).ToNot(HaveOccurred())
-			Expect(fake.ScrobbleCalled.Load()).To(BeFalse())
+			Expect(fake.ScrobbleCalled).To(BeFalse())
 		})
 
 		It("does not send track to agent if artist is unknown", func() {
@@ -284,7 +180,7 @@ var _ = Describe("PlayTracker", func() {
 			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: time.Now()}})
 
 			Expect(err).ToNot(HaveOccurred())
-			Expect(fake.ScrobbleCalled.Load()).To(BeFalse())
+			Expect(fake.ScrobbleCalled).To(BeFalse())
 		})
 
 		It("increments play counts even if it cannot scrobble", func() {
@@ -293,7 +189,7 @@ var _ = Describe("PlayTracker", func() {
 			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: time.Now()}})
 
 			Expect(err).ToNot(HaveOccurred())
-			Expect(fake.ScrobbleCalled.Load()).To(BeFalse())
+			Expect(fake.ScrobbleCalled).To(BeFalse())
 
 			Expect(track.PlayCount).To(Equal(int64(1)))
 			Expect(album.PlayCount).To(Equal(int64(1)))
@@ -302,208 +198,41 @@ var _ = Describe("PlayTracker", func() {
 			Expect(artist1.PlayCount).To(Equal(int64(1)))
 			Expect(artist2.PlayCount).To(Equal(int64(1)))
 		})
-
-		Context("Scrobble History", func() {
-			It("records scrobble in repository", func() {
-				conf.Server.EnableScrobbleHistory = true
-				ctx = request.WithUser(ctx, model.User{ID: "u-1", UserName: "user-1"})
-				ts := time.Now()
-
-				err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: ts}})
-
-				Expect(err).ToNot(HaveOccurred())
-
-				mockDS := ds.(*tests.MockDataStore)
-				mockScrobble := mockDS.Scrobble(ctx).(*tests.MockScrobbleRepo)
-				Expect(mockScrobble.RecordedScrobbles).To(HaveLen(1))
-				Expect(mockScrobble.RecordedScrobbles[0].MediaFileID).To(Equal("123"))
-				Expect(mockScrobble.RecordedScrobbles[0].UserID).To(Equal("u-1"))
-				Expect(mockScrobble.RecordedScrobbles[0].SubmissionTime).To(Equal(ts))
-			})
-
-			It("does not record scrobble when history is disabled", func() {
-				conf.Server.EnableScrobbleHistory = false
-				ctx = request.WithUser(ctx, model.User{ID: "u-1", UserName: "user-1"})
-				ts := time.Now()
-
-				err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: ts}})
-
-				Expect(err).ToNot(HaveOccurred())
-				mockDS := ds.(*tests.MockDataStore)
-				mockScrobble := mockDS.Scrobble(ctx).(*tests.MockScrobbleRepo)
-				Expect(mockScrobble.RecordedScrobbles).To(HaveLen(0))
-			})
-		})
 	})
 
-	Describe("Plugin scrobbler logic", func() {
-		var pluginLoader *mockPluginLoader
-		var pluginFake *fakeScrobbler
-
-		BeforeEach(func() {
-			pluginFake = &fakeScrobbler{Authorized: true}
-			pluginLoader = &mockPluginLoader{
-				names:      []string{"plugin1"},
-				scrobblers: map[string]Scrobbler{"plugin1": pluginFake},
-			}
-			tracker = newPlayTracker(ds, events.GetBroker(), pluginLoader)
-
-			// Bypass buffering for both built-in and plugin scrobblers
-			tracker.(*playTracker).builtinScrobblers["fake"] = fake
-			tracker.(*playTracker).pluginScrobblers["plugin1"] = pluginFake
-		})
-
-		It("registers and uses plugin scrobbler for NowPlaying", func() {
-			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
-			Expect(err).ToNot(HaveOccurred())
-			Eventually(func() bool { return pluginFake.GetNowPlayingCalled() }).Should(BeTrue())
-		})
-
-		It("removes plugin scrobbler if not present anymore", func() {
-			// First call: plugin present
-			_ = tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
-			Eventually(func() bool { return pluginFake.GetNowPlayingCalled() }).Should(BeTrue())
-			pluginFake.nowPlayingCalled.Store(false)
-			// Remove plugin
-			pluginLoader.SetNames([]string{})
-			_ = tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
-			// Should not be called since plugin was removed
-			Consistently(func() bool { return pluginFake.GetNowPlayingCalled() }).Should(BeFalse())
-		})
-
-		It("calls both builtin and plugin scrobblers for NowPlaying", func() {
-			fake.nowPlayingCalled.Store(false)
-			pluginFake.nowPlayingCalled.Store(false)
-			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
-			Expect(err).ToNot(HaveOccurred())
-			Eventually(func() bool { return fake.GetNowPlayingCalled() }).Should(BeTrue())
-			Eventually(func() bool { return pluginFake.GetNowPlayingCalled() }).Should(BeTrue())
-		})
-
-		It("calls plugin scrobbler for Submit", func() {
-			ts := time.Now()
-			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: ts}})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(pluginFake.ScrobbleCalled.Load()).To(BeTrue())
-		})
-	})
-
-	Describe("Plugin Scrobbler Management", func() {
-		var pluginScr *fakeScrobbler
-		var mockPlugin *mockPluginLoader
-		var pTracker *playTracker
-		var mockedBS *mockBufferedScrobbler
-
-		BeforeEach(func() {
-			ctx = GinkgoT().Context()
-			ctx = request.WithUser(ctx, model.User{ID: "u-1"})
-			ctx = request.WithPlayer(ctx, model.Player{ScrobbleEnabled: true})
-			ds = &tests.MockDataStore{}
-
-			// Setup plugin scrobbler
-			pluginScr = &fakeScrobbler{Authorized: true}
-			mockPlugin = &mockPluginLoader{
-				names:      []string{"plugin1"},
-				scrobblers: map[string]Scrobbler{"plugin1": pluginScr},
-			}
-
-			// Create a tracker with the mock plugin loader
-			pTracker = newPlayTracker(ds, events.GetBroker(), mockPlugin)
-
-			// Create a mock buffered scrobbler and explicitly cast it to Scrobbler
-			mockedBS = &mockBufferedScrobbler{
-				wrapped: pluginScr,
-			}
-			// Make sure the instance is added with its concrete type preserved
-			pTracker.pluginScrobblers["plugin1"] = mockedBS
-		})
-
-		It("calls Stop on scrobblers when removing them", func() {
-			// Change the plugin names to simulate a plugin being removed
-			mockPlugin.SetNames([]string{})
-
-			// Call refreshPluginScrobblers which should detect the removed plugin
-			pTracker.refreshPluginScrobblers()
-
-			// Verify the Stop method was called
-			Expect(mockedBS.stopCalled).To(BeTrue())
-
-			// Verify the scrobbler was removed from the map
-			Expect(pTracker.pluginScrobblers).NotTo(HaveKey("plugin1"))
-		})
-	})
 })
 
 type fakeScrobbler struct {
 	Authorized       bool
-	nowPlayingCalled atomic.Bool
-	ScrobbleCalled   atomic.Bool
-	userID           atomic.Pointer[string]
-	username         atomic.Pointer[string]
-	track            atomic.Pointer[model.MediaFile]
-	position         atomic.Int32
-	LastScrobble     atomic.Pointer[Scrobble]
+	NowPlayingCalled bool
+	ScrobbleCalled   bool
+	UserID           string
+	Track            *model.MediaFile
+	LastScrobble     Scrobble
 	Error            error
 }
 
-func (f *fakeScrobbler) GetNowPlayingCalled() bool {
-	return f.nowPlayingCalled.Load()
-}
-
-func (f *fakeScrobbler) GetUserID() string {
-	if p := f.userID.Load(); p != nil {
-		return *p
-	}
-	return ""
-}
-
-func (f *fakeScrobbler) GetTrack() *model.MediaFile {
-	return f.track.Load()
-}
-
-func (f *fakeScrobbler) GetPosition() int {
-	return int(f.position.Load())
-}
-
-func (f *fakeScrobbler) GetUsername() string {
-	if p := f.username.Load(); p != nil {
-		return *p
-	}
-	return ""
-}
-
 func (f *fakeScrobbler) IsAuthorized(ctx context.Context, userId string) bool {
 	return f.Error == nil && f.Authorized
 }
 
-func (f *fakeScrobbler) NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) error {
-	f.nowPlayingCalled.Store(true)
+func (f *fakeScrobbler) NowPlaying(ctx context.Context, userId string, track *model.MediaFile) error {
+	f.NowPlayingCalled = true
 	if f.Error != nil {
 		return f.Error
 	}
-	f.userID.Store(&userId)
-	// Capture username from context (this is what plugin scrobblers do)
-	username, _ := request.UsernameFrom(ctx)
-	if username == "" {
-		if u, ok := request.UserFrom(ctx); ok {
-			username = u.UserName
-		}
-	}
-	if username != "" {
-		f.username.Store(&username)
-	}
-	f.track.Store(track)
-	f.position.Store(int32(position))
+	f.UserID = userId
+	f.Track = track
 	return nil
 }
 
 func (f *fakeScrobbler) Scrobble(ctx context.Context, userId string, s Scrobble) error {
-	f.userID.Store(&userId)
-	f.LastScrobble.Store(&s)
-	f.ScrobbleCalled.Store(true)
+	f.ScrobbleCalled = true
 	if f.Error != nil {
 		return f.Error
 	}
+	f.UserID = userId
+	f.LastScrobble = s
 	return nil
 }
 
@@ -514,51 +243,3 @@ func _p(id, name string, sortName ...string) model.Participant {
 	}
 	return p
 }
-
-type fakeEventBroker struct {
-	http.Handler
-	events []events.Event
-	mu     sync.Mutex
-}
-
-func (f *fakeEventBroker) SendMessage(_ context.Context, event events.Event) {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	f.events = append(f.events, event)
-}
-
-func (f *fakeEventBroker) SendBroadcastMessage(_ context.Context, event events.Event) {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	f.events = append(f.events, event)
-}
-
-func (f *fakeEventBroker) getEvents() []events.Event {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	return f.events
-}
-
-var _ events.Broker = (*fakeEventBroker)(nil)
-
-// mockBufferedScrobbler used to test that Stop is called
-type mockBufferedScrobbler struct {
-	wrapped    Scrobbler
-	stopCalled bool
-}
-
-func (m *mockBufferedScrobbler) Stop() {
-	m.stopCalled = true
-}
-
-func (m *mockBufferedScrobbler) IsAuthorized(ctx context.Context, userId string) bool {
-	return m.wrapped.IsAuthorized(ctx, userId)
-}
-
-func (m *mockBufferedScrobbler) NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) error {
-	return m.wrapped.NowPlaying(ctx, userId, track, position)
-}
-
-func (m *mockBufferedScrobbler) Scrobble(ctx context.Context, userId string, s Scrobble) error {
-	return m.wrapped.Scrobble(ctx, userId, s)
-}

core/share.go

@@ -13,7 +13,6 @@ import (
 	"github.com/navidrome/navidrome/model"
 	. "github.com/navidrome/navidrome/utils/gg"
 	"github.com/navidrome/navidrome/utils/slice"
-	"github.com/navidrome/navidrome/utils/str"
 )
 
 type Share interface {
@@ -120,8 +119,9 @@ func (r *shareRepositoryWrapper) Save(entity interface{}) (string, error) {
 		log.Error(r.ctx, "Invalid Resource ID", "id", firstId)
 		return "", model.ErrNotFound
 	}
-
-	s.Contents = str.TruncateRunes(s.Contents, 30, "...")
+	if len(s.Contents) > 30 {
+		s.Contents = s.Contents[:26] + "..."
+	}
 
 	id, err = r.Persistable.Save(s)
 	return id, err
@@ -149,7 +149,7 @@ func (r *shareRepositoryWrapper) contentsLabelFromArtist(shareID string, ids str
 
 func (r *shareRepositoryWrapper) contentsLabelFromAlbums(shareID string, ids string) string {
 	idList := strings.Split(ids, ",")
-	all, err := r.ds.Album(r.ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"album.id": idList}})
+	all, err := r.ds.Album(r.ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"id": idList}})
 	if err != nil {
 		log.Error(r.ctx, "Error retrieving album names for share", "share", shareID, err)
 		return ""

core/share_test.go

@@ -38,38 +38,6 @@ var _ = Describe("Share", func() {
 				Expect(id).ToNot(BeEmpty())
 				Expect(entity.ID).To(Equal(id))
 			})
-
-			It("does not truncate ASCII labels shorter than 30 characters", func() {
-				_ = ds.MediaFile(ctx).Put(&model.MediaFile{ID: "456", Title: "Example Media File"})
-				entity := &model.Share{Description: "test", ResourceIDs: "456"}
-				_, err := repo.Save(entity)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(entity.Contents).To(Equal("Example Media File"))
-			})
-
-			It("truncates ASCII labels longer than 30 characters", func() {
-				_ = ds.MediaFile(ctx).Put(&model.MediaFile{ID: "789", Title: "Example Media File But The Title Is Really Long For Testing Purposes"})
-				entity := &model.Share{Description: "test", ResourceIDs: "789"}
-				_, err := repo.Save(entity)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(entity.Contents).To(Equal("Example Media File But The ..."))
-			})
-
-			It("does not truncate CJK labels shorter than 30 runes", func() {
-				_ = ds.MediaFile(ctx).Put(&model.MediaFile{ID: "456", Title: "青春コンプレックス"})
-				entity := &model.Share{Description: "test", ResourceIDs: "456"}
-				_, err := repo.Save(entity)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(entity.Contents).To(Equal("青春コンプレックス"))
-			})
-
-			It("truncates CJK labels longer than 30 runes", func() {
-				_ = ds.MediaFile(ctx).Put(&model.MediaFile{ID: "789", Title: "私の中の幻想的世界観及びその顕現を想起させたある現実での出来事に関する一考察"})
-				entity := &model.Share{Description: "test", ResourceIDs: "789"}
-				_, err := repo.Save(entity)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(entity.Contents).To(Equal("私の中の幻想的世界観及びその顕現を想起させたある現実で..."))
-			})
 		})
 
 		Describe("Update", func() {

core/storage/local/local_suite_test.go

@@ -3,15 +3,11 @@ package local
 import (
 	"testing"
 
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
 
 func TestLocal(t *testing.T) {
-	tests.Init(t, false)
-	log.SetLevel(log.LevelFatal)
 	RegisterFailHandler(Fail)
-	RunSpecs(t, "Local Storage Suite")
+	RunSpecs(t, "Local Storage Test Suite")
 }

core/storage/local/local_test.go

@@ -1,428 +0,0 @@
-package local
-
-import (
-	"io/fs"
-	"net/url"
-	"os"
-	"path/filepath"
-	"runtime"
-	"time"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/conf/configtest"
-	"github.com/navidrome/navidrome/core/storage"
-	"github.com/navidrome/navidrome/model/metadata"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("LocalStorage", func() {
-	var tempDir string
-	var testExtractor *mockTestExtractor
-
-	BeforeEach(func() {
-		DeferCleanup(configtest.SetupConfig())
-
-		// Create a temporary directory for testing
-		var err error
-		tempDir, err = os.MkdirTemp("", "navidrome-local-storage-test-")
-		Expect(err).ToNot(HaveOccurred())
-
-		DeferCleanup(func() {
-			os.RemoveAll(tempDir)
-		})
-
-		// Create and register a test extractor
-		testExtractor = &mockTestExtractor{
-			results: make(map[string]metadata.Info),
-		}
-		RegisterExtractor("test", func(fs.FS, string) Extractor {
-			return testExtractor
-		})
-		conf.Server.Scanner.Extractor = "test"
-	})
-
-	Describe("newLocalStorage", func() {
-		Context("with valid path", func() {
-			It("should create a localStorage instance with correct path", func() {
-				u, err := url.Parse("file://" + tempDir)
-				Expect(err).ToNot(HaveOccurred())
-
-				storage := newLocalStorage(*u)
-				localStorage := storage.(*localStorage)
-
-				Expect(localStorage.u.Scheme).To(Equal("file"))
-				// Check that the path is set correctly (could be resolved to real path on macOS)
-				Expect(localStorage.u.Path).To(ContainSubstring("navidrome-local-storage-test"))
-				Expect(localStorage.resolvedPath).To(ContainSubstring("navidrome-local-storage-test"))
-				Expect(localStorage.extractor).ToNot(BeNil())
-			})
-
-			It("should handle URL-decoded paths correctly", func() {
-				// Create a directory with spaces to test URL decoding
-				spacedDir := filepath.Join(tempDir, "test folder")
-				err := os.MkdirAll(spacedDir, 0755)
-				Expect(err).ToNot(HaveOccurred())
-
-				// Use proper URL construction instead of manual escaping
-				u := &url.URL{
-					Scheme: "file",
-					Path:   spacedDir,
-				}
-
-				storage := newLocalStorage(*u)
-				localStorage, ok := storage.(*localStorage)
-				Expect(ok).To(BeTrue())
-
-				Expect(localStorage.u.Path).To(Equal(spacedDir))
-			})
-
-			It("should resolve symlinks when possible", func() {
-				// Create a real directory and a symlink to it
-				realDir := filepath.Join(tempDir, "real")
-				linkDir := filepath.Join(tempDir, "link")
-
-				err := os.MkdirAll(realDir, 0755)
-				Expect(err).ToNot(HaveOccurred())
-
-				err = os.Symlink(realDir, linkDir)
-				Expect(err).ToNot(HaveOccurred())
-
-				u, err := url.Parse("file://" + linkDir)
-				Expect(err).ToNot(HaveOccurred())
-
-				storage := newLocalStorage(*u)
-				localStorage, ok := storage.(*localStorage)
-				Expect(ok).To(BeTrue())
-
-				Expect(localStorage.u.Path).To(Equal(linkDir))
-				// Check that the resolved path contains the real directory name
-				Expect(localStorage.resolvedPath).To(ContainSubstring("real"))
-			})
-
-			It("should use u.Path as resolvedPath when symlink resolution fails", func() {
-				// Use a non-existent path to trigger symlink resolution failure
-				nonExistentPath := filepath.Join(tempDir, "non-existent")
-
-				u, err := url.Parse("file://" + nonExistentPath)
-				Expect(err).ToNot(HaveOccurred())
-
-				storage := newLocalStorage(*u)
-				localStorage, ok := storage.(*localStorage)
-				Expect(ok).To(BeTrue())
-
-				Expect(localStorage.u.Path).To(Equal(nonExistentPath))
-				Expect(localStorage.resolvedPath).To(Equal(nonExistentPath))
-			})
-		})
-
-		Context("with Windows path", func() {
-			BeforeEach(func() {
-				if runtime.GOOS != "windows" {
-					Skip("Windows-specific test")
-				}
-			})
-
-			It("should handle Windows drive letters correctly", func() {
-				u, err := url.Parse("file://C:/music")
-				Expect(err).ToNot(HaveOccurred())
-
-				storage := newLocalStorage(*u)
-				localStorage, ok := storage.(*localStorage)
-				Expect(ok).To(BeTrue())
-
-				Expect(localStorage.u.Path).To(Equal("C:/music"))
-			})
-		})
-
-		Context("with invalid extractor", func() {
-			It("should handle extractor validation correctly", func() {
-				// Note: The actual implementation uses log.Fatal which exits the process,
-				// so we test the normal path where extractors exist
-
-				u, err := url.Parse("file://" + tempDir)
-				Expect(err).ToNot(HaveOccurred())
-
-				storage := newLocalStorage(*u)
-				Expect(storage).ToNot(BeNil())
-			})
-		})
-	})
-
-	Describe("localStorage.FS", func() {
-		Context("with existing directory", func() {
-			It("should return a localFS instance", func() {
-				u, err := url.Parse("file://" + tempDir)
-				Expect(err).ToNot(HaveOccurred())
-
-				storage := newLocalStorage(*u)
-				musicFS, err := storage.FS()
-				Expect(err).ToNot(HaveOccurred())
-				Expect(musicFS).ToNot(BeNil())
-
-				_, ok := musicFS.(*localFS)
-				Expect(ok).To(BeTrue())
-			})
-		})
-
-		Context("with non-existent directory", func() {
-			It("should return an error", func() {
-				nonExistentPath := filepath.Join(tempDir, "non-existent")
-				u, err := url.Parse("file://" + nonExistentPath)
-				Expect(err).ToNot(HaveOccurred())
-
-				storage := newLocalStorage(*u)
-				_, err = storage.FS()
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring(nonExistentPath))
-			})
-		})
-	})
-
-	Describe("localFS.ReadTags", func() {
-		var testFile string
-
-		BeforeEach(func() {
-			// Create a test file
-			testFile = filepath.Join(tempDir, "test.mp3")
-			err := os.WriteFile(testFile, []byte("test data"), 0600)
-			Expect(err).ToNot(HaveOccurred())
-
-			// Reset extractor state
-			testExtractor.results = make(map[string]metadata.Info)
-			testExtractor.err = nil
-		})
-
-		Context("when extractor returns complete metadata", func() {
-			It("should return the metadata as-is", func() {
-				expectedInfo := metadata.Info{
-					Tags: map[string][]string{
-						"title":  {"Test Song"},
-						"artist": {"Test Artist"},
-					},
-					AudioProperties: metadata.AudioProperties{
-						Duration: 180,
-						BitRate:  320,
-					},
-					FileInfo: &testFileInfo{name: "test.mp3"},
-				}
-
-				testExtractor.results["test.mp3"] = expectedInfo
-
-				u, err := url.Parse("file://" + tempDir)
-				Expect(err).ToNot(HaveOccurred())
-				storage := newLocalStorage(*u)
-				musicFS, err := storage.FS()
-				Expect(err).ToNot(HaveOccurred())
-
-				results, err := musicFS.ReadTags("test.mp3")
-				Expect(err).ToNot(HaveOccurred())
-				Expect(results).To(HaveKey("test.mp3"))
-				Expect(results["test.mp3"]).To(Equal(expectedInfo))
-			})
-		})
-
-		Context("when extractor returns metadata without FileInfo", func() {
-			It("should populate FileInfo from filesystem", func() {
-				incompleteInfo := metadata.Info{
-					Tags: map[string][]string{
-						"title": {"Test Song"},
-					},
-					FileInfo: nil, // Missing FileInfo
-				}
-
-				testExtractor.results["test.mp3"] = incompleteInfo
-
-				u, err := url.Parse("file://" + tempDir)
-				Expect(err).ToNot(HaveOccurred())
-				storage := newLocalStorage(*u)
-				musicFS, err := storage.FS()
-				Expect(err).ToNot(HaveOccurred())
-
-				results, err := musicFS.ReadTags("test.mp3")
-				Expect(err).ToNot(HaveOccurred())
-				Expect(results).To(HaveKey("test.mp3"))
-
-				result := results["test.mp3"]
-				Expect(result.FileInfo).ToNot(BeNil())
-				Expect(result.FileInfo.Name()).To(Equal("test.mp3"))
-
-				// Should be wrapped in localFileInfo
-				_, ok := result.FileInfo.(localFileInfo)
-				Expect(ok).To(BeTrue())
-			})
-		})
-
-		Context("when filesystem stat fails", func() {
-			It("should return an error", func() {
-				incompleteInfo := metadata.Info{
-					Tags:     map[string][]string{"title": {"Test Song"}},
-					FileInfo: nil,
-				}
-
-				testExtractor.results["non-existent.mp3"] = incompleteInfo
-
-				u, err := url.Parse("file://" + tempDir)
-				Expect(err).ToNot(HaveOccurred())
-				storage := newLocalStorage(*u)
-				musicFS, err := storage.FS()
-				Expect(err).ToNot(HaveOccurred())
-
-				_, err = musicFS.ReadTags("non-existent.mp3")
-				Expect(err).To(HaveOccurred())
-			})
-		})
-
-		Context("when extractor fails", func() {
-			It("should return the extractor error", func() {
-				testExtractor.err = &extractorError{message: "extractor failed"}
-
-				u, err := url.Parse("file://" + tempDir)
-				Expect(err).ToNot(HaveOccurred())
-				storage := newLocalStorage(*u)
-				musicFS, err := storage.FS()
-				Expect(err).ToNot(HaveOccurred())
-
-				_, err = musicFS.ReadTags("test.mp3")
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("extractor failed"))
-			})
-		})
-
-		Context("with multiple files", func() {
-			It("should process all files correctly", func() {
-				// Create another test file
-				testFile2 := filepath.Join(tempDir, "test2.mp3")
-				err := os.WriteFile(testFile2, []byte("test data 2"), 0600)
-				Expect(err).ToNot(HaveOccurred())
-
-				info1 := metadata.Info{
-					Tags:     map[string][]string{"title": {"Song 1"}},
-					FileInfo: &testFileInfo{name: "test.mp3"},
-				}
-				info2 := metadata.Info{
-					Tags:     map[string][]string{"title": {"Song 2"}},
-					FileInfo: nil, // This one needs FileInfo populated
-				}
-
-				testExtractor.results["test.mp3"] = info1
-				testExtractor.results["test2.mp3"] = info2
-
-				u, err := url.Parse("file://" + tempDir)
-				Expect(err).ToNot(HaveOccurred())
-				storage := newLocalStorage(*u)
-				musicFS, err := storage.FS()
-				Expect(err).ToNot(HaveOccurred())
-
-				results, err := musicFS.ReadTags("test.mp3", "test2.mp3")
-				Expect(err).ToNot(HaveOccurred())
-				Expect(results).To(HaveLen(2))
-
-				Expect(results["test.mp3"].FileInfo).To(Equal(&testFileInfo{name: "test.mp3"}))
-				Expect(results["test2.mp3"].FileInfo).ToNot(BeNil())
-				Expect(results["test2.mp3"].FileInfo.Name()).To(Equal("test2.mp3"))
-			})
-		})
-	})
-
-	Describe("localFileInfo", func() {
-		var testFile string
-		var fileInfo fs.FileInfo
-
-		BeforeEach(func() {
-			testFile = filepath.Join(tempDir, "test.mp3")
-			err := os.WriteFile(testFile, []byte("test data"), 0600)
-			Expect(err).ToNot(HaveOccurred())
-
-			fileInfo, err = os.Stat(testFile)
-			Expect(err).ToNot(HaveOccurred())
-		})
-
-		Describe("BirthTime", func() {
-			It("should return birth time when available", func() {
-				lfi := localFileInfo{FileInfo: fileInfo}
-				birthTime := lfi.BirthTime()
-
-				// Birth time should be a valid time (not zero value)
-				Expect(birthTime).ToNot(BeZero())
-				// Should be around the current time (within last few minutes)
-				Expect(birthTime).To(BeTemporally("~", time.Now(), 5*time.Minute))
-			})
-		})
-
-		It("should delegate all other FileInfo methods", func() {
-			lfi := localFileInfo{FileInfo: fileInfo}
-
-			Expect(lfi.Name()).To(Equal(fileInfo.Name()))
-			Expect(lfi.Size()).To(Equal(fileInfo.Size()))
-			Expect(lfi.Mode()).To(Equal(fileInfo.Mode()))
-			Expect(lfi.ModTime()).To(Equal(fileInfo.ModTime()))
-			Expect(lfi.IsDir()).To(Equal(fileInfo.IsDir()))
-			Expect(lfi.Sys()).To(Equal(fileInfo.Sys()))
-		})
-	})
-
-	Describe("Storage registration", func() {
-		It("should register localStorage for file scheme", func() {
-			// This tests the init() function indirectly
-			storage, err := storage.For("file://" + tempDir)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(storage).To(BeAssignableToTypeOf(&localStorage{}))
-		})
-	})
-})
-
-// Test extractor for testing
-type mockTestExtractor struct {
-	results map[string]metadata.Info
-	err     error
-}
-
-func (m *mockTestExtractor) Parse(files ...string) (map[string]metadata.Info, error) {
-	if m.err != nil {
-		return nil, m.err
-	}
-
-	result := make(map[string]metadata.Info)
-	for _, file := range files {
-		if info, exists := m.results[file]; exists {
-			result[file] = info
-		}
-	}
-	return result, nil
-}
-
-func (m *mockTestExtractor) Version() string {
-	return "test-1.0"
-}
-
-type extractorError struct {
-	message string
-}
-
-func (e *extractorError) Error() string {
-	return e.message
-}
-
-// Test FileInfo that implements metadata.FileInfo
-type testFileInfo struct {
-	name      string
-	size      int64
-	mode      fs.FileMode
-	modTime   time.Time
-	isDir     bool
-	birthTime time.Time
-}
-
-func (t *testFileInfo) Name() string       { return t.name }
-func (t *testFileInfo) Size() int64        { return t.size }
-func (t *testFileInfo) Mode() fs.FileMode  { return t.mode }
-func (t *testFileInfo) ModTime() time.Time { return t.modTime }
-func (t *testFileInfo) IsDir() bool        { return t.isDir }
-func (t *testFileInfo) Sys() any           { return nil }
-func (t *testFileInfo) BirthTime() time.Time {
-	if t.birthTime.IsZero() {
-		return time.Now()
-	}
-	return t.birthTime
-}

core/storage/storage.go

@@ -6,8 +6,6 @@ import (
 	"path/filepath"
 	"strings"
 	"sync"
-
-	"github.com/navidrome/navidrome/utils/slice"
 )
 
 const LocalSchemaID = "file"
@@ -38,14 +36,7 @@ func For(uri string) (Storage, error) {
 	if len(parts) < 2 {
 		uri, _ = filepath.Abs(uri)
 		uri = filepath.ToSlash(uri)
-
-		// Properly escape each path component using URL standards
-		pathParts := strings.Split(uri, "/")
-		escapedParts := slice.Map(pathParts, func(s string) string {
-			return url.PathEscape(s)
-		})
-
-		uri = LocalSchemaID + "://" + strings.Join(escapedParts, "/")
+		uri = LocalSchemaID + "://" + uri
 	}
 
 	u, err := url.Parse(uri)

core/storage/storage_test.go

@@ -65,21 +65,6 @@ var _ = Describe("Storage", func() {
 			_, err := For("webdav:///tmp")
 			Expect(err).To(HaveOccurred())
 		})
-		DescribeTable("should handle paths with special characters correctly",
-			func(inputPath string) {
-				s, err := For(inputPath)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(s).To(BeAssignableToTypeOf(&fakeLocalStorage{}))
-				Expect(s.(*fakeLocalStorage).u.Scheme).To(Equal("file"))
-				// The path should be exactly the same as the input - after URL parsing it gets decoded back
-				Expect(s.(*fakeLocalStorage).u.Path).To(Equal(inputPath))
-			},
-			Entry("hash symbols", "/tmp/test#folder/file.mp3"),
-			Entry("spaces", "/tmp/test folder/file with spaces.mp3"),
-			Entry("question marks", "/tmp/test?query/file.mp3"),
-			Entry("ampersands", "/tmp/test&amp/file.mp3"),
-			Entry("multiple special chars", "/tmp/Song #1 & More?.mp3"),
-		)
 	})
 })
 

core/wire_providers.go

@@ -17,8 +17,6 @@ var Set = wire.NewSet(
 	NewPlayers,
 	NewShare,
 	NewPlaylists,
-	NewLibrary,
-	NewMaintenance,
 	agents.GetAgents,
 	external.NewProvider,
 	wire.Bind(new(external.Agents), new(*agents.Agents)),