fix artist refreshstats query

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

.devcontainer/devcontainer.json

@@ -4,10 +4,10 @@
 		"dockerfile": "Dockerfile",
 		"args": {
 			// Update the VARIANT arg to pick a version of Go: 1, 1.15, 1.14
-			"VARIANT": "1.24",
+			"VARIANT": "1.25",
 			// Options
 			"INSTALL_NODE": "true",
-			"NODE_VERSION": "v20"
+			"NODE_VERSION": "v24"
 		}
 	},
 	"workspaceMount": "",

.github/copilot-instructions.md

@@ -1,53 +0,0 @@
-# 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

@@ -0,0 +1,38 @@
+### 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.0.2-1"
+  CROSS_TAGLIB_VERSION: "2.1.1-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@v4
+      - uses: actions/checkout@v5
         with:
           fetch-depth: 0
           fetch-tags: true
@@ -63,7 +63,7 @@ jobs:
     name: Lint Go code
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
       - name: Download TagLib
         uses: ./.github/actions/download-taglib
@@ -78,7 +78,7 @@ jobs:
           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$'`
+        run: go run golang.org/x/tools/cmd/goimports@latest -w `find . -name '*.go' | grep -v '_gen.go$' | grep -v '.pb.go$'`
       - run: go mod tidy
       - name: Verify no changes from goimports and go mod tidy
         run: |
@@ -93,7 +93,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check out code into the Go module directory
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Download TagLib
         uses: ./.github/actions/download-taglib
@@ -106,7 +106,7 @@ jobs:
       - name: Test
         run: |
           pkg-config --define-prefix --cflags --libs taglib # for debugging
-          go test -shuffle=on -tags netgo -race -cover ./... -v
+          go test -shuffle=on -tags netgo -race ./... -v
 
   js:
     name: Test JS code
@@ -114,10 +114,10 @@ jobs:
     env:
       NODE_OPTIONS: "--max_old_space_size=4096"
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v6
         with:
-          node-version: 20
+          node-version: 24
           cache: "npm"
           cache-dependency-path: "**/package-lock.json"
 
@@ -145,7 +145,7 @@ jobs:
     name: Lint i18n files
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - run: |
           set -e
           for file in resources/i18n/*.json; do
@@ -157,6 +157,8 @@ jobs:
               exit 1
             fi
           done
+      - run: ./.github/workflows/validate-translations.sh -v
+
 
   check-push-enabled:
     name: Check Docker configuration
@@ -189,7 +191,7 @@ jobs:
           PLATFORM=$(echo ${{ matrix.platform }} | tr '/' '_')
           echo "PLATFORM=$PLATFORM" >> $GITHUB_ENV
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
       - name: Prepare Docker Buildx
         uses: ./.github/actions/prepare-docker
@@ -262,10 +264,10 @@ jobs:
     env:
       REGISTRY_IMAGE: ghcr.io/${{ github.repository }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
       - name: Download digests
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v5
         with:
           path: /tmp/digests
           pattern: digests-*
@@ -316,9 +318,9 @@ jobs:
     runs-on: ubuntu-24.04
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v5
         with:
           path: ./binaries
           pattern: navidrome-windows*
@@ -350,12 +352,12 @@ jobs:
     outputs:
       package_list: ${{ steps.set-package-list.outputs.package_list }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           fetch-depth: 0
           fetch-tags: true
 
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v5
         with:
           path: ./binaries
           pattern: navidrome-*
@@ -404,7 +406,7 @@ jobs:
         item: ${{ fromJson(needs.release.outputs.package_list) }}
     steps:
       - name: Download all-packages artifact
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v5
         with:
           name: packages
           path: ./dist

.github/workflows/update-translations.yml

@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     if: ${{ github.repository_owner == 'navidrome' }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: Get updated translations
         id: poeditor
         env:

.github/workflows/validate-translations.sh

@@ -0,0 +1,236 @@
+#!/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,6 +5,7 @@
 /navidrome
 /iTunes*.xml
 /tmp
+/bin
 data/*
 vendor/*/
 wiki
@@ -23,7 +24,11 @@ music
 docker-compose.yml
 !contrib/docker-compose.yml
 binaries
-navidrome-master
+navidrome-*
 AGENTS.md
+.github/prompts
+.github/instructions
+.github/git-commit-instructions.md
 *.exe
-bin/
+*.test
+*.wasm

.nvmrc

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

Dockerfile

@@ -1,8 +1,8 @@
 FROM --platform=$BUILDPLATFORM ghcr.io/crazy-max/osxcross:14.5-debian AS osxcross
 
 ########################################################################################################################
-### Build xx (orignal image: tonistiigi/xx)
-FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/alpine:3.21 AS xx-build
+### Build xx (original image: tonistiigi/xx)
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/alpine:3.19 AS xx-build
 
 # v1.5.0
 ENV XX_VERSION=b4e4c451c778822e6742bfc9d9a91d7c7d885c8a
@@ -26,12 +26,14 @@ COPY --from=xx-build /out/ /usr/bin/
 
 ########################################################################################################################
 ### Get TagLib
-FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/alpine:3.21 AS taglib-build
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/alpine:3.19 AS taglib-build
 ARG TARGETPLATFORM
-ARG CROSS_TAGLIB_VERSION=2.0.2-1
+ARG CROSS_TAGLIB_VERSION=2.1.1-1
 ENV CROSS_TAGLIB_RELEASES_URL=https://github.com/navidrome/cross-taglib/releases/download/v${CROSS_TAGLIB_VERSION}/
 
+# wget in busybox can't follow redirects
 RUN <<EOT
+    apk add --no-cache wget
     PLATFORM=$(echo ${TARGETPLATFORM} | tr '/' '-')
     FILE=taglib-${PLATFORM}.tar.gz
 
@@ -61,7 +63,7 @@ COPY --from=ui /build /build
 
 ########################################################################################################################
 ### Build Navidrome binary
-FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.24-bookworm AS base
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.25-bookworm AS base
 RUN apt-get update && apt-get install -y clang lld
 COPY --from=xx / /
 WORKDIR /workspace
@@ -120,7 +122,7 @@ COPY --from=build /out /
 
 ########################################################################################################################
 ### Build Final Image
-FROM public.ecr.aws/docker/library/alpine:3.21 AS final
+FROM public.ecr.aws/docker/library/alpine:3.19 AS final
 LABEL maintainer="deluan@navidrome.org"
 LABEL org.opencontainers.image.source="https://github.com/navidrome/navidrome"
 

Makefile

@@ -15,7 +15,8 @@ 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.0.2-1
+CROSS_TAGLIB_VERSION ?= 2.1.1-1
+GOLANGCI_LINT_VERSION ?= v2.5.0
 
 UI_SRC_FILES := $(shell find ui -type f -not -path "ui/build/*" -not -path "ui/node_modules/*")
 
@@ -32,25 +33,55 @@ 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
+test: ##@Development Run Go tests. Use PKG variable to specify packages to test, e.g. make test PKG=./server
 	go test -tags netgo $(PKG)
 .PHONY: test
 
-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)
+testall: test-race test-i18n test-js ##@Development Run Go and JS tests
 .PHONY: testall
 
+test-race: ##@Development Run Go tests with race detector
+	go test -tags netgo -race -shuffle=on ./...
+.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
-	@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)
+	@INSTALL=false; \
+	if PATH=$$PATH:./bin which golangci-lint > /dev/null 2>&1; then \
+		CURRENT_VERSION=$$(PATH=$$PATH:./bin golangci-lint version 2>/dev/null | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -n1); \
+		REQUIRED_VERSION=$$(echo "$(GOLANGCI_LINT_VERSION)" | sed 's/^v//'); \
+		if [ "$$CURRENT_VERSION" != "$$REQUIRED_VERSION" ]; then \
+			echo "Found golangci-lint $$CURRENT_VERSION, but $$REQUIRED_VERSION is required. Reinstalling..."; \
+			rm -f ./bin/golangci-lint; \
+			INSTALL=true; \
+		fi; \
+	else \
+		INSTALL=true; \
+	fi; \
+	if [ "$$INSTALL" = "true" ]; then \
+		echo "Installing golangci-lint $(GOLANGCI_LINT_VERSION)..."; \
+		curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/HEAD/install.sh | sh -s $(GOLANGCI_LINT_VERSION); \
+	fi
 .PHONY: install-golangci-lint
 
 lint: install-golangci-lint ##@Development Lint Go code
@@ -64,7 +95,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$$`
+	@go tool goimports -w `find . -name '*.go' | grep -v _gen.go$$ | grep -v .pb.go$$`
 	@go mod tidy
 .PHONY: format
 
@@ -153,6 +184,20 @@ 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
@@ -221,6 +266,24 @@ deprecated:
 	@echo "WARNING: This target is deprecated and will be removed in future releases. Use 'make build' instead."
 .PHONY: deprecated
 
+# Generate Go code from plugins/api/api.proto
+plugin-gen: check_go_env ##@Development Generate Go code from plugins protobuf files
+	go generate ./plugins/...
+.PHONY: plugin-gen
+
+plugin-examples: check_go_env ##@Development Build all example plugins
+	$(MAKE) -C plugins/examples clean all
+.PHONY: plugin-examples
+
+plugin-clean: check_go_env ##@Development Clean all plugins
+	$(MAKE) -C plugins/examples clean
+	$(MAKE) -C plugins/testdata clean
+.PHONY: plugin-clean
+
+plugin-tests: check_go_env ##@Development Build all test plugins
+	$(MAKE) -C plugins/testdata clean all
+.PHONY: plugin-tests
+
 .DEFAULT_GOAL := help
 
 HELP_FUN = \

adapters/taglib/end_to_end_test.go

@@ -8,6 +8,7 @@ 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"
 )
@@ -78,22 +79,116 @@ 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) {
-			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")
+			mf := parseTestFile("tests/fixtures/test." + format)
 
 			for _, data := range roles {
 				role := data.Role
@@ -144,11 +239,40 @@ var _ = Describe("Extractor", func() {
 			Entry("FLAC format", "flac"),
 			Entry("M4a format", "m4a"),
 			Entry("OGG format", "ogg"),
-			Entry("WMA format", "wv"),
+			Entry("WV format", "wv"),
 
 			Entry("MP3 format", "mp3"),
 			Entry("WAV format", "wav"),
 			Entry("AIFF format", "aiff"),
 		)
+
+		It("should parse wma", func() {
+			mf := parseTestFile("tests/fixtures/test.wma")
+
+			for _, data := range roles {
+				role := data.Role
+				artists := data.ParticipantList
+				actual := mf.Participants[role]
+
+				// WMA has no Arranger role
+				if role == model.RoleArranger {
+					Expect(actual).To(HaveLen(0))
+					continue
+				}
+
+				Expect(actual).To(HaveLen(len(artists)), role.String())
+
+				// For some bizarre reason, the order is inverted. We also don't get
+				// sort names or MBIDs
+				for i := range artists {
+					idx := len(artists) - 1 - i
+
+					actualArtist := actual[i]
+					expectedArtist := artists[idx]
+
+					Expect(actualArtist.Name).To(Equal(expectedArtist.Name))
+				}
+			}
+		})
 	})
 })

adapters/taglib/taglib.go

@@ -7,6 +7,7 @@ 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"
@@ -42,23 +43,21 @@ func (e extractor) extractMetadata(filePath string) (*metadata.Info, error) {
 
 	// Parse audio properties
 	ap := metadata.AudioProperties{}
-	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)
+	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")
 
 	// Parse track/disc totals
 	parseTuple := func(prop string) {
@@ -106,6 +105,31 @@ 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".
@@ -148,4 +172,7 @@ 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, false),
+			Entry("correctly parses wv (wavpak) tags", "test.wv", "1s", 1, 44100, 16, "3.43 dB", "0.125061", "3.43 dB", "0.125061", false, true),
 
 			// ffmpeg -f lavfi -i "sine=frequency=1000:duration=1" test.wav
 			Entry("correctly parses wav tags", "test.wav", "1s", 1, 44100, 16, "3.06 dB", "0.125056", "3.06 dB", "0.125056", true, true),

adapters/taglib/taglib_wrapper.cpp

@@ -1,6 +1,5 @@
 #include <stdlib.h>
 #include <string.h>
-#include <typeinfo>
 
 #define TAGLIB_STATIC
 #include <apeproperties.h>
@@ -46,31 +45,63 @@ 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) })
-      goPutInt(id, (char *)"_bitspersample",  apeProperties->bitsPerSample());
-  if (const auto* asfProperties{ dynamic_cast<const TagLib::ASF::Properties*>(props) })
-      goPutInt(id, (char *)"_bitspersample",  asfProperties->bitsPerSample());
+      bitsPerSample = apeProperties->bitsPerSample();
+  else if (const auto* asfProperties{ dynamic_cast<const TagLib::ASF::Properties*>(props) })
+      bitsPerSample = asfProperties->bitsPerSample();
   else if (const auto* flacProperties{ dynamic_cast<const TagLib::FLAC::Properties*>(props) })
-      goPutInt(id, (char *)"_bitspersample",  flacProperties->bitsPerSample());
+      bitsPerSample = flacProperties->bitsPerSample();
   else if (const auto* mp4Properties{ dynamic_cast<const TagLib::MP4::Properties*>(props) })
-      goPutInt(id, (char *)"_bitspersample",  mp4Properties->bitsPerSample());
+      bitsPerSample = mp4Properties->bitsPerSample();
   else if (const auto* wavePackProperties{ dynamic_cast<const TagLib::WavPack::Properties*>(props) })
-      goPutInt(id, (char *)"_bitspersample",  wavePackProperties->bitsPerSample());
+      bitsPerSample = wavePackProperties->bitsPerSample();
   else if (const auto* aiffProperties{ dynamic_cast<const TagLib::RIFF::AIFF::Properties*>(props) })
-      goPutInt(id, (char *)"_bitspersample",  aiffProperties->bitsPerSample());
+      bitsPerSample = aiffProperties->bitsPerSample();
   else if (const auto* wavProperties{ dynamic_cast<const TagLib::RIFF::WAV::Properties*>(props) })
-      goPutInt(id, (char *)"_bitspersample",  wavProperties->bitsPerSample());
+      bitsPerSample = wavProperties->bitsPerSample();
   else if (const auto* dsfProperties{ dynamic_cast<const TagLib::DSF::Properties*>(props) })
-      goPutInt(id, (char *)"_bitspersample",  dsfProperties->bitsPerSample());
+      bitsPerSample = dsfProperties->bitsPerSample();
+  
+  if (bitsPerSample > 0) {
+      goPutInt(id, (char *)"__bitspersample", 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)
@@ -113,7 +144,7 @@ int taglib_read(const FILENAME_CHAR_T *filename, unsigned long id) {
             strncpy(language, bv.data(), 3);
           }
 
-          char *val = (char *)frame->text().toCString(true);
+          char *val = const_cast<char*>(frame->text().toCString(true));
 
           goPutLyrics(id, language, val);
         }
@@ -132,7 +163,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 = (char *)line.text.toCString(true);
+              char *text = const_cast<char*>(line.text.toCString(true));
               goPutLyricLine(id, language, text, line.time);
             }
           } else if (format == TagLib::ID3v2::SynchronizedLyricsFrame::AbsoluteMpegFrames) {
@@ -141,7 +172,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 = (char *)line.text.toCString(true);
+                char *text = const_cast<char*>(line.text.toCString(true));
                 goPutLyricLine(id, language, text, timeInMs);
               }
             }
@@ -160,9 +191,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 = (char *)item.first.toCString(true);
+      char *key = const_cast<char*>(item.first.toCString(true));
       for (const auto value: item.second.toStringList()) {
-        char *val = (char *)value.toCString(true);
+        char *val = const_cast<char*>(value.toCString(true));
         goPutM4AStr(id, key, val);
       }
     }
@@ -174,17 +205,24 @@ 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) {
-      tags.insert(item.first, item.second.front().toString());
+      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);
+      }
     }
   }
 
   // Send all collected tags to the Go map
   for (TagLib::PropertyMap::ConstIterator i = tags.begin(); i != tags.end();
        ++i) {
-    char *key = (char *)i->first.toCString(true);
+    char *key = const_cast<char*>(i->first.toCString(true));
     for (TagLib::StringList::ConstIterator j = i->second.begin();
          j != i->second.end(); ++j) {
-      char *val = (char *)(*j).toCString(true);
+      char *val = const_cast<char*>((*j).toCString(true));
       goPutStr(id, key, val);
     }
   }
@@ -242,7 +280,19 @@ 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 && asfFile->tag()->attributeListMap().contains("WM/Picture");
+    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();
+    }
   }
 
   return hasCover;

cmd/backup.go

@@ -1,186 +1,187 @@
 package cmd
 
-import (
-	"context"
-	"fmt"
-	"os"
-	"strings"
-	"time"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/db"
-	"github.com/navidrome/navidrome/log"
-	"github.com/spf13/cobra"
-)
-
-var (
-	backupCount int
-	backupDir   string
-	force       bool
-	restorePath string
-)
-
-func init() {
-	rootCmd.AddCommand(backupRoot)
-
-	backupCmd.Flags().StringVarP(&backupDir, "backup-dir", "d", "", "directory to manually make backup")
-	backupRoot.AddCommand(backupCmd)
-
-	pruneCmd.Flags().StringVarP(&backupDir, "backup-dir", "d", "", "directory holding Navidrome backups")
-	pruneCmd.Flags().IntVarP(&backupCount, "keep-count", "k", -1, "specify the number of backups to keep. 0 remove ALL backups, and negative values mean to use the default from configuration")
-	pruneCmd.Flags().BoolVarP(&force, "force", "f", false, "bypass warning when backup count is zero")
-	backupRoot.AddCommand(pruneCmd)
-
-	restoreCommand.Flags().StringVarP(&restorePath, "backup-file", "b", "", "path of backup database to restore")
-	restoreCommand.Flags().BoolVarP(&force, "force", "f", false, "bypass restore warning")
-	_ = restoreCommand.MarkFlagRequired("backup-file")
-	backupRoot.AddCommand(restoreCommand)
-}
-
-var (
-	backupRoot = &cobra.Command{
-		Use:     "backup",
-		Aliases: []string{"bkp"},
-		Short:   "Create, restore and prune database backups",
-		Long:    "Create, restore and prune database backups",
-	}
-
-	backupCmd = &cobra.Command{
-		Use:   "create",
-		Short: "Create a backup database",
-		Long:  "Manually backup Navidrome database. This will ignore BackupCount",
-		Run: func(cmd *cobra.Command, _ []string) {
-			runBackup(cmd.Context())
-		},
-	}
-
-	pruneCmd = &cobra.Command{
-		Use:   "prune",
-		Short: "Prune database backups",
-		Long:  "Manually prune database backups according to backup rules",
-		Run: func(cmd *cobra.Command, _ []string) {
-			runPrune(cmd.Context())
-		},
-	}
-
-	restoreCommand = &cobra.Command{
-		Use:   "restore",
-		Short: "Restore Navidrome database",
-		Long:  "Restore Navidrome database from a backup. This must be done offline",
-		Run: func(cmd *cobra.Command, _ []string) {
-			runRestore(cmd.Context())
-		},
-	}
-)
-
-func runBackup(ctx context.Context) {
-	if backupDir != "" {
-		conf.Server.Backup.Path = backupDir
-	}
-
-	idx := strings.LastIndex(conf.Server.DbPath, "?")
-	var path string
-
-	if idx == -1 {
-		path = conf.Server.DbPath
-	} else {
-		path = conf.Server.DbPath[:idx]
-	}
-
-	if _, err := os.Stat(path); os.IsNotExist(err) {
-		log.Fatal("No existing database", "path", path)
-		return
-	}
-
-	start := time.Now()
-	path, err := db.Backup(ctx)
-	if err != nil {
-		log.Fatal("Error backing up database", "backup path", conf.Server.BasePath, err)
-	}
-
-	elapsed := time.Since(start)
-	log.Info("Backup complete", "elapsed", elapsed, "path", path)
-}
-
-func runPrune(ctx context.Context) {
-	if backupDir != "" {
-		conf.Server.Backup.Path = backupDir
-	}
-
-	if backupCount != -1 {
-		conf.Server.Backup.Count = backupCount
-	}
-
-	if conf.Server.Backup.Count == 0 && !force {
-		fmt.Println("Warning: pruning ALL backups")
-		fmt.Printf("Please enter YES (all caps) to continue: ")
-		var input string
-		_, err := fmt.Scanln(&input)
-
-		if input != "YES" || err != nil {
-			log.Warn("Prune cancelled")
-			return
-		}
-	}
-
-	idx := strings.LastIndex(conf.Server.DbPath, "?")
-	var path string
-
-	if idx == -1 {
-		path = conf.Server.DbPath
-	} else {
-		path = conf.Server.DbPath[:idx]
-	}
-
-	if _, err := os.Stat(path); os.IsNotExist(err) {
-		log.Fatal("No existing database", "path", path)
-		return
-	}
-
-	start := time.Now()
-	count, err := db.Prune(ctx)
-	if err != nil {
-		log.Fatal("Error pruning up database", "backup path", conf.Server.BasePath, err)
-	}
-
-	elapsed := time.Since(start)
-
-	log.Info("Prune complete", "elapsed", elapsed, "successfully pruned", count)
-}
-
-func runRestore(ctx context.Context) {
-	idx := strings.LastIndex(conf.Server.DbPath, "?")
-	var path string
-
-	if idx == -1 {
-		path = conf.Server.DbPath
-	} else {
-		path = conf.Server.DbPath[:idx]
-	}
-
-	if _, err := os.Stat(path); os.IsNotExist(err) {
-		log.Fatal("No existing database", "path", path)
-		return
-	}
-
-	if !force {
-		fmt.Println("Warning: restoring the Navidrome database should only be done offline, especially if your backup is very old.")
-		fmt.Printf("Please enter YES (all caps) to continue: ")
-		var input string
-		_, err := fmt.Scanln(&input)
-
-		if input != "YES" || err != nil {
-			log.Warn("Restore cancelled")
-			return
-		}
-	}
-
-	start := time.Now()
-	err := db.Restore(ctx, restorePath)
-	if err != nil {
-		log.Fatal("Error restoring database", "backup path", conf.Server.BasePath, err)
-	}
-
-	elapsed := time.Since(start)
-	log.Info("Restore complete", "elapsed", elapsed)
-}
+//
+//import (
+//	"context"
+//	"fmt"
+//	"os"
+//	"strings"
+//	"time"
+//
+//	"github.com/navidrome/navidrome/conf"
+//	"github.com/navidrome/navidrome/db"
+//	"github.com/navidrome/navidrome/log"
+//	"github.com/spf13/cobra"
+//)
+//
+//var (
+//	backupCount int
+//	backupDir   string
+//	force       bool
+//	restorePath string
+//)
+//
+//func init() {
+//	rootCmd.AddCommand(backupRoot)
+//
+//	backupCmd.Flags().StringVarP(&backupDir, "backup-dir", "d", "", "directory to manually make backup")
+//	backupRoot.AddCommand(backupCmd)
+//
+//	pruneCmd.Flags().StringVarP(&backupDir, "backup-dir", "d", "", "directory holding Navidrome backups")
+//	pruneCmd.Flags().IntVarP(&backupCount, "keep-count", "k", -1, "specify the number of backups to keep. 0 remove ALL backups, and negative values mean to use the default from configuration")
+//	pruneCmd.Flags().BoolVarP(&force, "force", "f", false, "bypass warning when backup count is zero")
+//	backupRoot.AddCommand(pruneCmd)
+//
+//	restoreCommand.Flags().StringVarP(&restorePath, "backup-file", "b", "", "path of backup database to restore")
+//	restoreCommand.Flags().BoolVarP(&force, "force", "f", false, "bypass restore warning")
+//	_ = restoreCommand.MarkFlagRequired("backup-file")
+//	backupRoot.AddCommand(restoreCommand)
+//}
+//
+//var (
+//	backupRoot = &cobra.Command{
+//		Use:     "backup",
+//		Aliases: []string{"bkp"},
+//		Short:   "Create, restore and prune database backups",
+//		Long:    "Create, restore and prune database backups",
+//	}
+//
+//	backupCmd = &cobra.Command{
+//		Use:   "create",
+//		Short: "Create a backup database",
+//		Long:  "Manually backup Navidrome database. This will ignore BackupCount",
+//		Run: func(cmd *cobra.Command, _ []string) {
+//			runBackup(cmd.Context())
+//		},
+//	}
+//
+//	pruneCmd = &cobra.Command{
+//		Use:   "prune",
+//		Short: "Prune database backups",
+//		Long:  "Manually prune database backups according to backup rules",
+//		Run: func(cmd *cobra.Command, _ []string) {
+//			runPrune(cmd.Context())
+//		},
+//	}
+//
+//	restoreCommand = &cobra.Command{
+//		Use:   "restore",
+//		Short: "Restore Navidrome database",
+//		Long:  "Restore Navidrome database from a backup. This must be done offline",
+//		Run: func(cmd *cobra.Command, _ []string) {
+//			runRestore(cmd.Context())
+//		},
+//	}
+//)
+//
+//func runBackup(ctx context.Context) {
+//	if backupDir != "" {
+//		conf.Server.Backup.Path = backupDir
+//	}
+//
+//	idx := strings.LastIndex(conf.Server.DbPath, "?")
+//	var path string
+//
+//	if idx == -1 {
+//		path = conf.Server.DbPath
+//	} else {
+//		path = conf.Server.DbPath[:idx]
+//	}
+//
+//	if _, err := os.Stat(path); os.IsNotExist(err) {
+//		log.Fatal("No existing database", "path", path)
+//		return
+//	}
+//
+//	start := time.Now()
+//	path, err := db.Backup(ctx)
+//	if err != nil {
+//		log.Fatal("Error backing up database", "backup path", conf.Server.BasePath, err)
+//	}
+//
+//	elapsed := time.Since(start)
+//	log.Info("Backup complete", "elapsed", elapsed, "path", path)
+//}
+//
+//func runPrune(ctx context.Context) {
+//	if backupDir != "" {
+//		conf.Server.Backup.Path = backupDir
+//	}
+//
+//	if backupCount != -1 {
+//		conf.Server.Backup.Count = backupCount
+//	}
+//
+//	if conf.Server.Backup.Count == 0 && !force {
+//		fmt.Println("Warning: pruning ALL backups")
+//		fmt.Printf("Please enter YES (all caps) to continue: ")
+//		var input string
+//		_, err := fmt.Scanln(&input)
+//
+//		if input != "YES" || err != nil {
+//			log.Warn("Prune cancelled")
+//			return
+//		}
+//	}
+//
+//	idx := strings.LastIndex(conf.Server.DbPath, "?")
+//	var path string
+//
+//	if idx == -1 {
+//		path = conf.Server.DbPath
+//	} else {
+//		path = conf.Server.DbPath[:idx]
+//	}
+//
+//	if _, err := os.Stat(path); os.IsNotExist(err) {
+//		log.Fatal("No existing database", "path", path)
+//		return
+//	}
+//
+//	start := time.Now()
+//	count, err := db.Prune(ctx)
+//	if err != nil {
+//		log.Fatal("Error pruning up database", "backup path", conf.Server.BasePath, err)
+//	}
+//
+//	elapsed := time.Since(start)
+//
+//	log.Info("Prune complete", "elapsed", elapsed, "successfully pruned", count)
+//}
+//
+//func runRestore(ctx context.Context) {
+//	idx := strings.LastIndex(conf.Server.DbPath, "?")
+//	var path string
+//
+//	if idx == -1 {
+//		path = conf.Server.DbPath
+//	} else {
+//		path = conf.Server.DbPath[:idx]
+//	}
+//
+//	if _, err := os.Stat(path); os.IsNotExist(err) {
+//		log.Fatal("No existing database", "path", path)
+//		return
+//	}
+//
+//	if !force {
+//		fmt.Println("Warning: restoring the Navidrome database should only be done offline, especially if your backup is very old.")
+//		fmt.Printf("Please enter YES (all caps) to continue: ")
+//		var input string
+//		_, err := fmt.Scanln(&input)
+//
+//		if input != "YES" || err != nil {
+//			log.Warn("Restore cancelled")
+//			return
+//		}
+//	}
+//
+//	start := time.Now()
+//	err := db.Restore(ctx, restorePath)
+//	if err != nil {
+//		log.Fatal("Error restoring database", "backup path", conf.Server.BasePath, err)
+//	}
+//
+//	elapsed := time.Since(start)
+//	log.Info("Restore complete", "elapsed", elapsed)
+//}

cmd/cmd_suite_test.go

@@ -0,0 +1,17 @@
+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/plugin.go

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

cmd/plugin_test.go

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

cmd/root.go

@@ -16,7 +16,6 @@ import (
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/resources"
-	"github.com/navidrome/navidrome/scanner"
 	"github.com/navidrome/navidrome/scheduler"
 	"github.com/navidrome/navidrome/server/backgrounds"
 	"github.com/spf13/cobra"
@@ -81,9 +80,9 @@ func runNavidrome(ctx context.Context) {
 	g.Go(startPlaybackServer(ctx))
 	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 {
@@ -109,7 +108,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())
+		a.MountRouter("Native API", consts.URLPathNativeAPI, CreateNativeAPIRouter(ctx))
 		a.MountRouter("Subsonic API", consts.URLPathSubsonicAPI, CreateSubsonicAPIRouter(ctx))
 		a.MountRouter("Public Endpoints", consts.URLPathPublic, CreatePublicRouter())
 		if conf.Server.LastFM.Enabled {
@@ -147,7 +146,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)
@@ -172,6 +171,7 @@ 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()
@@ -190,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 {
-			scanner := CreateScanner(ctx)
+			s := CreateScanner(ctx)
 			switch {
 			case fullScanRequired == "1":
 				log.Warn(ctx, "Full scan required after migration")
@@ -204,7 +204,7 @@ func runInitialScan(ctx context.Context) func() error {
 				log.Info("Executing initial scan")
 			}
 
-			_, err = scanner.ScanAll(ctx, fullScanRequired == "1")
+			_, err = s.ScanAll(ctx, fullScanRequired == "1")
 			if err != nil {
 				log.Error(ctx, "Scan failed", err)
 			} else {
@@ -234,51 +234,37 @@ func startScanWatcher(ctx context.Context) func() error {
 
 func schedulePeriodicBackup(ctx context.Context) func() error {
 	return func() error {
-		schedule := conf.Server.Backup.Schedule
-		if schedule == "" {
-			log.Info(ctx, "Periodic backup is DISABLED")
-			return nil
-		}
-
-		schedulerInstance := scheduler.GetInstance()
-
-		log.Info("Scheduling periodic backup", "schedule", schedule)
-		err := schedulerInstance.Add(schedule, func() {
-			start := time.Now()
-			path, err := db.Backup(ctx)
-			elapsed := time.Since(start)
-			if err != nil {
-				log.Error(ctx, "Error backing up database", "elapsed", elapsed, err)
-				return
-			}
-			log.Info(ctx, "Backup complete", "elapsed", elapsed, "path", path)
-
-			count, err := db.Prune(ctx)
-			if err != nil {
-				log.Error(ctx, "Error pruning database", "error", err)
-			} else if count > 0 {
-				log.Info(ctx, "Successfully pruned old files", "count", count)
-			} else {
-				log.Info(ctx, "No backups pruned")
-			}
-		})
-
-		return err
-	}
-}
-
-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() {
-			if scanner.IsScanning() {
-				log.Debug(ctx, "Skipping DB optimization because a scan is in progress")
-				return
-			}
-			db.Optimize(ctx)
-		})
-		return err
+		//schedule := conf.Server.Backup.Schedule
+		//if schedule == "" {
+		//	log.Info(ctx, "Periodic backup is DISABLED")
+		//	return nil
+		//}
+		//
+		//schedulerInstance := scheduler.GetInstance()
+		//
+		//log.Info("Scheduling periodic backup", "schedule", schedule)
+		//_, err := schedulerInstance.Add(schedule, func() {
+		//	start := time.Now()
+		//	path, err := db.Backup(ctx)
+		//	elapsed := time.Since(start)
+		//	if err != nil {
+		//		log.Error(ctx, "Error backing up database", "elapsed", elapsed, err)
+		//		return
+		//	}
+		//	log.Info(ctx, "Backup complete", "elapsed", elapsed, "path", path)
+		//
+		//	count, err := db.Prune(ctx)
+		//	if err != nil {
+		//		log.Error(ctx, "Error pruning database", "error", err)
+		//	} else if count > 0 {
+		//		log.Info(ctx, "Successfully pruned old files", "count", count)
+		//	} else {
+		//		log.Info(ctx, "No backups pruned")
+		//	}
+		//})
+		//
+		//return err
+		return nil
 	}
 }
 
@@ -325,6 +311,22 @@ func startPlaybackServer(ctx context.Context) func() error {
 	}
 }
 
+// startPluginManager starts the plugin manager, if configured.
+func startPluginManager(ctx context.Context) func() error {
+	return func() error {
+		if !conf.Server.Plugins.Enabled {
+			log.Debug("Plugins are DISABLED")
+			return nil
+		}
+		log.Info(ctx, "Starting plugin manager")
+		// Get the manager instance and scan for plugins
+		manager := GetPluginManager(ctx)
+		manager.ScanPlugins()
+
+		return nil
+	}
+}
+
 // TODO: Implement some struct tags to map flags to viper
 func init() {
 	cobra.OnInitialize(func() {

cmd/scan.go

@@ -6,8 +6,6 @@ import (
 	"os"
 
 	"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/persistence"
@@ -65,12 +63,14 @@ func trackScanAsSubprocess(ctx context.Context, progress <-chan *scanner.Progres
 }
 
 func runScanner(ctx context.Context) {
+	defer db.Init(ctx)()
+
 	sqlDB := db.Db()
 	defer db.Db().Close()
 	ds := persistence.New(sqlDB)
 	pls := core.NewPlaylists(ds)
 
-	progress, err := scanner.CallScan(ctx, ds, artwork.NoopCacheWarmer(), pls, metrics.NewNoopInstance(), fullScan)
+	progress, err := scanner.CallScan(ctx, ds, pls, fullScan)
 	if err != nil {
 		log.Fatal(ctx, "Failed to scan", err)
 	}

cmd/wire_gen.go

@@ -22,6 +22,7 @@ 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"
@@ -46,18 +47,32 @@ func CreateServer() *server.Server {
 	sqlDB := db.Db()
 	dataStore := persistence.New(sqlDB)
 	broker := events.GetBroker()
-	insights := metrics.GetInstance(dataStore)
+	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
+	manager := plugins.GetManager(dataStore, metricsMetrics)
+	insights := metrics.GetInstance(dataStore, manager)
 	serverServer := server.New(dataStore, broker, insights)
 	return serverServer
 }
 
-func CreateNativeAPIRouter() *nativeapi.Router {
+func CreateNativeAPIRouter(ctx context.Context) *nativeapi.Router {
 	sqlDB := db.Db()
 	dataStore := persistence.New(sqlDB)
 	share := core.NewShare(dataStore)
 	playlists := core.NewPlaylists(dataStore)
-	insights := metrics.GetInstance(dataStore)
-	router := nativeapi.New(dataStore, share, playlists, insights)
+	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
+	manager := plugins.GetManager(dataStore, metricsMetrics)
+	insights := metrics.GetInstance(dataStore, manager)
+	fileCache := artwork.GetImageCache()
+	fFmpeg := ffmpeg.New()
+	agentsAgents := agents.GetAgents(dataStore, manager)
+	provider := external.NewProvider(dataStore, agentsAgents)
+	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
+	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
+	broker := events.GetBroker()
+	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
+	watcher := scanner.GetWatcher(dataStore, scannerScanner)
+	library := core.NewLibrary(dataStore, scannerScanner, watcher, broker)
+	router := nativeapi.New(dataStore, share, playlists, insights, library)
 	return router
 }
 
@@ -66,7 +81,9 @@ func CreateSubsonicAPIRouter(ctx context.Context) *subsonic.Router {
 	dataStore := persistence.New(sqlDB)
 	fileCache := artwork.GetImageCache()
 	fFmpeg := ffmpeg.New()
-	agentsAgents := agents.GetAgents(dataStore)
+	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
+	manager := plugins.GetManager(dataStore, metricsMetrics)
+	agentsAgents := agents.GetAgents(dataStore, manager)
 	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	transcodingCache := core.GetTranscodingCache()
@@ -77,11 +94,10 @@ func CreateSubsonicAPIRouter(ctx context.Context) *subsonic.Router {
 	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
 	broker := events.GetBroker()
 	playlists := core.NewPlaylists(dataStore)
-	metricsMetrics := metrics.NewPrometheusInstance(dataStore)
 	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
-	playTracker := scrobbler.GetPlayTracker(dataStore, broker)
+	playTracker := scrobbler.GetPlayTracker(dataStore, broker, manager)
 	playbackServer := playback.GetInstance(dataStore)
-	router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, scannerScanner, broker, playlists, playTracker, share, playbackServer)
+	router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, scannerScanner, broker, playlists, playTracker, share, playbackServer, metricsMetrics)
 	return router
 }
 
@@ -90,7 +106,9 @@ func CreatePublicRouter() *public.Router {
 	dataStore := persistence.New(sqlDB)
 	fileCache := artwork.GetImageCache()
 	fFmpeg := ffmpeg.New()
-	agentsAgents := agents.GetAgents(dataStore)
+	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
+	manager := plugins.GetManager(dataStore, metricsMetrics)
+	agentsAgents := agents.GetAgents(dataStore, manager)
 	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	transcodingCache := core.GetTranscodingCache()
@@ -118,14 +136,16 @@ func CreateListenBrainzRouter() *listenbrainz.Router {
 func CreateInsights() metrics.Insights {
 	sqlDB := db.Db()
 	dataStore := persistence.New(sqlDB)
-	insights := metrics.GetInstance(dataStore)
+	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
+	manager := plugins.GetManager(dataStore, metricsMetrics)
+	insights := metrics.GetInstance(dataStore, manager)
 	return insights
 }
 
 func CreatePrometheus() metrics.Metrics {
 	sqlDB := db.Db()
 	dataStore := persistence.New(sqlDB)
-	metricsMetrics := metrics.NewPrometheusInstance(dataStore)
+	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
 	return metricsMetrics
 }
 
@@ -134,13 +154,14 @@ func CreateScanner(ctx context.Context) scanner.Scanner {
 	dataStore := persistence.New(sqlDB)
 	fileCache := artwork.GetImageCache()
 	fFmpeg := ffmpeg.New()
-	agentsAgents := agents.GetAgents(dataStore)
+	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
+	manager := plugins.GetManager(dataStore, metricsMetrics)
+	agentsAgents := agents.GetAgents(dataStore, manager)
 	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
 	broker := events.GetBroker()
 	playlists := core.NewPlaylists(dataStore)
-	metricsMetrics := metrics.NewPrometheusInstance(dataStore)
 	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
 	return scannerScanner
 }
@@ -150,15 +171,16 @@ func CreateScanWatcher(ctx context.Context) scanner.Watcher {
 	dataStore := persistence.New(sqlDB)
 	fileCache := artwork.GetImageCache()
 	fFmpeg := ffmpeg.New()
-	agentsAgents := agents.GetAgents(dataStore)
+	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
+	manager := plugins.GetManager(dataStore, metricsMetrics)
+	agentsAgents := agents.GetAgents(dataStore, manager)
 	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
 	broker := events.GetBroker()
 	playlists := core.NewPlaylists(dataStore)
-	metricsMetrics := metrics.NewPrometheusInstance(dataStore)
 	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
-	watcher := scanner.NewWatcher(dataStore, scannerScanner)
+	watcher := scanner.GetWatcher(dataStore, scannerScanner)
 	return watcher
 }
 
@@ -169,6 +191,20 @@ func GetPlaybackServer() playback.PlaybackServer {
 	return playbackServer
 }
 
+func getPluginManager() plugins.Manager {
+	sqlDB := db.Db()
+	dataStore := persistence.New(sqlDB)
+	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
+	manager := plugins.GetManager(dataStore, metricsMetrics)
+	return manager
+}
+
 // wire_injectors.go:
 
-var allProviders = wire.NewSet(core.Set, artwork.Set, server.New, subsonic.New, nativeapi.New, public.New, persistence.New, lastfm.NewRouter, listenbrainz.NewRouter, events.GetBroker, scanner.New, scanner.NewWatcher, metrics.NewPrometheusInstance, db.Db)
+var allProviders = wire.NewSet(core.Set, artwork.Set, server.New, subsonic.New, nativeapi.New, public.New, persistence.New, lastfm.NewRouter, listenbrainz.NewRouter, events.GetBroker, scanner.New, scanner.GetWatcher, plugins.GetManager, metrics.GetPrometheusInstance, db.Db, wire.Bind(new(agents.PluginLoader), new(plugins.Manager)), wire.Bind(new(scrobbler.PluginLoader), new(plugins.Manager)), wire.Bind(new(metrics.PluginLoader), new(plugins.Manager)), wire.Bind(new(core.Scanner), new(scanner.Scanner)), wire.Bind(new(core.Watcher), new(scanner.Watcher)))
+
+func GetPluginManager(ctx context.Context) plugins.Manager {
+	manager := getPluginManager()
+	manager.SetSubsonicRouter(CreateSubsonicAPIRouter(ctx))
+	return manager
+}

cmd/wire_injectors.go

@@ -7,14 +7,17 @@ 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"
@@ -35,9 +38,15 @@ var allProviders = wire.NewSet(
 	listenbrainz.NewRouter,
 	events.GetBroker,
 	scanner.New,
-	scanner.NewWatcher,
-	metrics.NewPrometheusInstance,
+	scanner.GetWatcher,
+	plugins.GetManager,
+	metrics.GetPrometheusInstance,
 	db.Db,
+	wire.Bind(new(agents.PluginLoader), new(plugins.Manager)),
+	wire.Bind(new(scrobbler.PluginLoader), new(plugins.Manager)),
+	wire.Bind(new(metrics.PluginLoader), new(plugins.Manager)),
+	wire.Bind(new(core.Scanner), new(scanner.Scanner)),
+	wire.Bind(new(core.Watcher), new(scanner.Watcher)),
 )
 
 func CreateDataStore() model.DataStore {
@@ -52,7 +61,7 @@ func CreateServer() *server.Server {
 	))
 }
 
-func CreateNativeAPIRouter() *nativeapi.Router {
+func CreateNativeAPIRouter(ctx context.Context) *nativeapi.Router {
 	panic(wire.Build(
 		allProviders,
 	))
@@ -111,3 +120,15 @@ 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/chain"
+	"github.com/navidrome/navidrome/utils/run"
 	"github.com/robfig/cron/v3"
 	"github.com/spf13/viper"
 )
@@ -66,6 +66,7 @@ type configOptions struct {
 	CoverArtPriority                string
 	CoverJpegQuality                int
 	ArtistArtPriority               string
+	LyricsPriority                  string
 	EnableGravatar                  bool
 	EnableFavourites                bool
 	EnableStarRating                bool
@@ -79,6 +80,7 @@ type configOptions struct {
 	DefaultUIVolume                 int
 	EnableReplayGain                bool
 	EnableCoverAnimation            bool
+	EnableNowPlaying                bool
 	GATrackingID                    string
 	EnableLogRedacting              bool
 	AuthRequestLimit                int
@@ -86,25 +88,26 @@ type configOptions struct {
 	PasswordEncryptionKey           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
+	Plugins                         pluginsOptions
+	PluginConfig                    map[string]map[string]string
+	HTTPSecurityHeaders             secureOptions       `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"`
+	Tags                            map[string]TagConf  `json:",omitempty"`
+	Agents                          string
 
 	// DevFlags. These are used to enable/disable debugging and incomplete features
+	DevLogLevels                     map[string]string `json:",omitempty"`
 	DevLogSourceLine                 bool
-	DevLogLevels                     map[string]string
 	DevEnableProfiler                bool
 	DevAutoCreateAdminPassword       string
 	DevAutoLoginUsername             string
@@ -112,6 +115,8 @@ type configOptions struct {
 	DevActivityPanelUpdateRate       time.Duration
 	DevSidebarPlaylists              bool
 	DevShowArtistPage                bool
+	DevUIShowConfig                  bool
+	DevNewEventStream                bool
 	DevOffsetOptimize                int
 	DevArtworkMaxRequests            int
 	DevArtworkThrottleBacklogLimit   int
@@ -122,6 +127,9 @@ type configOptions struct {
 	DevScannerThreads                uint
 	DevInsightsInitialDelay          time.Duration
 	DevEnablePlayerInsights          bool
+	DevEnablePluginsInsights         bool
+	DevPluginCompilationTimeout      time.Duration
+	DevExternalArtistFetchMultiplier float64
 }
 
 type scannerOptions struct {
@@ -145,12 +153,12 @@ type subsonicOptions struct {
 }
 
 type TagConf struct {
-	Ignore    bool     `yaml:"ignore"`
-	Aliases   []string `yaml:"aliases"`
-	Type      string   `yaml:"type"`
-	MaxLength int      `yaml:"maxLength"`
-	Split     []string `yaml:"split"`
-	Album     bool     `yaml:"album"`
+	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"`
 }
 
 type lastfmOptions struct {
@@ -166,6 +174,10 @@ type spotifyOptions struct {
 	Secret string
 }
 
+type deezerOptions struct {
+	Enabled bool
+}
+
 type listenBrainzOptions struct {
 	Enabled bool
 	BaseURL string
@@ -208,6 +220,12 @@ type inspectOptions struct {
 	BacklogTimeout int
 }
 
+type pluginsOptions struct {
+	Enabled   bool
+	Folder    string
+	CacheSize string
+}
+
 var (
 	Server = &configOptions{}
 	hooks  []func()
@@ -247,6 +265,17 @@ 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)
@@ -275,7 +304,7 @@ func Load(noConfigDump bool) {
 	log.SetLogSourceLine(Server.DevLogSourceLine)
 	log.SetRedacting(Server.EnableLogRedacting)
 
-	err = chain.RunSequentially(
+	err = run.Sequentially(
 		validateScanSchedule,
 		validateBackupSchedule,
 		validatePlaylistsPath,
@@ -367,6 +396,7 @@ 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 {
@@ -478,10 +508,11 @@ func setViperDefaults() {
 	viper.SetDefault("ignoredarticles", "The El La Los Las Le Les Os As O A")
 	viper.SetDefault("indexgroups", "A B C D E F G H I J K L M N O P Q R S T U V W X-Z(XYZ) [Unknown]([)")
 	viper.SetDefault("ffmpegpath", "")
-	viper.SetDefault("mpvcmdtemplate", "mpv --audio-device=%d --no-audio-display --pause %f --input-ipc-server=%s")
+	viper.SetDefault("mpvcmdtemplate", "mpv --audio-device=%d --no-audio-display %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)
@@ -491,6 +522,7 @@ 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)
@@ -519,12 +551,12 @@ func setViperDefaults() {
 	viper.SetDefault("scanner.genreseparators", "")
 	viper.SetDefault("scanner.groupalbumreleases", false)
 	viper.SetDefault("scanner.followsymlinks", true)
-	viper.SetDefault("scanner.purgemissing", "never")
+	viper.SetDefault("scanner.purgemissing", consts.PurgeMissingNever)
 	viper.SetDefault("subsonic.appendsubtitle", true)
 	viper.SetDefault("subsonic.artistparticipations", false)
 	viper.SetDefault("subsonic.defaultreportrealpath", false)
 	viper.SetDefault("subsonic.legacyclients", "DSub")
-	viper.SetDefault("agents", "lastfm,spotify")
+	viper.SetDefault("agents", "lastfm,spotify,deezer")
 	viper.SetDefault("lastfm.enabled", true)
 	viper.SetDefault("lastfm.language", "en")
 	viper.SetDefault("lastfm.apikey", "")
@@ -532,6 +564,7 @@ func setViperDefaults() {
 	viper.SetDefault("lastfm.scrobblefirstartistonly", false)
 	viper.SetDefault("spotify.id", "")
 	viper.SetDefault("spotify.secret", "")
+	viper.SetDefault("deezer.enabled", true)
 	viper.SetDefault("listenbrainz.enabled", true)
 	viper.SetDefault("listenbrainz.baseurl", "https://api.listenbrainz.org/1/")
 	viper.SetDefault("httpsecurityheaders.customframeoptionsvalue", "DENY")
@@ -544,7 +577,11 @@ func setViperDefaults() {
 	viper.SetDefault("inspect.maxrequests", 1)
 	viper.SetDefault("inspect.backloglimit", consts.RequestThrottleBacklogLimit)
 	viper.SetDefault("inspect.backlogtimeout", consts.RequestThrottleBacklogTimeout)
-	viper.SetDefault("lyricspriority", ".lrc,.txt,embedded")
+	viper.SetDefault("plugins.folder", "")
+	viper.SetDefault("plugins.enabled", false)
+	viper.SetDefault("plugins.cachesize", "100MB")
+
+	// DevFlags. These are used to enable/disable debugging and incomplete features
 	viper.SetDefault("devlogsourceline", false)
 	viper.SetDefault("devenableprofiler", false)
 	viper.SetDefault("devautocreateadminpassword", "")
@@ -553,6 +590,8 @@ 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)
@@ -563,6 +602,9 @@ func setViperDefaults() {
 	viper.SetDefault("devscannerthreads", 5)
 	viper.SetDefault("devinsightsinitialdelay", consts.InsightsInitialDelay)
 	viper.SetDefault("devenableplayerinsights", true)
+	viper.SetDefault("devenablepluginsinsights", true)
+	viper.SetDefault("devplugincompilationtimeout", time.Minute)
+	viper.SetDefault("devexternalartistfetchmultiplier", 1.5)
 }
 
 func init() {

core/agents/agents.go

@@ -2,6 +2,7 @@ package agents
 
 import (
 	"context"
+	"slices"
 	"strings"
 	"time"
 
@@ -13,43 +14,107 @@ import (
 	"github.com/navidrome/navidrome/utils/singleton"
 )
 
-type Agents struct {
-	ds     model.DataStore
-	agents []Interface
+// 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)
 }
 
-func GetAgents(ds model.DataStore) *Agents {
+type Agents struct {
+	ds           model.DataStore
+	pluginLoader PluginLoader
+}
+
+// GetAgents returns the singleton instance of Agents
+func GetAgents(ds model.DataStore, pluginLoader PluginLoader) *Agents {
 	return singleton.GetInstance(func() *Agents {
-		return createAgents(ds)
+		return createAgents(ds, pluginLoader)
 	})
 }
 
-func createAgents(ds model.DataStore) *Agents {
-	var order []string
-	if conf.Server.Agents != "" {
-		order = strings.Split(conf.Server.Agents, ",")
+// createAgents creates a new Agents instance. Used in tests
+func createAgents(ds model.DataStore, pluginLoader PluginLoader) *Agents {
+	return &Agents{
+		ds:           ds,
+		pluginLoader: pluginLoader,
 	}
-	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
-		}
+}
 
-		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))
+// 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}}
 	}
-	log.Debug("List of agents enabled", "names", enabled)
 
-	return &Agents{ds: ds, agents: res}
+	// Get all available plugin names
+	var availablePlugins []string
+	if a.pluginLoader != nil {
+		availablePlugins = a.pluginLoader.PluginNames("MetadataAgent")
+	}
+
+	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.Warn("Unknown agent ignored", "name", name)
+		}
+	}
+	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)
+		}
+	}
+
+	return nil
 }
 
 func (a *Agents) AgentName() string {
@@ -64,15 +129,19 @@ func (a *Agents) GetArtistMBID(ctx context.Context, id string, name string) (str
 		return "", nil
 	}
 	start := time.Now()
-	for _, ag := range a.agents {
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
 		if utils.IsCtxDone(ctx) {
 			break
 		}
-		agent, ok := ag.(ArtistMBIDRetriever)
+		retriever, ok := ag.(ArtistMBIDRetriever)
 		if !ok {
 			continue
 		}
-		mbid, err := agent.GetArtistMBID(ctx, id, name)
+		mbid, err := retriever.GetArtistMBID(ctx, id, name)
 		if mbid != "" && err == nil {
 			log.Debug(ctx, "Got MBID", "agent", ag.AgentName(), "artist", name, "mbid", mbid, "elapsed", time.Since(start))
 			return mbid, nil
@@ -89,15 +158,19 @@ func (a *Agents) GetArtistURL(ctx context.Context, id, name, mbid string) (strin
 		return "", nil
 	}
 	start := time.Now()
-	for _, ag := range a.agents {
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
 		if utils.IsCtxDone(ctx) {
 			break
 		}
-		agent, ok := ag.(ArtistURLRetriever)
+		retriever, ok := ag.(ArtistURLRetriever)
 		if !ok {
 			continue
 		}
-		url, err := agent.GetArtistURL(ctx, id, name, mbid)
+		url, err := retriever.GetArtistURL(ctx, id, name, mbid)
 		if url != "" && err == nil {
 			log.Debug(ctx, "Got External Url", "agent", ag.AgentName(), "artist", name, "url", url, "elapsed", time.Since(start))
 			return url, nil
@@ -114,15 +187,19 @@ func (a *Agents) GetArtistBiography(ctx context.Context, id, name, mbid string)
 		return "", nil
 	}
 	start := time.Now()
-	for _, ag := range a.agents {
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
 		if utils.IsCtxDone(ctx) {
 			break
 		}
-		agent, ok := ag.(ArtistBiographyRetriever)
+		retriever, ok := ag.(ArtistBiographyRetriever)
 		if !ok {
 			continue
 		}
-		bio, err := agent.GetArtistBiography(ctx, id, name, mbid)
+		bio, err := retriever.GetArtistBiography(ctx, id, name, mbid)
 		if err == nil {
 			log.Debug(ctx, "Got Biography", "agent", ag.AgentName(), "artist", name, "len", len(bio), "elapsed", time.Since(start))
 			return bio, nil
@@ -131,6 +208,8 @@ 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:
@@ -138,16 +217,23 @@ 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 _, ag := range a.agents {
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
 		if utils.IsCtxDone(ctx) {
 			break
 		}
-		agent, ok := ag.(ArtistSimilarRetriever)
+		retriever, ok := ag.(ArtistSimilarRetriever)
 		if !ok {
 			continue
 		}
-		similar, err := agent.GetSimilarArtists(ctx, id, name, mbid, limit)
+		similar, err := retriever.GetSimilarArtists(ctx, id, name, mbid, overLimit)
 		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))
@@ -168,15 +254,19 @@ func (a *Agents) GetArtistImages(ctx context.Context, id, name, mbid string) ([]
 		return nil, nil
 	}
 	start := time.Now()
-	for _, ag := range a.agents {
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
 		if utils.IsCtxDone(ctx) {
 			break
 		}
-		agent, ok := ag.(ArtistImageRetriever)
+		retriever, ok := ag.(ArtistImageRetriever)
 		if !ok {
 			continue
 		}
-		images, err := agent.GetArtistImages(ctx, id, name, mbid)
+		images, err := retriever.GetArtistImages(ctx, id, name, mbid)
 		if len(images) > 0 && err == nil {
 			log.Debug(ctx, "Got Images", "agent", ag.AgentName(), "artist", name, "images", images, "elapsed", time.Since(start))
 			return images, nil
@@ -185,6 +275,8 @@ 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:
@@ -192,16 +284,23 @@ 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 _, ag := range a.agents {
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
 		if utils.IsCtxDone(ctx) {
 			break
 		}
-		agent, ok := ag.(ArtistTopSongsRetriever)
+		retriever, ok := ag.(ArtistTopSongsRetriever)
 		if !ok {
 			continue
 		}
-		songs, err := agent.GetArtistTopSongs(ctx, id, artistName, mbid, count)
+		songs, err := retriever.GetArtistTopSongs(ctx, id, artistName, mbid, overLimit)
 		if len(songs) > 0 && err == nil {
 			log.Debug(ctx, "Got Top Songs", "agent", ag.AgentName(), "artist", artistName, "songs", songs, "elapsed", time.Since(start))
 			return songs, nil
@@ -215,15 +314,19 @@ func (a *Agents) GetAlbumInfo(ctx context.Context, name, artist, mbid string) (*
 		return nil, ErrNotFound
 	}
 	start := time.Now()
-	for _, ag := range a.agents {
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
 		if utils.IsCtxDone(ctx) {
 			break
 		}
-		agent, ok := ag.(AlbumInfoRetriever)
+		retriever, ok := ag.(AlbumInfoRetriever)
 		if !ok {
 			continue
 		}
-		album, err := agent.GetAlbumInfo(ctx, name, artist, mbid)
+		album, err := retriever.GetAlbumInfo(ctx, name, artist, mbid)
 		if err == nil {
 			log.Debug(ctx, "Got Album Info", "agent", ag.AgentName(), "album", name, "artist", artist,
 				"mbid", mbid, "elapsed", time.Since(start))
@@ -233,6 +336,33 @@ 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 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)
@@ -241,3 +371,4 @@ 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

@@ -0,0 +1,281 @@
+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,6 +20,7 @@ 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}
@@ -29,7 +30,7 @@ var _ = Describe("Agents", func() {
 		var ag *Agents
 		BeforeEach(func() {
 			conf.Server.Agents = ""
-			ag = createAgents(ds)
+			ag = createAgents(ds, nil)
 		})
 
 		It("calls the placeholder GetArtistImages", func() {
@@ -49,12 +50,18 @@ 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)
+			ag = createAgents(ds, nil)
 			Expect(ag.AgentName()).To(Equal("agents"))
 		})
 
 		It("does not register disabled agents", func() {
-			ags := slice.Map(ag.agents, func(a Interface) string { return a.AgentName() })
+			var ags []string
+			for _, enabledAgent := range ag.getEnabledAgentNames() {
+				agent := ag.getAgent(enabledAgent)
+				if agent != nil {
+					ags = append(ags, agent.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"))
@@ -173,6 +180,42 @@ 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() {
@@ -199,6 +242,7 @@ 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",
@@ -206,6 +250,7 @@ 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))
@@ -217,6 +262,14 @@ 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() {
@@ -226,18 +279,6 @@ 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"))
 			})
@@ -333,18 +374,6 @@ 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
 }
 
@@ -355,3 +384,17 @@ 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

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

core/agents/deezer/client_test.go

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

core/agents/deezer/deezer.go

@@ -0,0 +1,97 @@
+package deezer
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strings"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils/cache"
+)
+
+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)
+	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
+	}
+
+	// If the first one has the same name, that's the one
+	if !strings.EqualFold(artists[0].Name, name) {
+		return nil, agents.ErrNotFound
+	}
+	return &artists[0], err
+}
+
+func init() {
+	conf.AddHook(func() {
+		if conf.Server.Deezer.Enabled {
+			agents.Register(deezerAgentName, deezerConstructor)
+		}
+	})
+}

core/agents/deezer/deezer_suite_test.go

@@ -0,0 +1,17 @@
+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

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

core/agents/deezer/responses_test.go

@@ -0,0 +1,38 @@
+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"))
+		})
+	})
+})

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,11 +40,16 @@ var (
 	ErrNotFound = errors.New("not found")
 )
 
-// TODO Break up this interface in more specific methods, like artists
+// AlbumInfoRetriever provides album info (no images)
 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

@@ -72,16 +72,23 @@ func (l *lastfmAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid strin
 		return nil, err
 	}
 
-	response := agents.AlbumInfo{
+	return &agents.AlbumInfo{
 		Name:        a.Name,
 		MBID:        a.MBID,
 		Description: a.Description.Summary,
 		URL:         a.URL,
-		Images:      make([]agents.ExternalImage, 0),
+	}, 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
 	}
 
 	// 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
@@ -92,23 +99,20 @@ func (l *lastfmAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid strin
 			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
-		} else {
-			if _, exists := seenSizes[numericSize]; !exists {
-				response.Images = append(response.Images, agents.ExternalImage{
-					Size: numericSize,
-					URL:  img.URL,
-				})
-				seenSizes[numericSize] = true
-			}
+		}
+		if _, exists := seenSizes[numericSize]; !exists {
+			images = append(images, agents.ExternalImage{
+				Size: numericSize,
+				URL:  img.URL,
+			})
+			seenSizes[numericSize] = true
 		}
 	}
-
-	return &response, nil
+	return images, nil
 }
 
 func (l *lastfmAgent) GetArtistMBID(ctx context.Context, id string, name string) (string, error) {
@@ -286,7 +290,7 @@ func (l *lastfmAgent) getArtistForScrobble(track *model.MediaFile) string {
 	return track.Artist
 }
 
-func (l *lastfmAgent) NowPlaying(ctx context.Context, userId string, track *model.MediaFile) error {
+func (l *lastfmAgent) NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) error {
 	sk, err := l.sessionKeys.Get(ctx, userId)
 	if err != nil || sk == "" {
 		return scrobbler.ErrNotAuthorized

core/agents/lastfm/agent_test.go

@@ -209,7 +209,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)
+				err := agent.NowPlaying(ctx, "user-1", track, 0)
 
 				Expect(err).ToNot(HaveOccurred())
 				Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodPost))
@@ -226,7 +226,7 @@ var _ = Describe("lastfmAgent", func() {
 			})
 
 			It("returns ErrNotAuthorized if user is not linked", func() {
-				err := agent.NowPlaying(ctx, "user-2", track)
+				err := agent.NowPlaying(ctx, "user-2", track, 0)
 				Expect(err).To(MatchError(scrobbler.ErrNotAuthorized))
 			})
 		})
@@ -345,24 +345,6 @@ 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"))
@@ -372,9 +354,8 @@ 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",
-				Images: []agents.ExternalImage{},
+				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",
 			}))
 			Expect(httpClient.RequestCount).To(Equal(1))
 			Expect(httpClient.SavedRequest.URL.Query().Get("album")).To(Equal("The Definitive Less Damage And More Joy"))

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) error {
+func (l *listenBrainzAgent) NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) 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)
+			err := agent.NowPlaying(ctx, "user-1", track, 0)
 			Expect(err).ToNot(HaveOccurred())
 		})
 
 		It("returns ErrNotAuthorized if user is not linked", func() {
-			err := agent.NowPlaying(ctx, "user-2", track)
+			err := agent.NowPlaying(ctx, "user-2", track, 0)
 			Expect(err).To(MatchError(scrobbler.ErrNotAuthorized))
 		})
 	})

core/artwork/cache_warmer.go

@@ -96,8 +96,11 @@ func (a *cacheWarmer) run(ctx context.Context) {
 
 		// If cache not available, keep waiting
 		if !a.cache.Available(ctx) {
-			if len(a.buffer) > 0 {
-				log.Trace(ctx, "Cache not available, buffering precache request", "bufferLen", len(a.buffer))
+			a.mutex.Lock()
+			bufferLen := len(a.buffer)
+			a.mutex.Unlock()
+			if bufferLen > 0 {
+				log.Trace(ctx, "Cache not available, buffering precache request", "bufferLen", bufferLen)
 			}
 			continue
 		}

core/artwork/cache_warmer_test.go

@@ -80,6 +80,7 @@ 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"))
@@ -214,3 +215,7 @@ 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_artist.go

@@ -20,6 +20,12 @@ 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
@@ -38,7 +44,7 @@ func newArtistArtworkReader(ctx context.Context, artwork *artwork, artID model.A
 	als, err := artwork.ds.Album(ctx).GetAll(model.QueryOptions{
 		Filters: squirrel.And{
 			squirrel.Eq{"album_artist_id": artID.ID},
-			squirrel.Eq{"json_array_length(participants, '$.albumartist')": 1},
+			squirrel.Eq{"jsonb_array_length(participants->'albumartist')": 1},
 		},
 	})
 	if err != nil {
@@ -108,36 +114,52 @@ 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) {
-		fsys := os.DirFS(artistFolder)
-		matches, err := fs.Glob(fsys, pattern)
-		if err != nil {
-			log.Warn(ctx, "Error matching artist image pattern", "pattern", pattern, "folder", artistFolder)
-			return nil, "", err
-		}
-		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
+		current := artistFolder
+		for i := 0; i < maxArtistFolderTraversalDepth; i++ {
+			if reader, path, err := findImageInFolder(ctx, current, pattern); err == nil {
+				return reader, path, nil
 			}
-			f, err := os.Open(filePath)
-			if err != nil {
-				log.Warn(ctx, "Could not open cover art file", "file", filePath, err)
-				return nil, "", err
+
+			parent := filepath.Dir(current)
+			if parent == current {
+				break
 			}
-			return f, filePath, nil
+			current = parent
 		}
-		return nil, "", nil
+		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
+	}
+
+	for _, m := range matches {
+		if !model.IsImageFile(m) {
+			continue
+		}
+		filePath := filepath.Join(folder, m)
+		f, err := os.Open(filePath)
+		if err != nil {
+			log.Warn(ctx, "Could not open cover art file", "file", filePath, err)
+			continue
+		}
+		return f, filePath, 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
+	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
 
 	folderPath := str.LongestCommonPrefix(paths)
 	if !strings.HasSuffix(folderPath, string(filepath.Separator)) {

core/artwork/reader_artist_test.go

@@ -3,6 +3,8 @@ package artwork
 import (
 	"context"
 	"errors"
+	"io"
+	"os"
 	"path/filepath"
 	"time"
 
@@ -108,6 +110,254 @@ 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.jpg"), []byte("jpg image"), 0600)).To(Succeed())
+				Expect(os.WriteFile(filepath.Join(artistDir, "artist.png"), []byte("png image"), 0600)).To(Succeed())
+				Expect(os.WriteFile(filepath.Join(artistDir, "artist.txt"), []byte("text file"), 0600)).To(Succeed())
+
+				testFunc = fromArtistFolder(ctx, artistDir, "artist.*")
+			})
+
+			It("returns the first valid image file", func() {
+				reader, path, err := testFunc()
+				Expect(err).ToNot(HaveOccurred())
+				Expect(reader).ToNot(BeNil())
+
+				// Should return an image file, not the text file
+				Expect(path).To(SatisfyAny(
+					ContainSubstring("artist.jpg"),
+					ContainSubstring("artist.png"),
+				))
+				Expect(path).ToNot(ContainSubstring("artist.txt"))
+				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

@@ -188,7 +188,7 @@ func fromURL(ctx context.Context, imageUrl *url.URL) (io.ReadCloser, string, err
 	}
 	if resp.StatusCode != http.StatusOK {
 		resp.Body.Close()
-		return nil, "", fmt.Errorf("error retrieveing artwork from %s: %s", imageUrl, resp.Status)
+		return nil, "", fmt.Errorf("error retrieving artwork from %s: %s", imageUrl, resp.Status)
 	}
 	return resp.Body, imageUrl.String(), nil
 }

core/external/extdata_helper_test.go

@@ -190,10 +190,13 @@ type mockAgents struct {
 	topSongsAgent  agents.ArtistTopSongsRetriever
 	similarAgent   agents.ArtistSimilarRetriever
 	imageAgent     agents.ArtistImageRetriever
-	albumInfoAgent agents.AlbumInfoRetriever
-	bioAgent       agents.ArtistBiographyRetriever
-	mbidAgent      agents.ArtistMBIDRetriever
-	urlAgent       agents.ArtistURLRetriever
+	albumInfoAgent interface {
+		agents.AlbumInfoRetriever
+		agents.AlbumImageRetriever
+	}
+	bioAgent  agents.ArtistBiographyRetriever
+	mbidAgent agents.ArtistMBIDRetriever
+	urlAgent  agents.ArtistURLRetriever
 	agents.Interface
 }
 
@@ -268,3 +271,14 @@ 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,6 +3,7 @@ package external
 import (
 	"context"
 	"errors"
+	"fmt"
 	"net/url"
 	"sort"
 	"strings"
@@ -11,6 +12,7 @@ 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"
@@ -34,7 +36,7 @@ const (
 type Provider interface {
 	UpdateAlbumInfo(ctx context.Context, id string) (*model.Album, error)
 	UpdateArtistInfo(ctx context.Context, id string, count int, includeNotPresent bool) (*model.Artist, error)
-	SimilarSongs(ctx context.Context, id string, count int) (model.MediaFiles, error)
+	ArtistRadio(ctx context.Context, id string, count int) (model.MediaFiles, error)
 	TopSongs(ctx context.Context, artist string, count int) (model.MediaFiles, error)
 	ArtistImage(ctx context.Context, id string) (*url.URL, error)
 	AlbumImage(ctx context.Context, id string) (*url.URL, error)
@@ -59,6 +61,7 @@ type auxArtist struct {
 
 type Agents interface {
 	agents.AlbumInfoRetriever
+	agents.AlbumImageRetriever
 	agents.ArtistBiographyRetriever
 	agents.ArtistMBIDRetriever
 	agents.ArtistImageRetriever
@@ -139,19 +142,20 @@ func (e *provider) populateAlbumInfo(ctx context.Context, album auxAlbum) (auxAl
 		album.Description = info.Description
 	}
 
-	if len(info.Images) > 0 {
-		sort.Slice(info.Images, func(i, j int) bool {
-			return info.Images[i].Size > info.Images[j].Size
+	images, err := e.ag.GetAlbumImages(ctx, album.Name, album.AlbumArtist, album.MbzAlbumID)
+	if err == nil && len(images) > 0 {
+		sort.Slice(images, func(i, j int) bool {
+			return images[i].Size > images[j].Size
 		})
 
-		album.LargeImageUrl = info.Images[0].URL
+		album.LargeImageUrl = images[0].URL
 
-		if len(info.Images) >= 2 {
-			album.MediumImageUrl = info.Images[1].URL
+		if len(images) >= 2 {
+			album.MediumImageUrl = images[1].URL
 		}
 
-		if len(info.Images) >= 3 {
-			album.SmallImageUrl = info.Images[2].URL
+		if len(images) >= 3 {
+			album.SmallImageUrl = images[2].URL
 		}
 	}
 
@@ -257,7 +261,7 @@ func (e *provider) populateArtistInfo(ctx context.Context, artist auxArtist) (au
 	return artist, nil
 }
 
-func (e *provider) SimilarSongs(ctx context.Context, id string, count int) (model.MediaFiles, error) {
+func (e *provider) ArtistRadio(ctx context.Context, id string, count int) (model.MediaFiles, error) {
 	artist, err := e.getArtist(ctx, id)
 	if err != nil {
 		return nil, err
@@ -265,14 +269,14 @@ func (e *provider) SimilarSongs(ctx context.Context, id string, count int) (mode
 
 	e.callGetSimilar(ctx, e.ag, &artist, 15, false)
 	if utils.IsCtxDone(ctx) {
-		log.Warn(ctx, "SimilarSongs call canceled", ctx.Err())
+		log.Warn(ctx, "ArtistRadio call canceled", ctx.Err())
 		return nil, ctx.Err()
 	}
 
 	weightedSongs := random.NewWeightedChooser[model.MediaFile]()
 	addArtist := func(a model.Artist, weightedSongs *random.WeightedChooser[model.MediaFile], count, artistWeight int) error {
 		if utils.IsCtxDone(ctx) {
-			log.Warn(ctx, "SimilarSongs call canceled", ctx.Err())
+			log.Warn(ctx, "ArtistRadio call canceled", ctx.Err())
 			return ctx.Err()
 		}
 
@@ -340,29 +344,28 @@ func (e *provider) AlbumImage(ctx context.Context, id string) (*url.URL, error)
 		return nil, err
 	}
 
-	info, err := e.ag.GetAlbumInfo(ctx, album.Name, album.AlbumArtist, album.MbzAlbumID)
+	images, err := e.ag.GetAlbumImages(ctx, album.Name, album.AlbumArtist, album.MbzAlbumID)
 	if err != nil {
 		switch {
 		case errors.Is(err, agents.ErrNotFound):
 			log.Trace(ctx, "Album not found in agent", "albumID", id, "name", album.Name, "artist", album.AlbumArtist)
 			return nil, model.ErrNotFound
 		case errors.Is(err, context.Canceled):
-			log.Debug(ctx, "GetAlbumInfo call canceled", err)
+			log.Debug(ctx, "GetAlbumImages call canceled", err)
 		default:
-			log.Warn(ctx, "Error getting album info from agent", "albumID", id, "name", album.Name, "artist", album.AlbumArtist, err)
+			log.Warn(ctx, "Error getting album images from agent", "albumID", id, "name", album.Name, "artist", album.AlbumArtist, err)
 		}
-
 		return nil, err
 	}
 
-	if info == nil {
-		log.Warn(ctx, "Agent returned nil info without error", "albumID", id, "name", album.Name, "artist", album.AlbumArtist)
+	if len(images) == 0 {
+		log.Warn(ctx, "Agent returned no images 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 info.Images {
+	for _, i := range images {
 		if img.Size <= i.Size {
 			img = i
 		}
@@ -400,20 +403,21 @@ 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) {
 	songs, err := agent.GetArtistTopSongs(ctx, artist.ID, artist.Name, artist.MbzArtistID, count)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get top songs for artist %s: %w", artist.Name, 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
-		}
+	mbidMatches, err := e.loadTracksByMBID(ctx, songs)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load tracks by MBID: %w", err)
 	}
+	titleMatches, err := e.loadTracksByTitle(ctx, songs, artist, mbidMatches)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load tracks by title: %w", err)
+	}
+
+	log.Trace(ctx, "Top Songs loaded", "name", artist.Name, "numSongs", len(songs), "numMBIDMatches", len(mbidMatches), "numTitleMatches", len(titleMatches))
+	mfs := e.selectTopSongs(songs, mbidMatches, titleMatches, count)
+
 	if len(mfs) == 0 {
 		log.Debug(ctx, "No matching top songs found", "name", artist.Name)
 	} else {
@@ -423,35 +427,94 @@ func (e *provider) getMatchingTopSongs(ctx context.Context, agent agents.ArtistT
 	return mfs, nil
 }
 
-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
+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)
 		}
-		return e.findMatchingTrack(ctx, "", artistID, title)
 	}
-	mfs, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+	matches := map[string]model.MediaFile{}
+	if len(mbids) == 0 {
+		return matches, nil
+	}
+	res, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+		Filters: squirrel.And{
+			squirrel.Eq{"mbz_recording_id": mbids},
+			squirrel.Eq{"missing": false},
+		},
+	})
+	if err != nil {
+		return matches, err
+	}
+	for _, mf := range res {
+		if id := mf.MbzRecordingID; id != "" {
+			if _, ok := matches[id]; !ok {
+				matches[id] = mf
+			}
+		}
+	}
+	return matches, nil
+}
+
+func (e *provider) loadTracksByTitle(ctx context.Context, songs []agents.Song, artist *auxArtist, mbidMatches map[string]model.MediaFile) (map[string]model.MediaFile, error) {
+	titleMap := map[string]string{}
+	for _, s := range songs {
+		if s.MBID != "" && mbidMatches[s.MBID].ID != "" {
+			continue
+		}
+		sanitized := str.SanitizeFieldForSorting(s.Name)
+		titleMap[sanitized] = s.Name
+	}
+	matches := map[string]model.MediaFile{}
+	if len(titleMap) == 0 {
+		return matches, nil
+	}
+	titleFilters := squirrel.Or{}
+	for sanitized := range titleMap {
+		titleFilters = append(titleFilters, squirrel.Like{"order_title": sanitized})
+	}
+
+	res, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
 		Filters: squirrel.And{
 			squirrel.Or{
-				squirrel.Eq{"artist_id": artistID},
-				squirrel.Eq{"album_artist_id": artistID},
+				squirrel.Eq{"artist_id": artist.ID},
+				squirrel.Eq{"album_artist_id": artist.ID},
 			},
-			squirrel.Like{"order_title": str.SanitizeFieldForSorting(title)},
+			titleFilters,
 			squirrel.Eq{"missing": false},
 		},
 		Sort: "starred desc, rating desc, year asc, compilation asc ",
-		Max:  1,
 	})
-	if err != nil || len(mfs) == 0 {
-		return nil, model.ErrNotFound
+	if err != nil {
+		return matches, err
 	}
-	return &mfs[0], nil
+	for _, mf := range res {
+		sanitized := str.SanitizeFieldForSorting(mf.Title)
+		if _, ok := matches[sanitized]; !ok {
+			matches[sanitized] = mf
+		}
+	}
+	return matches, nil
+}
+
+func (e *provider) selectTopSongs(songs []agents.Song, byMBID, byTitle map[string]model.MediaFile, count int) model.MediaFiles {
+	var mfs model.MediaFiles
+	for _, t := range songs {
+		if len(mfs) == count {
+			break
+		}
+		if t.MBID != "" {
+			if mf, ok := byMBID[t.MBID]; ok {
+				mfs = append(mfs, mf)
+				continue
+			}
+		}
+		if mf, ok := byTitle[str.SanitizeFieldForSorting(t.Name)]; ok {
+			mfs = append(mfs, mf)
+		}
+	}
+	return mfs
 }
 
 func (e *provider) callGetURL(ctx context.Context, agent agents.ArtistURLRetriever, artist *auxArtist) {
@@ -497,7 +560,7 @@ func (e *provider) callGetSimilar(ctx context.Context, agent agents.ArtistSimila
 		return
 	}
 	start := time.Now()
-	sa, err := e.mapSimilarArtists(ctx, similar, includeNotPresent)
+	sa, err := e.mapSimilarArtists(ctx, similar, limit, includeNotPresent)
 	log.Debug(ctx, "Mapped Similar Artists", "artist", artist.Name, "numSimilar", len(sa), "elapsed", time.Since(start))
 	if err != nil {
 		return
@@ -505,7 +568,7 @@ func (e *provider) callGetSimilar(ctx context.Context, agent agents.ArtistSimila
 	artist.SimilarArtists = sa
 }
 
-func (e *provider) mapSimilarArtists(ctx context.Context, similar []agents.Artist, includeNotPresent bool) (model.Artists, error) {
+func (e *provider) mapSimilarArtists(ctx context.Context, similar []agents.Artist, limit int, includeNotPresent bool) (model.Artists, error) {
 	var result model.Artists
 	var notPresent []string
 
@@ -528,21 +591,33 @@ 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 {
+	if includeNotPresent && count < limit {
 		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
+			}
 		}
 	}
 

core/external/provider_albumimage_test.go

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

core/external/provider_artistradio_test.go

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

core/external/provider_topsongs_test.go

@@ -42,10 +42,6 @@ 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"}
@@ -58,11 +54,10 @@ 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
+		// 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}, nil).Once()
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song2}, nil).Once()
+		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1, song2}, nil).Once()
 
 		songs, err := p.TopSongs(ctx, "Artist One", 2)
 
@@ -155,11 +150,10 @@ 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)
+		// Mock finding matching tracks (only find song 1 on bulk query)
 		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()
-		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)
+		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
 
 		songs, err := p.TopSongs(ctx, "Artist One", 2)
 
@@ -190,4 +184,91 @@ 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,9 +74,6 @@ 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/library.go

@@ -0,0 +1,412 @@
+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"
+)
+
+// Scanner interface for triggering scans
+type Scanner interface {
+	ScanAll(ctx context.Context, fullScan bool) (warnings []string, err error)
+}
+
+// Watcher interface for managing file system watchers
+type Watcher interface {
+	Watch(ctx context.Context, lib *model.Library) error
+	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 Scanner
+	watcher Watcher
+	broker  events.Broker
+}
+
+// NewLibrary creates a new Library service
+func NewLibrary(ds model.DataStore, scanner 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 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{}, cols ...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

@@ -0,0 +1,980 @@
+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 *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 = &mockScanner{}
+		// 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.len()
+			}, "1s", "10ms").Should(Equal(1))
+
+			// Verify scan was called with correct parameters
+			Expect(scanner.ScanCalls[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.len()
+			}, "1s", "10ms").Should(Equal(1))
+
+			// Verify scan was called with correct parameters
+			Expect(scanner.ScanCalls[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.len()
+			}, "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.len()
+			}, "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.len()
+			}, "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.len()
+			}, "1s", "10ms").Should(Equal(1))
+
+			// Verify scan was called with correct parameters
+			Expect(scanner.ScanCalls[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.len()
+			}, "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))
+		})
+	})
+})
+
+// mockScanner provides a simple mock implementation of core.Scanner for testing
+type mockScanner struct {
+	ScanCalls []ScanCall
+	mu        sync.RWMutex
+}
+
+type ScanCall struct {
+	FullScan bool
+}
+
+func (m *mockScanner) ScanAll(ctx context.Context, fullScan bool) (warnings []string, err error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.ScanCalls = append(m.ScanCalls, ScanCall{
+		FullScan: fullScan,
+	})
+	return []string{}, nil
+}
+
+func (m *mockScanner) len() int {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return len(m.ScanCalls)
+}
+
+// mockWatcherManager provides a simple mock implementation of core.Watcher for testing
+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,6 +8,7 @@ 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) {
@@ -27,8 +28,7 @@ func fromExternalFile(ctx context.Context, mf *model.MediaFile, suffix string) (
 
 	externalLyric := basePath[0:len(basePath)-len(ext)] + suffix
 
-	contents, err := os.ReadFile(externalLyric)
-
+	contents, err := ioutils.UTF8ReadFile(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,5 +108,39 @@ 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/metrics/insights.go

@@ -21,6 +21,7 @@ import (
 	"github.com/navidrome/navidrome/core/metrics/insights"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/plugins/schema"
 	"github.com/navidrome/navidrome/utils/singleton"
 )
 
@@ -34,12 +35,18 @@ var (
 )
 
 type insightsCollector struct {
-	ds         model.DataStore
-	lastRun    atomic.Int64
-	lastStatus atomic.Bool
+	ds           model.DataStore
+	pluginLoader PluginLoader
+	lastRun      atomic.Int64
+	lastStatus   atomic.Bool
 }
 
-func GetInstance(ds model.DataStore) Insights {
+// PluginLoader defines an interface for loading plugins
+type PluginLoader interface {
+	PluginList() map[string]schema.PluginManifest
+}
+
+func GetInstance(ds model.DataStore, pluginLoader PluginLoader) Insights {
 	return singleton.GetInstance(func() *insightsCollector {
 		id, err := ds.Property(context.TODO()).Get(consts.InsightsIDKey)
 		if err != nil {
@@ -51,7 +58,7 @@ func GetInstance(ds model.DataStore) Insights {
 			}
 		}
 		insightsID = id
-		return &insightsCollector{ds: ds}
+		return &insightsCollector{ds: ds, pluginLoader: pluginLoader}
 	})
 }
 
@@ -176,13 +183,15 @@ 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
+	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.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
@@ -198,6 +207,9 @@ 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.ReverseProxyWhitelist != ""
+	data.Config.HasCustomPID = conf.Server.PID.Track != "" || conf.Server.PID.Album != ""
+	data.Config.HasCustomTags = len(conf.Server.Tags) > 0
 
 	return data
 })
@@ -232,12 +244,29 @@ 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)},
@@ -263,3 +292,23 @@ 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 {
+	plugins := make(map[string]insights.PluginInfo)
+	for id, manifest := range c.pluginLoader.PluginList() {
+		plugins[id] = insights.PluginInfo{
+			Name:    manifest.Name,
+			Version: manifest.Version,
+		}
+	}
+	return plugins
+}

core/metrics/insights/data.go

@@ -36,6 +36,7 @@ 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"`
@@ -55,11 +56,13 @@ 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"`
@@ -68,7 +71,17 @@ 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/prometheus.go

@@ -2,7 +2,6 @@ package metrics
 
 import (
 	"context"
-	"fmt"
 	"net/http"
 	"strconv"
 	"sync"
@@ -13,6 +12,7 @@ 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,6 +20,8 @@ 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
 }
 
@@ -27,11 +29,14 @@ type metrics struct {
 	ds model.DataStore
 }
 
-func NewPrometheusInstance(ds model.DataStore) Metrics {
-	if conf.Server.Prometheus.Enabled {
-		return &metrics{ds: ds}
+func GetPrometheusInstance(ds model.DataStore) Metrics {
+	if !conf.Server.Prometheus.Enabled {
+		return noopMetrics{}
 	}
-	return noopMetrics{}
+
+	return singleton.GetInstance(func() *metrics {
+		return &metrics{ds: ds}
+	})
 }
 
 func NewNoopInstance() Metrics {
@@ -51,6 +56,38 @@ 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()
 
@@ -59,20 +96,31 @@ 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
+	dbTotal               *prometheus.GaugeVec
+	versionInfo           *prometheus.GaugeVec
+	lastMediaScan         *prometheus.GaugeVec
+	mediaScansCounter     *prometheus.CounterVec
+	httpRequestCounter    *prometheus.CounterVec
+	httpRequestDuration   *prometheus.SummaryVec
+	pluginRequestCounter  *prometheus.CounterVec
+	pluginRequestDuration *prometheus.SummaryVec
 }
 
 // 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{
@@ -102,23 +150,49 @@ 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"},
+		),
 	}
-	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))
-	}
+
+	prometheus.DefaultRegisterer.MustRegister(
+		instance.dbTotal,
+		instance.versionInfo,
+		instance.lastMediaScan,
+		instance.mediaScansCounter,
+		instance.httpRequestCounter,
+		instance.httpRequestDuration,
+		instance.pluginRequestCounter,
+		instance.pluginRequestDuration,
+	)
+
 	return instance
 })
 
@@ -159,4 +233,8 @@ 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

@@ -0,0 +1,46 @@
+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,11 +10,15 @@ 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()
@@ -71,28 +75,32 @@ func (j *Executor) wait() {
 
 // Path will always be an absolute path
 func createMPVCommand(deviceName string, filename string, socketName string) []string {
-	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
+	// 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
 	}
-	return split
-}
 
-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)
+	// 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
+			}
 		}
 	}
-	return strings.Join(result, " ")
+
+	return templateArgs
 }
 
 // This is a 1:1 copy of the stuff in ffmpeg.go, need to be unified.

core/playback/mpv/mpv_suite_test.go

@@ -0,0 +1,17 @@
+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

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

core/playlists.go

@@ -20,7 +20,9 @@ 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 {
@@ -96,12 +98,13 @@ 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, file)
+		err = s.parseNSP(ctx, pls, reader)
 	default:
-		err = s.parseM3U(ctx, pls, folder, file)
+		err = s.parseM3U(ctx, pls, folder, reader)
 	}
 	return pls, err
 }
@@ -203,10 +206,10 @@ func (s *playlists) parseM3U(ctx context.Context, pls *model.Playlist, folder *m
 		}
 		existing := make(map[string]int, len(found))
 		for idx := range found {
-			existing[strings.ToLower(found[idx].Path)] = idx
+			existing[normalizePathForComparison(found[idx].Path)] = idx
 		}
 		for _, path := range paths {
-			idx, ok := existing[strings.ToLower(path)]
+			idx, ok := existing[normalizePathForComparison(path)]
 			if ok {
 				mfs = append(mfs, found[idx])
 			} else {
@@ -223,6 +226,13 @@ func (s *playlists) parseM3U(ctx context.Context, pls *model.Playlist, folder *m
 	return nil
 }
 
+// normalizePathForComparison normalizes a file path to NFC form and converts to lowercase
+// for consistent comparison. This fixes Unicode normalization issues on macOS where
+// Apple Music creates playlists with NFC-encoded paths but the filesystem uses NFD.
+func normalizePathForComparison(path string) string {
+	return strings.ToLower(norm.NFC.String(path))
+}
+
 // 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)
@@ -326,7 +336,7 @@ func (s *playlists) Update(ctx context.Context, playlistID string,
 		if needsTrackRefresh {
 			pls, err = repo.GetWithTracks(playlistID, true, false)
 			pls.RemoveTracks(idxToRemove)
-			pls.AddTracks(idsToAdd)
+			pls.AddMediaFilesByID(idsToAdd)
 		} else {
 			if len(idsToAdd) > 0 {
 				_, err = tracks.Add(idsToAdd)

core/playlists_test.go

@@ -15,6 +15,7 @@ import (
 	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
+	"golang.org/x/text/unicode/norm"
 )
 
 var _ = Describe("Playlists", func() {
@@ -73,6 +74,24 @@ 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() {
@@ -186,6 +205,54 @@ 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", func() {
+			// Test case for Apple Music playlists that use NFC encoding vs macOS filesystem NFD
+			// The character "è" can be represented as NFC (single codepoint) or NFD (e + combining accent)
+
+			const pathWithAccents = "artist/Michèle Desrosiers/album/Noël.m4a"
+
+			// Simulate a database entry with NFD encoding (as stored by macOS filesystem)
+			nfdPath := norm.NFD.String(pathWithAccents)
+			repo.data = []string{nfdPath}
+
+			// Simulate an Apple Music M3U playlist entry with NFC encoding
+			nfcPath := norm.NFC.String("/music/" + pathWithAccents)
+			m3u := strings.Join([]string{
+				nfcPath,
+			}, "\n")
+			f := strings.NewReader(m3u)
+
+			pls, err := ps.ImportM3U(ctx, f)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(pls.Tracks).To(HaveLen(1), "Should find the track despite Unicode normalization differences")
+			Expect(pls.Tracks[0].Path).To(Equal(nfdPath))
+		})
+	})
+
+	Describe("normalizePathForComparison", func() {
+		It("normalizes Unicode characters to NFC form and converts to lowercase", func() {
+			// Test with NFD (decomposed) input - as would come from macOS filesystem
+			nfdPath := norm.NFD.String("Michèle") // Explicitly convert to NFD form
+			normalized := normalizePathForComparison(nfdPath)
+			Expect(normalized).To(Equal("michèle"))
+
+			// Test with NFC (composed) input - as would come from Apple Music M3U
+			nfcPath := "Michèle" // This might be in NFC form
+			normalizedNfc := normalizePathForComparison(nfcPath)
+
+			// Ensure the two paths are not equal in their original forms
+			Expect(nfdPath).ToNot(Equal(nfcPath))
+
+			// Both should normalize to the same result
+			Expect(normalized).To(Equal(normalizedNfc))
+		})
+
+		It("handles paths with mixed case and Unicode characters", func() {
+			path := "Artist/Noël Coward/Album/Song.mp3"
+			normalized := normalizePathForComparison(path)
+			Expect(normalized).To(Equal("artist/noël coward/album/song.mp3"))
+		})
 	})
 
 	Describe("InPlaylistsPath", func() {

core/scrobbler/buffered_scrobbler.go

@@ -10,9 +10,16 @@ import (
 )
 
 func newBufferedScrobbler(ds model.DataStore, s Scrobbler, service string) *bufferedScrobbler {
-	b := &bufferedScrobbler{ds: ds, wrapped: s, service: service}
-	b.wakeSignal = make(chan struct{}, 1)
-	go b.run(context.TODO())
+	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)
 	return b
 }
 
@@ -21,14 +28,22 @@ 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) error {
-	return b.wrapped.NowPlaying(ctx, userId, track)
+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) Scrobble(ctx context.Context, userId string, s Scrobble) error {

core/scrobbler/buffered_scrobbler_test.go

@@ -0,0 +1,88 @@
+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.NowPlayingCalled).To(BeTrue())
+		Expect(scr.UserID).To(Equal("user1"))
+		Expect(scr.Track).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())
+		Expect(buffer.Length()).To(Equal(int64(1)))
+
+		// Wait for the scrobble to be sent
+		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) error
+	NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) error
 	Scrobble(ctx context.Context, userId string, s Scrobble) error
 }
 

core/scrobbler/play_tracker.go

@@ -2,9 +2,12 @@ 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"
@@ -17,6 +20,7 @@ import (
 type NowPlayingInfo struct {
 	MediaFile  model.MediaFile
 	Start      time.Time
+	Position   int
 	Username   string
 	PlayerId   string
 	PlayerName string
@@ -28,30 +32,52 @@ type Submission struct {
 }
 
 type PlayTracker interface {
-	NowPlaying(ctx context.Context, playerId string, playerName string, trackId string) error
+	NowPlaying(ctx context.Context, playerId string, playerName string, trackId string, position int) error
 	GetNowPlaying(ctx context.Context) ([]NowPlayingInfo, error)
 	Submit(ctx context.Context, submissions []Submission) error
 }
 
-type playTracker struct {
-	ds         model.DataStore
-	broker     events.Broker
-	playMap    cache.SimpleCache[string, NowPlayingInfo]
-	scrobblers map[string]Scrobbler
+// 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)
 }
 
-func GetPlayTracker(ds model.DataStore, broker events.Broker) PlayTracker {
+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
+}
+
+func GetPlayTracker(ds model.DataStore, broker events.Broker, pluginManager PluginLoader) PlayTracker {
 	return singleton.GetInstance(func() *playTracker {
-		return newPlayTracker(ds, broker)
+		return newPlayTracker(ds, broker, pluginManager)
 	})
 }
 
 // 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) *playTracker {
+func newPlayTracker(ds model.DataStore, broker events.Broker, pluginManager PluginLoader) *playTracker {
 	m := cache.NewSimpleCache[string, NowPlayingInfo]()
-	p := &playTracker{ds: ds, playMap: m, broker: broker}
-	p.scrobblers = make(map[string]Scrobbler)
+	p := &playTracker{
+		ds:                ds,
+		playMap:           m,
+		broker:            broker,
+		builtinScrobblers: make(map[string]Scrobbler),
+		pluginScrobblers:  make(map[string]Scrobbler),
+		pluginLoader:      pluginManager,
+	}
+	if conf.Server.EnableNowPlaying {
+		m.OnExpiration(func(_ string, _ NowPlayingInfo) {
+			broker.SendBroadcastMessage(context.Background(), &events.NowPlayingCount{Count: m.Len()})
+		})
+	}
+
 	var enabled []string
 	for name, constructor := range constructors {
 		s := constructor(ds)
@@ -61,13 +87,87 @@ func newPlayTracker(ds model.DataStore, broker events.Broker) *playTracker {
 		}
 		enabled = append(enabled, name)
 		s = newBufferedScrobbler(ds, s, name)
-		p.scrobblers[name] = s
+		p.builtinScrobblers[name] = s
 	}
-	log.Debug("List of scrobblers enabled", "names", enabled)
+	log.Debug("List of builtin scrobblers enabled", "names", enabled)
 	return p
 }
 
-func (p *playTracker) NowPlaying(ctx context.Context, playerId string, playerName string, trackId string) error {
+// 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 {
 	mf, err := p.ds.MediaFile(ctx).GetWithParticipants(trackId)
 	if err != nil {
 		log.Error(ctx, "Error retrieving mediaFile", "id", trackId, err)
@@ -78,31 +178,43 @@ 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,
 	}
 
-	ttl := time.Duration(int(mf.Duration)+5) * time.Second
+	// 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
 	_ = 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.dispatchNowPlaying(ctx, user.ID, mf)
+		p.dispatchNowPlaying(ctx, user.ID, mf, position)
 	}
 	return nil
 }
 
-func (p *playTracker) dispatchNowPlaying(ctx context.Context, userId string, t *model.MediaFile) {
+func (p *playTracker) dispatchNowPlaying(ctx context.Context, userId string, t *model.MediaFile, position int) {
 	if t.Artist == consts.UnknownArtist {
 		log.Debug(ctx, "Ignoring external NowPlaying update for track with unknown artist", "track", t.Title, "artist", t.Artist)
 		return
 	}
-	for name, s := range p.scrobblers {
+	allScrobblers := p.getActiveScrobblers()
+	for name, s := range allScrobblers {
 		if !s.IsAuthorized(ctx, userId) {
 			continue
 		}
-		log.Debug(ctx, "Sending NowPlaying update", "scrobbler", name, "track", t.Title, "artist", t.Artist)
-		err := s.NowPlaying(ctx, userId, t)
+		log.Debug(ctx, "Sending NowPlaying update", "scrobbler", name, "track", t.Title, "artist", t.Artist, "position", position)
+		err := s.NowPlaying(ctx, userId, t, position)
 		if err != nil {
 			log.Error(ctx, "Error sending NowPlayingInfo", "scrobbler", name, "track", t.Title, "artist", t.Artist, err)
 			continue
@@ -174,9 +286,11 @@ 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 p.scrobblers {
+	for name, s := range allScrobblers {
 		if !s.IsAuthorized(ctx, u.ID) {
 			continue
 		}

core/scrobbler/play_tracker_test.go

@@ -3,8 +3,13 @@ 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"
@@ -15,10 +20,28 @@ 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 {
+	names      []string
+	scrobblers map[string]Scrobbler
+}
+
+func (m *mockPluginLoader) PluginNames(service string) []string {
+	return m.names
+}
+
+func (m *mockPluginLoader) LoadScrobbler(name string) (Scrobbler, bool) {
+	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
@@ -26,6 +49,7 @@ var _ = Describe("PlayTracker", func() {
 	var fake fakeScrobbler
 
 	BeforeEach(func() {
+		DeferCleanup(configtest.SetupConfig())
 		ctx = context.Background()
 		ctx = request.WithUser(ctx, model.User{ID: "u-1"})
 		ctx = request.WithPlayer(ctx, model.Player{ScrobbleEnabled: true})
@@ -37,8 +61,9 @@ var _ = Describe("PlayTracker", func() {
 		Register("disabled", func(model.DataStore) Scrobbler {
 			return nil
 		})
-		tracker = newPlayTracker(ds, events.GetBroker())
-		tracker.(*playTracker).scrobblers["fake"] = &fake // Bypass buffering for tests
+		eventBroker = &fakeEventBroker{}
+		tracker = newPlayTracker(ds, eventBroker, nil)
+		tracker.(*playTracker).builtinScrobblers["fake"] = &fake // Bypass buffering for tests
 
 		track = model.MediaFile{
 			ID:             "123",
@@ -62,13 +87,13 @@ var _ = Describe("PlayTracker", func() {
 	})
 
 	It("does not register disabled scrobblers", func() {
-		Expect(tracker.(*playTracker).scrobblers).To(HaveKey("fake"))
-		Expect(tracker.(*playTracker).scrobblers).ToNot(HaveKey("disabled"))
+		Expect(tracker.(*playTracker).builtinScrobblers).To(HaveKey("fake"))
+		Expect(tracker.(*playTracker).builtinScrobblers).ToNot(HaveKey("disabled"))
 	})
 
 	Describe("NowPlaying", func() {
 		It("sends track to agent", func() {
-			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123")
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(fake.NowPlayingCalled).To(BeTrue())
 			Expect(fake.UserID).To(Equal("u-1"))
@@ -78,7 +103,7 @@ var _ = Describe("PlayTracker", func() {
 		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")
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
 
 			Expect(err).ToNot(HaveOccurred())
 			Expect(fake.NowPlayingCalled).To(BeFalse())
@@ -86,7 +111,7 @@ var _ = Describe("PlayTracker", func() {
 		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")
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
 
 			Expect(err).ToNot(HaveOccurred())
 			Expect(fake.NowPlayingCalled).To(BeFalse())
@@ -94,11 +119,40 @@ var _ = Describe("PlayTracker", func() {
 		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")
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
 
 			Expect(err).ToNot(HaveOccurred())
 			Expect(fake.NowPlayingCalled).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())
+
+			playing, err := tracker.GetNowPlaying(ctx)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(playing).To(HaveLen(1))
+			Expect(playing[0].Position).To(Equal(pos))
+			Expect(fake.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())
+		})
 	})
 
 	Describe("GetNowPlaying", func() {
@@ -107,9 +161,9 @@ var _ = Describe("PlayTracker", func() {
 			track2.ID = "456"
 			_ = ds.MediaFile(ctx).Put(&track2)
 			ctx = request.WithUser(context.Background(), model.User{UserName: "user-1"})
-			_ = tracker.NowPlaying(ctx, "player-1", "player-one", "123")
+			_ = tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
 			ctx = request.WithUser(context.Background(), model.User{UserName: "user-2"})
-			_ = tracker.NowPlaying(ctx, "player-2", "player-two", "456")
+			_ = tracker.NowPlaying(ctx, "player-2", "player-two", "456", 0)
 
 			playing, err := tracker.GetNowPlaying(ctx)
 
@@ -127,6 +181,26 @@ 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"})
@@ -135,10 +209,12 @@ var _ = Describe("PlayTracker", func() {
 			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: ts}})
 
 			Expect(err).ToNot(HaveOccurred())
-			Expect(fake.ScrobbleCalled).To(BeTrue())
+			Expect(fake.ScrobbleCalled.Load()).To(BeTrue())
 			Expect(fake.UserID).To(Equal("u-1"))
-			Expect(fake.LastScrobble.ID).To(Equal("123"))
-			Expect(fake.LastScrobble.Participants).To(Equal(track.Participants))
+			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))
 		})
 
 		It("increments play counts in the DB", func() {
@@ -162,7 +238,7 @@ var _ = Describe("PlayTracker", func() {
 			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: time.Now()}})
 
 			Expect(err).ToNot(HaveOccurred())
-			Expect(fake.ScrobbleCalled).To(BeFalse())
+			Expect(fake.ScrobbleCalled.Load()).To(BeFalse())
 		})
 
 		It("does not send track to agent if player is not enabled to send scrobbles", func() {
@@ -171,7 +247,7 @@ var _ = Describe("PlayTracker", func() {
 			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: time.Now()}})
 
 			Expect(err).ToNot(HaveOccurred())
-			Expect(fake.ScrobbleCalled).To(BeFalse())
+			Expect(fake.ScrobbleCalled.Load()).To(BeFalse())
 		})
 
 		It("does not send track to agent if artist is unknown", func() {
@@ -180,7 +256,7 @@ var _ = Describe("PlayTracker", func() {
 			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: time.Now()}})
 
 			Expect(err).ToNot(HaveOccurred())
-			Expect(fake.ScrobbleCalled).To(BeFalse())
+			Expect(fake.ScrobbleCalled.Load()).To(BeFalse())
 		})
 
 		It("increments play counts even if it cannot scrobble", func() {
@@ -189,7 +265,7 @@ var _ = Describe("PlayTracker", func() {
 			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: time.Now()}})
 
 			Expect(err).ToNot(HaveOccurred())
-			Expect(fake.ScrobbleCalled).To(BeFalse())
+			Expect(fake.ScrobbleCalled.Load()).To(BeFalse())
 
 			Expect(track.PlayCount).To(Equal(int64(1)))
 			Expect(album.PlayCount).To(Equal(int64(1)))
@@ -200,15 +276,111 @@ var _ = Describe("PlayTracker", func() {
 		})
 	})
 
+	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())
+			Expect(pluginFake.NowPlayingCalled).To(BeTrue())
+		})
+
+		It("removes plugin scrobbler if not present anymore", func() {
+			// First call: plugin present
+			_ = tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+			Expect(pluginFake.NowPlayingCalled).To(BeTrue())
+			pluginFake.NowPlayingCalled = false
+			// Remove plugin
+			pluginLoader.names = []string{}
+			_ = tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+			Expect(pluginFake.NowPlayingCalled).To(BeFalse())
+		})
+
+		It("calls both builtin and plugin scrobblers for NowPlaying", func() {
+			fake.NowPlayingCalled = false
+			pluginFake.NowPlayingCalled = false
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(fake.NowPlayingCalled).To(BeTrue())
+			Expect(pluginFake.NowPlayingCalled).To(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 = context.Background()
+			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.names = []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 bool
-	ScrobbleCalled   bool
+	ScrobbleCalled   atomic.Bool
 	UserID           string
 	Track            *model.MediaFile
-	LastScrobble     Scrobble
+	Position         int
+	LastScrobble     atomic.Pointer[Scrobble]
 	Error            error
 }
 
@@ -216,23 +388,24 @@ 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) error {
+func (f *fakeScrobbler) NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) error {
 	f.NowPlayingCalled = true
 	if f.Error != nil {
 		return f.Error
 	}
 	f.UserID = userId
 	f.Track = track
+	f.Position = position
 	return nil
 }
 
 func (f *fakeScrobbler) Scrobble(ctx context.Context, userId string, s Scrobble) error {
-	f.ScrobbleCalled = true
+	f.UserID = userId
+	f.LastScrobble.Store(&s)
+	f.ScrobbleCalled.Store(true)
 	if f.Error != nil {
 		return f.Error
 	}
-	f.UserID = userId
-	f.LastScrobble = s
 	return nil
 }
 
@@ -243,3 +416,51 @@ 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

@@ -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{"id": idList}})
+	all, err := r.ds.Album(r.ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"album.id": idList}})
 	if err != nil {
 		log.Error(r.ctx, "Error retrieving album names for share", "share", shareID, err)
 		return ""

core/storage/local/local_suite_test.go

@@ -3,11 +3,15 @@ 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 Test Suite")
+	RunSpecs(t, "Local Storage Suite")
 }

core/storage/local/local_test.go

@@ -0,0 +1,428 @@
+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,6 +6,8 @@ import (
 	"path/filepath"
 	"strings"
 	"sync"
+
+	"github.com/navidrome/navidrome/utils/slice"
 )
 
 const LocalSchemaID = "file"
@@ -36,7 +38,14 @@ func For(uri string) (Storage, error) {
 	if len(parts) < 2 {
 		uri, _ = filepath.Abs(uri)
 		uri = filepath.ToSlash(uri)
-		uri = LocalSchemaID + "://" + 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, "/")
 	}
 
 	u, err := url.Parse(uri)

core/storage/storage_test.go

@@ -65,6 +65,21 @@ 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,6 +17,7 @@ var Set = wire.NewSet(
 	NewPlayers,
 	NewShare,
 	NewPlaylists,
+	NewLibrary,
 	agents.GetAgents,
 	external.NewProvider,
 	wire.Bind(new(external.Agents), new(*agents.Agents)),

db/backup.go

@@ -1,167 +1,168 @@
 package db
 
-import (
-	"context"
-	"database/sql"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"regexp"
-	"slices"
-	"time"
-
-	"github.com/mattn/go-sqlite3"
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/log"
-)
-
-const (
-	backupPrefix      = "navidrome_backup"
-	backupRegexString = backupPrefix + "_(.+)\\.db"
-)
-
-var backupRegex = regexp.MustCompile(backupRegexString)
-
-const backupSuffixLayout = "2006.01.02_15.04.05"
-
-func backupPath(t time.Time) string {
-	return filepath.Join(
-		conf.Server.Backup.Path,
-		fmt.Sprintf("%s_%s.db", backupPrefix, t.Format(backupSuffixLayout)),
-	)
-}
-
-func backupOrRestore(ctx context.Context, isBackup bool, path string) error {
-	// heavily inspired by https://codingrabbits.dev/posts/go_and_sqlite_backup_and_maybe_restore/
-	existingConn, err := Db().Conn(ctx)
-	if err != nil {
-		return fmt.Errorf("getting existing connection: %w", err)
-	}
-	defer existingConn.Close()
-
-	backupDb, err := sql.Open(Driver, path)
-	if err != nil {
-		return fmt.Errorf("opening backup database in '%s': %w", path, err)
-	}
-	defer backupDb.Close()
-
-	backupConn, err := backupDb.Conn(ctx)
-	if err != nil {
-		return fmt.Errorf("getting backup connection: %w", err)
-	}
-	defer backupConn.Close()
-
-	err = existingConn.Raw(func(existing any) error {
-		return backupConn.Raw(func(backup any) error {
-			var sourceOk, destOk bool
-			var sourceConn, destConn *sqlite3.SQLiteConn
-
-			if isBackup {
-				sourceConn, sourceOk = existing.(*sqlite3.SQLiteConn)
-				destConn, destOk = backup.(*sqlite3.SQLiteConn)
-			} else {
-				sourceConn, sourceOk = backup.(*sqlite3.SQLiteConn)
-				destConn, destOk = existing.(*sqlite3.SQLiteConn)
-			}
-
-			if !sourceOk {
-				return fmt.Errorf("error trying to convert source to sqlite connection")
-			}
-			if !destOk {
-				return fmt.Errorf("error trying to convert destination to sqlite connection")
-			}
-
-			backupOp, err := destConn.Backup("main", sourceConn, "main")
-			if err != nil {
-				return fmt.Errorf("error starting sqlite backup: %w", err)
-			}
-			defer backupOp.Close()
-
-			// Caution: -1 means that sqlite will hold a read lock until the operation finishes
-			// This will lock out other writes that could happen at the same time
-			done, err := backupOp.Step(-1)
-			if !done {
-				return fmt.Errorf("backup not done with step -1")
-			}
-			if err != nil {
-				return fmt.Errorf("error during backup step: %w", err)
-			}
-
-			err = backupOp.Finish()
-			if err != nil {
-				return fmt.Errorf("error finishing backup: %w", err)
-			}
-
-			return nil
-		})
-	})
-
-	return err
-}
-
-func Backup(ctx context.Context) (string, error) {
-	destPath := backupPath(time.Now())
-	log.Debug(ctx, "Creating backup", "path", destPath)
-	err := backupOrRestore(ctx, true, destPath)
-	if err != nil {
-		return "", err
-	}
-
-	return destPath, nil
-}
-
-func Restore(ctx context.Context, path string) error {
-	log.Debug(ctx, "Restoring backup", "path", path)
-	return backupOrRestore(ctx, false, path)
-}
-
-func Prune(ctx context.Context) (int, error) {
-	files, err := os.ReadDir(conf.Server.Backup.Path)
-	if err != nil {
-		return 0, fmt.Errorf("unable to read database backup entries: %w", err)
-	}
-
-	var backupTimes []time.Time
-
-	for _, file := range files {
-		if !file.IsDir() {
-			submatch := backupRegex.FindStringSubmatch(file.Name())
-			if len(submatch) == 2 {
-				timestamp, err := time.Parse(backupSuffixLayout, submatch[1])
-				if err == nil {
-					backupTimes = append(backupTimes, timestamp)
-				}
-			}
-		}
-	}
-
-	if len(backupTimes) <= conf.Server.Backup.Count {
-		return 0, nil
-	}
-
-	slices.SortFunc(backupTimes, func(a, b time.Time) int {
-		return b.Compare(a)
-	})
-
-	pruneCount := 0
-	var errs []error
-
-	for _, timeToPrune := range backupTimes[conf.Server.Backup.Count:] {
-		log.Debug(ctx, "Pruning backup", "time", timeToPrune)
-		path := backupPath(timeToPrune)
-		err = os.Remove(path)
-		if err != nil {
-			errs = append(errs, err)
-		} else {
-			pruneCount++
-		}
-	}
-
-	if len(errs) > 0 {
-		err = errors.Join(errs...)
-		log.Error(ctx, "Failed to delete one or more files", "errors", err)
-	}
-
-	return pruneCount, err
-}
+//
+//import (
+//	"context"
+//	"database/sql"
+//	"errors"
+//	"fmt"
+//	"os"
+//	"path/filepath"
+//	"regexp"
+//	"slices"
+//	"time"
+//
+//	"github.com/mattn/go-sqlite3"
+//	"github.com/navidrome/navidrome/conf"
+//	"github.com/navidrome/navidrome/log"
+//)
+//
+//const (
+//	backupPrefix      = "navidrome_backup"
+//	backupRegexString = backupPrefix + "_(.+)\\.db"
+//)
+//
+//var backupRegex = regexp.MustCompile(backupRegexString)
+//
+//const backupSuffixLayout = "2006.01.02_15.04.05"
+//
+//func backupPath(t time.Time) string {
+//	return filepath.Join(
+//		conf.Server.Backup.Path,
+//		fmt.Sprintf("%s_%s.db", backupPrefix, t.Format(backupSuffixLayout)),
+//	)
+//}
+//
+//func backupOrRestore(ctx context.Context, isBackup bool, path string) error {
+//	// heavily inspired by https://codingrabbits.dev/posts/go_and_sqlite_backup_and_maybe_restore/
+//	existingConn, err := Db().Conn(ctx)
+//	if err != nil {
+//		return fmt.Errorf("getting existing connection: %w", err)
+//	}
+//	defer existingConn.Close()
+//
+//	backupDb, err := sql.Open(Driver, path)
+//	if err != nil {
+//		return fmt.Errorf("opening backup database in '%s': %w", path, err)
+//	}
+//	defer backupDb.Close()
+//
+//	backupConn, err := backupDb.Conn(ctx)
+//	if err != nil {
+//		return fmt.Errorf("getting backup connection: %w", err)
+//	}
+//	defer backupConn.Close()
+//
+//	err = existingConn.Raw(func(existing any) error {
+//		return backupConn.Raw(func(backup any) error {
+//			var sourceOk, destOk bool
+//			var sourceConn, destConn *sqlite3.SQLiteConn
+//
+//			if isBackup {
+//				sourceConn, sourceOk = existing.(*sqlite3.SQLiteConn)
+//				destConn, destOk = backup.(*sqlite3.SQLiteConn)
+//			} else {
+//				sourceConn, sourceOk = backup.(*sqlite3.SQLiteConn)
+//				destConn, destOk = existing.(*sqlite3.SQLiteConn)
+//			}
+//
+//			if !sourceOk {
+//				return fmt.Errorf("error trying to convert source to sqlite connection")
+//			}
+//			if !destOk {
+//				return fmt.Errorf("error trying to convert destination to sqlite connection")
+//			}
+//
+//			backupOp, err := destConn.Backup("main", sourceConn, "main")
+//			if err != nil {
+//				return fmt.Errorf("error starting sqlite backup: %w", err)
+//			}
+//			defer backupOp.Close()
+//
+//			// Caution: -1 means that sqlite will hold a read lock until the operation finishes
+//			// This will lock out other writes that could happen at the same time
+//			done, err := backupOp.Step(-1)
+//			if !done {
+//				return fmt.Errorf("backup not done with step -1")
+//			}
+//			if err != nil {
+//				return fmt.Errorf("error during backup step: %w", err)
+//			}
+//
+//			err = backupOp.Finish()
+//			if err != nil {
+//				return fmt.Errorf("error finishing backup: %w", err)
+//			}
+//
+//			return nil
+//		})
+//	})
+//
+//	return err
+//}
+//
+//func Backup(ctx context.Context) (string, error) {
+//	destPath := backupPath(time.Now())
+//	log.Debug(ctx, "Creating backup", "path", destPath)
+//	err := backupOrRestore(ctx, true, destPath)
+//	if err != nil {
+//		return "", err
+//	}
+//
+//	return destPath, nil
+//}
+//
+//func Restore(ctx context.Context, path string) error {
+//	log.Debug(ctx, "Restoring backup", "path", path)
+//	return backupOrRestore(ctx, false, path)
+//}
+//
+//func Prune(ctx context.Context) (int, error) {
+//	files, err := os.ReadDir(conf.Server.Backup.Path)
+//	if err != nil {
+//		return 0, fmt.Errorf("unable to read database backup entries: %w", err)
+//	}
+//
+//	var backupTimes []time.Time
+//
+//	for _, file := range files {
+//		if !file.IsDir() {
+//			submatch := backupRegex.FindStringSubmatch(file.Name())
+//			if len(submatch) == 2 {
+//				timestamp, err := time.Parse(backupSuffixLayout, submatch[1])
+//				if err == nil {
+//					backupTimes = append(backupTimes, timestamp)
+//				}
+//			}
+//		}
+//	}
+//
+//	if len(backupTimes) <= conf.Server.Backup.Count {
+//		return 0, nil
+//	}
+//
+//	slices.SortFunc(backupTimes, func(a, b time.Time) int {
+//		return b.Compare(a)
+//	})
+//
+//	pruneCount := 0
+//	var errs []error
+//
+//	for _, timeToPrune := range backupTimes[conf.Server.Backup.Count:] {
+//		log.Debug(ctx, "Pruning backup", "time", timeToPrune)
+//		path := backupPath(timeToPrune)
+//		err = os.Remove(path)
+//		if err != nil {
+//			errs = append(errs, err)
+//		} else {
+//			pruneCount++
+//		}
+//	}
+//
+//	if len(errs) > 0 {
+//		err = errors.Join(errs...)
+//		log.Error(ctx, "Failed to delete one or more files", "errors", err)
+//	}
+//
+//	return pruneCount, err
+//}

db/db.go

@@ -5,20 +5,22 @@ import (
 	"database/sql"
 	"embed"
 	"fmt"
-	"runtime"
+	"path/filepath"
+	"strings"
+	"time"
 
-	"github.com/mattn/go-sqlite3"
+	embeddedpostgres "github.com/fergusstrange/embedded-postgres"
+	_ "github.com/jackc/pgx/v5/stdlib"
 	"github.com/navidrome/navidrome/conf"
 	_ "github.com/navidrome/navidrome/db/migrations"
 	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/utils/hasher"
 	"github.com/navidrome/navidrome/utils/singleton"
 	"github.com/pressly/goose/v3"
 )
 
 var (
-	Dialect = "sqlite3"
-	Driver  = Dialect + "_custom"
+	Dialect = "postgres"
+	Driver  = "pgx"
 	Path    string
 )
 
@@ -27,29 +29,77 @@ var embedMigrations embed.FS
 
 const migrationsFolder = "migrations"
 
+var postgresInstance *embeddedpostgres.EmbeddedPostgres
+
 func Db() *sql.DB {
 	return singleton.GetInstance(func() *sql.DB {
-		sql.Register(Driver, &sqlite3.SQLiteDriver{
-			ConnectHook: func(conn *sqlite3.SQLiteConn) error {
-				return conn.RegisterFunc("SEEDEDRAND", hasher.HashFunc(), false)
-			},
-		})
-		Path = conf.Server.DbPath
-		if Path == ":memory:" {
-			Path = "file::memory:?cache=shared&_foreign_keys=on"
-			conf.Server.DbPath = Path
+		start := time.Now()
+		log.Info("Starting Embedded Postgres...")
+		postgresInstance = embeddedpostgres.NewDatabase(
+			embeddedpostgres.
+				DefaultConfig().
+				Port(5432).
+				//Password(password).
+				Logger(&logAdapter{ctx: context.Background()}).
+				DataPath(filepath.Join(conf.Server.DataFolder, "postgres")).
+				StartParameters(map[string]string{
+					"unix_socket_directories": "/tmp",
+					"unix_socket_permissions": "0700",
+				}).
+				BinariesPath(filepath.Join(conf.Server.CacheFolder, "postgres")),
+		)
+		if err := postgresInstance.Start(); err != nil {
+			if !strings.Contains(err.Error(), "already listening on port") {
+				_ = postgresInstance.Stop()
+				log.Fatal("Failed to start embedded Postgres", err)
+			}
+			log.Info("Server already running on port 5432, assuming it's our embedded Postgres", "elapsed", time.Since(start))
+		} else {
+			log.Info("Embedded Postgres started", "elapsed", time.Since(start))
 		}
+
+		// Create the navidrome database if it doesn't exist
+		adminPath := "postgresql://postgres:postgres@/postgres?sslmode=disable&host=/tmp"
+		adminDB, err := sql.Open(Driver, adminPath)
+		if err != nil {
+			_ = postgresInstance.Stop()
+			log.Fatal("Error connecting to admin database", err)
+		}
+		defer adminDB.Close()
+
+		// Check if navidrome database exists, create if not
+		var exists bool
+		err = adminDB.QueryRow("SELECT EXISTS(SELECT 1 FROM pg_database WHERE datname = 'navidrome')").Scan(&exists)
+		if err != nil {
+			_ = postgresInstance.Stop()
+			log.Fatal("Error checking if database exists", err)
+		}
+		if !exists {
+			log.Info("Creating navidrome database...")
+			_, err = adminDB.Exec("CREATE DATABASE navidrome")
+			if err != nil {
+				_ = postgresInstance.Stop()
+				log.Fatal("Error creating navidrome database", err)
+			}
+		}
+
+		// TODO: Implement seeded random function
+		//sql.Register(Driver, &sqlite3.SQLiteDriver{
+		//	ConnectHook: func(conn *sqlite3.SQLiteConn) error {
+		//		return conn.RegisterFunc("SEEDEDRAND", hasher.HashFunc(), false)
+		//	},
+		//})
+		//Path = conf.Server.DbPath
+		// Ensure client does not attempt TLS when connecting to the embedded Postgres
+		// and avoid shadowing the package-level Path variable.
+		Path = "postgresql://postgres:postgres@/navidrome?sslmode=disable&host=/tmp"
 		log.Debug("Opening DataBase", "dbPath", Path, "driver", Driver)
 		db, err := sql.Open(Driver, Path)
-		db.SetMaxOpenConns(max(4, runtime.NumCPU()))
+		//db.SetMaxOpenConns(max(4, runtime.NumCPU()))
 		if err != nil {
+			_ = postgresInstance.Stop()
 			log.Fatal("Error opening database", err)
 		}
-		_, err = db.Exec("PRAGMA optimize=0x10002")
-		if err != nil {
-			log.Error("Error applying PRAGMA optimize", err)
-			return nil
-		}
 		return db
 	})
 }
@@ -58,33 +108,24 @@ func Close(ctx context.Context) {
 	// Ignore cancellations when closing the DB
 	ctx = context.WithoutCancel(ctx)
 
-	// Run optimize before closing
-	Optimize(ctx)
-
 	log.Info(ctx, "Closing Database")
 	err := Db().Close()
 	if err != nil {
 		log.Error(ctx, "Error closing Database", err)
 	}
+	if postgresInstance != nil {
+		err = postgresInstance.Stop()
+		if err != nil {
+			log.Error(ctx, "Error stopping embedded Postgres", err)
+		}
+	}
 }
 
 func Init(ctx context.Context) func() {
 	db := Db()
 
-	// Disable foreign_keys to allow re-creating tables in migrations
-	_, err := db.ExecContext(ctx, "PRAGMA foreign_keys=off")
-	defer func() {
-		_, err := db.ExecContext(ctx, "PRAGMA foreign_keys=on")
-		if err != nil {
-			log.Error(ctx, "Error re-enabling foreign_keys", err)
-		}
-	}()
-	if err != nil {
-		log.Error(ctx, "Error disabling foreign_keys", err)
-	}
-
 	goose.SetBaseFS(embedMigrations)
-	err = goose.SetDialect(Dialect)
+	err := goose.SetDialect(Dialect)
 	if err != nil {
 		log.Fatal(ctx, "Invalid DB driver", "driver", Driver, err)
 	}
@@ -99,51 +140,17 @@ func Init(ctx context.Context) func() {
 		log.Fatal(ctx, "Failed to apply new migrations", err)
 	}
 
-	if hasSchemaChanges {
-		log.Debug(ctx, "Applying PRAGMA optimize after schema changes")
-		_, err = db.ExecContext(ctx, "PRAGMA optimize")
-		if err != nil {
-			log.Error(ctx, "Error applying PRAGMA optimize", err)
-		}
-	}
-
 	return func() {
 		Close(ctx)
 	}
 }
 
-// Optimize runs PRAGMA optimize on each connection in the pool
-func Optimize(ctx context.Context) {
-	numConns := Db().Stats().OpenConnections
-	if numConns == 0 {
-		log.Debug(ctx, "No open connections to optimize")
-		return
-	}
-	log.Debug(ctx, "Optimizing open connections", "numConns", numConns)
-	var conns []*sql.Conn
-	for i := 0; i < numConns; i++ {
-		conn, err := Db().Conn(ctx)
-		conns = append(conns, conn)
-		if err != nil {
-			log.Error(ctx, "Error getting connection from pool", err)
-			continue
-		}
-		_, err = conn.ExecContext(ctx, "PRAGMA optimize;")
-		if err != nil {
-			log.Error(ctx, "Error running PRAGMA optimize", err)
-		}
-	}
-
-	// Return all connections to the Connection Pool
-	for _, conn := range conns {
-		conn.Close()
-	}
-}
-
 type statusLogger struct{ numPending int }
 
 func (*statusLogger) Fatalf(format string, v ...interface{}) { log.Fatal(fmt.Sprintf(format, v...)) }
 func (l *statusLogger) Printf(format string, v ...interface{}) {
+	// format is part of the goose logger signature; reference it to avoid linter warnings
+	_ = format
 	if len(v) < 1 {
 		return
 	}
@@ -165,11 +172,15 @@ func hasPendingMigrations(ctx context.Context, db *sql.DB, folder string) bool {
 }
 
 func isSchemaEmpty(ctx context.Context, db *sql.DB) bool {
-	rows, err := db.QueryContext(ctx, "SELECT name FROM sqlite_master WHERE type='table' AND name='goose_db_version';") // nolint:rowserrcheck
+	rows, err := db.QueryContext(ctx, "SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename = 'goose_db_version';") // nolint:rowserrcheck
 	if err != nil {
 		log.Fatal(ctx, "Database could not be opened!", err)
 	}
-	defer rows.Close()
+	defer func() {
+		if cerr := rows.Close(); cerr != nil {
+			log.Error(ctx, "Error closing rows", cerr)
+		}
+	}()
 	return !rows.Next()
 }
 
@@ -178,6 +189,11 @@ type logAdapter struct {
 	silent bool
 }
 
+func (l *logAdapter) Write(p []byte) (n int, err error) {
+	log.Debug(l.ctx, string(p))
+	return len(p), nil
+}
+
 func (l *logAdapter) Fatal(v ...interface{}) {
 	log.Fatal(l.ctx, fmt.Sprint(v...))
 }

db/migrations/20200130083147_create_schema.go

@@ -1,184 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/navidrome/navidrome/log"
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200130083147, Down20200130083147)
-}
-
-func Up20200130083147(_ context.Context, tx *sql.Tx) error {
-	log.Info("Creating DB Schema")
-	_, err := tx.Exec(`
-create table if not exists album
-(
-	id varchar(255) not null
-		primary key,
-	name varchar(255) default '' not null,
-	artist_id varchar(255) default '' not null,
-	cover_art_path varchar(255) default '' not null,
-	cover_art_id varchar(255) default '' not null,
-	artist varchar(255) default '' not null,
-	album_artist varchar(255) default '' not null,
-	year integer default 0 not null,
-	compilation bool default FALSE not null,
-	song_count integer default 0 not null,
-	duration integer default 0 not null,
-	genre varchar(255) default '' not null,
-	created_at datetime,
-	updated_at datetime
-);
-
-create index if not exists album_artist
-	on album (artist);
-
-create index if not exists album_artist_id
-	on album (artist_id);
-
-create index if not exists album_genre
-	on album (genre);
-
-create index if not exists album_name
-	on album (name);
-
-create index if not exists album_year
-	on album (year);
-
-create table if not exists annotation
-(
-	ann_id varchar(255) not null
-		primary key,
-	user_id varchar(255) default '' not null,
-	item_id varchar(255) default '' not null,
-	item_type varchar(255) default '' not null,
-	play_count integer,
-	play_date datetime,
-	rating integer,
-	starred bool default FALSE not null,
-	starred_at datetime,
-	unique (user_id, item_id, item_type)
-);
-
-create index if not exists annotation_play_count
-	on annotation (play_count);
-
-create index if not exists annotation_play_date
-	on annotation (play_date);
-
-create index if not exists annotation_rating
-	on annotation (rating);
-
-create index if not exists annotation_starred
-	on annotation (starred);
-
-create table if not exists artist
-(
-	id varchar(255) not null
-		primary key,
-	name varchar(255) default '' not null,
-	album_count integer default 0 not null
-);
-
-create index if not exists artist_name
-	on artist (name);
-
-create table if not exists media_file
-(
-	id varchar(255) not null
-		primary key,
-	path varchar(255) default '' not null,
-	title varchar(255) default '' not null,
-	album varchar(255) default '' not null,
-	artist varchar(255) default '' not null,
-	artist_id varchar(255) default '' not null,
-	album_artist varchar(255) default '' not null,
-	album_id varchar(255) default '' not null,
-	has_cover_art bool default FALSE not null,
-	track_number integer default 0 not null,
-	disc_number integer default 0 not null,
-	year integer default 0 not null,
-	size integer default 0 not null,
-	suffix varchar(255) default '' not null,
-	duration integer default 0 not null,
-	bit_rate integer default 0 not null,
-	genre varchar(255) default '' not null,
-	compilation bool default FALSE not null,
-	created_at datetime,
-	updated_at datetime
-);
-
-create index if not exists media_file_album_id
-	on media_file (album_id);
-
-create index if not exists media_file_genre
-	on media_file (genre);
-
-create index if not exists media_file_path
-	on media_file (path);
-
-create index if not exists media_file_title
-	on media_file (title);
-
-create table if not exists playlist
-(
-	id varchar(255) not null
-		primary key,
-	name varchar(255) default '' not null,
-	comment varchar(255) default '' not null,
-	duration integer default 0 not null,
-	owner varchar(255) default '' not null,
-	public bool default FALSE not null,
-	tracks text not null
-);
-
-create index if not exists playlist_name
-	on playlist (name);
-
-create table if not exists property
-(
-	id varchar(255) not null
-		primary key,
-	value varchar(255) default '' not null
-);
-
-create table if not exists search
-(
-	id varchar(255) not null
-		primary key,
-	"table" varchar(255) default '' not null,
-	full_text varchar(255) default '' not null
-);
-
-create index if not exists search_full_text
-	on search (full_text);
-
-create index if not exists search_table
-	on search ("table");
-
-create table if not exists user
-(
-	id varchar(255) not null
-		primary key,
-	user_name varchar(255) default '' not null
-		unique,
-	name varchar(255) default '' not null,
-	email varchar(255) default '' not null
-		unique,
-	password varchar(255) default '' not null,
-	is_admin bool default FALSE not null,
-	last_login_at datetime,
-	last_access_at datetime,
-	created_at datetime not null,
-	updated_at datetime not null
-);`)
-	return err
-}
-
-func Down20200130083147(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200131183653_standardize_item_type.go

@@ -1,64 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200131183653, Down20200131183653)
-}
-
-func Up20200131183653(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-create table search_dg_tmp
-(
-	id varchar(255) not null
-		primary key,
-	item_type varchar(255) default '' not null,
-	full_text varchar(255) default '' not null
-);
-
-insert into search_dg_tmp(id, item_type, full_text) select id, "table", full_text from search;
-
-drop table search;
-
-alter table search_dg_tmp rename to search;
-
-create index search_full_text
-	on search (full_text);
-create index search_table
-	on search (item_type);
-
-update annotation set item_type = 'media_file' where item_type = 'mediaFile';
-`)
-	return err
-}
-
-func Down20200131183653(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-create table search_dg_tmp
-(
-	id varchar(255) not null
-		primary key,
-	"table" varchar(255) default '' not null,
-	full_text varchar(255) default '' not null
-);
-
-insert into search_dg_tmp(id, "table", full_text) select id, item_type, full_text from search;
-
-drop table search;
-
-alter table search_dg_tmp rename to search;
-
-create index search_full_text
-	on search (full_text);
-create index search_table
-	on search ("table");
-
-update annotation set item_type = 'mediaFile' where item_type = 'media_file';
-`)
-	return err
-}

db/migrations/20200208222418_add_defaults_to_annotations.go

@@ -1,56 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200208222418, Down20200208222418)
-}
-
-func Up20200208222418(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-update annotation set play_count = 0 where play_count is null;
-update annotation set rating = 0 where rating is null;
-create table annotation_dg_tmp
-(
-	ann_id varchar(255) not null
-		primary key,
-	user_id varchar(255) default '' not null,
-	item_id varchar(255) default '' not null,
-	item_type varchar(255) default '' not null,
-	play_count integer default 0,
-	play_date datetime,
-	rating integer default 0,
-	starred bool default FALSE not null,
-	starred_at datetime,
-	unique (user_id, item_id, item_type)
-);
-
-insert into annotation_dg_tmp(ann_id, user_id, item_id, item_type, play_count, play_date, rating, starred, starred_at) select ann_id, user_id, item_id, item_type, play_count, play_date, rating, starred, starred_at from annotation;
-
-drop table annotation;
-
-alter table annotation_dg_tmp rename to annotation;
-
-create index annotation_play_count
-	on annotation (play_count);
-
-create index annotation_play_date
-	on annotation (play_date);
-
-create index annotation_rating
-	on annotation (rating);
-
-create index annotation_starred
-	on annotation (starred);
-`)
-	return err
-}
-
-func Down20200208222418(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200220143731_change_duration_to_float.go

@@ -1,130 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200220143731, Down20200220143731)
-}
-
-func Up20200220143731(_ context.Context, tx *sql.Tx) error {
-	notice(tx, "This migration will force the next scan to be a full rescan!")
-	_, err := tx.Exec(`
-create table media_file_dg_tmp
-(
-	id varchar(255) not null
-		primary key,
-	path varchar(255) default '' not null,
-	title varchar(255) default '' not null,
-	album varchar(255) default '' not null,
-	artist varchar(255) default '' not null,
-	artist_id varchar(255) default '' not null,
-	album_artist varchar(255) default '' not null,
-	album_id varchar(255) default '' not null,
-	has_cover_art bool default FALSE not null,
-	track_number integer default 0 not null,
-	disc_number integer default 0 not null,
-	year integer default 0 not null,
-	size integer default 0 not null,
-	suffix varchar(255) default '' not null,
-	duration real default 0 not null,
-	bit_rate integer default 0 not null,
-	genre varchar(255) default '' not null,
-	compilation bool default FALSE not null,
-	created_at datetime,
-	updated_at datetime
-);
-
-insert into media_file_dg_tmp(id, path, title, album, artist, artist_id, album_artist, album_id, has_cover_art, track_number, disc_number, year, size, suffix, duration, bit_rate, genre, compilation, created_at, updated_at) select id, path, title, album, artist, artist_id, album_artist, album_id, has_cover_art, track_number, disc_number, year, size, suffix, duration, bit_rate, genre, compilation, created_at, updated_at from media_file;
-
-drop table media_file;
-
-alter table media_file_dg_tmp rename to media_file;
-
-create index media_file_album_id
-	on media_file (album_id);
-
-create index media_file_genre
-	on media_file (genre);
-
-create index media_file_path
-	on media_file (path);
-
-create index media_file_title
-	on media_file (title);
-
-create table album_dg_tmp
-(
-	id varchar(255) not null
-		primary key,
-	name varchar(255) default '' not null,
-	artist_id varchar(255) default '' not null,
-	cover_art_path varchar(255) default '' not null,
-	cover_art_id varchar(255) default '' not null,
-	artist varchar(255) default '' not null,
-	album_artist varchar(255) default '' not null,
-	year integer default 0 not null,
-	compilation bool default FALSE not null,
-	song_count integer default 0 not null,
-	duration real default 0 not null,
-	genre varchar(255) default '' not null,
-	created_at datetime,
-	updated_at datetime
-);
-
-insert into album_dg_tmp(id, name, artist_id, cover_art_path, cover_art_id, artist, album_artist, year, compilation, song_count, duration, genre, created_at, updated_at) select id, name, artist_id, cover_art_path, cover_art_id, artist, album_artist, year, compilation, song_count, duration, genre, created_at, updated_at from album;
-
-drop table album;
-
-alter table album_dg_tmp rename to album;
-
-create index album_artist
-	on album (artist);
-
-create index album_artist_id
-	on album (artist_id);
-
-create index album_genre
-	on album (genre);
-
-create index album_name
-	on album (name);
-
-create index album_year
-	on album (year);
-
-create table playlist_dg_tmp
-(
-	id varchar(255) not null
-		primary key,
-	name varchar(255) default '' not null,
-	comment varchar(255) default '' not null,
-	duration real default 0 not null,
-	owner varchar(255) default '' not null,
-	public bool default FALSE not null,
-	tracks text not null
-);
-
-insert into playlist_dg_tmp(id, name, comment, duration, owner, public, tracks) select id, name, comment, duration, owner, public, tracks from playlist;
-
-drop table playlist;
-
-alter table playlist_dg_tmp rename to playlist;
-
-create index playlist_name
-	on playlist (name);
-
--- Force a full rescan
-delete from property where id like 'LastScan%';
-update media_file set updated_at = '0001-01-01';
-`)
-	return err
-}
-
-func Down20200220143731(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200310171621_enable_search_by_albumartist.go

@@ -1,21 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200310171621, Down20200310171621)
-}
-
-func Up20200310171621(_ context.Context, tx *sql.Tx) error {
-	notice(tx, "A full rescan will be performed to enable search by Album Artist!")
-	return forceFullRescan(tx)
-}
-
-func Down20200310171621(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200310181627_add_transcoding_and_player_tables.go

@@ -1,54 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200310181627, Down20200310181627)
-}
-
-func Up20200310181627(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-create table transcoding
-(
-	id varchar(255) not null primary key,
-	name varchar(255) not null,
-	target_format varchar(255) not null,
-	command varchar(255) default '' not null,
-	default_bit_rate int default 192,
-	unique (name),
-	unique (target_format)
-);
-
-create table player 
-(
-	id varchar(255) not null primary key,
-    name varchar not null,
-    type varchar,
-    user_name varchar not null, 
-    client varchar not null, 
-    ip_address varchar,
-    last_seen timestamp,
-    max_bit_rate int default 0,
-    transcoding_id varchar,
-	unique (name),
-	foreign key (transcoding_id)
-	   references transcoding(id)
-		  on update restrict 
-		  on delete restrict
-);
-`)
-	return err
-}
-
-func Down20200310181627(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-drop table transcoding;
-drop table player;
-`)
-	return err
-}

db/migrations/20200319211049_merge_search_into_main_tables.go

@@ -1,42 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200319211049, Down20200319211049)
-}
-
-func Up20200319211049(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-alter table media_file
-	add full_text varchar(255) default '';
-create index if not exists media_file_full_text
-	on media_file (full_text);
-
-alter table album
-	add full_text varchar(255) default '';
-create index if not exists album_full_text
-	on album (full_text);
-
-alter table artist
-	add full_text varchar(255) default '';
-create index if not exists artist_full_text
-	on artist (full_text);
-
-drop table if exists search;
-`)
-	if err != nil {
-		return err
-	}
-	notice(tx, "A full rescan will be performed!")
-	return forceFullRescan(tx)
-}
-
-func Down20200319211049(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200325185135_add_album_artist_id.go

@@ -1,35 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200325185135, Down20200325185135)
-}
-
-func Up20200325185135(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-alter table album
-	add album_artist_id varchar(255) default '';
-create index album_artist_album_id
-	on album (album_artist_id);
-
-alter table media_file
-	add album_artist_id varchar(255) default '';
-create index media_file_artist_album_id
-	on media_file (album_artist_id);
-`)
-	if err != nil {
-		return err
-	}
-	notice(tx, "A full rescan will be performed!")
-	return forceFullRescan(tx)
-}
-
-func Down20200325185135(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200326090707_fix_album_artists_importing.go

@@ -1,21 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200326090707, Down20200326090707)
-}
-
-func Up20200326090707(_ context.Context, tx *sql.Tx) error {
-	notice(tx, "A full rescan will be performed!")
-	return forceFullRescan(tx)
-}
-
-func Down20200326090707(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200327193744_add_year_range_to_album.go

@@ -1,81 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200327193744, Down20200327193744)
-}
-
-func Up20200327193744(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-create table album_dg_tmp
-(
-	id varchar(255) not null
-		primary key,
-	name varchar(255) default '' not null,
-	artist_id varchar(255) default '' not null,
-	cover_art_path varchar(255) default '' not null,
-	cover_art_id varchar(255) default '' not null,
-	artist varchar(255) default '' not null,
-	album_artist varchar(255) default '' not null,
-    min_year int default 0 not null,
-	max_year integer default 0 not null,
-	compilation bool default FALSE not null,
-	song_count integer default 0 not null,
-	duration real default 0 not null,
-	genre varchar(255) default '' not null,
-	created_at datetime,
-	updated_at datetime,
-	full_text varchar(255) default '',
-	album_artist_id varchar(255) default ''
-);
-
-insert into album_dg_tmp(id, name, artist_id, cover_art_path, cover_art_id, artist, album_artist, max_year, compilation, song_count, duration, genre, created_at, updated_at, full_text, album_artist_id) select id, name, artist_id, cover_art_path, cover_art_id, artist, album_artist, year, compilation, song_count, duration, genre, created_at, updated_at, full_text, album_artist_id from album;
-
-drop table album;
-
-alter table album_dg_tmp rename to album;
-
-create index album_artist
-	on album (artist);
-
-create index album_artist_album
-	on album (artist);
-
-create index album_artist_album_id
-	on album (album_artist_id);
-
-create index album_artist_id
-	on album (artist_id);
-
-create index album_full_text
-	on album (full_text);
-
-create index album_genre
-	on album (genre);
-
-create index album_name
-	on album (name);
-
-create index album_min_year
-	on album (min_year);
-
-create index album_max_year
-	on album (max_year);
-
-`)
-	if err != nil {
-		return err
-	}
-	notice(tx, "A full rescan will be performed!")
-	return forceFullRescan(tx)
-}
-
-func Down20200327193744(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200404214704_add_indexes.go

@@ -1,30 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200404214704, Down20200404214704)
-}
-
-func Up20200404214704(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-create index if not exists media_file_year
-	on media_file (year);
-
-create index if not exists media_file_duration
-	on media_file (duration);
-
-create index if not exists media_file_track_number
-	on media_file (disc_number, track_number);
-`)
-	return err
-}
-
-func Down20200404214704(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200409002249_enable_search_by_tracks_artists.go

@@ -1,21 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200409002249, Down20200409002249)
-}
-
-func Up20200409002249(_ context.Context, tx *sql.Tx) error {
-	notice(tx, "A full rescan will be performed to enable search by individual Artist in an Album!")
-	return forceFullRescan(tx)
-}
-
-func Down20200409002249(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200411164603_add_created_and_updated_fields_to_playlists.go

@@ -1,28 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200411164603, Down20200411164603)
-}
-
-func Up20200411164603(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-alter table playlist
-	add created_at datetime;
-alter table playlist
-	add updated_at datetime;
-update playlist 
-	set created_at = datetime('now'), updated_at = datetime('now');
-`)
-	return err
-}
-
-func Down20200411164603(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200418110522_reindex_to_fix_album_years.go

@@ -1,21 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200418110522, Down20200418110522)
-}
-
-func Up20200418110522(_ context.Context, tx *sql.Tx) error {
-	notice(tx, "A full rescan will be performed to fix search Albums by year")
-	return forceFullRescan(tx)
-}
-
-func Down20200418110522(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200419222708_reindex_to_change_full_text_search.go

@@ -1,21 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200419222708, Down20200419222708)
-}
-
-func Up20200419222708(_ context.Context, tx *sql.Tx) error {
-	notice(tx, "A full rescan will be performed to change the search behaviour")
-	return forceFullRescan(tx)
-}
-
-func Down20200419222708(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200423204116_add_sort_fields.go

@@ -1,66 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200423204116, Down20200423204116)
-}
-
-func Up20200423204116(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-alter table artist
-	add order_artist_name varchar(255) collate nocase;
-alter table artist
-	add sort_artist_name varchar(255) collate nocase;
-create index if not exists artist_order_artist_name
-	on artist (order_artist_name);
-
-alter table album
-	add order_album_name varchar(255) collate nocase;
-alter table album
-	add order_album_artist_name varchar(255) collate nocase;
-alter table album
-	add sort_album_name varchar(255) collate nocase;
-alter table album
-	add sort_artist_name varchar(255) collate nocase;
-alter table album
-	add sort_album_artist_name varchar(255) collate nocase;
-create index if not exists album_order_album_name
-	on album (order_album_name);
-create index if not exists album_order_album_artist_name
-	on album (order_album_artist_name);
-
-alter table media_file
-	add order_album_name varchar(255) collate nocase;
-alter table media_file
-	add order_album_artist_name varchar(255) collate nocase;
-alter table media_file
-	add order_artist_name varchar(255) collate nocase;
-alter table media_file
-	add sort_album_name varchar(255) collate nocase;
-alter table media_file
-	add sort_artist_name varchar(255) collate nocase;
-alter table media_file
-	add sort_album_artist_name varchar(255) collate nocase;
-alter table media_file
-	add sort_title varchar(255) collate nocase;
-create index if not exists media_file_order_album_name
-	on media_file (order_album_name);
-create index if not exists media_file_order_artist_name
-	on media_file (order_artist_name);
-`)
-	if err != nil {
-		return err
-	}
-	notice(tx, "A full rescan will be performed to change the search behaviour")
-	return forceFullRescan(tx)
-}
-
-func Down20200423204116(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200508093059_add_artist_song_count.go

@@ -1,28 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200508093059, Down20200508093059)
-}
-
-func Up20200508093059(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-alter table artist
-	add song_count integer default 0 not null;
-`)
-	if err != nil {
-		return err
-	}
-	notice(tx, "A full rescan will be performed to calculate artists' song counts")
-	return forceFullRescan(tx)
-}
-
-func Down20200508093059(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200512104202_add_disc_subtitle.go

@@ -1,28 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200512104202, Down20200512104202)
-}
-
-func Up20200512104202(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-alter table media_file 
-    add disc_subtitle varchar(255);
-    `)
-	if err != nil {
-		return err
-	}
-	notice(tx, "A full rescan will be performed to import disc subtitles")
-	return forceFullRescan(tx)
-}
-
-func Down20200512104202(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200516140647_add_playlist_tracks_table.go

@@ -1,101 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-	"strings"
-
-	"github.com/navidrome/navidrome/log"
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200516140647, Down20200516140647)
-}
-
-func Up20200516140647(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-create table if not exists playlist_tracks
-(
-	id integer default 0 not null, 
-    playlist_id varchar(255) not null, 
-	media_file_id varchar(255) not null
-);
-
-create unique index if not exists playlist_tracks_pos
-	on playlist_tracks (playlist_id, id);
-`)
-	if err != nil {
-		return err
-	}
-	rows, err := tx.Query("select id, tracks from playlist")
-	if err != nil {
-		return err
-	}
-	defer rows.Close()
-	var id, tracks string
-	for rows.Next() {
-		err := rows.Scan(&id, &tracks)
-		if err != nil {
-			return err
-		}
-		err = Up20200516140647UpdatePlaylistTracks(tx, id, tracks)
-		if err != nil {
-			return err
-		}
-	}
-	err = rows.Err()
-	if err != nil {
-		return err
-	}
-
-	_, err = tx.Exec(`
-create table playlist_dg_tmp
-(
-	id varchar(255) not null
-		primary key,
-	name varchar(255) default '' not null,
-	comment varchar(255) default '' not null,
-	duration real default 0 not null,
-	song_count integer default 0 not null,
-	owner varchar(255) default '' not null,
-	public bool default FALSE not null,
-	created_at datetime,
-	updated_at datetime
-);
-
-insert into playlist_dg_tmp(id, name, comment, duration, owner, public, created_at, updated_at) 
-	select id, name, comment, duration, owner, public, created_at, updated_at from playlist;
-
-drop table playlist;
-
-alter table playlist_dg_tmp rename to playlist;
-
-create index playlist_name
-	on playlist (name);
-
-update playlist set song_count = (select count(*) from playlist_tracks where playlist_id = playlist.id)
-where id <> ''
-
-`)
-	return err
-}
-
-func Up20200516140647UpdatePlaylistTracks(tx *sql.Tx, id string, tracks string) error {
-	trackList := strings.Split(tracks, ",")
-	stmt, err := tx.Prepare("insert into playlist_tracks (playlist_id, media_file_id, id) values (?, ?, ?)")
-	if err != nil {
-		return err
-	}
-	for i, trackId := range trackList {
-		_, err := stmt.Exec(id, trackId, i+1)
-		if err != nil {
-			log.Error("Error adding track to playlist", "playlistId", id, "trackId", trackId, err)
-		}
-	}
-	return nil
-}
-
-func Down20200516140647(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200608153717_referential_integrity.go

@@ -1,138 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(Up20200608153717, Down20200608153717)
-}
-
-func Up20200608153717(_ context.Context, tx *sql.Tx) error {
-	// First delete dangling players
-	_, err := tx.Exec(`
-delete from player where user_name not in (select user_name from user)`)
-	if err != nil {
-		return err
-	}
-
-	// Also delete dangling players
-	_, err = tx.Exec(`
-delete from playlist where owner not in (select user_name from user)`)
-	if err != nil {
-		return err
-	}
-
-	// Also delete dangling playlist tracks
-	_, err = tx.Exec(`
-delete from playlist_tracks where playlist_id not in (select id from playlist)`)
-	if err != nil {
-		return err
-	}
-
-	// Add foreign key to player table
-	err = updatePlayer_20200608153717(tx)
-	if err != nil {
-		return err
-	}
-
-	// Add foreign key to playlist table
-	err = updatePlaylist_20200608153717(tx)
-	if err != nil {
-		return err
-	}
-
-	// Add foreign keys to playlist_tracks table
-	return updatePlaylistTracks_20200608153717(tx)
-}
-
-func updatePlayer_20200608153717(tx *sql.Tx) error {
-	_, err := tx.Exec(`
-create table player_dg_tmp
-(
-	id varchar(255) not null
-		primary key,
-	name varchar not null
-		unique,
-	type varchar,
-	user_name varchar not null
-		references user (user_name)
-			on update cascade on delete cascade,
-	client varchar not null,
-	ip_address varchar,
-	last_seen timestamp,
-	max_bit_rate int default 0,
-	transcoding_id varchar null
-);
-
-insert into player_dg_tmp(id, name, type, user_name, client, ip_address, last_seen, max_bit_rate, transcoding_id) select id, name, type, user_name, client, ip_address, last_seen, max_bit_rate, transcoding_id from player;
-
-drop table player;
-
-alter table player_dg_tmp rename to player;
-`)
-	return err
-}
-
-func updatePlaylist_20200608153717(tx *sql.Tx) error {
-	_, err := tx.Exec(`
-create table playlist_dg_tmp
-(
-	id varchar(255) not null
-		primary key,
-	name varchar(255) default '' not null,
-	comment varchar(255) default '' not null,
-	duration real default 0 not null,
-	song_count integer default 0 not null,
-	owner varchar(255) default '' not null
-		constraint playlist_user_user_name_fk
-			references user (user_name)
-				on update cascade on delete cascade,
-	public bool default FALSE not null,
-	created_at datetime,
-	updated_at datetime
-);
-
-insert into playlist_dg_tmp(id, name, comment, duration, song_count, owner, public, created_at, updated_at) select id, name, comment, duration, song_count, owner, public, created_at, updated_at from playlist;
-
-drop table playlist;
-
-alter table playlist_dg_tmp rename to playlist;
-
-create index playlist_name
-	on playlist (name);
-`)
-	return err
-}
-
-func updatePlaylistTracks_20200608153717(tx *sql.Tx) error {
-	_, err := tx.Exec(`
-create table playlist_tracks_dg_tmp
-(
-	id integer default 0 not null,
-	playlist_id varchar(255) not null
-		constraint playlist_tracks_playlist_id_fk
-			references playlist
-				on update cascade on delete cascade,
-	media_file_id varchar(255) not null
-);
-
-insert into playlist_tracks_dg_tmp(id, playlist_id, media_file_id) select id, playlist_id, media_file_id from playlist_tracks;
-
-drop table playlist_tracks;
-
-alter table playlist_tracks_dg_tmp rename to playlist_tracks;
-
-create unique index playlist_tracks_pos
-	on playlist_tracks (playlist_id, id);
-
-`)
-	return err
-}
-
-func Down20200608153717(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200706231659_add_default_transcodings.go

@@ -1,43 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/navidrome/navidrome/consts"
-	"github.com/navidrome/navidrome/model/id"
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(upAddDefaultTranscodings, downAddDefaultTranscodings)
-}
-
-func upAddDefaultTranscodings(_ context.Context, tx *sql.Tx) error {
-	row := tx.QueryRow("SELECT COUNT(*) FROM transcoding")
-	var count int
-	err := row.Scan(&count)
-	if err != nil {
-		return err
-	}
-	if count > 0 {
-		return nil
-	}
-
-	stmt, err := tx.Prepare("insert into transcoding (id, name, target_format, default_bit_rate, command) values (?, ?, ?, ?, ?)")
-	if err != nil {
-		return err
-	}
-
-	for _, t := range consts.DefaultTranscodings {
-		_, err := stmt.Exec(id.NewRandom(), t.Name, t.TargetFormat, t.DefaultBitRate, t.Command)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func downAddDefaultTranscodings(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200710211442_add_playlist_path.go

@@ -1,28 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(upAddPlaylistPath, downAddPlaylistPath)
-}
-
-func upAddPlaylistPath(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-alter table playlist
-	add path string default '' not null;
-
-alter table playlist
-	add sync bool default false not null;
-`)
-
-	return err
-}
-
-func downAddPlaylistPath(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200731095603_create_play_queues_table.go

@@ -1,37 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(upCreatePlayQueuesTable, downCreatePlayQueuesTable)
-}
-
-func upCreatePlayQueuesTable(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-create table playqueue
-(
-    id         varchar(255) not null primary key,
-    user_id    varchar(255) not null
-            references user (id)
-            on update cascade on delete cascade,
-	comment    varchar(255),
-    current    varchar(255) not null,
-    position   integer,
-    changed_by varchar(255),
-    items      varchar(255),
-    created_at datetime,
-    updated_at datetime
-);
-`)
-
-	return err
-}
-
-func downCreatePlayQueuesTable(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200801101355_create_bookmark_table.go

@@ -1,54 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(upCreateBookmarkTable, downCreateBookmarkTable)
-}
-
-func upCreateBookmarkTable(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-create table bookmark
-(
-    user_id    varchar(255) not null
-        references user
-            on update cascade on delete cascade,
-    item_id    varchar(255) not null,
-    item_type  varchar(255) not null,
-    comment    varchar(255),
-    position   integer,
-    changed_by varchar(255),
-    created_at datetime,
-    updated_at datetime,
-    constraint bookmark_pk
-        unique (user_id, item_id, item_type)
-);
-
-create table playqueue_dg_tmp
-(
-	id varchar(255) not null,
-	user_id varchar(255) not null
-		references user
-			on update cascade on delete cascade,
-	current varchar(255),
-	position real,
-	changed_by varchar(255),
-	items varchar(255),
-	created_at datetime,
-	updated_at datetime
-);
-drop table playqueue;
-alter table playqueue_dg_tmp rename to playqueue;
-`)
-
-	return err
-}
-
-func downCreateBookmarkTable(_ context.Context, tx *sql.Tx) error {
-	return nil
-}

db/migrations/20200819111809_drop_email_unique_constraint.go

@@ -1,43 +0,0 @@
-package migrations
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/pressly/goose/v3"
-)
-
-func init() {
-	goose.AddMigrationContext(upDropEmailUniqueConstraint, downDropEmailUniqueConstraint)
-}
-
-func upDropEmailUniqueConstraint(_ context.Context, tx *sql.Tx) error {
-	_, err := tx.Exec(`
-create table user_dg_tmp
-(
-	id varchar(255) not null
-		primary key,
-	user_name varchar(255) default '' not null
-		unique,
-	name varchar(255) default '' not null,
-	email varchar(255) default '' not null,
-	password varchar(255) default '' not null,
-	is_admin bool default FALSE not null,
-	last_login_at datetime,
-	last_access_at datetime,
-	created_at datetime not null,
-	updated_at datetime not null
-);
-
-insert into user_dg_tmp(id, user_name, name, email, password, is_admin, last_login_at, last_access_at, created_at, updated_at) select id, user_name, name, email, password, is_admin, last_login_at, last_access_at, created_at, updated_at from user;
-
-drop table user;
-
-alter table user_dg_tmp rename to user;
-`)
-	return err
-}
-
-func downDropEmailUniqueConstraint(_ context.Context, tx *sql.Tx) error {
-	return nil
-}