go mod tidy

Bumps [github.com/prometheus/client_golang](https://github.com/prometheus/client_golang) from 1.14.0 to 1.15.1.
- [Release notes](https://github.com/prometheus/client_golang/releases)
- [Changelog](https://github.com/prometheus/client_golang/blob/main/CHANGELOG.md)
- [Commits](https://github.com/prometheus/client_golang/compare/v1.14.0...v1.15.1)

---
updated-dependencies:
- dependency-name: github.com/prometheus/client_golang
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.devcontainer/devcontainer.json

@@ -4,16 +4,18 @@
 		"dockerfile": "Dockerfile",
 		"args": {
 			// Update the VARIANT arg to pick a version of Go: 1, 1.15, 1.14
-			"VARIANT": "1.16",
+			"VARIANT": "1.19",
 			// Options
 			"INSTALL_NODE": "true",
-			"NODE_VERSION": "v14"
+			"NODE_VERSION": "v16"
 		}
 	},
+	"workspaceMount": "",
 	"runArgs": [
 		"--cap-add=SYS_PTRACE",
 		"--security-opt",
-		"seccomp=unconfined"
+		"seccomp=unconfined",
+		"--volume=${localWorkspaceFolder}:/workspaces/${localWorkspaceFolderBasename}:Z"
 	],
 	// Set *default* container specific settings.json values on container create.
 	"settings": {

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,37 +0,0 @@
----
-name: Bug Report
-about: Use this template for submitting a bug report.
-title: ""
-labels: bug
-assignees: ""
----
-<!-- Please check that another issue for the same bug has not been already made by searching the [issues](https://github.com/navidrome/navidrome/issues) -->
-
-### Description
-
-A clear and concise description of what the bug is.
-
-### Expected Behaviour
-
-What you would have expected to happen instead.
-
-### Steps to reproduce
-
-1. Open the '...'
-2. Click on '...'
-3. Scroll down to '...'
-4. See error
-
-### Platform information
-
- - Navidrome version: <!-- e.g. v0.40.0 -->
- - Browser and version: <!-- e.g. Firefox v87.0b9 -->
- - Operating System: <!-- e.g. Ubuntu 20.04 and whether using a binary, docker or built from source  -->
-
-### Additional information
-
-Any other information that may be relevant or give context to the problem.
-
- - Screenshots (if applicable)?
- - Logs? <!-- Turn the log level up to trace -->
- - Client used? <!-- e.g. DSub v5.5.2R2 -->

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,103 @@
+name: Bug Report
+description: Before opening a new issue, please search to see if an issue already exists for the bug you encountered.
+title: "[Bug]: "
+labels: ["bug", "triage"]
+#assignees:
+#  - deluan
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ### Thanks for taking the time to fill out this bug report!
+  - type: checkboxes
+    id: requirements
+    attributes:
+      label: "I confirm that:"
+      options:
+        - label: I have searched the existing [open AND closed issues](https://github.com/navidrome/navidrome/issues?q=is%3Aissue) to see if an issue already exists for the bug I've encountered
+          required: true
+        - label: I'm using the latest version (your issue may have been fixed already)
+          required: false
+  - type: input
+    id: version
+    attributes:
+      label: Version
+      description: What version of Navidrome are you running? (please try upgrading first, as your issue may have been fixed already).
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Current Behavior
+      description: A concise description of what you're experiencing.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Expected Behavior
+      description: A concise description of what you expected to happen.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Steps To Reproduce
+      description: Steps to reproduce the behavior.
+      placeholder: |
+        1. In this scenario...
+        2. With this config...
+        3. Click (or Execute) '...'
+        4. See error...
+    validations:
+      required: false
+  - type: textarea
+    id: env
+    attributes:
+      label: Environment
+      description: |
+        examples:
+          - **OS**: Ubuntu 20.04
+          - **Browser**: Chrome 110.0.5481.177 on Windows 11
+          - **Client**: DSub 5.5.1
+      value: |
+        - OS:
+        - Browser:
+        - Client:
+      render: markdown
+  - type: dropdown
+    id: distribution
+    attributes:
+      label: How Navidrome is installed?
+      multiple: false
+      options:
+        - Docker
+        - Binary (from downloads page)
+        - Package
+        - Built from sources
+    validations:
+      required: true
+  - type: textarea
+    id: config
+    attributes:
+      label: Configuration
+      description: Please copy and paste your `navidrome.toml` (and/or `docker-compose.yml`) configuration. This will be automatically formatted into code, so no need for backticks.
+      render: toml
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output (change your `LogLevel` (`ND_LOGLEVEL`) to debug). This will be automatically formatted into code, so no need for backticks. ([Where I can find the logs?](https://www.navidrome.org/docs/faq/#where-are-the-logs))
+      render: shell
+  - type: textarea
+    attributes:
+      label: Anything else?
+      description: |
+        Links? References? Anything that will give us more context about the issue you are encountering!
+
+        Tip: You can attach screenshots by clicking this area to highlight it and then dragging files in.
+  - type: checkboxes
+    id: terms
+    attributes:
+      label: Code of Conduct
+      description: By submitting this issue, you agree to follow our [Code of Conduct](https://github.com/navidrome/navidrome/blob/master/CODE_OF_CONDUCT.md).
+      options:
+        - label: I agree to follow Navidrome's Code of Conduct
+          required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Ideas for new features
+    url: https://github.com/navidrome/navidrome/discussions/categories/ideas
+    about: This is the place to share and discuss new ideas and potentially new features.
+  - name: Support requests
+    url: https://github.com/navidrome/navidrome/discussions/categories/q-a
+    about: This is the place to ask questions.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,24 +0,0 @@
----
-name: Feature Request
-about: Use this template to request for a feature.
-title: ""
-labels: enhancement
-assignees: ""
----
-<!-- Please check that another issue for the same feature request has not been already made by searching the [issues](https://github.com/navidrome/navidrome/issues) -->
-
-### Is your feature request related to a problem? Please describe.
-
-A clear and concise description of what the problem is. For e.g. I'm always frustrated when '...'
-
-### Describe the solution you'd like
-
-A clear and concise description of what you would like to happen.
-
-### Describe alternative solutions that would also satisfy this problem
-
-A clear and concise description of any alternative solutions or features you've considered.
-
-### Additional context
-
-Add any other context or screenshots about the feature request here.

.github/workflows/docker-tags.sh

@@ -1,22 +0,0 @@
-#!/bin/bash
-
-GIT_TAG="${GITHUB_REF##refs/tags/}"
-GIT_BRANCH="${GITHUB_REF##refs/heads/}"
-GIT_SHA=$(git rev-parse --short HEAD)
-PR_NUM=$(jq --raw-output .pull_request.number "$GITHUB_EVENT_PATH")
-
-DOCKER_IMAGE_TAG="--tag ${DOCKER_IMAGE}:sha-${GIT_SHA}"
-
-if [[ $PR_NUM != "null" ]]; then
-  DOCKER_IMAGE_TAG="${DOCKER_IMAGE_TAG} --tag ${DOCKER_IMAGE}:pr-${PR_NUM}"
-fi
-
-if [[ $GITHUB_REF != "$GIT_TAG" ]]; then
-    DOCKER_IMAGE_TAG="${DOCKER_IMAGE_TAG} --tag ${DOCKER_IMAGE}:${GIT_TAG#v}  --tag ${DOCKER_IMAGE}:latest"
-elif [[ $GITHUB_REF == "refs/heads/master" ]]; then
-    DOCKER_IMAGE_TAG="${DOCKER_IMAGE_TAG} --tag ${DOCKER_IMAGE}:develop"
-elif [[ $GIT_BRANCH = feature/* ]]; then
-    DOCKER_IMAGE_TAG="${DOCKER_IMAGE_TAG} --tag ${DOCKER_IMAGE}:$(echo $GIT_BRANCH | tr / -)"
-fi
-
-echo ${DOCKER_IMAGE_TAG}

.github/workflows/download-link-on-pr.yml

@@ -0,0 +1,54 @@
+name: Add download link to PR
+on:
+  workflow_run:
+    workflows: ['Pipeline: Test, Lint, Build']
+    types: [completed]
+jobs:
+  pr_comment:
+    if: github.event.workflow_run.event == 'pull_request' && github.event.workflow_run.conclusion == 'success'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@v3
+        with:
+          # This snippet is public-domain, taken from
+          # https://github.com/oprypin/nightly.link/blob/master/.github/workflows/pr-comment.yml
+          script: |
+            const {owner, repo} = context.repo;
+            const run_id = ${{github.event.workflow_run.id}};
+            const pull_head_sha = '${{github.event.workflow_run.head_sha}}';
+            const pull_user_id = ${{github.event.sender.id}};
+
+            const issue_number = await (async () => {
+              const pulls = await github.pulls.list({owner, repo});
+              for await (const {data} of github.paginate.iterator(pulls)) {
+                for (const pull of data) {
+                  if (pull.head.sha === pull_head_sha && pull.user.id === pull_user_id) {
+                    return pull.number;
+                  }
+                }
+              }
+            })();
+            if (issue_number) {
+              core.info(`Using pull request ${issue_number}`);
+            } else {
+              return core.error(`No matching pull request found`);
+            }
+
+            const {data: {artifacts}} = await github.actions.listWorkflowRunArtifacts({owner, repo, run_id});
+            if (!artifacts.length) {
+              return core.error(`No artifacts found`);
+            }
+            let body = `Download the artifacts for this pull request:\n`;
+            for (const art of artifacts) {
+              body += `\n* [${art.name}.zip](https://nightly.link/${owner}/${repo}/actions/artifacts/${art.id}.zip)`;
+            }
+
+            const {data: comments} = await github.issues.listComments({repo, owner, issue_number});
+            const existing_comment = comments.find((c) => c.user.login === 'github-actions[bot]');
+            if (existing_comment) {
+              core.info(`Updating comment ${existing_comment.id}`);
+              await github.issues.updateComment({repo, owner, comment_id: existing_comment.id, body});
+            } else {
+              core.info(`Creating a comment`);
+              await github.issues.createComment({repo, owner, issue_number, body});
+            }

.github/workflows/pipeline.dockerfile

@@ -6,7 +6,8 @@ ARG TARGETPLATFORM
 RUN echo "Target Platform = ${TARGETPLATFORM}"
 
 COPY dist .
-RUN if [ "$TARGETPLATFORM" = "linux/amd64" ];  then cp navidrome_linux_amd64_linux_amd64/navidrome /navidrome; fi
+RUN if [ "$TARGETPLATFORM" = "linux/amd64" ];  then cp navidrome_linux_amd64_linux_amd64_v1/navidrome /navidrome; fi
+RUN if [ "$TARGETPLATFORM" = "linux/386" ];  then cp navidrome_linux_386_linux_386/navidrome /navidrome; fi
 RUN if [ "$TARGETPLATFORM" = "linux/arm64" ];  then cp navidrome_linux_arm64_linux_arm64/navidrome /navidrome; fi
 RUN if [ "$TARGETPLATFORM" = "linux/arm/v6" ]; then cp navidrome_linux_arm_linux_arm_6/navidrome /navidrome; fi
 RUN if [ "$TARGETPLATFORM" = "linux/arm/v7" ]; then cp navidrome_linux_arm_linux_arm_7/navidrome /navidrome; fi

.github/workflows/pipeline.yml

@@ -1,4 +1,4 @@
-name: Pipeline
+name: 'Pipeline: Test, Lint, Build'
 on:
   push:
     branches:
@@ -9,49 +9,58 @@ on:
     branches:
       - master
 jobs:
-  golangci-lint:
-    name: Lint Server
+  go-lint:
+    name: Lint Go code
     runs-on: ubuntu-latest
     steps:
       - name: Install taglib
         run: sudo apt-get install libtag1-dev
 
-      - uses: actions/checkout@v2
+      - name: Set up Go 1.20
+        uses: actions/setup-go@v3
+        with:
+          go-version: 1.20.x
+
+      - uses: actions/checkout@v3
 
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v2
+        uses: golangci/golangci-lint-action@v3
         with:
-          version: v1.38
+          version: latest
           github-token: ${{ secrets.GITHUB_TOKEN }}
           args: --timeout 2m
 
+      - name: Install goimports
+        run: go install golang.org/x/tools/cmd/goimports
+
+      - run: goimports -w `find . -name '*.go' | grep -v '_gen.go$'`
+      - run: go mod tidy
+      - name: Verify no changes from goimports and go mod tidy
+        run: |
+          git status --porcelain
+          if [ -n "$(git status --porcelain)" ]; then
+            echo 'To fix this check, run "goimports -w $(find . -name '*.go' | grep -v '_gen.go$') && go mod tidy"'
+            exit 1
+          fi
+
   go:
-    name: Test Server with Go ${{ matrix.go_version }}
+    name: Test with Go ${{ matrix.go_version }}
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go_version: [1.16.x]
+        go_version: [1.20.x,1.19.x]
     steps:
       - name: Install taglib
         run: sudo apt-get install libtag1-dev
 
-      - name: Set up Go ${{ matrix.go_version }}
-        uses: actions/setup-go@v2
-        with:
-          stable: '!contains(${{ matrix.go_version }}, "beta") && !contains(${{ matrix.go_version }}, "rc")'
-          go-version: ${{ matrix.go_version }}
-        id: go
-
       - name: Check out code into the Go module directory
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
-      - uses: actions/cache@v2
-        id: cache-go
+      - name: Set up Go ${{ matrix.go_version }}
+        uses: actions/setup-go@v3
         with:
-          path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ matrix.go_version }}-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-${{ matrix.go_version }}-
+          go-version: ${{ matrix.go_version }}
+          cache: true
 
       - name: Download dependencies
         if: steps.cache-go.outputs.cache-hit != 'true'
@@ -60,35 +69,30 @@ jobs:
 
       - name: Test
         continue-on-error: ${{contains(matrix.go_version, 'beta') || contains(matrix.go_version, 'rc')}}
-        run: go test -cover ./... -v
+        run: go test -shuffle=on -race -cover ./... -v
+
   js:
     name: Build JS bundle
     runs-on: ubuntu-latest
     env:
       NODE_OPTIONS: '--max_old_space_size=4096'
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
         with:
-          node-version: 14
-
-      - uses: actions/cache@v2
-        id: cache-npm
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-node-${{ hashFiles('ui/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-node-
+          node-version: 16
+          cache: 'npm'
+          cache-dependency-path: '**/package-lock.json'
 
       - name: npm install dependencies
         run: |
           cd ui
           npm ci
 
-      - name: npm check-formatting
+      - name: npm lint
         run: |
           cd ui
-          npm run check-formatting
+          npm run check-formatting && npm run lint
 
       - name: npm test
         run: |
@@ -100,35 +104,37 @@ jobs:
           cd ui
           npm run build
 
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v3
         with:
           name: js-bundle
           path: ui/build
+          retention-days: 7
 
   binaries:
-    name: Binaries
-    needs: [js, go, golangci-lint]
+    name: Build binaries
+    needs: [js, go, go-lint]
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
-      - uses: actions/download-artifact@v2
+      - uses: actions/download-artifact@v3
         with:
           name: js-bundle
           path: ui/build
 
-      - name: Show Tags
-        run: git tag
-
-      - name: Show Version
-        run: git describe --tags
+      - name: Config /github/workspace folder as trusted
+        uses: docker://deluan/ci-goreleaser:1.20.3-1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          args: /bin/bash -c "git config --global --add safe.directory /github/workspace;  git describe --dirty --always --tags"
 
       - name: Run GoReleaser - SNAPSHOT
         if: startsWith(github.ref, 'refs/tags/') != true
-        uses: docker://deluan/ci-goreleaser:1.16.2-1
+        uses: docker://deluan/ci-goreleaser:1.20.3-1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
@@ -136,22 +142,23 @@ jobs:
 
       - name: Run GoReleaser - RELEASE
         if: startsWith(github.ref, 'refs/tags/')
-        uses: docker://deluan/ci-goreleaser:1.16.2-1
+        uses: docker://deluan/ci-goreleaser:1.20.3-1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           args: goreleaser release --rm-dist
 
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v3
         with:
           name: binaries
           path: |
             dist
             !dist/*.tar.gz
             !dist/*.zip
+          retention-days: 7
 
   docker:
-    name: Docker images
+    name: Build and publish Docker images
     needs: [binaries]
     runs-on: ubuntu-latest
     env:
@@ -159,28 +166,59 @@ jobs:
     steps:
       - name: Set up QEMU
         id: qemu
-        uses: docker/setup-qemu-action@v1
+        uses: docker/setup-qemu-action@v2
         if: env.DOCKER_IMAGE != ''
 
       - name: Set up Docker Buildx
         id: buildx
-        uses: docker/setup-buildx-action@v1
+        uses: docker/setup-buildx-action@v2
         if: env.DOCKER_IMAGE != ''
 
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         if: env.DOCKER_IMAGE != ''
 
-      - uses: actions/download-artifact@v2
+      - uses: actions/download-artifact@v3
         if: env.DOCKER_IMAGE != ''
         with:
           name: binaries
           path: dist
 
-      - name: Build the Docker image and push
+      - name: Login to Docker Hub
         if: env.DOCKER_IMAGE != ''
-        env:
-          DOCKER_IMAGE: ${{secrets.DOCKER_IMAGE}}
-          DOCKER_PLATFORM: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
-        run: |
-          echo ${{secrets.DOCKER_PASSWORD}} | docker login -u ${{secrets.DOCKER_USERNAME}} --password-stdin
-          docker buildx build --platform ${DOCKER_PLATFORM} `.github/workflows/docker-tags.sh` -f .github/workflows/pipeline.dockerfile --push .
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Login to GitHub Container Registry
+        if: env.DOCKER_IMAGE != ''
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata for Docker
+        if: env.DOCKER_IMAGE != ''
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          labels: |
+            maintainer=deluan
+          images: |
+            name=${{secrets.DOCKER_IMAGE}},enable=${{env.GITHUB_REF_TYPE == 'tag' || github.ref == format('refs/heads/{0}', 'master')}}
+            name=ghcr.io/${{ github.repository }}
+          tags: |
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=raw,value=develop,enable={{is_default_branch}}
+
+      - name: Build and Push
+        if: env.DOCKER_IMAGE != ''
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          file: .github/workflows/pipeline.dockerfile
+          platforms: linux/amd64,linux/386,linux/arm/v6,linux/arm/v7,linux/arm64
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}

.github/workflows/remove-old-artifacts.yml

@@ -1,18 +0,0 @@
-name: Remove old artifacts
-
-on:
-  schedule:
-    # Every day at 1am
-    - cron: '0 1 * * *'
-
-jobs:
-  remove-old-artifacts:
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-
-    steps:
-      - name: Remove old artifacts
-        uses: c-hive/gha-remove-artifacts@v1
-        with:
-          age: '7 days'
-          skip-tags: false

.github/workflows/stale.yml

@@ -0,0 +1,55 @@
+name: 'Close stale issues and PRs'
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '30 1 * * *'
+permissions:
+  contents: read
+jobs:
+  stale:
+    permissions:
+      issues: write
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: dessant/lock-threads@v4.0.0
+        with:
+          issue-inactive-days: 120
+          pr-inactive-days: 120
+          log-output: true
+          add-issue-labels: 'frozen-due-to-age'
+          add-pr-labels: 'frozen-due-to-age'
+          issue-comment: >
+            This issue has been automatically locked since there
+            has not been any recent activity after it was closed.
+            Please open a new issue for related bugs.
+          pr-comment: >
+            This pull request has been automatically locked since there
+            has not been any recent activity after it was closed.
+            Please open a new issue for related bugs.
+      - uses: actions/stale@v7
+        with:
+          operations-per-run: 999
+          days-before-issue-stale: 180
+          days-before-pr-stale: 180
+          days-before-issue-close: 30
+          days-before-pr-close: 30
+          stale-issue-message: >
+            This issue has been automatically marked as stale because it has not had
+            recent activity. The resources of the Navidrome team are limited, and so we are asking for your help.
+
+            If this is a **bug** and you can still reproduce this error on the <code>master</code> branch, please reply with all of the information you have about it in order to keep the issue open.
+
+            If this is a **feature request**, and you feel that it is still relevant and valuable, please tell us why.
+
+            This issue will automatically be closed in the near future if no further activity occurs. Thank you for all your contributions.
+          stale-pr-message: This PR has been automatically marked as stale because it has not had
+            recent activity. The resources of the Navidrome team are limited, and so we are asking for your help.
+
+            Please check https://github.com/navidrome/navidrome/blob/master/CONTRIBUTING.md#pull-requests and verify that this code contribution fits with the description. If yes, tell it in a comment.
+
+            This PR will automatically be closed in the near future if no further activity occurs. Thank you for all your contributions.
+          stale-issue-label: 'stale'
+          exempt-issue-labels: 'keep,security'
+          stale-pr-label: 'stale'
+          exempt-pr-labels: 'keep,security'

.github/workflows/update-translations.yml

@@ -0,0 +1,27 @@
+name: POEditor import
+on:
+  workflow_dispatch:
+  schedule:
+    - cron:  '0 10 * * *'
+jobs:
+  update-translations:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Get updated translations
+        env:
+          POEDITOR_PROJECTID: ${{ secrets.POEDITOR_PROJECTID }}
+          POEDITOR_APIKEY: ${{ secrets.POEDITOR_APIKEY }}
+        run: |
+          ./update-translations.sh
+      - name: Show changes, if any
+        run: |
+          git status --porcelain
+          git diff
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.PAT }}
+          commit-message: Update translations
+          title: Update translations from POEditor
+          branch: update-translations

.gitignore

@@ -14,12 +14,14 @@ navidrome.toml
 master.zip
 testDB
 navidrome.db
+cache/*
 *.swp
 embedded_gen.go
 dist
 music
-docker-compose.yml
 navidrome.db-shm
 navidrome.db-wal
 tags
-
+.gitinfo
+docker-compose.yml
+!contrib/docker-compose.yml

.golangci.yml

@@ -1,25 +1,32 @@
+run:
+  go: "1.19"
+
 linters:
   enable:
+    - asasalint
+    - asciicheck
+    - bidichk
     - bodyclose
-    - deadcode
+    - depguard
     - dogsled
+    - durationcheck
     - errcheck
+    - errorlint
+    - exportloopref
     - gocyclo
-    - goimports
     - goprintffuncname
     - gosec
     - gosimple
     - govet
     - ineffassign
-    - interfacer
     - misspell
+    - nakedret
+    - nilerr
     - rowserrcheck
     - staticcheck
-    - structcheck
     - typecheck
     - unconvert
     - unused
-    - varcheck
     - whitespace
 
 issues:

.goreleaser.yml

@@ -10,7 +10,7 @@ builds:
     goarch:
       - amd64
     flags:
-      - -tags=embed,netgo
+      - -tags=netgo
     ldflags:
       - "-extldflags '-static -lz'"
       - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
@@ -18,12 +18,13 @@ builds:
   - id: navidrome_linux_386
     env:
       - CGO_ENABLED=1
+      - PKG_CONFIG_PATH=/i386/lib/pkgconfig
     goos:
       - linux
     goarch:
-      - 386
+      - "386"
     flags:
-      - -tags=embed,netgo
+      - -tags=netgo
     ldflags:
       - "-extldflags '-static'"
       - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
@@ -33,16 +34,17 @@ builds:
       - CGO_ENABLED=1
       - CC=arm-linux-gnueabi-gcc
       - CXX=arm-linux-gnueabi-g++
+      - PKG_CONFIG_PATH=/arm/lib/pkgconfig
     goos:
       - linux
     goarch:
       - arm
     goarm:
-      - 5
-      - 6
-      - 7
+      - "5"
+      - "6"
+      - "7"
     flags:
-      - -tags=embed,netgo
+      - -tags=netgo
     ldflags:
       - "-extldflags '-static'"
       - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
@@ -52,17 +54,18 @@ builds:
       - CGO_ENABLED=1
       - CC=aarch64-linux-gnu-gcc
       - CXX=aarch64-linux-gnu-g++
+      - PKG_CONFIG_PATH=/arm64/lib/pkgconfig
     goos:
       - linux
     goarch:
       - arm64
     flags:
-      - -tags=embed,netgo
+      - -tags=netgo
     ldflags:
       - "-extldflags '-static'"
       - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
 
-  - id: navidrome_windows_i686
+  - id: navidrome_windows_386
     env:
       - CGO_ENABLED=1
       - CC=i686-w64-mingw32-gcc
@@ -71,14 +74,14 @@ builds:
     goos:
       - windows
     goarch:
-      - 386
+      - "386"
     flags:
-      - -tags=embed,netgo
+      - -tags=netgo
     ldflags:
       - "-extldflags '-static'"
       - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
 
-  - id: navidrome_windows_x64
+  - id: navidrome_windows_amd64
     env:
       - CGO_ENABLED=1
       - CC=x86_64-w64-mingw32-gcc
@@ -89,12 +92,12 @@ builds:
     goarch:
       - amd64
     flags:
-      - -tags=embed,netgo
+      - -tags=netgo
     ldflags:
       - "-extldflags '-static'"
       - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
 
-  - id: navidrome_darwin
+  - id: navidrome_darwin_amd64
     env:
       - CGO_ENABLED=1
       - CC=o64-clang
@@ -105,7 +108,7 @@ builds:
     goarch:
       - amd64
     flags:
-      - -tags=embed,netgo
+      - -tags=netgo
     ldflags:
       - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
 

.nvmrc

@@ -1 +1 @@
-v14
+v16

CONTRIBUTING.md

@@ -2,26 +2,26 @@
 
 Navidrome is a streaming service which allows you to enjoy your music collection from anywhere. We'd welcome you to contribute to our open source project and make Navidrome even better. There are some basic guidelines which you need to follow if you like to contribute to Navidrome.
 
+- [Asking Support Questions](#asking-support-questions)
 - [Code of Conduct](#code-of-conduct)
 - [Issues](#issues)
-- [Questions](#questions)
 - [Pull Requests](#pull-requests)
 
 
+## Asking Support Questions
+We have an active [discussion forum](https://github.com/navidrome/navidrome/discussions) where users and developers can ask questions. Please don't use the GitHub issue tracker to ask questions.
+
 ## Code of Conduct
 Please read the following [Code of Conduct](https://github.com/navidrome/navidrome/blob/master/CODE_OF_CONDUCT.md).
 
 ## Issues
 Found any issue or bug in our codebase? Have a great idea you want to propose or discuss with 
 the developers? You can help by submitting an [issue](https://github.com/navidrome/navidrome/issues/new/choose)
-to the Github repository. 
+to the GitHub repository. 
 
 **Before opening a new issue, please check if the issue has not been already made by searching 
 the [issues](https://github.com/navidrome/navidrome/issues)**
 
-## Questions
-We would like to have discussions and general queries related to Navidrome on our [Discord channel](https://discord.gg/2qMuMyHfSV).
-
 ## Pull requests
 Before submitting a pull request, ensure that you go through the following:
 - Open a corresponding issue for the Pull Request, if not existing. The issue can be opened following [these guidelines](#issues)

Makefile

@@ -1,122 +1,123 @@
 GO_VERSION=$(shell grep "^go " go.mod | cut -f 2 -d ' ')
 NODE_VERSION=$(shell cat .nvmrc)
 
+ifneq ("$(wildcard .git/HEAD)","")
 GIT_SHA=$(shell git rev-parse --short HEAD)
 GIT_TAG=$(shell git describe --tags `git rev-list --tags --max-count=1`)
+else
+GIT_SHA=source_archive
+GIT_TAG=$(patsubst navidrome-%,v%,$(notdir $(PWD)))
+endif
 
-## Default target just build the Go project.
-default:
-	go build -ldflags="-X github.com/navidrome/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/navidrome/navidrome/consts.gitTag=master"
-.PHONY: default
+CI_RELEASER_VERSION=1.20.3-1 ## https://github.com/navidrome/ci-goreleaser
 
-dev: check_dev_env
+setup: check_env download-deps setup-git ##@1_Run_First Install dependencies and prepare development environment
+	@echo Downloading Node dependencies...
+	@(cd ./ui && npm ci)
+.PHONY: setup
+
+dev: check_env   ##@Development Start Navidrome in development mode, with hot-reload for both frontend and backend
 	npx foreman -j Procfile.dev -p 4533 start
 .PHONY: dev
 
-server: check_go_dev_env
-	@go run github.com/cespare/reflex -d none -c reflex.conf
+server: check_go_env  ##@Development Start the backend in development mode
+	@go run github.com/cespare/reflex@latest -d none -c reflex.conf
 .PHONY: server
 
-wire: check_go_env
-	go run github.com/google/wire/cmd/wire ./...
-.PHONY: wire
-
-watch: check_go_env
-	go run github.com/onsi/ginkgo/ginkgo watch -notify ./...
+watch: ##@Development Start Go tests in watch mode (re-run when code changes)
+	go run github.com/onsi/ginkgo/v2/ginkgo@latest watch -notify ./...
 .PHONY: watch
 
-test: check_go_env
-	go test ./... -v
+test: ##@Development Run Go tests
+	go test -race -shuffle=on ./...
 .PHONY: test
 
-testall: check_go_env test
+testall: test ##@Development Run Go and JS tests
 	@(cd ./ui && npm test -- --watchAll=false)
 .PHONY: testall
 
-lint:
-	go run github.com/golangci/golangci-lint/cmd/golangci-lint run -v --timeout 5m
+lint: ##@Development Lint Go code
+	go run github.com/golangci/golangci-lint/cmd/golangci-lint@latest run -v --timeout 5m
 .PHONY: lint
 
-lintall: check_node_dev_env lint
-	@(cd ./ui && npm run check-formatting && npm run lint)
+lintall: lint ##@Development Lint Go and JS code
+	@(cd ./ui && npm run check-formatting) || (echo "\n\nPlease run 'npm run prettier' to fix formatting issues." && exit 1)
+	@(cd ./ui && npm run lint)
 .PHONY: lintall
 
-update-snapshots: check_go_env
-	UPDATE_SNAPSHOTS=true go run github.com/onsi/ginkgo/ginkgo ./server/subsonic/...
-.PHONY: update-snapshots
+wire: check_go_env ##@Development Update Dependency Injection
+	go run github.com/google/wire/cmd/wire@latest ./...
+.PHONY: wire
 
-migration:
-	@if [ -z "${name}" ]; then echo "Usage: make migration name=name_of_migration_file"; exit 1; fi
-	go run github.com/pressly/goose/cmd/goose -dir db/migration create ${name}
+snapshots: ##@Development Update (GoLang) Snapshot tests
+	UPDATE_SNAPSHOTS=true go run github.com/onsi/ginkgo/v2/ginkgo@latest ./server/subsonic/...
+.PHONY: snapshots
+
+migration-sql: ##@Development Create an empty SQL migration file
+	@if [ -z "${name}" ]; then echo "Usage: make migration-sql name=name_of_migration_file"; exit 1; fi
+	go run github.com/pressly/goose/v3/cmd/goose@latest -dir db/migration create ${name} sql
 .PHONY: migration
 
-setup: download-deps
-	@echo Installing tools from tools.go
-	@cat tools.go | grep _ | awk -F'"' '{print $$2}' | xargs -tI % go install %
-.PHONY: setup
+migration-go: ##@Development Create an empty Go migration file
+	@if [ -z "${name}" ]; then echo "Usage: make migration-go name=name_of_migration_file"; exit 1; fi
+	go run github.com/pressly/goose/v3/cmd/goose@latest -dir db/migration create ${name}
+.PHONY: migration
 
-download-deps:
-	@echo Downloading Go dependencies...
-	@go mod download -x
-	@go mod tidy # To revert any changes made by the `go mod download` command
-	@echo Downloading Node dependencies...
-	@(cd ./ui && npm ci)
-.PHONY: download-deps
-
-setup-dev: setup setup-git
+setup-dev: setup
 .PHONY: setup-dev
 
-setup-git:
+setup-git: ##@Development Setup Git hooks (pre-commit and pre-push)
 	@echo Setting up git hooks
 	@mkdir -p .git/hooks
 	@(cd .git/hooks && ln -sf ../../git/* .)
 .PHONY: setup-git
 
-check_dev_env: check_go_dev_env check_node_dev_env
-.PHONY: check_dev_env
-
-check_go_dev_env:
-	@(hash go) || (echo "\nERROR: GO environment not setup properly!\n"; exit 1)
-	@current_go_version=`go version | cut -d ' ' -f 3 | cut -c3-` && \
-		echo "$(GO_VERSION) $$current_go_version" | \
-		tr ' ' '\n' | sort -V | tail -1 | \
-		grep -q "^$${current_go_version}$$" || \
-		(echo "\nERROR: Please upgrade your GO version\nThis project requires at least the version $(GO_VERSION)"; exit 1)
-.PHONY: check_go_dev_env
-
-check_node_dev_env:
-	@(hash node) || (echo "\nERROR: Node environment not setup properly!\n"; exit 1)
-	@current_node_version=`node --version` && \
-		echo "$(NODE_VERSION) $$current_node_version" | \
-		tr ' ' '\n' | sort -V | tail -1 | \
-		grep -q "^$${current_node_version}$$" || \
-		(echo "\nERROR: Please check your Node version. Should be at least $(NODE_VERSION)\n"; exit 1)
-.PHONY: check_node_dev_env
-
-check_env: check_go_env check_node_env
-.PHONY: check_env
-
-check_go_env:
-	@(hash go) || (echo "\nERROR: GO environment not setup properly!\n"; exit 1)
-	@go version | grep -q $(GO_VERSION) || (echo "\nERROR: Please upgrade your GO version\nThis project requires version $(GO_VERSION)"; exit 1)
-.PHONY: check_go_env
-
-check_node_env:
-	@(hash node) || (echo "\nERROR: Node environment not setup properly!\n"; exit 1)
-	@node --version | grep -q $(NODE_VERSION) || (echo "\nERROR: Please check your Node version. Should be $(NODE_VERSION)\n"; exit 1)
-.PHONY: check_node_env
-
-build: check_go_env
-	go build -ldflags="-X github.com/navidrome/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/navidrome/navidrome/consts.gitTag=$(GIT_TAG)-SNAPSHOT"
-.PHONY: build
-
-buildall: check_env
-	@(cd ./ui && npm run build)
-	go build -ldflags="-X github.com/navidrome/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/navidrome/navidrome/consts.gitTag=$(GIT_TAG)-SNAPSHOT" -tags=netgo
+buildall: buildjs build ##@Build Build the project, both frontend and backend
 .PHONY: buildall
 
-pre-push: lintall testall
-.PHONY: pre-push
+build: warning-noui-build check_go_env  ##@Build Build only backend
+	go build -ldflags="-X github.com/navidrome/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/navidrome/navidrome/consts.gitTag=$(GIT_TAG)-SNAPSHOT" -tags=netgo
+.PHONY: build
+
+buildjs: check_node_env ##@Build Build only frontend
+	@(cd ./ui && npm run build)
+.PHONY: buildjs
+
+all: warning-noui-build ##@Cross_Compilation Build binaries for all supported platforms. It does not build the frontend
+	docker run -t -v $(PWD):/workspace -w /workspace deluan/ci-goreleaser:$(CI_RELEASER_VERSION) \
+ 		goreleaser release --rm-dist --skip-publish --snapshot
+.PHONY: all
+
+single: warning-noui-build ##@Cross_Compilation Build binaries for a single supported platforms. It does not build the frontend
+	@if [ -z "${GOOS}" -o -z "${GOARCH}" ]; then \
+		echo "Usage: GOOS=<os> GOARCH=<arch> make single"; \
+		echo "Options:"; \
+		grep -- "- id: navidrome_" .goreleaser.yml | sed 's/- id: navidrome_//g'; \
+		exit 1; \
+	fi
+	@echo "Building binaries for ${GOOS}/${GOARCH}"
+	docker run -t -v $(PWD):/workspace -e GOOS -e GOARCH -w /workspace deluan/ci-goreleaser:$(CI_RELEASER_VERSION) \
+ 		goreleaser build --rm-dist --snapshot --single-target --id navidrome_${GOOS}_${GOARCH}
+.PHONY: single
+
+warning-noui-build:
+	@echo "WARNING: This command does not build the frontend, it uses the latest built with 'make buildjs'"
+.PHONY: warning-noui-build
+
+get-music: ##@Development Download some free music from Navidrome's demo instance
+	mkdir -p music
+	( cd music; \
+	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=ec2093ec4801402f1e17cc462195cdbb" > brock.zip; \
+	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=NavidromeUI&id=b376eeb4652d2498aa2b25ba0696725e" > back_on_earth.zip; \
+	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=NavidromeUI&id=e49c609b542fc51899ee8b53aa858cb4" > ugress.zip; \
+	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=NavidromeUI&id=350bcab3a4c1d93869e39ce496464f03" > voodoocuts.zip; \
+	for file in *.zip; do unzip -n $${file}; done )
+	@echo "Done. Remember to set your MusicFolder to ./music"
+.PHONY: get-music
+
+
+##########################################
+#### Miscellaneous
 
 release:
 	@if [[ ! "${V}" =~ ^[0-9]+\.[0-9]+\.[0-9]+.*$$ ]]; then echo "Usage: make release V=X.X.X"; exit 1; fi
@@ -127,6 +128,44 @@ release:
 	git push origin v${V} --no-verify
 .PHONY: release
 
-snapshot:
-	 docker run -t -v $(PWD):/workspace -w /workspace deluan/ci-goreleaser:1.16.2-1 goreleaser release --rm-dist --skip-publish --snapshot
-.PHONY: snapshot
+download-deps:
+	@echo Downloading Go dependencies...
+	@go mod download
+	@go mod tidy # To revert any changes made by the `go mod download` command
+.PHONY: download-deps
+
+check_env: check_go_env check_node_env
+.PHONY: check_env
+
+check_go_env:
+	@(hash go) || (echo "\nERROR: GO environment not setup properly!\n"; exit 1)
+	@current_go_version=`go version | cut -d ' ' -f 3 | cut -c3-` && \
+		echo "$(GO_VERSION) $$current_go_version" | \
+		tr ' ' '\n' | sort -V | tail -1 | \
+		grep -q "^$${current_go_version}$$" || \
+		(echo "\nERROR: Please upgrade your GO version\nThis project requires at least the version $(GO_VERSION)"; exit 1)
+.PHONY: check_go_env
+
+check_node_env:
+	@(hash node) || (echo "\nERROR: Node environment not setup properly!\n"; exit 1)
+	@current_node_version=`node --version` && \
+		echo "$(NODE_VERSION) $$current_node_version" | \
+		tr ' ' '\n' | sort -V | tail -1 | \
+		grep -q "^$${current_node_version}$$" || \
+		(echo "\nERROR: Please check your Node version. Should be at least $(NODE_VERSION)\n"; exit 1)
+.PHONY: check_node_env
+
+pre-push: lintall testall
+.PHONY: pre-push
+
+.DEFAULT_GOAL := help
+
+HELP_FUN = \
+	%help; while(<>){push@{$$help{$$2//'options'}},[$$1,$$3] \
+	if/^([\w-_]+)\s*:.*\#\#(?:@(\w+))?\s(.*)$$/}; \
+	print"$$_:\n", map"  $$_->[0]".(" "x(20-length($$_->[0])))."$$_->[1]\n",\
+	@{$$help{$$_}},"\n" for sort keys %help; \
+
+help: ##@Miscellaneous Show this help
+	@echo "Usage: make [target] ...\n"
+	@perl -e '$(HELP_FUN)' $(MAKEFILE_LIST)

Procfile.dev

@@ -1,2 +1,2 @@
 JS: sh -c "cd ./ui && npm start"
-GO: go run github.com/cespare/reflex -c reflex.conf
+GO: go run github.com/cespare/reflex@latest -d none -c reflex.conf

README.md

@@ -1,18 +1,25 @@
-# Navidrome Music Server
+<a href="https://www.navidrome.org"><img src="resources/logo-192x192.png" alt="Navidrome logo" title="navidrome" align="right" height="60px" /></a>
 
-[![Last Release](https://img.shields.io/github/v/release/navidrome/navidrome?label=latest&style=flat-square)](https://github.com/navidrome/navidrome/releases)
-[![Build](https://img.shields.io/github/workflow/status/navidrome/navidrome/Build?style=flat-square)](https://github.com/navidrome/navidrome/actions)
-[![Downloads](https://img.shields.io/github/downloads/navidrome/navidrome/total?style=flat-square)](https://github.com/navidrome/navidrome/releases/latest)
-[![Docker Pulls](https://img.shields.io/docker/pulls/deluan/navidrome?style=flat-square)](https://hub.docker.com/r/deluan/navidrome)
-[![Dev Chat](https://img.shields.io/discord/671335427726114836?label=chat&style=flat-square)](https://discord.gg/xh7j7yF)
-[![Subreddit](https://img.shields.io/reddit/subreddit-subscribers/navidrome?style=flat-square)](https://www.reddit.com/r/navidrome/)
+# Navidrome Music Server &nbsp;[![Tweet](https://img.shields.io/twitter/url/http/shields.io.svg?style=social)](https://twitter.com/intent/tweet?text=Tired%20of%20paying%20for%20music%20subscriptions%2C%20and%20not%20finding%20what%20you%20really%20like%3F%20Roll%20your%20own%20streaming%20service%21&url=https://navidrome.org&via=navidrome)
+
+[![Last Release](https://img.shields.io/github/v/release/navidrome/navidrome?logo=github&label=latest&style=flat-square)](https://github.com/navidrome/navidrome/releases)
+[![Build](https://img.shields.io/github/actions/workflow/status/navidrome/navidrome/pipeline.yml?branch=master&logo=github&style=flat-square)](https://nightly.link/navidrome/navidrome/workflows/pipeline/master)
+[![Downloads](https://img.shields.io/github/downloads/navidrome/navidrome/total?logo=github&style=flat-square)](https://github.com/navidrome/navidrome/releases/latest)
+[![Docker Pulls](https://img.shields.io/docker/pulls/deluan/navidrome?logo=docker&label=pulls&style=flat-square)](https://hub.docker.com/r/deluan/navidrome)
+[![Dev Chat](https://img.shields.io/discord/671335427726114836?logo=discord&label=discord&style=flat-square)](https://discord.gg/xh7j7yF)
+[![Subreddit](https://img.shields.io/reddit/subreddit-subscribers/navidrome?logo=reddit&label=/r/navidrome&style=flat-square)](https://www.reddit.com/r/navidrome/)
 [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.0-ff69b4.svg?style=flat-square)](CODE_OF_CONDUCT.md)
 
-## [Check out our Live Demo!](https://www.navidrome.org/demo/)
-
-Navidrome is an open source web-based music collection server and streamer. It gives you freedom to listen to your 
+Navidrome is an open source web-based music collection server and streamer. It gives you freedom to listen to your
 music collection from any browser or mobile device. It's like your personal Spotify!
 
+
+**Note**: The `master` branch may be in an unstable or even broken state during development. 
+Please use [releases](https://github.com/navidrome/navidrome/releases) instead of 
+the `master` branch in order to get a stable set of binaries.
+
+## [Check out our Live Demo!](https://www.navidrome.org/demo/)
+
 __Any feedback is welcome!__ If you need/want a new feature, find a bug or think of any way to improve Navidrome, 
 please file a [GitHub issue](https://github.com/navidrome/navidrome/issues) or join the discussion in our 
 [Subreddit](https://www.reddit.com/r/navidrome/). If you want to contribute to the project in any other way 
@@ -23,7 +30,15 @@ please file a [GitHub issue](https://github.com/navidrome/navidrome/issues) or j
 
 ## Installation
 
-See instructions in the [project's website](https://www.navidrome.org/docs/installation/)
+See instructions on the [project's website](https://www.navidrome.org/docs/installation/)
+
+## Cloud Hosting
+
+[PikaPods](https://www.pikapods.com) has partnered with us to offer you an 
+[officially supported, cloud-hosted solution](https://www.navidrome.org/docs/installation/managed/#pikapods). 
+A share of the revenue helps fund the development of Navidrome at no additional cost for you.
+
+[![PikaPods](https://www.pikapods.com/static/run-button.svg)](https://www.pikapods.com/pods?run=navidrome)
 
 ## Features
  

cmd/pls.go

@@ -0,0 +1,72 @@
+package cmd
+
+import (
+	"context"
+	"errors"
+	"os"
+
+	"github.com/Masterminds/squirrel"
+	"github.com/navidrome/navidrome/core/auth"
+	"github.com/navidrome/navidrome/db"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/persistence"
+	"github.com/spf13/cobra"
+)
+
+var (
+	playlistID string
+	outputFile string
+)
+
+func init() {
+	plsCmd.Flags().StringVarP(&playlistID, "playlist", "p", "", "playlist name or ID")
+	plsCmd.Flags().StringVarP(&outputFile, "output", "o", "", "output file (default stdout)")
+	_ = plsCmd.MarkFlagRequired("playlist")
+	rootCmd.AddCommand(plsCmd)
+}
+
+var plsCmd = &cobra.Command{
+	Use:     "playlists",
+	Aliases: []string{"pls", "playlist"},
+	Short:   "Export playlists",
+	Long:    "Export Navidrome playlists to M3U files",
+	Run: func(cmd *cobra.Command, args []string) {
+		runExporter()
+	},
+}
+
+func runExporter() {
+	sqlDB := db.Db()
+	ds := persistence.New(sqlDB)
+	ctx := auth.WithAdminUser(context.Background(), ds)
+	playlist, err := ds.Playlist(ctx).GetWithTracks(playlistID, true)
+	if err != nil && !errors.Is(err, model.ErrNotFound) {
+		log.Fatal("Error retrieving playlist", "name", playlistID, err)
+	}
+	if errors.Is(err, model.ErrNotFound) {
+		playlists, err := ds.Playlist(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"playlist.name": playlistID}})
+		if err != nil {
+			log.Fatal("Error retrieving playlist", "name", playlistID, err)
+		}
+		if len(playlists) > 0 {
+			playlist, err = ds.Playlist(ctx).GetWithTracks(playlists[0].ID, true)
+			if err != nil {
+				log.Fatal("Error retrieving playlist", "name", playlistID, err)
+			}
+		}
+	}
+	if playlist == nil {
+		log.Fatal("Playlist not found", "name", playlistID)
+	}
+	pls := playlist.ToM3U8()
+	if outputFile == "-" || outputFile == "" {
+		println(pls)
+		return
+	}
+
+	err = os.WriteFile(outputFile, []byte(pls), 0600)
+	if err != nil {
+		log.Fatal("Error writing to the output file", "file", outputFile, err)
+	}
+}

cmd/root.go

@@ -2,19 +2,30 @@ package cmd
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
+	"strings"
 	"time"
 
+	"github.com/go-chi/chi/v5/middleware"
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/db"
 	"github.com/navidrome/navidrome/log"
-	"github.com/oklog/run"
+	"github.com/navidrome/navidrome/resources"
+	"github.com/navidrome/navidrome/scheduler"
+	"github.com/navidrome/navidrome/server/backgrounds"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"golang.org/x/sync/errgroup"
+
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
 
+var interrupted = errors.New("service was interrupted")
+
 var (
 	cfgFile  string
 	noBanner bool
@@ -28,9 +39,9 @@ Complete documentation is available at https://www.navidrome.org/docs`,
 			preRun()
 		},
 		Run: func(cmd *cobra.Command, args []string) {
-			runNavidrome()
+			runNavidrome(context.Background())
 		},
-		Version: consts.Version(),
+		Version: consts.Version,
 	}
 )
 
@@ -44,62 +55,95 @@ func Execute() {
 
 func preRun() {
 	if !noBanner {
-		println(consts.Banner())
+		println(resources.Banner())
 	}
 	conf.Load()
 }
 
-func runNavidrome() {
-	db.EnsureLatestVersion()
+func runNavidrome(ctx context.Context) {
+	db.Init()
+	defer func() {
+		if err := db.Close(); err != nil {
+			log.Error("Error closing DB", err)
+		}
+		log.Info("Navidrome stopped, bye.")
+	}()
 
-	var g run.Group
-	g.Add(startServer())
-	g.Add(startScanner())
+	g, ctx := errgroup.WithContext(ctx)
+	g.Go(startServer(ctx))
+	g.Go(startSignaler(ctx))
+	g.Go(startScheduler(ctx))
+	g.Go(schedulePeriodicScan(ctx))
 
-	if err := g.Run(); err != nil {
+	if err := g.Wait(); err != nil && !errors.Is(err, interrupted) {
 		log.Error("Fatal error in Navidrome. Aborting", err)
 	}
 }
 
-func startServer() (func() error, func(err error)) {
+func startServer(ctx context.Context) func() error {
 	return func() error {
-			a := CreateServer(conf.Server.MusicFolder)
-			a.MountRouter(consts.URLPathSubsonicAPI, CreateSubsonicAPIRouter())
-			a.MountRouter(consts.URLPathUI, CreateAppRouter())
-			return a.Run(fmt.Sprintf("%s:%d", conf.Server.Address, conf.Server.Port))
-		}, func(err error) {
-			if err != nil {
-				log.Error("Shutting down Server due to error", err)
-			} else {
-				log.Info("Shutting down Server")
-			}
+		a := CreateServer(conf.Server.MusicFolder)
+		a.MountRouter("Native API", consts.URLPathNativeAPI, CreateNativeAPIRouter())
+		a.MountRouter("Subsonic API", consts.URLPathSubsonicAPI, CreateSubsonicAPIRouter())
+		a.MountRouter("Public Endpoints", consts.URLPathPublic, CreatePublicRouter())
+		if conf.Server.LastFM.Enabled {
+			a.MountRouter("LastFM Auth", consts.URLPathNativeAPI+"/lastfm", CreateLastFMRouter())
 		}
+		if conf.Server.ListenBrainz.Enabled {
+			a.MountRouter("ListenBrainz Auth", consts.URLPathNativeAPI+"/listenbrainz", CreateListenBrainzRouter())
+		}
+		if conf.Server.Prometheus.Enabled {
+			// blocking call because takes <1ms but useful if fails
+			core.WriteInitialMetrics()
+			a.MountRouter("Prometheus metrics", conf.Server.Prometheus.MetricsPath, promhttp.Handler())
+		}
+		if conf.Server.DevEnableProfiler {
+			a.MountRouter("Profiling", "/debug", middleware.Profiler())
+		}
+		if strings.HasPrefix(conf.Server.UILoginBackgroundURL, "/") {
+			a.MountRouter("Background images", consts.DefaultUILoginBackgroundURL, backgrounds.NewHandler())
+		}
+		return a.Run(ctx, conf.Server.Address, conf.Server.Port, conf.Server.TLSCert, conf.Server.TLSKey)
+	}
 }
 
-func startScanner() (func() error, func(err error)) {
-	interval := conf.Server.ScanInterval
-	log.Info("Starting scanner", "interval", interval.String())
-	scanner := GetScanner()
-	ctx, cancel := context.WithCancel(context.Background())
+func schedulePeriodicScan(ctx context.Context) func() error {
+	return func() error {
+		schedule := conf.Server.ScanSchedule
+		if schedule == "" {
+			log.Warn("Periodic scan is DISABLED")
+			return nil
+		}
+
+		scanner := GetScanner()
+		schedulerInstance := scheduler.GetInstance()
+
+		log.Info("Scheduling periodic scan", "schedule", schedule)
+		err := schedulerInstance.Add(schedule, func() {
+			_ = scanner.RescanAll(ctx, false)
+		})
+		if err != nil {
+			log.Error("Error scheduling periodic scan", err)
+		}
+
+		time.Sleep(2 * time.Second) // Wait 2 seconds before the initial scan
+		log.Debug("Executing initial scan")
+		if err := scanner.RescanAll(ctx, false); err != nil {
+			log.Error("Error executing initial scan", err)
+		}
+		log.Debug("Finished initial scan")
+		return nil
+	}
+}
+
+func startScheduler(ctx context.Context) func() error {
+	log.Info(ctx, "Starting scheduler")
+	schedulerInstance := scheduler.GetInstance()
 
 	return func() error {
-			if interval != 0 {
-				time.Sleep(2 * time.Second) // Wait 2 seconds before the first scan
-				scanner.Run(ctx, interval)
-			} else {
-				log.Warn("Periodic scan is DISABLED", "interval", interval)
-				<-ctx.Done()
-			}
-
-			return nil
-		}, func(err error) {
-			cancel()
-			if err != nil {
-				log.Error("Shutting down Scanner due to error", err)
-			} else {
-				log.Info("Shutting down Scanner")
-			}
-		}
+		schedulerInstance.Run(ctx)
+		return nil
+	}
 }
 
 // TODO: Implement some struct tags to map flags to viper
@@ -118,23 +162,36 @@ func init() {
 	_ = viper.BindPFlag("datafolder", rootCmd.PersistentFlags().Lookup("datafolder"))
 	_ = viper.BindPFlag("loglevel", rootCmd.PersistentFlags().Lookup("loglevel"))
 
-	rootCmd.Flags().StringP("address", "a", viper.GetString("address"), "IP address to bind")
-	rootCmd.Flags().IntP("port", "p", viper.GetInt("port"), "HTTP port Navidrome will use")
+	rootCmd.Flags().StringP("address", "a", viper.GetString("address"), "IP address to bind to")
+	rootCmd.Flags().IntP("port", "p", viper.GetInt("port"), "HTTP port Navidrome will listen to")
+	rootCmd.Flags().String("baseurl", viper.GetString("baseurl"), "base URL to configure Navidrome behind a proxy (ex: /music or http://my.server.com)")
+	rootCmd.Flags().String("tlscert", viper.GetString("tlscert"), "optional path to a TLS cert file (enables HTTPS listening)")
+	rootCmd.Flags().String("tlskey", viper.GetString("tlskey"), "optional path to a TLS key file (enables HTTPS listening)")
+
 	rootCmd.Flags().Duration("sessiontimeout", viper.GetDuration("sessiontimeout"), "how long Navidrome will wait before closing web ui idle sessions")
 	rootCmd.Flags().Duration("scaninterval", viper.GetDuration("scaninterval"), "how frequently to scan for changes in your music library")
-	rootCmd.Flags().String("baseurl", viper.GetString("baseurl"), "base URL (only the path part) to configure Navidrome behind a proxy (ex: /music)")
 	rootCmd.Flags().String("uiloginbackgroundurl", viper.GetString("uiloginbackgroundurl"), "URL to a backaground image used in the Login page")
 	rootCmd.Flags().Bool("enabletranscodingconfig", viper.GetBool("enabletranscodingconfig"), "enables transcoding configuration in the UI")
 	rootCmd.Flags().String("transcodingcachesize", viper.GetString("transcodingcachesize"), "size of transcoding cache")
 	rootCmd.Flags().String("imagecachesize", viper.GetString("imagecachesize"), "size of image (art work) cache. set to 0 to disable cache")
 	rootCmd.Flags().Bool("autoimportplaylists", viper.GetBool("autoimportplaylists"), "enable/disable .m3u playlist auto-import`")
 
+	rootCmd.Flags().Bool("prometheus.enabled", viper.GetBool("prometheus.enabled"), "enable/disable prometheus metrics endpoint`")
+	rootCmd.Flags().String("prometheus.metricspath", viper.GetString("prometheus.metricspath"), "http endpoint for prometheus metrics")
+
 	_ = viper.BindPFlag("address", rootCmd.Flags().Lookup("address"))
 	_ = viper.BindPFlag("port", rootCmd.Flags().Lookup("port"))
+	_ = viper.BindPFlag("tlscert", rootCmd.Flags().Lookup("tlscert"))
+	_ = viper.BindPFlag("tlskey", rootCmd.Flags().Lookup("tlskey"))
+	_ = viper.BindPFlag("baseurl", rootCmd.Flags().Lookup("baseurl"))
+
 	_ = viper.BindPFlag("sessiontimeout", rootCmd.Flags().Lookup("sessiontimeout"))
 	_ = viper.BindPFlag("scaninterval", rootCmd.Flags().Lookup("scaninterval"))
-	_ = viper.BindPFlag("baseurl", rootCmd.Flags().Lookup("baseurl"))
 	_ = viper.BindPFlag("uiloginbackgroundurl", rootCmd.Flags().Lookup("uiloginbackgroundurl"))
+
+	_ = viper.BindPFlag("prometheus.enabled", rootCmd.Flags().Lookup("prometheus.enabled"))
+	_ = viper.BindPFlag("prometheus.metricspath", rootCmd.Flags().Lookup("prometheus.metricspath"))
+
 	_ = viper.BindPFlag("enabletranscodingconfig", rootCmd.Flags().Lookup("enabletranscodingconfig"))
 	_ = viper.BindPFlag("transcodingcachesize", rootCmd.Flags().Lookup("transcodingcachesize"))
 	_ = viper.BindPFlag("imagecachesize", rootCmd.Flags().Lookup("imagecachesize"))

cmd/scan.go

@@ -1,10 +1,10 @@
 package cmd
 
 import (
-	"github.com/navidrome/navidrome/conf"
+	"context"
+
 	"github.com/navidrome/navidrome/log"
 	"github.com/spf13/cobra"
-	"golang.org/x/net/context"
 )
 
 var fullRescan bool
@@ -24,8 +24,6 @@ var scanCmd = &cobra.Command{
 }
 
 func runScanner() {
-	conf.Server.DevPreCacheAlbumArtwork = false
-
 	scanner := GetScanner()
 	_ = scanner.RescanAll(context.Background(), fullRescan)
 	if fullRescan {

cmd/signaler_nonunix.go

@@ -0,0 +1,27 @@
+//go:build windows || plan9
+
+package cmd
+
+import (
+	"context"
+	"os"
+	"os/signal"
+
+	"github.com/navidrome/navidrome/log"
+)
+
+func startSignaler(ctx context.Context) func() error {
+	log.Info(ctx, "Starting signaler")
+
+	return func() error {
+		var sigChan = make(chan os.Signal, 1)
+		signal.Notify(sigChan, os.Interrupt)
+		select {
+		case sig := <-sigChan:
+			log.Info(ctx, "Received termination signal", "signal", sig)
+			return interrupted
+		case <-ctx.Done():
+			return nil
+		}
+	}
+}

cmd/signaler_unix.go

@@ -0,0 +1,51 @@
+//go:build !windows && !plan9
+
+package cmd
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/navidrome/navidrome/log"
+)
+
+const triggerScanSignal = syscall.SIGUSR1
+
+func startSignaler(ctx context.Context) func() error {
+	log.Info(ctx, "Starting signaler")
+	scanner := GetScanner()
+
+	return func() error {
+		var sigChan = make(chan os.Signal, 1)
+		signal.Notify(
+			sigChan,
+			os.Interrupt,
+			triggerScanSignal,
+			syscall.SIGHUP,
+			syscall.SIGTERM,
+			syscall.SIGABRT,
+		)
+
+		for {
+			select {
+			case sig := <-sigChan:
+				if sig != triggerScanSignal {
+					log.Info(ctx, "Received termination signal", "signal", sig)
+					return interrupted
+				}
+				log.Info(ctx, "Received signal, triggering a new scan", "signal", sig)
+				start := time.Now()
+				err := scanner.RescanAll(ctx, false)
+				if err != nil {
+					log.Error(ctx, "Error scanning", err)
+				}
+				log.Info(ctx, "Triggered scan complete", "elapsed", time.Since(start).Round(100*time.Millisecond))
+			case <-ctx.Done():
+				return nil
+			}
+		}
+	}
+}

cmd/svc.go

@@ -0,0 +1,191 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+
+	"github.com/kardianos/service"
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/log"
+	"github.com/spf13/cobra"
+)
+
+var (
+	svcStatusLabels = map[service.Status]string{
+		service.StatusUnknown: "Unknown",
+		service.StatusStopped: "Stopped",
+		service.StatusRunning: "Running",
+	}
+)
+
+func init() {
+	svcCmd.AddCommand(buildInstallCmd())
+	svcCmd.AddCommand(buildUninstallCmd())
+	svcCmd.AddCommand(buildStartCmd())
+	svcCmd.AddCommand(buildStopCmd())
+	svcCmd.AddCommand(buildStatusCmd())
+	rootCmd.AddCommand(svcCmd)
+}
+
+var svcCmd = &cobra.Command{
+	Use:     "service",
+	Aliases: []string{"svc"},
+	Short:   "Manage Navidrome as a service",
+	Long:    fmt.Sprintf("Manage Navidrome as a service, using the OS service manager (%s)", service.Platform()),
+	Run:     runServiceCmd,
+}
+
+type svcControl struct {
+	ctx    context.Context
+	cancel context.CancelFunc
+}
+
+func (p *svcControl) Start(_ service.Service) error {
+	p.ctx, p.cancel = context.WithCancel(context.Background())
+	go p.run()
+	return nil
+}
+
+func (p *svcControl) run() {
+	runNavidrome(p.ctx)
+}
+
+func (p *svcControl) Stop(_ service.Service) error {
+	log.Info("Stopping service")
+	p.cancel()
+	return nil
+}
+
+var (
+	svc     service.Service
+	svcOnce = sync.Once{}
+)
+
+func svcInstance() service.Service {
+	svcOnce.Do(func() {
+		options := make(service.KeyValue)
+		options["Restart"] = "on-success"
+		options["SuccessExitStatus"] = "1 2 8 SIGKILL"
+		options["UserService"] = true
+		options["LogDirectory"] = conf.Server.DataFolder
+		svcConfig := &service.Config{
+			Name:        "Navidrome",
+			DisplayName: "Navidrome",
+			Description: "Navidrome is a self-hosted music server and streamer",
+			Dependencies: []string{
+				"Requires=network.target",
+				"After=network-online.target syslog.target"},
+			WorkingDirectory: executablePath(),
+			Option:           options,
+		}
+		if conf.Server.ConfigFile != "" {
+			svcConfig.Arguments = []string{"-c", conf.Server.ConfigFile}
+		}
+		prg := &svcControl{}
+		var err error
+		svc, err = service.New(prg, svcConfig)
+		if err != nil {
+			log.Fatal(err)
+		}
+	})
+	return svc
+}
+
+func runServiceCmd(cmd *cobra.Command, _ []string) {
+	_ = cmd.Help()
+}
+
+func executablePath() string {
+	ex, err := os.Executable()
+	if err != nil {
+		log.Fatal(err)
+	}
+	return filepath.Dir(ex)
+}
+
+func buildInstallCmd() *cobra.Command {
+	runInstallCmd := func(_ *cobra.Command, _ []string) {
+		var err error
+		println("Installing service with:")
+		println("  working directory: " + executablePath())
+		println("  music folder:      " + conf.Server.MusicFolder)
+		println("  data folder:       " + conf.Server.DataFolder)
+		if cfgFile != "" {
+			conf.Server.ConfigFile, err = filepath.Abs(cfgFile)
+			if err != nil {
+				log.Fatal(err)
+			}
+			println("  config file:       " + conf.Server.ConfigFile)
+		}
+		err = svcInstance().Install()
+		if err != nil {
+			log.Fatal(err)
+		}
+		println("Service installed. Use 'navidrome svc start' to start it.")
+	}
+
+	return &cobra.Command{
+		Use:   "install",
+		Short: "Install Navidrome service.",
+		Run:   runInstallCmd,
+	}
+}
+
+func buildUninstallCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "uninstall",
+		Short: "Uninstall Navidrome service. Does not delete the music or data folders",
+		Run: func(cmd *cobra.Command, args []string) {
+			err := svcInstance().Uninstall()
+			if err != nil {
+				log.Fatal(err)
+			}
+			println("Service uninstalled. Music and data folders are still intact.")
+		},
+	}
+}
+
+func buildStartCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "start",
+		Short: "Start Navidrome service",
+		Run: func(cmd *cobra.Command, args []string) {
+			err := svcInstance().Start()
+			if err != nil {
+				log.Fatal(err)
+			}
+			println("Service started. Use 'navidrome svc status' to check its status.")
+		},
+	}
+}
+
+func buildStopCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "stop",
+		Short: "Stop Navidrome service",
+		Run: func(cmd *cobra.Command, args []string) {
+			err := svcInstance().Stop()
+			if err != nil {
+				log.Fatal(err)
+			}
+			println("Service stopped. Use 'navidrome svc status' to check its status.")
+		},
+	}
+}
+
+func buildStatusCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "status",
+		Short: "Show Navidrome service status",
+		Run: func(cmd *cobra.Command, args []string) {
+			status, err := svcInstance().Status()
+			if err != nil {
+				log.Fatal(err)
+			}
+			fmt.Printf("Navidrome is %s.\n", svcStatusLabels[status])
+		},
+	}
+}

cmd/wire_gen.go

@@ -1,19 +1,27 @@
 // Code generated by Wire. DO NOT EDIT.
 
 //go:generate go run github.com/google/wire/cmd/wire
-//+build !wireinject
+//go:build !wireinject
+// +build !wireinject
 
 package cmd
 
 import (
 	"github.com/google/wire"
 	"github.com/navidrome/navidrome/core"
-	"github.com/navidrome/navidrome/core/transcoder"
+	"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/ffmpeg"
+	"github.com/navidrome/navidrome/core/scrobbler"
+	"github.com/navidrome/navidrome/db"
 	"github.com/navidrome/navidrome/persistence"
 	"github.com/navidrome/navidrome/scanner"
 	"github.com/navidrome/navidrome/server"
-	"github.com/navidrome/navidrome/server/app"
 	"github.com/navidrome/navidrome/server/events"
+	"github.com/navidrome/navidrome/server/nativeapi"
+	"github.com/navidrome/navidrome/server/public"
 	"github.com/navidrome/navidrome/server/subsonic"
 	"sync"
 )
@@ -21,51 +29,90 @@ import (
 // Injectors from wire_injectors.go:
 
 func CreateServer(musicFolder string) *server.Server {
-	dataStore := persistence.New()
-	serverServer := server.New(dataStore)
+	sqlDB := db.Db()
+	dataStore := persistence.New(sqlDB)
+	broker := events.GetBroker()
+	serverServer := server.New(dataStore, broker)
 	return serverServer
 }
 
-func CreateAppRouter() *app.Router {
-	dataStore := persistence.New()
-	broker := GetBroker()
-	router := app.New(dataStore, broker)
+func CreateNativeAPIRouter() *nativeapi.Router {
+	sqlDB := db.Db()
+	dataStore := persistence.New(sqlDB)
+	share := core.NewShare(dataStore)
+	router := nativeapi.New(dataStore, share)
 	return router
 }
 
 func CreateSubsonicAPIRouter() *subsonic.Router {
-	dataStore := persistence.New()
-	artworkCache := core.GetImageCache()
-	artwork := core.NewArtwork(dataStore, artworkCache)
-	transcoderTranscoder := transcoder.New()
+	sqlDB := db.Db()
+	dataStore := persistence.New(sqlDB)
+	fileCache := artwork.GetImageCache()
+	fFmpeg := ffmpeg.New()
+	agentsAgents := agents.New(dataStore)
+	externalMetadata := core.NewExternalMetadata(dataStore, agentsAgents)
+	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, externalMetadata)
 	transcodingCache := core.GetTranscodingCache()
-	mediaStreamer := core.NewMediaStreamer(dataStore, transcoderTranscoder, transcodingCache)
-	archiver := core.NewArchiver(dataStore)
+	mediaStreamer := core.NewMediaStreamer(dataStore, fFmpeg, transcodingCache)
+	share := core.NewShare(dataStore)
+	archiver := core.NewArchiver(mediaStreamer, dataStore, share)
 	players := core.NewPlayers(dataStore)
-	externalMetadata := core.NewExternalMetadata(dataStore)
 	scanner := GetScanner()
-	router := subsonic.New(dataStore, artwork, mediaStreamer, archiver, players, externalMetadata, scanner)
+	broker := events.GetBroker()
+	playlists := core.NewPlaylists(dataStore)
+	playTracker := scrobbler.GetPlayTracker(dataStore, broker)
+	router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, externalMetadata, scanner, broker, playlists, playTracker, share)
+	return router
+}
+
+func CreatePublicRouter() *public.Router {
+	sqlDB := db.Db()
+	dataStore := persistence.New(sqlDB)
+	fileCache := artwork.GetImageCache()
+	fFmpeg := ffmpeg.New()
+	agentsAgents := agents.New(dataStore)
+	externalMetadata := core.NewExternalMetadata(dataStore, agentsAgents)
+	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, externalMetadata)
+	transcodingCache := core.GetTranscodingCache()
+	mediaStreamer := core.NewMediaStreamer(dataStore, fFmpeg, transcodingCache)
+	share := core.NewShare(dataStore)
+	archiver := core.NewArchiver(mediaStreamer, dataStore, share)
+	router := public.New(dataStore, artworkArtwork, mediaStreamer, share, archiver)
+	return router
+}
+
+func CreateLastFMRouter() *lastfm.Router {
+	sqlDB := db.Db()
+	dataStore := persistence.New(sqlDB)
+	router := lastfm.NewRouter(dataStore)
+	return router
+}
+
+func CreateListenBrainzRouter() *listenbrainz.Router {
+	sqlDB := db.Db()
+	dataStore := persistence.New(sqlDB)
+	router := listenbrainz.NewRouter(dataStore)
 	return router
 }
 
 func createScanner() scanner.Scanner {
-	dataStore := persistence.New()
-	artworkCache := core.GetImageCache()
-	artwork := core.NewArtwork(dataStore, artworkCache)
-	cacheWarmer := core.NewCacheWarmer(artwork, artworkCache)
-	broker := GetBroker()
-	scannerScanner := scanner.New(dataStore, cacheWarmer, broker)
+	sqlDB := db.Db()
+	dataStore := persistence.New(sqlDB)
+	playlists := core.NewPlaylists(dataStore)
+	fileCache := artwork.GetImageCache()
+	fFmpeg := ffmpeg.New()
+	agentsAgents := agents.New(dataStore)
+	externalMetadata := core.NewExternalMetadata(dataStore, agentsAgents)
+	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, externalMetadata)
+	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
+	broker := events.GetBroker()
+	scannerScanner := scanner.New(dataStore, playlists, cacheWarmer, broker)
 	return scannerScanner
 }
 
-func createBroker() events.Broker {
-	broker := events.NewBroker()
-	return broker
-}
-
 // wire_injectors.go:
 
-var allProviders = wire.NewSet(core.Set, subsonic.New, app.New, persistence.New)
+var allProviders = wire.NewSet(core.Set, artwork.Set, subsonic.New, nativeapi.New, public.New, persistence.New, lastfm.NewRouter, listenbrainz.NewRouter, events.GetBroker, db.Db)
 
 // Scanner must be a Singleton
 var (
@@ -79,16 +126,3 @@ func GetScanner() scanner.Scanner {
 	})
 	return scannerInstance
 }
-
-// Broker must be a Singleton
-var (
-	onceBroker     sync.Once
-	brokerInstance events.Broker
-)
-
-func GetBroker() events.Broker {
-	onceBroker.Do(func() {
-		brokerInstance = createBroker()
-	})
-	return brokerInstance
-}

cmd/wire_injectors.go

@@ -1,4 +1,4 @@
-//+build wireinject
+//go:build wireinject
 
 package cmd
 
@@ -7,19 +7,30 @@ import (
 
 	"github.com/google/wire"
 	"github.com/navidrome/navidrome/core"
+	"github.com/navidrome/navidrome/core/agents/lastfm"
+	"github.com/navidrome/navidrome/core/agents/listenbrainz"
+	"github.com/navidrome/navidrome/core/artwork"
+	"github.com/navidrome/navidrome/db"
 	"github.com/navidrome/navidrome/persistence"
 	"github.com/navidrome/navidrome/scanner"
 	"github.com/navidrome/navidrome/server"
-	"github.com/navidrome/navidrome/server/app"
 	"github.com/navidrome/navidrome/server/events"
+	"github.com/navidrome/navidrome/server/nativeapi"
+	"github.com/navidrome/navidrome/server/public"
 	"github.com/navidrome/navidrome/server/subsonic"
 )
 
 var allProviders = wire.NewSet(
 	core.Set,
+	artwork.Set,
 	subsonic.New,
-	app.New,
+	nativeapi.New,
+	public.New,
 	persistence.New,
+	lastfm.NewRouter,
+	listenbrainz.NewRouter,
+	events.GetBroker,
+	db.Db,
 )
 
 func CreateServer(musicFolder string) *server.Server {
@@ -29,10 +40,9 @@ func CreateServer(musicFolder string) *server.Server {
 	))
 }
 
-func CreateAppRouter() *app.Router {
+func CreateNativeAPIRouter() *nativeapi.Router {
 	panic(wire.Build(
 		allProviders,
-		GetBroker,
 	))
 }
 
@@ -43,6 +53,24 @@ func CreateSubsonicAPIRouter() *subsonic.Router {
 	))
 }
 
+func CreatePublicRouter() *public.Router {
+	panic(wire.Build(
+		allProviders,
+	))
+}
+
+func CreateLastFMRouter() *lastfm.Router {
+	panic(wire.Build(
+		allProviders,
+	))
+}
+
+func CreateListenBrainzRouter() *listenbrainz.Router {
+	panic(wire.Build(
+		allProviders,
+	))
+}
+
 // Scanner must be a Singleton
 var (
 	onceScanner     sync.Once
@@ -59,26 +87,6 @@ func GetScanner() scanner.Scanner {
 func createScanner() scanner.Scanner {
 	panic(wire.Build(
 		allProviders,
-		GetBroker,
 		scanner.New,
 	))
 }
-
-// Broker must be a Singleton
-var (
-	onceBroker     sync.Once
-	brokerInstance events.Broker
-)
-
-func GetBroker() events.Broker {
-	onceBroker.Do(func() {
-		brokerInstance = createBroker()
-	})
-	return brokerInstance
-}
-
-func createBroker() events.Broker {
-	panic(wire.Build(
-		events.NewBroker,
-	))
-}

conf/configtest/configtest.go

@@ -0,0 +1,10 @@
+package configtest
+
+import "github.com/navidrome/navidrome/conf"
+
+func SetupConfig() func() {
+	oldValues := *conf.Server
+	return func() {
+		conf.Server = &oldValues
+	}
+}

conf/configuration.go

@@ -2,71 +2,111 @@ package conf
 
 import (
 	"fmt"
+	"net/url"
 	"os"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"time"
 
 	"github.com/kr/pretty"
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/utils/number"
+	"github.com/robfig/cron/v3"
 	"github.com/spf13/viper"
 )
 
 type configOptions struct {
-	ConfigFile              string
-	Address                 string
-	Port                    int
-	MusicFolder             string
-	DataFolder              string
-	DbPath                  string
-	LogLevel                string
-	ScanInterval            time.Duration
-	SessionTimeout          time.Duration
-	BaseURL                 string
-	UILoginBackgroundURL    string
-	EnableTranscodingConfig bool
-	EnableDownloads         bool
-	TranscodingCacheSize    string
-	ImageCacheSize          string
-	AutoImportPlaylists     bool
+	ConfigFile                   string
+	Address                      string
+	Port                         int
+	MusicFolder                  string
+	DataFolder                   string
+	DbPath                       string
+	LogLevel                     string
+	ScanInterval                 time.Duration
+	ScanSchedule                 string
+	SessionTimeout               time.Duration
+	BaseURL                      string
+	BasePath                     string
+	BaseHost                     string
+	BaseScheme                   string
+	TLSCert                      string
+	TLSKey                       string
+	UILoginBackgroundURL         string
+	UIWelcomeMessage             string
+	MaxSidebarPlaylists          int
+	EnableTranscodingConfig      bool
+	EnableDownloads              bool
+	EnableExternalServices       bool
+	EnableMediaFileCoverArt      bool
+	TranscodingCacheSize         string
+	ImageCacheSize               string
+	EnableArtworkPrecache        bool
+	AutoImportPlaylists          bool
+	PlaylistsPath                string
+	AutoTranscodeDownload        bool
+	DefaultDownsamplingFormat    string
+	SearchFullString             bool
+	RecentlyAddedByModTime       bool
+	IgnoredArticles              string
+	IndexGroups                  string
+	SubsonicArtistParticipations bool
+	FFmpegPath                   string
+	CoverArtPriority             string
+	CoverJpegQuality             int
+	ArtistArtPriority            string
+	EnableGravatar               bool
+	EnableFavourites             bool
+	EnableStarRating             bool
+	EnableUserEditing            bool
+	EnableSharing                bool
+	DefaultDownloadableShare     bool
+	DefaultTheme                 string
+	DefaultLanguage              string
+	DefaultUIVolume              int
+	EnableReplayGain             bool
+	EnableCoverAnimation         bool
+	GATrackingID                 string
+	EnableLogRedacting           bool
+	AuthRequestLimit             int
+	AuthWindowLength             time.Duration
+	PasswordEncryptionKey        string
+	ReverseProxyUserHeader       string
+	ReverseProxyWhitelist        string
+	Prometheus                   prometheusOptions
+	Scanner                      scannerOptions
 
-	SearchFullString       bool
-	RecentlyAddedByModTime bool
-	IgnoredArticles        string
-	IndexGroups            string
-	ProbeCommand           string
-	CoverArtPriority       string
-	CoverJpegQuality       int
-	UIWelcomeMessage       string
-	EnableGravatar         bool
-	EnableFavourites       bool
-	EnableStarRating       bool
-	DefaultTheme           string
-	GATrackingID           string
-	AuthRequestLimit       int
-	AuthWindowLength       time.Duration
-
-	Scanner scannerOptions
-
-	Agents  string
-	LastFM  lastfmOptions
-	Spotify spotifyOptions
+	Agents       string
+	LastFM       lastfmOptions
+	Spotify      spotifyOptions
+	ListenBrainz listenBrainzOptions
 
 	// DevFlags. These are used to enable/disable debugging and incomplete features
-	DevLogSourceLine           bool
-	DevAutoCreateAdminPassword string
-	DevPreCacheAlbumArtwork    bool
-	DevFastAccessCoverArt      bool
-	DevOldCacheLayout          bool
-	DevActivityPanel           bool
+	DevLogSourceLine                 bool
+	DevLogLevels                     map[string]string
+	DevEnableProfiler                bool
+	DevAutoCreateAdminPassword       string
+	DevAutoLoginUsername             string
+	DevActivityPanel                 bool
+	DevSidebarPlaylists              bool
+	DevEnableBufferedScrobble        bool
+	DevShowArtistPage                bool
+	DevArtworkMaxRequests            int
+	DevArtworkThrottleBacklogLimit   int
+	DevArtworkThrottleBacklogTimeout time.Duration
+	DevArtistInfoTimeToLive          time.Duration
+	DevAlbumInfoTimeToLive           time.Duration
 }
 
 type scannerOptions struct {
-	Extractor string
+	Extractor       string
+	GenreSeparators string
 }
 
 type lastfmOptions struct {
+	Enabled  bool
 	ApiKey   string
 	Secret   string
 	Language string
@@ -77,6 +117,16 @@ type spotifyOptions struct {
 	Secret string
 }
 
+type listenBrainzOptions struct {
+	Enabled bool
+	BaseURL string
+}
+
+type prometheusOptions struct {
+	Enabled     bool
+	MetricsPath string
+}
+
 var (
 	Server = &configOptions{}
 	hooks  []func()
@@ -90,12 +140,12 @@ func LoadFromFile(confFile string) {
 func Load() {
 	err := viper.Unmarshal(&Server)
 	if err != nil {
-		fmt.Println("Error parsing config:", err)
+		_, _ = fmt.Fprintln(os.Stderr, "FATAL: Error parsing config:", err)
 		os.Exit(1)
 	}
 	err = os.MkdirAll(Server.DataFolder, os.ModePerm)
 	if err != nil {
-		fmt.Println("Error creating data path:", "path", Server.DataFolder, err)
+		_, _ = fmt.Fprintln(os.Stderr, "FATAL: Error creating data path:", "path", Server.DataFolder, err)
 		os.Exit(1)
 	}
 	Server.ConfigFile = viper.GetViper().ConfigFileUsed()
@@ -104,9 +154,38 @@ func Load() {
 	}
 
 	log.SetLevelString(Server.LogLevel)
+	log.SetLogLevels(Server.DevLogLevels)
 	log.SetLogSourceLine(Server.DevLogSourceLine)
+	log.SetRedacting(Server.EnableLogRedacting)
+
+	if err := validateScanSchedule(); err != nil {
+		os.Exit(1)
+	}
+
+	if Server.BaseURL != "" {
+		u, err := url.Parse(Server.BaseURL)
+		if err != nil {
+			_, _ = fmt.Fprintf(os.Stderr, "FATAL: Invalid BaseURL %s: %s\n", Server.BaseURL, err.Error())
+			os.Exit(1)
+		}
+		Server.BasePath = u.Path
+		u.Path = ""
+		u.RawQuery = ""
+		Server.BaseHost = u.Host
+		Server.BaseScheme = u.Scheme
+	}
+
+	// Print current configuration if log level is Debug
 	if log.CurrentLevel() >= log.LevelDebug {
-		pretty.Printf("Loaded configuration from '%s': %# v\n", Server.ConfigFile, Server)
+		prettyConf := pretty.Sprintf("Loaded configuration from '%s': %# v", Server.ConfigFile, Server)
+		if Server.EnableLogRedacting {
+			prettyConf = log.Redact(prettyConf)
+		}
+		_, _ = fmt.Fprintln(os.Stderr, prettyConf)
+	}
+
+	if !Server.EnableExternalServices {
+		disableExternalServices()
 	}
 
 	// Call init hooks
@@ -115,6 +194,46 @@ func Load() {
 	}
 }
 
+func disableExternalServices() {
+	log.Info("All external integrations are DISABLED!")
+	Server.LastFM.Enabled = false
+	Server.Spotify.ID = ""
+	Server.ListenBrainz.Enabled = false
+	Server.Agents = ""
+	if Server.UILoginBackgroundURL == consts.DefaultUILoginBackgroundURL {
+		Server.UILoginBackgroundURL = consts.DefaultUILoginBackgroundURLOffline
+	}
+}
+
+func validateScanSchedule() error {
+	if Server.ScanInterval != -1 {
+		log.Warn("ScanInterval is DEPRECATED. Please use ScanSchedule. See docs at https://navidrome.org/docs/usage/configuration-options/")
+		if Server.ScanSchedule != "@every 1m" {
+			log.Error("You cannot specify both ScanInterval and ScanSchedule, ignoring ScanInterval")
+		} else {
+			if Server.ScanInterval == 0 {
+				Server.ScanSchedule = ""
+			} else {
+				Server.ScanSchedule = fmt.Sprintf("@every %s", Server.ScanInterval)
+			}
+			log.Warn("Setting ScanSchedule", "schedule", Server.ScanSchedule)
+		}
+	}
+	if Server.ScanSchedule == "0" || Server.ScanSchedule == "" {
+		Server.ScanSchedule = ""
+		return nil
+	}
+	if _, err := time.ParseDuration(Server.ScanSchedule); err == nil {
+		Server.ScanSchedule = "@every " + Server.ScanSchedule
+	}
+	c := cron.New()
+	_, err := c.AddFunc(Server.ScanSchedule, func() {})
+	if err != nil {
+		log.Error("Invalid ScanSchedule. Please read format spec at https://pkg.go.dev/github.com/robfig/cron#hdr-CRON_Expression_Format", "schedule", Server.ScanSchedule, err)
+	}
+	return err
+}
+
 // AddHook is used to register initialization code that should run as soon as the config is loaded
 func AddHook(hook func()) {
 	hooks = append(hooks, hook)
@@ -127,47 +246,84 @@ func init() {
 	viper.SetDefault("address", "0.0.0.0")
 	viper.SetDefault("port", 4533)
 	viper.SetDefault("sessiontimeout", consts.DefaultSessionTimeout)
-	viper.SetDefault("scaninterval", time.Minute)
+	viper.SetDefault("scaninterval", -1)
+	viper.SetDefault("scanschedule", "@every 1m")
 	viper.SetDefault("baseurl", "")
+	viper.SetDefault("tlscert", "")
+	viper.SetDefault("tlskey", "")
 	viper.SetDefault("uiloginbackgroundurl", consts.DefaultUILoginBackgroundURL)
+	viper.SetDefault("uiwelcomemessage", "")
+	viper.SetDefault("maxsidebarplaylists", consts.DefaultMaxSidebarPlaylists)
 	viper.SetDefault("enabletranscodingconfig", false)
 	viper.SetDefault("transcodingcachesize", "100MB")
 	viper.SetDefault("imagecachesize", "100MB")
+	viper.SetDefault("enableartworkprecache", true)
 	viper.SetDefault("autoimportplaylists", true)
+	viper.SetDefault("playlistspath", consts.DefaultPlaylistsPath)
 	viper.SetDefault("enabledownloads", true)
-
-	// Config options only valid for file/env configuration
+	viper.SetDefault("enableexternalservices", true)
+	viper.SetDefault("enableMediaFileCoverArt", true)
+	viper.SetDefault("autotranscodedownload", false)
+	viper.SetDefault("defaultdownsamplingformat", consts.DefaultDownsamplingFormat)
 	viper.SetDefault("searchfullstring", false)
 	viper.SetDefault("recentlyaddedbymodtime", false)
 	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("probecommand", "ffmpeg %s -f ffmetadata")
-	viper.SetDefault("coverartpriority", "embedded, cover.*, folder.*, front.*")
+	viper.SetDefault("subsonicartistparticipations", false)
+	viper.SetDefault("ffmpegpath", "")
+	viper.SetDefault("coverartpriority", "cover.*, folder.*, front.*, embedded, external")
 	viper.SetDefault("coverjpegquality", 75)
-	viper.SetDefault("uiwelcomemessage", "")
+	viper.SetDefault("artistartpriority", "artist.*, album/artist.*, external")
 	viper.SetDefault("enablegravatar", false)
 	viper.SetDefault("enablefavourites", true)
 	viper.SetDefault("enablestarrating", true)
+	viper.SetDefault("enableuserediting", true)
 	viper.SetDefault("defaulttheme", "Dark")
+	viper.SetDefault("defaultlanguage", "")
+	viper.SetDefault("defaultuivolume", consts.DefaultUIVolume)
+	viper.SetDefault("enablereplaygain", true)
+	viper.SetDefault("enablecoveranimation", true)
 	viper.SetDefault("gatrackingid", "")
+	viper.SetDefault("enablelogredacting", true)
 	viper.SetDefault("authrequestlimit", 5)
 	viper.SetDefault("authwindowlength", 20*time.Second)
+	viper.SetDefault("passwordencryptionkey", "")
+
+	viper.SetDefault("reverseproxyuserheader", "Remote-User")
+	viper.SetDefault("reverseproxywhitelist", "")
+
+	viper.SetDefault("prometheus.enabled", false)
+	viper.SetDefault("prometheus.metricspath", "/metrics")
+
+	viper.SetDefault("scanner.extractor", consts.DefaultScannerExtractor)
+	viper.SetDefault("scanner.genreseparators", ";/,")
 
-	viper.SetDefault("scanner.extractor", "taglib")
 	viper.SetDefault("agents", "lastfm,spotify")
+	viper.SetDefault("lastfm.enabled", true)
 	viper.SetDefault("lastfm.language", "en")
-	viper.SetDefault("lastfm.apikey", "")
-	viper.SetDefault("lastfm.secret", "")
+	viper.SetDefault("lastfm.apikey", consts.LastFMAPIKey)
+	viper.SetDefault("lastfm.secret", consts.LastFMAPISecret)
 	viper.SetDefault("spotify.id", "")
 	viper.SetDefault("spotify.secret", "")
+	viper.SetDefault("listenbrainz.enabled", true)
+	viper.SetDefault("listenbrainz.baseurl", "https://api.listenbrainz.org/1/")
 
 	// DevFlags. These are used to enable/disable debugging and incomplete features
 	viper.SetDefault("devlogsourceline", false)
+	viper.SetDefault("devenableprofiler", false)
 	viper.SetDefault("devautocreateadminpassword", "")
-	viper.SetDefault("devprecachealbumartwork", false)
-	viper.SetDefault("devoldcachelayout", false)
-	viper.SetDefault("devFastAccessCoverArt", false)
+	viper.SetDefault("devautologinusername", "")
 	viper.SetDefault("devactivitypanel", true)
+	viper.SetDefault("enablesharing", false)
+	viper.SetDefault("defaultdownloadableshare", false)
+	viper.SetDefault("devenablebufferedscrobble", true)
+	viper.SetDefault("devsidebarplaylists", true)
+	viper.SetDefault("devshowartistpage", true)
+	viper.SetDefault("devartworkmaxrequests", number.Max(2, runtime.NumCPU()/3))
+	viper.SetDefault("devartworkthrottlebackloglimit", consts.RequestThrottleBacklogLimit)
+	viper.SetDefault("devartworkthrottlebacklogtimeout", consts.RequestThrottleBacklogTimeout)
+	viper.SetDefault("devartistinfotimetolive", consts.ArtistInfoTimeToLive)
+	viper.SetDefault("devalbuminfotimetolive", consts.AlbumInfoTimeToLive)
 }
 
 func InitConfig(cfgFile string) {
@@ -188,8 +344,8 @@ func InitConfig(cfgFile string) {
 	viper.AutomaticEnv()
 
 	err := viper.ReadInConfig()
-	if cfgFile != "" && err != nil {
-		fmt.Println("Navidrome could not open config file: ", err)
+	if viper.ConfigFileUsed() != "" && err != nil {
+		_, _ = fmt.Fprintln(os.Stderr, "FATAL: Navidrome could not open config file: ", err)
 		os.Exit(1)
 	}
 }

consts/banner.go

@@ -1,20 +0,0 @@
-package consts
-
-import (
-	"fmt"
-	"strings"
-	"unicode"
-
-	"github.com/navidrome/navidrome/resources"
-)
-
-func getBanner() string {
-	data, _ := resources.Asset("banner.txt")
-	return strings.TrimRightFunc(string(data), unicode.IsSpace)
-}
-
-func Banner() string {
-	version := "Version: " + Version()
-	padding := strings.Repeat(" ", 52-len(version))
-	return fmt.Sprintf("%s\n%s%s\n", getBanner(), padding, version)
-}

consts/consts.go

@@ -3,6 +3,7 @@ package consts
 import (
 	"crypto/md5"
 	"fmt"
+	"path/filepath"
 	"strings"
 	"time"
 )
@@ -13,32 +14,59 @@ const (
 	DefaultDbPath       = "navidrome.db?cache=shared&_busy_timeout=15000&_journal_mode=WAL&_foreign_keys=on"
 	InitialSetupFlagKey = "InitialSetup"
 
-	UIAuthorizationHeader = "X-ND-Authorization"
-	JWTSecretKey          = "JWTSecret"
-	JWTIssuer             = "ND"
-	DefaultSessionTimeout = 24 * time.Hour
+	UIAuthorizationHeader  = "X-ND-Authorization"
+	UIClientUniqueIDHeader = "X-ND-Client-Unique-Id"
+	JWTSecretKey           = "JWTSecret"
+	JWTIssuer              = "ND"
+	DefaultSessionTimeout  = 24 * time.Hour
+	CookieExpiry           = 365 * 24 * 3600 // One year
+
+	// DefaultEncryptionKey This is the encryption key used if none is specified in the `PasswordEncryptionKey` option
+	// Never ever change this! Or it will break all Navidrome installations that don't set the config option
+	DefaultEncryptionKey  = "just for obfuscation"
+	PasswordsEncryptedKey = "PasswordsEncryptedKey"
+	PasswordAutogenPrefix = "__NAVIDROME_AUTOGEN__" //nolint:gosec
 
 	DevInitialUserName = "admin"
 	DevInitialName     = "Dev Admin"
 
-	URLPathUI          = "/app"
-	URLPathSubsonicAPI = "/rest"
+	URLPathUI           = "/app"
+	URLPathNativeAPI    = "/api"
+	URLPathSubsonicAPI  = "/rest"
+	URLPathPublic       = "/share"
+	URLPathPublicImages = URLPathPublic + "/img"
 
-	// Login backgrounds from https://unsplash.com/collections/20072696/navidrome
-	DefaultUILoginBackgroundURL = "https://source.unsplash.com/collection/20072696/1600x900"
+	// DefaultUILoginBackgroundURL uses Navidrome curated background images collection,
+	// available at https://unsplash.com/collections/20072696/navidrome
+	DefaultUILoginBackgroundURL = "/backgrounds"
+
+	// DefaultUILoginBackgroundOffline Background image used in case external integrations are disabled
+	DefaultUILoginBackgroundOffline    = "iVBORw0KGgoAAAANSUhEUgAAAMgAAADICAIAAAAiOjnJAAAABGdBTUEAALGPC/xhBQAAAiJJREFUeF7t0IEAAAAAw6D5Ux/khVBhwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDDwMDDVlwABBWcSrQAAAABJRU5ErkJggg=="
+	DefaultUILoginBackgroundURLOffline = "data:image/png;base64," + DefaultUILoginBackgroundOffline
+	DefaultMaxSidebarPlaylists         = 100
 
 	RequestThrottleBacklogLimit   = 100
 	RequestThrottleBacklogTimeout = time.Minute
 
-	ArtistInfoTimeToLive = 1 * time.Hour
+	ServerReadHeaderTimeout = 3 * time.Second
+
+	ArtistInfoTimeToLive = 24 * time.Hour
+	AlbumInfoTimeToLive  = 7 * 24 * time.Hour
 
 	I18nFolder   = "i18n"
 	SkipScanFile = ".ndignore"
 
-	PlaceholderAlbumArt = "navidrome-600x600.png"
-	PlaceholderAvatar   = "logo-192x192.png"
+	PlaceholderArtistArt = "artist-placeholder.webp"
+	PlaceholderAlbumArt  = "placeholder.png"
+	PlaceholderAvatar    = "logo-192x192.png"
+	UICoverArtSize       = 300
+	DefaultUIVolume      = 100
 
-	DefaultCachedHttpClientTTL = 10 * time.Second
+	DefaultHttpClientTimeOut = 10 * time.Second
+
+	DefaultScannerExtractor = "taglib"
+
+	Zwsp = string('\u200b')
 )
 
 // Cache options
@@ -53,8 +81,15 @@ const (
 	DefaultCacheCleanUpInterval = 10 * time.Minute
 )
 
+// Shared secrets (only add here "secrets" that can be public)
+const (
+	LastFMAPIKey    = "9b94a5515ea66b2da3ec03c12300327e" // nolint:gosec
+	LastFMAPISecret = "74cb6557cec7171d921af5d7d887c587" // nolint:gosec
+)
+
 var (
-	DefaultTranscodings = []map[string]interface{}{
+	DefaultDownsamplingFormat = "opus"
+	DefaultTranscodings       = []map[string]interface{}{
 		{
 			"name":           "mp3 audio",
 			"targetFormat":   "mp3",
@@ -67,13 +102,24 @@ var (
 			"defaultBitRate": 128,
 			"command":        "ffmpeg -i %s -map 0:0 -b:a %bk -v 0 -c:a libopus -f opus -",
 		},
+		{
+			"name":           "aac audio",
+			"targetFormat":   "aac",
+			"defaultBitRate": 256,
+			"command":        "ffmpeg -i %s -map 0:0 -b:a %bk -v 0 -c:a aac -f adts -",
+		},
 	}
+
+	DefaultPlaylistsPath = strings.Join([]string{".", "**/**"}, string(filepath.ListSeparator))
 )
 
 var (
-	VariousArtists   = "Various Artists"
-	VariousArtistsID = fmt.Sprintf("%x", md5.Sum([]byte(strings.ToLower(VariousArtists))))
-	UnknownArtist    = "[Unknown Artist]"
+	VariousArtists      = "Various Artists"
+	VariousArtistsID    = fmt.Sprintf("%x", md5.Sum([]byte(strings.ToLower(VariousArtists))))
+	UnknownAlbum        = "[Unknown Album]"
+	UnknownArtist       = "[Unknown Artist]"
+	UnknownArtistID     = fmt.Sprintf("%x", md5.Sum([]byte(strings.ToLower(UnknownArtist))))
+	VariousArtistsMbzId = "89ad4ac3-39f7-470e-963a-56509c546377"
 
 	ServerStart = time.Now()
 )

consts/mime_types.go

@@ -1,43 +1,64 @@
 package consts
 
-import "mime"
+import (
+	"mime"
+	"sort"
+	"strings"
+)
 
-var LosslessFormats = []string{
-	"flac", "wav", "alac", "ape", "dsf", "wav", "shn", "wv", "wvp",
+type format struct {
+	typ      string
+	lossless bool
 }
 
+var audioFormats = map[string]format{
+	".mp3":  {typ: "audio/mpeg"},
+	".ogg":  {typ: "audio/ogg"},
+	".oga":  {typ: "audio/ogg"},
+	".opus": {typ: "audio/ogg"},
+	".aac":  {typ: "audio/mp4"},
+	".alac": {typ: "audio/mp4", lossless: true},
+	".m4a":  {typ: "audio/mp4"},
+	".m4b":  {typ: "audio/mp4"},
+	".flac": {typ: "audio/flac", lossless: true},
+	".wav":  {typ: "audio/x-wav", lossless: true},
+	".wma":  {typ: "audio/x-ms-wma"},
+	".ape":  {typ: "audio/x-monkeys-audio", lossless: true},
+	".mpc":  {typ: "audio/x-musepack"},
+	".shn":  {typ: "audio/x-shn", lossless: true},
+	".aif":  {typ: "audio/x-aiff"},
+	".aiff": {typ: "audio/x-aiff"},
+	".m3u":  {typ: "audio/x-mpegurl"},
+	".pls":  {typ: "audio/x-scpls"},
+	".dsf":  {typ: "audio/dsd", lossless: true},
+	".wv":   {typ: "audio/x-wavpack", lossless: true},
+	".wvp":  {typ: "audio/x-wavpack", lossless: true},
+	".mka":  {typ: "audio/x-matroska"},
+}
+var imageFormats = map[string]string{
+	".gif":  "image/gif",
+	".jpg":  "image/jpeg",
+	".jpeg": "image/jpeg",
+	".webp": "image/webp",
+	".png":  "image/png",
+	".bmp":  "image/bmp",
+}
+
+var LosslessFormats []string
+
 func init() {
-	mt := map[string]string{
-		".mp3":  "audio/mpeg",
-		".ogg":  "audio/ogg",
-		".oga":  "audio/ogg",
-		".opus": "audio/ogg",
-		".aac":  "audio/mp4",
-		".alac": "audio/mp4",
-		".m4a":  "audio/mp4",
-		".m4b":  "audio/mp4",
-		".flac": "audio/flac",
-		".wav":  "audio/x-wav",
-		".wma":  "audio/x-ms-wma",
-		".ape":  "audio/x-monkeys-audio",
-		".mpc":  "audio/x-musepack",
-		".shn":  "audio/x-shn",
-		".aif":  "audio/x-aiff",
-		".aiff": "audio/x-aiff",
-		".m3u":  "audio/x-mpegurl",
-		".pls":  "audio/x-scpls",
-		".dsf":  "audio/dsd",
-		".wv":   "audio/x-wavpack",
-		".wvp":  "audio/x-wavpack",
-		".gif":  "image/gif",
-		".jpg":  "image/jpeg",
-		".jpeg": "image/jpeg",
-		".webp": "image/webp",
-		".png":  "image/png",
-		".bmp":  "image/bmp",
+	for ext, fmt := range audioFormats {
+		_ = mime.AddExtensionType(ext, fmt.typ)
+		if fmt.lossless {
+			LosslessFormats = append(LosslessFormats, strings.TrimPrefix(ext, "."))
+		}
 	}
-
-	for ext, typ := range mt {
+	sort.Strings(LosslessFormats)
+	for ext, typ := range imageFormats {
 		_ = mime.AddExtensionType(ext, typ)
 	}
+
+	// In some circumstances, Windows sets JS mime-type to `text/plain`!
+	_ = mime.AddExtensionType(".js", "text/javascript")
+	_ = mime.AddExtensionType(".css", "text/css")
 }

consts/version.go

@@ -11,15 +11,16 @@ var (
 	gitSha string
 )
 
-// Formats:
+// Version holds the version string, with tag and git sha info.
+// Examples:
 // dev
 // v0.2.0 (5b84188)
 // v0.3.2-SNAPSHOT (715f552)
 // master (9ed35cb)
-func Version() string {
+var Version = func() string {
 	if gitSha == "" {
 		return "dev"
 	}
 	gitTag = strings.TrimPrefix(gitTag, "v")
 	return fmt.Sprintf("%s (%s)", gitTag, gitSha)
-}
+}()

contrib/docker-compose/Caddyfile

@@ -0,0 +1,7 @@
+https://your.website {
+  reverse_proxy * navidrome:4533 {
+    header_up Host {http.reverse_proxy.upstream.hostport}
+    header_up X-Forwarded-For {http.request.remote}
+    header_up X-Real-IP {http.reverse_proxy.upstream.port}
+  }
+}

contrib/docker-compose/docker-compose-caddy.yml

@@ -0,0 +1,31 @@
+version: '3.6'
+
+volumes:
+  caddy_data:
+  navidrome_data:
+
+services:
+
+  caddy:
+    container_name: "caddy"
+    image: caddy:2.6-alpine
+    restart: unless-stopped
+    read_only: true
+    volumes:
+      - "caddy_data:/data:rw"
+      - "./Caddyfile:/etc/caddy/Caddyfile:ro"
+    ports:
+      - "80:80"
+      - "443:443"
+
+  navidrome:
+    container_name: "navidrome"
+    image: deluan/navidrome:latest
+    restart: unless-stopped
+    read_only: true
+    # user: 1000:1000
+    ports:
+      - "4533:4533"
+    volumes:
+      - "navidrome_data:/data"
+      #- "/mnt/music:/music:ro"

contrib/docker-compose/docker-compose-traefik.yml

@@ -0,0 +1,51 @@
+version: "3.6"
+
+volumes:
+  traefik_data:
+  navidrome_data:
+
+services:
+
+  traefik:
+    container_name: "traefik"
+    image: traefik:2.9
+    restart: unless-stopped
+    read_only: true
+    command:
+      - "--log.level=ERROR"
+      - "--providers.docker=true"
+      - "--providers.docker.exposedbydefault=false"
+      - "--entrypoints.websecure.address=:443"
+      - "--certificatesresolvers.tc.acme.tlschallenge=true"
+      #- "--certificatesresolvers.tc.acme.caserver=https://acme-staging-v02.api.letsencrypt.org/directory"
+      - "--certificatesresolvers.tc.acme.email=foo@foo.com"
+      - "--certificatesresolvers.tc.acme.storage=/letsencrypt/acme.json"
+    ports:
+      - "443:443"
+    volumes:
+      - "traefik_data:/letsencrypt"
+      #- "/var/run/docker.sock:/var/run/docker.sock:ro"
+
+  navidrome:
+    container_name: "navidrome"
+    image: deluan/navidrome:latest
+    restart: unless-stopped
+    read_only: true
+    # user: 1000:1000
+    ports:
+      - "4533:4533"
+    environment:
+      ND_SCANINTERVAL: 6h
+      ND_LOGLEVEL: info
+      ND_SESSIONTIMEOUT: 168h
+      ND_BASEURL: ""
+    volumes:
+      - "navidrome_data:/data"
+      #- "/mnt/music:/music:ro"
+    labels:
+      - "traefik.enable=true"
+      - "traefik.http.routers.navidrome.rule=Host(`foo.com`)"
+      - "traefik.http.routers.navidrome.entrypoints=websecure"
+      - "traefik.http.routers.navidrome.tls=true"
+      - "traefik.http.routers.navidrome.tls.certresolver=tc"
+      - "traefik.http.services.navidrome.loadbalancer.server.port=4533"

contrib/docker-compose/docker-compose.yml

@@ -0,0 +1,18 @@
+version: '3.6'
+
+volumes:
+  navidrome_data:
+
+services:
+
+  navidrome:
+    container_name: "navidrome"
+    image: deluan/navidrome:latest
+    restart: unless-stopped
+    read_only: true
+    # user: 1000:1000
+    ports:
+      - "4533:4533"
+    volumes:
+      - "navidrome_data:/data"
+      #- "/mnt/music:/music:ro"

contrib/k8s/README.md

@@ -0,0 +1,11 @@
+# Kubernetes
+
+A couple things to keep in mind with this manifest:
+
+1. This creates a namespace called `navidrome`. Adjust this as needed.
+1. This manifest was created on [K3s](https://github.com/k3s-io/k3s), which uses its own storage provisioner called [local-path-provisioner](https://github.com/rancher/local-path-provisioner). Be sure to change the `storageClassName` of the `PersistentVolumeClaim` as needed.
+1. The `PersistentVolumeClaim` sets up a 2Gi volume for Navidrome's database. Adjust this as needed.
+1. Be sure to change the `image` tag from `ghcr.io/navidrome/navidrome:0.49.3` to whatever the newest version is.
+1. This assumes your music is mounted on the host using `hostPath` at `/path/to/your/music/on/the/host`. Adjust this as needed.
+1. The `Ingress` is already configured for `cert-manager` to obtain a Let's Encrypt TLS certificate and uses Traefik for routing. Adjust this as needed. 
+1. The `Ingress` presents the service at `navidrome.${SECRET_INTERNAL_DOMAIN_NAME}`, which needs to already be setup in DNS.

contrib/k8s/manifest.yml

@@ -0,0 +1,111 @@
+---
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: navidrome
+---
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: navidrome-data-pvc
+  namespace: navidrome
+  annotations:
+    volumeType: local
+spec:
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 2Gi
+  storageClassName: local-path
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: navidrome-deployment
+  namespace: navidrome
+spec:
+  replicas: 1
+  revisionHistoryLimit: 2
+  selector:
+    matchLabels:
+      app: navidrome
+  template:
+    metadata:
+      labels:
+        app: navidrome
+    spec:
+      containers:
+        - name: navidrome
+          image: ghcr.io/navidrome/navidrome:0.49.3
+          ports:
+            - containerPort: 4533
+          env:
+            - name: ND_SCANSCHEDULE
+              value: "12h"
+            - name: ND_SESSIONTIMEOUT
+              value: "24h"
+            - name: ND_LOGLEVEL
+              value: "info"
+            - name: ND_ENABLETRANSCODINGCONFIG
+              value: "false"
+            - name: ND_TRANSCODINGCACHESIZE
+              value: "512MB"
+            - name: ND_ENABLESTARRATING
+              value: "false"
+            - name: ND_ENABLEFAVOURITES
+              value: "false"
+          volumeMounts:
+            - name: data
+              mountPath: /data
+            - name: music
+              mountPath: /music
+              readOnly: true
+      volumes:
+        - name: data
+          persistentVolumeClaim:
+            claimName: navidrome-data-pvc
+        - name: music
+          hostPath:
+            path: /path/to/your/music/on/the/host
+            type: Directory
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: navidrome-service
+  namespace: navidrome
+spec:
+  type: ClusterIP
+  ports:
+    - name: http
+      targetPort: 4533
+      port: 4533
+      protocol: TCP
+  selector:
+    app: navidrome
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: navidrome-ingress
+  namespace: navidrome
+  annotations:
+    cert-manager.io/cluster-issuer: letsencrypt-production
+    traefik.ingress.kubernetes.io/router.tls: "true"
+spec:
+  rules:
+    - host: navidrome.${SECRET_INTERNAL_DOMAIN_NAME}
+      http:
+        paths:
+          - path: /
+            pathType: Prefix
+            backend:
+              service:
+                name: navidrome-service
+                port:
+                  number: 4533
+  tls:
+    - hosts:
+        - navidrome.${SECRET_INTERNAL_DOMAIN_NAME}
+      secretName: navidrome-tls

contrib/navidrome.service

@@ -3,7 +3,6 @@
 [Unit]
 Description=Navidrome Music Server and Streamer compatible with Subsonic/Airsonic
 After=remote-fs.target network.target
-AssertPathExists=/var/lib/navidrome
 
 [Install]
 WantedBy=multi-user.target
@@ -13,6 +12,7 @@ User=navidrome
 Group=navidrome
 Type=simple
 ExecStart=/usr/bin/navidrome
+StateDirectory=navidrome
 WorkingDirectory=/var/lib/navidrome
 TimeoutStopSec=20
 KillMode=process
@@ -21,18 +21,26 @@ Restart=on-failure
 EnvironmentFile=-/etc/sysconfig/navidrome
 
 # See https://www.freedesktop.org/software/systemd/man/systemd.exec.html
+CapabilityBoundingSet=
 DevicePolicy=closed
 NoNewPrivileges=yes
+LockPersonality=yes
 PrivateTmp=yes
 PrivateUsers=yes
 ProtectControlGroups=yes
 ProtectKernelModules=yes
 ProtectKernelTunables=yes
+ProtectClock=yes
+ProtectHostname=yes
+ProtectKernelLogs=yes
 RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
 RestrictNamespaces=yes
 RestrictRealtime=yes
-SystemCallFilter=~@clock @debug @module @mount @obsolete @privileged @reboot @setuid @swap
-ReadWritePaths=/var/lib/navidrome
+SystemCallFilter=@system-service
+SystemCallFilter=~@privileged @resources
+SystemCallFilter=setrlimit
+SystemCallArchitectures=native
+UMask=0066
 
 # You can uncomment the following line if you're not using the jukebox This
 # will prevent navidrome from accessing any real (physical) devices

core/agents/README.md

@@ -1,6 +1,6 @@
 This folder abstracts metadata lookup into "agents". Each agent can be implemented to get as
 much info as the external source provides, by using a granular set of interfaces 
-(see [interfaces](interfaces.go)].
+(see [interfaces](interfaces.go)).
 
 A new agent must comply with these simple implementation rules:
 1) Implement the `AgentName()` method. It just returns the name of the agent for logging purposes.
@@ -9,4 +9,4 @@ A new agent must comply with these simple implementation rules:
 
 For an agent to be used it needs to be listed in the `Agents` config option (default is `"lastfm,spotify"`). The order dictates the priority of the agents
 
-For a simple Agent example, look at the [placeholders.go](placeholders.go) agent source code.
+For a simple Agent example, look at the [local_agent](local_agent.go) agent source code.

core/agents/agents.go

@@ -0,0 +1,228 @@
+package agents
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils"
+)
+
+type Agents struct {
+	ds     model.DataStore
+	agents []Interface
+}
+
+func New(ds model.DataStore) *Agents {
+	var order []string
+	if conf.Server.Agents != "" {
+		order = strings.Split(conf.Server.Agents, ",")
+	}
+	order = append(order, LocalAgentName)
+	var res []Interface
+	for _, name := range order {
+		init, ok := Map[name]
+		if !ok {
+			log.Error("Agent not available. Check configuration", "name", name)
+			continue
+		}
+
+		res = append(res, init(ds))
+	}
+
+	return &Agents{ds: ds, agents: res}
+}
+
+func (a *Agents) AgentName() string {
+	return "agents"
+}
+
+func (a *Agents) GetArtistMBID(ctx context.Context, id string, name string) (string, error) {
+	switch id {
+	case consts.UnknownArtistID:
+		return "", ErrNotFound
+	case consts.VariousArtistsID:
+		return "", nil
+	}
+	start := time.Now()
+	for _, ag := range a.agents {
+		if utils.IsCtxDone(ctx) {
+			break
+		}
+		agent, ok := ag.(ArtistMBIDRetriever)
+		if !ok {
+			continue
+		}
+		mbid, err := agent.GetArtistMBID(ctx, id, name)
+		if mbid != "" && err == nil {
+			log.Debug(ctx, "Got MBID", "agent", ag.AgentName(), "artist", name, "mbid", mbid, "elapsed", time.Since(start))
+			return mbid, nil
+		}
+	}
+	return "", ErrNotFound
+}
+
+func (a *Agents) GetArtistURL(ctx context.Context, id, name, mbid string) (string, error) {
+	switch id {
+	case consts.UnknownArtistID:
+		return "", ErrNotFound
+	case consts.VariousArtistsID:
+		return "", nil
+	}
+	start := time.Now()
+	for _, ag := range a.agents {
+		if utils.IsCtxDone(ctx) {
+			break
+		}
+		agent, ok := ag.(ArtistURLRetriever)
+		if !ok {
+			continue
+		}
+		url, err := agent.GetArtistURL(ctx, id, name, mbid)
+		if url != "" && err == nil {
+			log.Debug(ctx, "Got External Url", "agent", ag.AgentName(), "artist", name, "url", url, "elapsed", time.Since(start))
+			return url, nil
+		}
+	}
+	return "", ErrNotFound
+}
+
+func (a *Agents) GetArtistBiography(ctx context.Context, id, name, mbid string) (string, error) {
+	switch id {
+	case consts.UnknownArtistID:
+		return "", ErrNotFound
+	case consts.VariousArtistsID:
+		return "", nil
+	}
+	start := time.Now()
+	for _, ag := range a.agents {
+		if utils.IsCtxDone(ctx) {
+			break
+		}
+		agent, ok := ag.(ArtistBiographyRetriever)
+		if !ok {
+			continue
+		}
+		bio, err := agent.GetArtistBiography(ctx, id, name, mbid)
+		if err == nil {
+			log.Debug(ctx, "Got Biography", "agent", ag.AgentName(), "artist", name, "len", len(bio), "elapsed", time.Since(start))
+			return bio, nil
+		}
+	}
+	return "", ErrNotFound
+}
+
+func (a *Agents) GetSimilarArtists(ctx context.Context, id, name, mbid string, limit int) ([]Artist, error) {
+	switch id {
+	case consts.UnknownArtistID:
+		return nil, ErrNotFound
+	case consts.VariousArtistsID:
+		return nil, nil
+	}
+	start := time.Now()
+	for _, ag := range a.agents {
+		if utils.IsCtxDone(ctx) {
+			break
+		}
+		agent, ok := ag.(ArtistSimilarRetriever)
+		if !ok {
+			continue
+		}
+		similar, err := agent.GetSimilarArtists(ctx, id, name, mbid, limit)
+		if len(similar) > 0 && err == nil {
+			if log.CurrentLevel() >= log.LevelTrace {
+				log.Debug(ctx, "Got Similar Artists", "agent", ag.AgentName(), "artist", name, "similar", similar, "elapsed", time.Since(start))
+			} else {
+				log.Debug(ctx, "Got Similar Artists", "agent", ag.AgentName(), "artist", name, "similarReceived", len(similar), "elapsed", time.Since(start))
+			}
+			return similar, err
+		}
+	}
+	return nil, ErrNotFound
+}
+
+func (a *Agents) GetArtistImages(ctx context.Context, id, name, mbid string) ([]ExternalImage, error) {
+	switch id {
+	case consts.UnknownArtistID:
+		return nil, ErrNotFound
+	case consts.VariousArtistsID:
+		return nil, nil
+	}
+	start := time.Now()
+	for _, ag := range a.agents {
+		if utils.IsCtxDone(ctx) {
+			break
+		}
+		agent, ok := ag.(ArtistImageRetriever)
+		if !ok {
+			continue
+		}
+		images, err := agent.GetArtistImages(ctx, id, name, mbid)
+		if len(images) > 0 && err == nil {
+			log.Debug(ctx, "Got Images", "agent", ag.AgentName(), "artist", name, "images", images, "elapsed", time.Since(start))
+			return images, nil
+		}
+	}
+	return nil, ErrNotFound
+}
+
+func (a *Agents) GetArtistTopSongs(ctx context.Context, id, artistName, mbid string, count int) ([]Song, error) {
+	switch id {
+	case consts.UnknownArtistID:
+		return nil, ErrNotFound
+	case consts.VariousArtistsID:
+		return nil, nil
+	}
+	start := time.Now()
+	for _, ag := range a.agents {
+		if utils.IsCtxDone(ctx) {
+			break
+		}
+		agent, ok := ag.(ArtistTopSongsRetriever)
+		if !ok {
+			continue
+		}
+		songs, err := agent.GetArtistTopSongs(ctx, id, artistName, mbid, count)
+		if len(songs) > 0 && err == nil {
+			log.Debug(ctx, "Got Top Songs", "agent", ag.AgentName(), "artist", artistName, "songs", songs, "elapsed", time.Since(start))
+			return songs, nil
+		}
+	}
+	return nil, ErrNotFound
+}
+
+func (a *Agents) GetAlbumInfo(ctx context.Context, name, artist, mbid string) (*AlbumInfo, error) {
+	if name == consts.UnknownAlbum {
+		return nil, ErrNotFound
+	}
+	start := time.Now()
+	for _, ag := range a.agents {
+		if utils.IsCtxDone(ctx) {
+			break
+		}
+		agent, ok := ag.(AlbumInfoRetriever)
+		if !ok {
+			continue
+		}
+		album, err := agent.GetAlbumInfo(ctx, name, artist, mbid)
+		if err == nil {
+			log.Debug(ctx, "Got Album Info", "agent", ag.AgentName(), "album", name, "artist", artist,
+				"mbid", mbid, "elapsed", time.Since(start))
+			return album, nil
+		}
+	}
+	return nil, ErrNotFound
+}
+
+var _ Interface = (*Agents)(nil)
+var _ ArtistMBIDRetriever = (*Agents)(nil)
+var _ ArtistURLRetriever = (*Agents)(nil)
+var _ ArtistBiographyRetriever = (*Agents)(nil)
+var _ ArtistSimilarRetriever = (*Agents)(nil)
+var _ ArtistImageRetriever = (*Agents)(nil)
+var _ ArtistTopSongsRetriever = (*Agents)(nil)
+var _ AlbumInfoRetriever = (*Agents)(nil)

core/agents/agents_suite_test.go

@@ -5,13 +5,13 @@ import (
 
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
 
 func TestAgents(t *testing.T) {
 	tests.Init(t, false)
-	log.SetLevel(log.LevelCritical)
+	log.SetLevel(log.LevelFatal)
 	RegisterFailHandler(Fail)
 	RunSpecs(t, "Agents Test Suite")
 }

core/agents/agents_test.go

@@ -0,0 +1,346 @@
+package agents
+
+import (
+	"context"
+	"errors"
+
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
+
+	"github.com/navidrome/navidrome/conf"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Agents", func() {
+	var ctx context.Context
+	var cancel context.CancelFunc
+	var ds model.DataStore
+	var mfRepo *tests.MockMediaFileRepo
+	BeforeEach(func() {
+		ctx, cancel = context.WithCancel(context.Background())
+		mfRepo = tests.CreateMockMediaFileRepo()
+		ds = &tests.MockDataStore{MockedMediaFile: mfRepo}
+	})
+
+	Describe("Local", func() {
+		var ag *Agents
+		BeforeEach(func() {
+			conf.Server.Agents = ""
+			ag = New(ds)
+		})
+
+		It("calls the placeholder GetArtistImages", func() {
+			mfRepo.SetData(model.MediaFiles{{ID: "1", Title: "One", MbzReleaseTrackID: "111"}, {ID: "2", Title: "Two", MbzReleaseTrackID: "222"}})
+			songs, err := ag.GetArtistTopSongs(ctx, "123", "John Doe", "mb123", 2)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(songs).To(ConsistOf([]Song{{Name: "One", MBID: "111"}, {Name: "Two", MBID: "222"}}))
+		})
+	})
+
+	Describe("Agents", func() {
+		var ag *Agents
+		var mock *mockAgent
+		BeforeEach(func() {
+			mock = &mockAgent{}
+			Register("fake", func(ds model.DataStore) Interface {
+				return mock
+			})
+			Register("empty", func(ds model.DataStore) Interface {
+				return struct {
+					Interface
+				}{}
+			})
+			conf.Server.Agents = "empty,fake"
+			ag = New(ds)
+			Expect(ag.AgentName()).To(Equal("agents"))
+		})
+
+		Describe("GetArtistMBID", func() {
+			It("returns on first match", func() {
+				Expect(ag.GetArtistMBID(ctx, "123", "test")).To(Equal("mbid"))
+				Expect(mock.Args).To(ConsistOf("123", "test"))
+			})
+			It("returns empty if artist is Various Artists", func() {
+				mbid, err := ag.GetArtistMBID(ctx, consts.VariousArtistsID, consts.VariousArtists)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(mbid).To(BeEmpty())
+				Expect(mock.Args).To(BeEmpty())
+			})
+			It("returns not found if artist is Unknown Artist", func() {
+				mbid, err := ag.GetArtistMBID(ctx, consts.VariousArtistsID, consts.VariousArtists)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(mbid).To(BeEmpty())
+				Expect(mock.Args).To(BeEmpty())
+			})
+			It("skips the agent if it returns an error", func() {
+				mock.Err = errors.New("error")
+				_, err := ag.GetArtistMBID(ctx, "123", "test")
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(ConsistOf("123", "test"))
+			})
+			It("interrupts if the context is canceled", func() {
+				cancel()
+				_, err := ag.GetArtistMBID(ctx, "123", "test")
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(BeEmpty())
+			})
+		})
+
+		Describe("GetArtistURL", func() {
+			It("returns on first match", func() {
+				Expect(ag.GetArtistURL(ctx, "123", "test", "mb123")).To(Equal("url"))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123"))
+			})
+			It("returns empty if artist is Various Artists", func() {
+				url, err := ag.GetArtistURL(ctx, consts.VariousArtistsID, consts.VariousArtists, "")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(url).To(BeEmpty())
+				Expect(mock.Args).To(BeEmpty())
+			})
+			It("returns not found if artist is Unknown Artist", func() {
+				url, err := ag.GetArtistURL(ctx, consts.VariousArtistsID, consts.VariousArtists, "")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(url).To(BeEmpty())
+				Expect(mock.Args).To(BeEmpty())
+			})
+			It("skips the agent if it returns an error", func() {
+				mock.Err = errors.New("error")
+				_, err := ag.GetArtistURL(ctx, "123", "test", "mb123")
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123"))
+			})
+			It("interrupts if the context is canceled", func() {
+				cancel()
+				_, err := ag.GetArtistURL(ctx, "123", "test", "mb123")
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(BeEmpty())
+			})
+		})
+
+		Describe("GetArtistBiography", func() {
+			It("returns on first match", func() {
+				Expect(ag.GetArtistBiography(ctx, "123", "test", "mb123")).To(Equal("bio"))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123"))
+			})
+			It("returns empty if artist is Various Artists", func() {
+				bio, err := ag.GetArtistBiography(ctx, consts.VariousArtistsID, consts.VariousArtists, "")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(bio).To(BeEmpty())
+				Expect(mock.Args).To(BeEmpty())
+			})
+			It("returns not found if artist is Unknown Artist", func() {
+				bio, err := ag.GetArtistBiography(ctx, consts.VariousArtistsID, consts.VariousArtists, "")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(bio).To(BeEmpty())
+				Expect(mock.Args).To(BeEmpty())
+			})
+			It("skips the agent if it returns an error", func() {
+				mock.Err = errors.New("error")
+				_, err := ag.GetArtistBiography(ctx, "123", "test", "mb123")
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123"))
+			})
+			It("interrupts if the context is canceled", func() {
+				cancel()
+				_, err := ag.GetArtistBiography(ctx, "123", "test", "mb123")
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(BeEmpty())
+			})
+		})
+
+		Describe("GetArtistImages", func() {
+			It("returns on first match", func() {
+				Expect(ag.GetArtistImages(ctx, "123", "test", "mb123")).To(Equal([]ExternalImage{{
+					URL:  "imageUrl",
+					Size: 100,
+				}}))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123"))
+			})
+			It("skips the agent if it returns an error", func() {
+				mock.Err = errors.New("error")
+				_, err := ag.GetArtistImages(ctx, "123", "test", "mb123")
+				Expect(err).To(MatchError("not found"))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123"))
+			})
+			It("interrupts if the context is canceled", func() {
+				cancel()
+				_, err := ag.GetArtistImages(ctx, "123", "test", "mb123")
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(BeEmpty())
+			})
+		})
+
+		Describe("GetSimilarArtists", func() {
+			It("returns on first match", func() {
+				Expect(ag.GetSimilarArtists(ctx, "123", "test", "mb123", 1)).To(Equal([]Artist{{
+					Name: "Joe Dohn",
+					MBID: "mbid321",
+				}}))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123", 1))
+			})
+			It("skips the agent if it returns an error", func() {
+				mock.Err = errors.New("error")
+				_, err := ag.GetSimilarArtists(ctx, "123", "test", "mb123", 1)
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123", 1))
+			})
+			It("interrupts if the context is canceled", func() {
+				cancel()
+				_, err := ag.GetSimilarArtists(ctx, "123", "test", "mb123", 1)
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(BeEmpty())
+			})
+		})
+
+		Describe("GetArtistTopSongs", func() {
+			It("returns on first match", func() {
+				Expect(ag.GetArtistTopSongs(ctx, "123", "test", "mb123", 2)).To(Equal([]Song{{
+					Name: "A Song",
+					MBID: "mbid444",
+				}}))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123", 2))
+			})
+			It("skips the agent if it returns an error", func() {
+				mock.Err = errors.New("error")
+				_, err := ag.GetArtistTopSongs(ctx, "123", "test", "mb123", 2)
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123", 2))
+			})
+			It("interrupts if the context is canceled", func() {
+				cancel()
+				_, err := ag.GetArtistTopSongs(ctx, "123", "test", "mb123", 2)
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(BeEmpty())
+			})
+		})
+
+		Describe("GetAlbumInfo", func() {
+			It("returns meaningful data", func() {
+				Expect(ag.GetAlbumInfo(ctx, "album", "artist", "mbid")).To(Equal(&AlbumInfo{
+					Name:        "A Song",
+					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(ConsistOf("album", "artist", "mbid"))
+			})
+			It("skips the agent if it returns an error", func() {
+				mock.Err = errors.New("error")
+				_, err := ag.GetAlbumInfo(ctx, "album", "artist", "mbid")
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(ConsistOf("album", "artist", "mbid"))
+			})
+			It("interrupts if the context is canceled", func() {
+				cancel()
+				_, err := ag.GetAlbumInfo(ctx, "album", "artist", "mbid")
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(BeEmpty())
+			})
+		})
+	})
+})
+
+type mockAgent struct {
+	Args []interface{}
+	Err  error
+}
+
+func (a *mockAgent) AgentName() string {
+	return "fake"
+}
+
+func (a *mockAgent) GetArtistMBID(_ context.Context, id string, name string) (string, error) {
+	a.Args = []interface{}{id, name}
+	if a.Err != nil {
+		return "", a.Err
+	}
+	return "mbid", nil
+}
+
+func (a *mockAgent) GetArtistURL(_ context.Context, id, name, mbid string) (string, error) {
+	a.Args = []interface{}{id, name, mbid}
+	if a.Err != nil {
+		return "", a.Err
+	}
+	return "url", nil
+}
+
+func (a *mockAgent) GetArtistBiography(_ context.Context, id, name, mbid string) (string, error) {
+	a.Args = []interface{}{id, name, mbid}
+	if a.Err != nil {
+		return "", a.Err
+	}
+	return "bio", nil
+}
+
+func (a *mockAgent) GetArtistImages(_ context.Context, id, name, mbid string) ([]ExternalImage, error) {
+	a.Args = []interface{}{id, name, mbid}
+	if a.Err != nil {
+		return nil, a.Err
+	}
+	return []ExternalImage{{
+		URL:  "imageUrl",
+		Size: 100,
+	}}, nil
+}
+
+func (a *mockAgent) GetSimilarArtists(_ context.Context, id, name, mbid string, limit int) ([]Artist, error) {
+	a.Args = []interface{}{id, name, mbid, limit}
+	if a.Err != nil {
+		return nil, a.Err
+	}
+	return []Artist{{
+		Name: "Joe Dohn",
+		MBID: "mbid321",
+	}}, nil
+}
+
+func (a *mockAgent) GetArtistTopSongs(_ context.Context, id, artistName, mbid string, count int) ([]Song, error) {
+	a.Args = []interface{}{id, artistName, mbid, count}
+	if a.Err != nil {
+		return nil, a.Err
+	}
+	return []Song{{
+		Name: "A Song",
+		MBID: "mbid444",
+	}}, nil
+}
+
+func (a *mockAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid string) (*AlbumInfo, error) {
+	a.Args = []interface{}{name, artist, mbid}
+	if a.Err != nil {
+		return nil, a.Err
+	}
+	return &AlbumInfo{
+		Name:        "A Song",
+		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
+}

core/agents/interfaces.go

@@ -3,20 +3,30 @@ package agents
 import (
 	"context"
 	"errors"
+
+	"github.com/navidrome/navidrome/model"
 )
 
-type Constructor func(ctx context.Context) Interface
+type Constructor func(ds model.DataStore) Interface
 
 type Interface interface {
 	AgentName() string
 }
 
+type AlbumInfo struct {
+	Name        string
+	MBID        string
+	Description string
+	URL         string
+	Images      []ExternalImage
+}
+
 type Artist struct {
 	Name string
 	MBID string
 }
 
-type ArtistImage struct {
+type ExternalImage struct {
 	URL  string
 	Size int
 }
@@ -30,28 +40,33 @@ var (
 	ErrNotFound = errors.New("not found")
 )
 
+// TODO Break up this interface in more specific methods, like artists
+type AlbumInfoRetriever interface {
+	GetAlbumInfo(ctx context.Context, name, artist, mbid string) (*AlbumInfo, error)
+}
+
 type ArtistMBIDRetriever interface {
-	GetMBID(id string, name string) (string, error)
+	GetArtistMBID(ctx context.Context, id string, name string) (string, error)
 }
 
 type ArtistURLRetriever interface {
-	GetURL(id, name, mbid string) (string, error)
+	GetArtistURL(ctx context.Context, id, name, mbid string) (string, error)
 }
 
 type ArtistBiographyRetriever interface {
-	GetBiography(id, name, mbid string) (string, error)
+	GetArtistBiography(ctx context.Context, id, name, mbid string) (string, error)
 }
 
 type ArtistSimilarRetriever interface {
-	GetSimilar(id, name, mbid string, limit int) ([]Artist, error)
+	GetSimilarArtists(ctx context.Context, id, name, mbid string, limit int) ([]Artist, error)
 }
 
 type ArtistImageRetriever interface {
-	GetImages(id, name, mbid string) ([]ArtistImage, error)
+	GetArtistImages(ctx context.Context, id, name, mbid string) ([]ExternalImage, error)
 }
 
 type ArtistTopSongsRetriever interface {
-	GetTopSongs(id, artistName, mbid string, count int) ([]Song, error)
+	GetArtistTopSongs(ctx context.Context, id, artistName, mbid string, count int) ([]Song, error)
 }
 
 var Map map[string]Constructor

core/agents/lastfm.go

@@ -1,140 +0,0 @@
-package agents
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/consts"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/utils/lastfm"
-)
-
-const lastFMAgentName = "lastfm"
-
-type lastfmAgent struct {
-	ctx    context.Context
-	apiKey string
-	lang   string
-	client *lastfm.Client
-}
-
-func lastFMConstructor(ctx context.Context) Interface {
-	l := &lastfmAgent{
-		ctx:    ctx,
-		apiKey: conf.Server.LastFM.ApiKey,
-		lang:   conf.Server.LastFM.Language,
-	}
-	hc := NewCachedHTTPClient(http.DefaultClient, consts.DefaultCachedHttpClientTTL)
-	l.client = lastfm.NewClient(l.apiKey, l.lang, hc)
-	return l
-}
-
-func (l *lastfmAgent) AgentName() string {
-	return lastFMAgentName
-}
-
-func (l *lastfmAgent) GetMBID(id string, name string) (string, error) {
-	a, err := l.callArtistGetInfo(name, "")
-	if err != nil {
-		return "", err
-	}
-	if a.MBID == "" {
-		return "", ErrNotFound
-	}
-	return a.MBID, nil
-}
-
-func (l *lastfmAgent) GetURL(id, name, mbid string) (string, error) {
-	a, err := l.callArtistGetInfo(name, mbid)
-	if err != nil {
-		return "", err
-	}
-	if a.URL == "" {
-		return "", ErrNotFound
-	}
-	return a.URL, nil
-}
-
-func (l *lastfmAgent) GetBiography(id, name, mbid string) (string, error) {
-	a, err := l.callArtistGetInfo(name, mbid)
-	if err != nil {
-		return "", err
-	}
-	if a.Bio.Summary == "" {
-		return "", ErrNotFound
-	}
-	return a.Bio.Summary, nil
-}
-
-func (l *lastfmAgent) GetSimilar(id, name, mbid string, limit int) ([]Artist, error) {
-	resp, err := l.callArtistGetSimilar(name, mbid, limit)
-	if err != nil {
-		return nil, err
-	}
-	if len(resp) == 0 {
-		return nil, ErrNotFound
-	}
-	var res []Artist
-	for _, a := range resp {
-		res = append(res, Artist{
-			Name: a.Name,
-			MBID: a.MBID,
-		})
-	}
-	return res, nil
-}
-
-func (l *lastfmAgent) GetTopSongs(id, artistName, mbid string, count int) ([]Song, error) {
-	resp, err := l.callArtistGetTopTracks(artistName, mbid, count)
-	if err != nil {
-		return nil, err
-	}
-	if len(resp) == 0 {
-		return nil, ErrNotFound
-	}
-	var res []Song
-	for _, t := range resp {
-		res = append(res, Song{
-			Name: t.Name,
-			MBID: t.MBID,
-		})
-	}
-	return res, nil
-}
-
-func (l *lastfmAgent) callArtistGetInfo(name string, mbid string) (*lastfm.Artist, error) {
-	a, err := l.client.ArtistGetInfo(l.ctx, name, mbid)
-	if err != nil {
-		log.Error(l.ctx, "Error calling LastFM/artist.getInfo", "artist", name, "mbid", mbid, err)
-		return nil, err
-	}
-	return a, nil
-}
-
-func (l *lastfmAgent) callArtistGetSimilar(name string, mbid string, limit int) ([]lastfm.Artist, error) {
-	s, err := l.client.ArtistGetSimilar(l.ctx, name, mbid, limit)
-	if err != nil {
-		log.Error(l.ctx, "Error calling LastFM/artist.getSimilar", "artist", name, "mbid", mbid, err)
-		return nil, err
-	}
-	return s, nil
-}
-
-func (l *lastfmAgent) callArtistGetTopTracks(artistName, mbid string, count int) ([]lastfm.Track, error) {
-	t, err := l.client.ArtistGetTopTracks(l.ctx, artistName, mbid, count)
-	if err != nil {
-		log.Error(l.ctx, "Error calling LastFM/artist.getTopTracks", "artist", artistName, "mbid", mbid, err)
-		return nil, err
-	}
-	return t, nil
-}
-
-func init() {
-	conf.AddHook(func() {
-		if conf.Server.LastFM.ApiKey != "" {
-			log.Info("Last.FM integration is ENABLED")
-			Register(lastFMAgentName, lastFMConstructor)
-		}
-	})
-}

core/agents/lastfm/agent.go

@@ -0,0 +1,322 @@
+package lastfm
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/core/scrobbler"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils"
+)
+
+const (
+	lastFMAgentName    = "lastfm"
+	sessionKeyProperty = "LastFMSessionKey"
+)
+
+var ignoredBiographies = []string{
+	// Unknown Artist
+	`<a href="https://www.last.fm/music/`,
+}
+
+type lastfmAgent struct {
+	ds          model.DataStore
+	sessionKeys *agents.SessionKeys
+	apiKey      string
+	secret      string
+	lang        string
+	client      *client
+}
+
+func lastFMConstructor(ds model.DataStore) *lastfmAgent {
+	l := &lastfmAgent{
+		ds:          ds,
+		lang:        conf.Server.LastFM.Language,
+		apiKey:      conf.Server.LastFM.ApiKey,
+		secret:      conf.Server.LastFM.Secret,
+		sessionKeys: &agents.SessionKeys{DataStore: ds, KeyName: sessionKeyProperty},
+	}
+	hc := &http.Client{
+		Timeout: consts.DefaultHttpClientTimeOut,
+	}
+	chc := utils.NewCachedHTTPClient(hc, consts.DefaultHttpClientTimeOut)
+	l.client = newClient(l.apiKey, l.secret, l.lang, chc)
+	return l
+}
+
+func (l *lastfmAgent) AgentName() string {
+	return lastFMAgentName
+}
+
+var imageRegex = regexp.MustCompile(`u\/(\d+)`)
+
+func (l *lastfmAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid string) (*agents.AlbumInfo, error) {
+	a, err := l.callAlbumGetInfo(ctx, name, artist, mbid)
+	if err != nil {
+		return nil, err
+	}
+
+	response := agents.AlbumInfo{
+		Name:        a.Name,
+		MBID:        a.MBID,
+		Description: a.Description.Summary,
+		URL:         a.URL,
+		Images:      make([]agents.ExternalImage, 0),
+	}
+
+	// Last.fm can return duplicate sizes.
+	seenSizes := map[int]bool{}
+
+	// This assumes that Last.fm returns images with size small, medium, and large.
+	// This is true as of December 29, 2022
+	for _, img := range a.Image {
+		size := imageRegex.FindStringSubmatch(img.URL)
+		// Last.fm can return images without URL
+		if len(size) == 0 || len(size[0]) < 4 {
+			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
+			}
+		}
+	}
+
+	return &response, nil
+}
+
+func (l *lastfmAgent) GetArtistMBID(ctx context.Context, id string, name string) (string, error) {
+	a, err := l.callArtistGetInfo(ctx, name, "")
+	if err != nil {
+		return "", err
+	}
+	if a.MBID == "" {
+		return "", agents.ErrNotFound
+	}
+	return a.MBID, nil
+}
+
+func (l *lastfmAgent) GetArtistURL(ctx context.Context, id, name, mbid string) (string, error) {
+	a, err := l.callArtistGetInfo(ctx, name, mbid)
+	if err != nil {
+		return "", err
+	}
+	if a.URL == "" {
+		return "", agents.ErrNotFound
+	}
+	return a.URL, nil
+}
+
+func (l *lastfmAgent) GetArtistBiography(ctx context.Context, id, name, mbid string) (string, error) {
+	a, err := l.callArtistGetInfo(ctx, name, mbid)
+	if err != nil {
+		return "", err
+	}
+	a.Bio.Summary = strings.TrimSpace(a.Bio.Summary)
+	if a.Bio.Summary == "" {
+		return "", agents.ErrNotFound
+	}
+	for _, ign := range ignoredBiographies {
+		if strings.HasPrefix(a.Bio.Summary, ign) {
+			return "", nil
+		}
+	}
+	return a.Bio.Summary, nil
+}
+
+func (l *lastfmAgent) GetSimilarArtists(ctx context.Context, id, name, mbid string, limit int) ([]agents.Artist, error) {
+	resp, err := l.callArtistGetSimilar(ctx, name, mbid, limit)
+	if err != nil {
+		return nil, err
+	}
+	if len(resp) == 0 {
+		return nil, agents.ErrNotFound
+	}
+	var res []agents.Artist
+	for _, a := range resp {
+		res = append(res, agents.Artist{
+			Name: a.Name,
+			MBID: a.MBID,
+		})
+	}
+	return res, nil
+}
+
+func (l *lastfmAgent) GetArtistTopSongs(ctx context.Context, id, artistName, mbid string, count int) ([]agents.Song, error) {
+	resp, err := l.callArtistGetTopTracks(ctx, artistName, mbid, count)
+	if err != nil {
+		return nil, err
+	}
+	if len(resp) == 0 {
+		return nil, agents.ErrNotFound
+	}
+	var res []agents.Song
+	for _, t := range resp {
+		res = append(res, agents.Song{
+			Name: t.Name,
+			MBID: t.MBID,
+		})
+	}
+	return res, nil
+}
+
+func (l *lastfmAgent) callAlbumGetInfo(ctx context.Context, name, artist, mbid string) (*Album, error) {
+	a, err := l.client.albumGetInfo(ctx, name, artist, mbid)
+	var lfErr *lastFMError
+	isLastFMError := errors.As(err, &lfErr)
+
+	if mbid != "" && (isLastFMError && lfErr.Code == 6) {
+		log.Warn(ctx, "LastFM/album.getInfo could not find album by mbid, trying again", "album", name, "mbid", mbid)
+		return l.callAlbumGetInfo(ctx, name, artist, "")
+	}
+
+	if err != nil {
+		if isLastFMError && lfErr.Code == 6 {
+			log.Debug(ctx, "Album not found", "album", name, "mbid", mbid, err)
+		} else {
+			log.Error(ctx, "Error calling LastFM/album.getInfo", "album", name, "mbid", mbid, err)
+		}
+		return nil, err
+	}
+	return a, nil
+}
+
+func (l *lastfmAgent) callArtistGetInfo(ctx context.Context, name string, mbid string) (*Artist, error) {
+	a, err := l.client.artistGetInfo(ctx, name, mbid)
+	var lfErr *lastFMError
+	isLastFMError := errors.As(err, &lfErr)
+
+	if mbid != "" && ((err == nil && a.Name == "[unknown]") || (isLastFMError && lfErr.Code == 6)) {
+		log.Warn(ctx, "LastFM/artist.getInfo could not find artist by mbid, trying again", "artist", name, "mbid", mbid)
+		return l.callArtistGetInfo(ctx, name, "")
+	}
+
+	if err != nil {
+		log.Error(ctx, "Error calling LastFM/artist.getInfo", "artist", name, "mbid", mbid, err)
+		return nil, err
+	}
+	return a, nil
+}
+
+func (l *lastfmAgent) callArtistGetSimilar(ctx context.Context, name string, mbid string, limit int) ([]Artist, error) {
+	s, err := l.client.artistGetSimilar(ctx, name, mbid, limit)
+	var lfErr *lastFMError
+	isLastFMError := errors.As(err, &lfErr)
+	if mbid != "" && ((err == nil && s.Attr.Artist == "[unknown]") || (isLastFMError && lfErr.Code == 6)) {
+		log.Warn(ctx, "LastFM/artist.getSimilar could not find artist by mbid, trying again", "artist", name, "mbid", mbid)
+		return l.callArtistGetSimilar(ctx, name, "", limit)
+	}
+	if err != nil {
+		log.Error(ctx, "Error calling LastFM/artist.getSimilar", "artist", name, "mbid", mbid, err)
+		return nil, err
+	}
+	return s.Artists, nil
+}
+
+func (l *lastfmAgent) callArtistGetTopTracks(ctx context.Context, artistName, mbid string, count int) ([]Track, error) {
+	t, err := l.client.artistGetTopTracks(ctx, artistName, mbid, count)
+	var lfErr *lastFMError
+	isLastFMError := errors.As(err, &lfErr)
+	if mbid != "" && ((err == nil && t.Attr.Artist == "[unknown]") || (isLastFMError && lfErr.Code == 6)) {
+		log.Warn(ctx, "LastFM/artist.getTopTracks could not find artist by mbid, trying again", "artist", artistName, "mbid", mbid)
+		return l.callArtistGetTopTracks(ctx, artistName, "", count)
+	}
+	if err != nil {
+		log.Error(ctx, "Error calling LastFM/artist.getTopTracks", "artist", artistName, "mbid", mbid, err)
+		return nil, err
+	}
+	return t.Track, nil
+}
+
+func (l *lastfmAgent) NowPlaying(ctx context.Context, userId string, track *model.MediaFile) error {
+	sk, err := l.sessionKeys.Get(ctx, userId)
+	if err != nil || sk == "" {
+		return scrobbler.ErrNotAuthorized
+	}
+
+	err = l.client.updateNowPlaying(ctx, sk, ScrobbleInfo{
+		artist:      track.Artist,
+		track:       track.Title,
+		album:       track.Album,
+		trackNumber: track.TrackNumber,
+		mbid:        track.MbzTrackID,
+		duration:    int(track.Duration),
+		albumArtist: track.AlbumArtist,
+	})
+	if err != nil {
+		log.Warn(ctx, "Last.fm client.updateNowPlaying returned error", "track", track.Title, err)
+		return scrobbler.ErrUnrecoverable
+	}
+	return nil
+}
+
+func (l *lastfmAgent) Scrobble(ctx context.Context, userId string, s scrobbler.Scrobble) error {
+	sk, err := l.sessionKeys.Get(ctx, userId)
+	if err != nil || sk == "" {
+		return scrobbler.ErrNotAuthorized
+	}
+
+	if s.Duration <= 30 {
+		log.Debug(ctx, "Skipping Last.fm scrobble for short song", "track", s.Title, "duration", s.Duration)
+		return nil
+	}
+	err = l.client.scrobble(ctx, sk, ScrobbleInfo{
+		artist:      s.Artist,
+		track:       s.Title,
+		album:       s.Album,
+		trackNumber: s.TrackNumber,
+		mbid:        s.MbzTrackID,
+		duration:    int(s.Duration),
+		albumArtist: s.AlbumArtist,
+		timestamp:   s.TimeStamp,
+	})
+	if err == nil {
+		return nil
+	}
+	var lfErr *lastFMError
+	isLastFMError := errors.As(err, &lfErr)
+	if !isLastFMError {
+		log.Warn(ctx, "Last.fm client.scrobble returned error", "track", s.Title, err)
+		return scrobbler.ErrRetryLater
+	}
+	if lfErr.Code == 11 || lfErr.Code == 16 {
+		return scrobbler.ErrRetryLater
+	}
+	return scrobbler.ErrUnrecoverable
+}
+
+func (l *lastfmAgent) IsAuthorized(ctx context.Context, userId string) bool {
+	sk, err := l.sessionKeys.Get(ctx, userId)
+	return err == nil && sk != ""
+}
+
+func init() {
+	conf.AddHook(func() {
+		if conf.Server.LastFM.Enabled {
+			agents.Register(lastFMAgentName, func(ds model.DataStore) agents.Interface {
+				return lastFMConstructor(ds)
+			})
+			scrobbler.Register(lastFMAgentName, func(ds model.DataStore) scrobbler.Scrobbler {
+				return lastFMConstructor(ds)
+			})
+		}
+	})
+}

core/agents/lastfm/agent_test.go

@@ -0,0 +1,438 @@
+package lastfm
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"io"
+	"net/http"
+	"os"
+	"strconv"
+	"time"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/core/scrobbler"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+const (
+	lastfmError3 = `{"error":3,"message":"Invalid Method - No method with that name in this package","links":[]}`
+	lastfmError6 = `{"error":6,"message":"The artist you supplied could not be found","links":[]}`
+)
+
+var _ = Describe("lastfmAgent", func() {
+	var ds model.DataStore
+	var ctx context.Context
+	BeforeEach(func() {
+		ds = &tests.MockDataStore{}
+		ctx = context.Background()
+	})
+	Describe("lastFMConstructor", func() {
+		It("uses configured api key and language", func() {
+			conf.Server.LastFM.ApiKey = "123"
+			conf.Server.LastFM.Secret = "secret"
+			conf.Server.LastFM.Language = "pt"
+			agent := lastFMConstructor(ds)
+			Expect(agent.apiKey).To(Equal("123"))
+			Expect(agent.secret).To(Equal("secret"))
+			Expect(agent.lang).To(Equal("pt"))
+		})
+	})
+
+	Describe("GetArtistBiography", func() {
+		var agent *lastfmAgent
+		var httpClient *tests.FakeHttpClient
+		BeforeEach(func() {
+			httpClient = &tests.FakeHttpClient{}
+			client := newClient("API_KEY", "SECRET", "pt", httpClient)
+			agent = lastFMConstructor(ds)
+			agent.client = client
+		})
+
+		It("returns the biography", func() {
+			f, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
+			httpClient.Res = http.Response{Body: f, StatusCode: 200}
+			Expect(agent.GetArtistBiography(ctx, "123", "U2", "mbid-1234")).To(Equal("U2 é uma das mais importantes bandas de rock de todos os tempos. Formada em 1976 em Dublin, composta por Bono (vocalista  e guitarrista), The Edge (guitarrista, pianista e backing vocal), Adam Clayton (baixista), Larry Mullen, Jr. (baterista e percussionista).\n\nDesde a década de 80, U2 é uma das bandas mais populares no mundo. Seus shows são únicos e um verdadeiro festival de efeitos especiais, além de serem um dos que mais arrecadam anualmente. <a href=\"https://www.last.fm/music/U2\">Read more on Last.fm</a>"))
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.fm call fails", func() {
+			httpClient.Err = errors.New("error")
+			_, err := agent.GetArtistBiography(ctx, "123", "U2", "mbid-1234")
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.fm call returns an error", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError3)), StatusCode: 200}
+			_, err := agent.GetArtistBiography(ctx, "123", "U2", "mbid-1234")
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.fm call returns an error 6 and mbid is empty", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
+			_, err := agent.GetArtistBiography(ctx, "123", "U2", "")
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+		})
+
+		Context("MBID non existent in Last.fm", func() {
+			It("calls again when the response is artist == [unknown]", func() {
+				f, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.unknown.json")
+				httpClient.Res = http.Response{Body: f, StatusCode: 200}
+				_, _ = agent.GetArtistBiography(ctx, "123", "U2", "mbid-1234")
+				Expect(httpClient.RequestCount).To(Equal(2))
+				Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
+			})
+			It("calls again when last.fm returns an error 6", func() {
+				httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
+				_, _ = agent.GetArtistBiography(ctx, "123", "U2", "mbid-1234")
+				Expect(httpClient.RequestCount).To(Equal(2))
+				Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
+			})
+		})
+	})
+
+	Describe("GetSimilarArtists", func() {
+		var agent *lastfmAgent
+		var httpClient *tests.FakeHttpClient
+		BeforeEach(func() {
+			httpClient = &tests.FakeHttpClient{}
+			client := newClient("API_KEY", "SECRET", "pt", httpClient)
+			agent = lastFMConstructor(ds)
+			agent.client = client
+		})
+
+		It("returns similar artists", func() {
+			f, _ := os.Open("tests/fixtures/lastfm.artist.getsimilar.json")
+			httpClient.Res = http.Response{Body: f, StatusCode: 200}
+			Expect(agent.GetSimilarArtists(ctx, "123", "U2", "mbid-1234", 2)).To(Equal([]agents.Artist{
+				{Name: "Passengers", MBID: "e110c11f-1c94-4471-a350-c38f46b29389"},
+				{Name: "INXS", MBID: "481bf5f9-2e7c-4c44-b08a-05b32bc7c00d"},
+			}))
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.fm call fails", func() {
+			httpClient.Err = errors.New("error")
+			_, err := agent.GetSimilarArtists(ctx, "123", "U2", "mbid-1234", 2)
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.fm call returns an error", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError3)), StatusCode: 200}
+			_, err := agent.GetSimilarArtists(ctx, "123", "U2", "mbid-1234", 2)
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.fm call returns an error 6 and mbid is empty", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
+			_, err := agent.GetSimilarArtists(ctx, "123", "U2", "", 2)
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+		})
+
+		Context("MBID non existent in Last.fm", func() {
+			It("calls again when the response is artist == [unknown]", func() {
+				f, _ := os.Open("tests/fixtures/lastfm.artist.getsimilar.unknown.json")
+				httpClient.Res = http.Response{Body: f, StatusCode: 200}
+				_, _ = agent.GetSimilarArtists(ctx, "123", "U2", "mbid-1234", 2)
+				Expect(httpClient.RequestCount).To(Equal(2))
+				Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
+			})
+			It("calls again when last.fm returns an error 6", func() {
+				httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
+				_, _ = agent.GetSimilarArtists(ctx, "123", "U2", "mbid-1234", 2)
+				Expect(httpClient.RequestCount).To(Equal(2))
+				Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
+			})
+		})
+	})
+
+	Describe("GetArtistTopSongs", func() {
+		var agent *lastfmAgent
+		var httpClient *tests.FakeHttpClient
+		BeforeEach(func() {
+			httpClient = &tests.FakeHttpClient{}
+			client := newClient("API_KEY", "SECRET", "pt", httpClient)
+			agent = lastFMConstructor(ds)
+			agent.client = client
+		})
+
+		It("returns top songs", func() {
+			f, _ := os.Open("tests/fixtures/lastfm.artist.gettoptracks.json")
+			httpClient.Res = http.Response{Body: f, StatusCode: 200}
+			Expect(agent.GetArtistTopSongs(ctx, "123", "U2", "mbid-1234", 2)).To(Equal([]agents.Song{
+				{Name: "Beautiful Day", MBID: "f7f264d0-a89b-4682-9cd7-a4e7c37637af"},
+				{Name: "With or Without You", MBID: "6b9a509f-6907-4a6e-9345-2f12da09ba4b"},
+			}))
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.fm call fails", func() {
+			httpClient.Err = errors.New("error")
+			_, err := agent.GetArtistTopSongs(ctx, "123", "U2", "mbid-1234", 2)
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.fm call returns an error", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError3)), StatusCode: 200}
+			_, err := agent.GetArtistTopSongs(ctx, "123", "U2", "mbid-1234", 2)
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.fm call returns an error 6 and mbid is empty", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
+			_, err := agent.GetArtistTopSongs(ctx, "123", "U2", "", 2)
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+		})
+
+		Context("MBID non existent in Last.fm", func() {
+			It("calls again when the response is artist == [unknown]", func() {
+				f, _ := os.Open("tests/fixtures/lastfm.artist.gettoptracks.unknown.json")
+				httpClient.Res = http.Response{Body: f, StatusCode: 200}
+				_, _ = agent.GetArtistTopSongs(ctx, "123", "U2", "mbid-1234", 2)
+				Expect(httpClient.RequestCount).To(Equal(2))
+				Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
+			})
+			It("calls again when last.fm returns an error 6", func() {
+				httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
+				_, _ = agent.GetArtistTopSongs(ctx, "123", "U2", "mbid-1234", 2)
+				Expect(httpClient.RequestCount).To(Equal(2))
+				Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
+			})
+		})
+	})
+
+	Describe("Scrobbling", func() {
+		var agent *lastfmAgent
+		var httpClient *tests.FakeHttpClient
+		var track *model.MediaFile
+		BeforeEach(func() {
+			_ = ds.UserProps(ctx).Put("user-1", sessionKeyProperty, "SK-1")
+			httpClient = &tests.FakeHttpClient{}
+			client := newClient("API_KEY", "SECRET", "en", httpClient)
+			agent = lastFMConstructor(ds)
+			agent.client = client
+			track = &model.MediaFile{
+				ID:          "123",
+				Title:       "Track Title",
+				Album:       "Track Album",
+				Artist:      "Track Artist",
+				AlbumArtist: "Track AlbumArtist",
+				TrackNumber: 1,
+				Duration:    180,
+				MbzTrackID:  "mbz-123",
+			}
+		})
+
+		Describe("NowPlaying", 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)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodPost))
+				sentParams := httpClient.SavedRequest.URL.Query()
+				Expect(sentParams.Get("method")).To(Equal("track.updateNowPlaying"))
+				Expect(sentParams.Get("sk")).To(Equal("SK-1"))
+				Expect(sentParams.Get("track")).To(Equal(track.Title))
+				Expect(sentParams.Get("album")).To(Equal(track.Album))
+				Expect(sentParams.Get("artist")).To(Equal(track.Artist))
+				Expect(sentParams.Get("albumArtist")).To(Equal(track.AlbumArtist))
+				Expect(sentParams.Get("trackNumber")).To(Equal(strconv.Itoa(track.TrackNumber)))
+				Expect(sentParams.Get("duration")).To(Equal(strconv.FormatFloat(float64(track.Duration), 'G', -1, 32)))
+				Expect(sentParams.Get("mbid")).To(Equal(track.MbzTrackID))
+			})
+
+			It("returns ErrNotAuthorized if user is not linked", func() {
+				err := agent.NowPlaying(ctx, "user-2", track)
+				Expect(err).To(MatchError(scrobbler.ErrNotAuthorized))
+			})
+		})
+
+		Describe("scrobble", func() {
+			It("calls Last.fm with correct params", func() {
+				ts := time.Now()
+				httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString("{}")), StatusCode: 200}
+
+				err := agent.Scrobble(ctx, "user-1", scrobbler.Scrobble{MediaFile: *track, TimeStamp: ts})
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodPost))
+				sentParams := httpClient.SavedRequest.URL.Query()
+				Expect(sentParams.Get("method")).To(Equal("track.scrobble"))
+				Expect(sentParams.Get("sk")).To(Equal("SK-1"))
+				Expect(sentParams.Get("track")).To(Equal(track.Title))
+				Expect(sentParams.Get("album")).To(Equal(track.Album))
+				Expect(sentParams.Get("artist")).To(Equal(track.Artist))
+				Expect(sentParams.Get("albumArtist")).To(Equal(track.AlbumArtist))
+				Expect(sentParams.Get("trackNumber")).To(Equal(strconv.Itoa(track.TrackNumber)))
+				Expect(sentParams.Get("duration")).To(Equal(strconv.FormatFloat(float64(track.Duration), 'G', -1, 32)))
+				Expect(sentParams.Get("mbid")).To(Equal(track.MbzTrackID))
+				Expect(sentParams.Get("timestamp")).To(Equal(strconv.FormatInt(ts.Unix(), 10)))
+			})
+
+			It("skips songs with less than 31 seconds", func() {
+				track.Duration = 29
+				httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString("{}")), StatusCode: 200}
+
+				err := agent.Scrobble(ctx, "user-1", scrobbler.Scrobble{MediaFile: *track, TimeStamp: time.Now()})
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(httpClient.SavedRequest).To(BeNil())
+			})
+
+			It("returns ErrNotAuthorized if user is not linked", func() {
+				err := agent.Scrobble(ctx, "user-2", scrobbler.Scrobble{MediaFile: *track, TimeStamp: time.Now()})
+				Expect(err).To(MatchError(scrobbler.ErrNotAuthorized))
+			})
+
+			It("returns ErrRetryLater on error 11", func() {
+				httpClient.Res = http.Response{
+					Body:       io.NopCloser(bytes.NewBufferString(`{"error":11,"message":"Service Offline - This service is temporarily offline. Try again later."}`)),
+					StatusCode: 400,
+				}
+
+				err := agent.Scrobble(ctx, "user-1", scrobbler.Scrobble{MediaFile: *track, TimeStamp: time.Now()})
+				Expect(err).To(MatchError(scrobbler.ErrRetryLater))
+			})
+
+			It("returns ErrRetryLater on error 16", func() {
+				httpClient.Res = http.Response{
+					Body:       io.NopCloser(bytes.NewBufferString(`{"error":16,"message":"There was a temporary error processing your request. Please try again"}`)),
+					StatusCode: 400,
+				}
+
+				err := agent.Scrobble(ctx, "user-1", scrobbler.Scrobble{MediaFile: *track, TimeStamp: time.Now()})
+				Expect(err).To(MatchError(scrobbler.ErrRetryLater))
+			})
+
+			It("returns ErrRetryLater on http errors", func() {
+				httpClient.Res = http.Response{
+					Body:       io.NopCloser(bytes.NewBufferString(`internal server error`)),
+					StatusCode: 500,
+				}
+
+				err := agent.Scrobble(ctx, "user-1", scrobbler.Scrobble{MediaFile: *track, TimeStamp: time.Now()})
+				Expect(err).To(MatchError(scrobbler.ErrRetryLater))
+			})
+
+			It("returns ErrUnrecoverable on other errors", func() {
+				httpClient.Res = http.Response{
+					Body:       io.NopCloser(bytes.NewBufferString(`{"error":8,"message":"Operation failed - Something else went wrong"}`)),
+					StatusCode: 400,
+				}
+
+				err := agent.Scrobble(ctx, "user-1", scrobbler.Scrobble{MediaFile: *track, TimeStamp: time.Now()})
+				Expect(err).To(MatchError(scrobbler.ErrUnrecoverable))
+			})
+		})
+	})
+
+	Describe("GetAlbumInfo", func() {
+		var agent *lastfmAgent
+		var httpClient *tests.FakeHttpClient
+		BeforeEach(func() {
+			httpClient = &tests.FakeHttpClient{}
+			client := newClient("API_KEY", "SECRET", "pt", httpClient)
+			agent = lastFMConstructor(ds)
+			agent.client = client
+		})
+
+		It("returns the biography", func() {
+			f, _ := os.Open("tests/fixtures/lastfm.album.getinfo.json")
+			httpClient.Res = http.Response{Body: f, StatusCode: 200}
+			Expect(agent.GetAlbumInfo(ctx, "Believe", "Cher", "03c91c40-49a6-44a7-90e7-a700edf97a62")).To(Equal(&agents.AlbumInfo{
+				Name:        "Believe",
+				MBID:        "03c91c40-49a6-44a7-90e7-a700edf97a62",
+				Description: "Believe is the twenty-third studio album by American singer-actress Cher, released on November 10, 1998 by Warner Bros. Records. The RIAA certified it Quadruple Platinum on December 23, 1999, recognizing four million shipments in the United States; Worldwide, the album has sold more than 20 million copies, making it the biggest-selling album of her career. In 1999 the album received three Grammy Awards nominations including \"Record of the Year\", \"Best Pop Album\" and winning \"Best Dance Recording\" for the single \"Believe\". It was released by Warner Bros. Records at the end of 1998. The album was executive produced by Rob <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"))
+		})
+
+		It("returns empty images if no images are available", 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{},
+			}))
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("album")).To(Equal("The Definitive Less Damage And More Joy"))
+		})
+
+		It("returns an error if Last.fm call fails", func() {
+			httpClient.Err = errors.New("error")
+			_, err := agent.GetAlbumInfo(ctx, "123", "U2", "mbid-1234")
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.fm call returns an error", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError3)), StatusCode: 200}
+			_, err := agent.GetAlbumInfo(ctx, "123", "U2", "mbid-1234")
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.fm call returns an error 6 and mbid is empty", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
+			_, err := agent.GetAlbumInfo(ctx, "123", "U2", "")
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+		})
+
+		Context("MBID non existent in Last.fm", func() {
+			It("calls again when last.fm returns an error 6", func() {
+				httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
+				_, _ = agent.GetAlbumInfo(ctx, "123", "U2", "mbid-1234")
+				Expect(httpClient.RequestCount).To(Equal(2))
+				Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
+			})
+		})
+	})
+})

core/agents/lastfm/auth_router.go

@@ -0,0 +1,129 @@
+package lastfm
+
+import (
+	"bytes"
+	"context"
+	_ "embed"
+	"errors"
+	"net/http"
+	"time"
+
+	"github.com/deluan/rest"
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+	"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/model/request"
+	"github.com/navidrome/navidrome/server"
+	"github.com/navidrome/navidrome/utils"
+)
+
+//go:embed token_received.html
+var tokenReceivedPage []byte
+
+type Router struct {
+	http.Handler
+	ds          model.DataStore
+	sessionKeys *agents.SessionKeys
+	client      *client
+	apiKey      string
+	secret      string
+}
+
+func NewRouter(ds model.DataStore) *Router {
+	r := &Router{
+		ds:          ds,
+		apiKey:      conf.Server.LastFM.ApiKey,
+		secret:      conf.Server.LastFM.Secret,
+		sessionKeys: &agents.SessionKeys{DataStore: ds, KeyName: sessionKeyProperty},
+	}
+	r.Handler = r.routes()
+	hc := &http.Client{
+		Timeout: consts.DefaultHttpClientTimeOut,
+	}
+	r.client = newClient(r.apiKey, r.secret, "en", hc)
+	return r
+}
+
+func (s *Router) routes() http.Handler {
+	r := chi.NewRouter()
+
+	r.Group(func(r chi.Router) {
+		r.Use(server.Authenticator(s.ds))
+		r.Use(server.JWTRefresher)
+
+		r.Get("/link", s.getLinkStatus)
+		r.Delete("/link", s.unlink)
+	})
+
+	r.Get("/link/callback", s.callback)
+
+	return r
+}
+
+func (s *Router) getLinkStatus(w http.ResponseWriter, r *http.Request) {
+	resp := map[string]interface{}{}
+	u, _ := request.UserFrom(r.Context())
+	key, err := s.sessionKeys.Get(r.Context(), u.ID)
+	if err != nil && !errors.Is(err, model.ErrNotFound) {
+		resp["error"] = err
+		resp["status"] = false
+		_ = rest.RespondWithJSON(w, http.StatusInternalServerError, resp)
+		return
+	}
+	resp["status"] = key != ""
+	_ = rest.RespondWithJSON(w, http.StatusOK, resp)
+}
+
+func (s *Router) unlink(w http.ResponseWriter, r *http.Request) {
+	u, _ := request.UserFrom(r.Context())
+	err := s.sessionKeys.Delete(r.Context(), u.ID)
+	if err != nil {
+		_ = rest.RespondWithError(w, http.StatusInternalServerError, err.Error())
+	} else {
+		_ = rest.RespondWithJSON(w, http.StatusOK, map[string]string{})
+	}
+}
+
+func (s *Router) callback(w http.ResponseWriter, r *http.Request) {
+	token := utils.ParamString(r, "token")
+	if token == "" {
+		_ = rest.RespondWithError(w, http.StatusBadRequest, "token not received")
+		return
+	}
+	uid := utils.ParamString(r, "uid")
+	if uid == "" {
+		_ = rest.RespondWithError(w, http.StatusBadRequest, "uid not received")
+		return
+	}
+
+	// Need to add user to context, as this is a non-authenticated endpoint, so it does not
+	// automatically contain any user info
+	ctx := request.WithUser(r.Context(), model.User{ID: uid})
+	err := s.fetchSessionKey(ctx, uid, token)
+	if err != nil {
+		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+		w.WriteHeader(http.StatusBadRequest)
+		_, _ = w.Write([]byte("An error occurred while authorizing with Last.fm. \n\nRequest ID: " + middleware.GetReqID(ctx)))
+		return
+	}
+
+	http.ServeContent(w, r, "response", time.Now(), bytes.NewReader(tokenReceivedPage))
+}
+
+func (s *Router) fetchSessionKey(ctx context.Context, uid, token string) error {
+	sessionKey, err := s.client.getSession(ctx, token)
+	if err != nil {
+		log.Error(ctx, "Could not fetch LastFM session key", "userId", uid, "token", token,
+			"requestId", middleware.GetReqID(ctx), err)
+		return err
+	}
+	err = s.sessionKeys.Put(ctx, uid, sessionKey)
+	if err != nil {
+		log.Error("Could not save LastFM session key", "userId", uid, "requestId", middleware.GetReqID(ctx), err)
+	}
+	return err
+}

core/agents/lastfm/client.go

@@ -0,0 +1,236 @@
+package lastfm
+
+import (
+	"context"
+	"crypto/md5"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/navidrome/navidrome/log"
+	"golang.org/x/exp/slices"
+)
+
+const (
+	apiBaseUrl = "https://ws.audioscrobbler.com/2.0/"
+)
+
+type lastFMError struct {
+	Code    int
+	Message string
+}
+
+func (e *lastFMError) Error() string {
+	return fmt.Sprintf("last.fm error(%d): %s", e.Code, e.Message)
+}
+
+type httpDoer interface {
+	Do(req *http.Request) (*http.Response, error)
+}
+
+func newClient(apiKey string, secret string, lang string, hc httpDoer) *client {
+	return &client{apiKey, secret, lang, hc}
+}
+
+type client struct {
+	apiKey string
+	secret string
+	lang   string
+	hc     httpDoer
+}
+
+func (c *client) albumGetInfo(ctx context.Context, name string, artist string, mbid string) (*Album, error) {
+	params := url.Values{}
+	params.Add("method", "album.getInfo")
+	params.Add("album", name)
+	params.Add("artist", artist)
+	params.Add("mbid", mbid)
+	params.Add("lang", c.lang)
+	response, err := c.makeRequest(ctx, http.MethodGet, params, false)
+	if err != nil {
+		return nil, err
+	}
+	return &response.Album, nil
+}
+
+func (c *client) artistGetInfo(ctx context.Context, name string, mbid string) (*Artist, error) {
+	params := url.Values{}
+	params.Add("method", "artist.getInfo")
+	params.Add("artist", name)
+	params.Add("mbid", mbid)
+	params.Add("lang", c.lang)
+	response, err := c.makeRequest(ctx, http.MethodGet, params, false)
+	if err != nil {
+		return nil, err
+	}
+	return &response.Artist, nil
+}
+
+func (c *client) artistGetSimilar(ctx context.Context, name string, mbid string, limit int) (*SimilarArtists, error) {
+	params := url.Values{}
+	params.Add("method", "artist.getSimilar")
+	params.Add("artist", name)
+	params.Add("mbid", mbid)
+	params.Add("limit", strconv.Itoa(limit))
+	response, err := c.makeRequest(ctx, http.MethodGet, params, false)
+	if err != nil {
+		return nil, err
+	}
+	return &response.SimilarArtists, nil
+}
+
+func (c *client) artistGetTopTracks(ctx context.Context, name string, mbid string, limit int) (*TopTracks, error) {
+	params := url.Values{}
+	params.Add("method", "artist.getTopTracks")
+	params.Add("artist", name)
+	params.Add("mbid", mbid)
+	params.Add("limit", strconv.Itoa(limit))
+	response, err := c.makeRequest(ctx, http.MethodGet, params, false)
+	if err != nil {
+		return nil, err
+	}
+	return &response.TopTracks, nil
+}
+
+func (c *client) GetToken(ctx context.Context) (string, error) {
+	params := url.Values{}
+	params.Add("method", "auth.getToken")
+	c.sign(params)
+	response, err := c.makeRequest(ctx, http.MethodGet, params, true)
+	if err != nil {
+		return "", err
+	}
+	return response.Token, nil
+}
+
+func (c *client) getSession(ctx context.Context, token string) (string, error) {
+	params := url.Values{}
+	params.Add("method", "auth.getSession")
+	params.Add("token", token)
+	response, err := c.makeRequest(ctx, http.MethodGet, params, true)
+	if err != nil {
+		return "", err
+	}
+	return response.Session.Key, nil
+}
+
+type ScrobbleInfo struct {
+	artist      string
+	track       string
+	album       string
+	trackNumber int
+	mbid        string
+	duration    int
+	albumArtist string
+	timestamp   time.Time
+}
+
+func (c *client) updateNowPlaying(ctx context.Context, sessionKey string, info ScrobbleInfo) error {
+	params := url.Values{}
+	params.Add("method", "track.updateNowPlaying")
+	params.Add("artist", info.artist)
+	params.Add("track", info.track)
+	params.Add("album", info.album)
+	params.Add("trackNumber", strconv.Itoa(info.trackNumber))
+	params.Add("mbid", info.mbid)
+	params.Add("duration", strconv.Itoa(info.duration))
+	params.Add("albumArtist", info.albumArtist)
+	params.Add("sk", sessionKey)
+	resp, err := c.makeRequest(ctx, http.MethodPost, params, true)
+	if err != nil {
+		return err
+	}
+	if resp.NowPlaying.IgnoredMessage.Code != "0" {
+		log.Warn(ctx, "LastFM: NowPlaying was ignored", "code", resp.NowPlaying.IgnoredMessage.Code,
+			"text", resp.NowPlaying.IgnoredMessage.Text)
+	}
+	return nil
+}
+
+func (c *client) scrobble(ctx context.Context, sessionKey string, info ScrobbleInfo) error {
+	params := url.Values{}
+	params.Add("method", "track.scrobble")
+	params.Add("timestamp", strconv.FormatInt(info.timestamp.Unix(), 10))
+	params.Add("artist", info.artist)
+	params.Add("track", info.track)
+	params.Add("album", info.album)
+	params.Add("trackNumber", strconv.Itoa(info.trackNumber))
+	params.Add("mbid", info.mbid)
+	params.Add("duration", strconv.Itoa(info.duration))
+	params.Add("albumArtist", info.albumArtist)
+	params.Add("sk", sessionKey)
+	resp, err := c.makeRequest(ctx, http.MethodPost, params, true)
+	if err != nil {
+		return err
+	}
+	if resp.Scrobbles.Scrobble.IgnoredMessage.Code != "0" {
+		log.Warn(ctx, "LastFM: scrobble was ignored", "code", resp.Scrobbles.Scrobble.IgnoredMessage.Code,
+			"text", resp.Scrobbles.Scrobble.IgnoredMessage.Text, "info", info)
+	}
+	if resp.Scrobbles.Attr.Accepted != 1 {
+		log.Warn(ctx, "LastFM: scrobble was not accepted", "code", resp.Scrobbles.Scrobble.IgnoredMessage.Code,
+			"text", resp.Scrobbles.Scrobble.IgnoredMessage.Text, "info", info)
+	}
+	return nil
+}
+
+func (c *client) makeRequest(ctx context.Context, method string, params url.Values, signed bool) (*Response, error) {
+	params.Add("format", "json")
+	params.Add("api_key", c.apiKey)
+
+	if signed {
+		c.sign(params)
+	}
+
+	req, _ := http.NewRequestWithContext(ctx, method, apiBaseUrl, nil)
+	req.URL.RawQuery = params.Encode()
+
+	log.Trace(ctx, fmt.Sprintf("Sending Last.fm %s request", req.Method), "url", req.URL)
+	resp, err := c.hc.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	defer resp.Body.Close()
+	decoder := json.NewDecoder(resp.Body)
+
+	var response Response
+	jsonErr := decoder.Decode(&response)
+	if resp.StatusCode != 200 && jsonErr != nil {
+		return nil, fmt.Errorf("last.fm http status: (%d)", resp.StatusCode)
+	}
+	if jsonErr != nil {
+		return nil, jsonErr
+	}
+	if response.Error != 0 {
+		return &response, &lastFMError{Code: response.Error, Message: response.Message}
+	}
+
+	return &response, nil
+}
+
+func (c *client) sign(params url.Values) {
+	// the parameters must be in order before hashing
+	keys := make([]string, 0, len(params))
+	for k := range params {
+		if slices.Contains([]string{"format", "callback"}, k) {
+			continue
+		}
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	msg := strings.Builder{}
+	for _, k := range keys {
+		msg.WriteString(k)
+		msg.WriteString(params[k][0])
+	}
+	msg.WriteString(c.secret)
+	hash := md5.Sum([]byte(msg.String()))
+	params.Add("api_sig", hex.EncodeToString(hash[:]))
+}

core/agents/lastfm/client_test.go

@@ -0,0 +1,173 @@
+package lastfm
+
+import (
+	"bytes"
+	"context"
+	"crypto/md5"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("client", func() {
+	var httpClient *tests.FakeHttpClient
+	var client *client
+
+	BeforeEach(func() {
+		httpClient = &tests.FakeHttpClient{}
+		client = newClient("API_KEY", "SECRET", "pt", httpClient)
+	})
+
+	Describe("albumGetInfo", func() {
+		It("returns an album on successful response", func() {
+			f, _ := os.Open("tests/fixtures/lastfm.album.getinfo.json")
+			httpClient.Res = http.Response{Body: f, StatusCode: 200}
+
+			album, err := client.albumGetInfo(context.Background(), "Believe", "U2", "mbid-1234")
+			Expect(err).To(BeNil())
+			Expect(album.Name).To(Equal("Believe"))
+			Expect(httpClient.SavedRequest.URL.String()).To(Equal(apiBaseUrl + "?album=Believe&api_key=API_KEY&artist=U2&format=json&lang=pt&mbid=mbid-1234&method=album.getInfo"))
+		})
+	})
+
+	Describe("artistGetInfo", func() {
+		It("returns an artist for a successful response", func() {
+			f, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
+			httpClient.Res = http.Response{Body: f, StatusCode: 200}
+
+			artist, err := client.artistGetInfo(context.Background(), "U2", "123")
+			Expect(err).To(BeNil())
+			Expect(artist.Name).To(Equal("U2"))
+			Expect(httpClient.SavedRequest.URL.String()).To(Equal(apiBaseUrl + "?api_key=API_KEY&artist=U2&format=json&lang=pt&mbid=123&method=artist.getInfo"))
+		})
+
+		It("fails if Last.fm returns an http status != 200", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`Internal Server Error`)),
+				StatusCode: 500,
+			}
+
+			_, err := client.artistGetInfo(context.Background(), "U2", "123")
+			Expect(err).To(MatchError("last.fm http status: (500)"))
+		})
+
+		It("fails if Last.fm returns an http status != 200", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`{"error":3,"message":"Invalid Method - No method with that name in this package"}`)),
+				StatusCode: 400,
+			}
+
+			_, err := client.artistGetInfo(context.Background(), "U2", "123")
+			Expect(err).To(MatchError(&lastFMError{Code: 3, Message: "Invalid Method - No method with that name in this package"}))
+		})
+
+		It("fails if Last.fm returns an error", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`{"error":6,"message":"The artist you supplied could not be found"}`)),
+				StatusCode: 200,
+			}
+
+			_, err := client.artistGetInfo(context.Background(), "U2", "123")
+			Expect(err).To(MatchError(&lastFMError{Code: 6, Message: "The artist you supplied could not be found"}))
+		})
+
+		It("fails if HttpClient.Do() returns error", func() {
+			httpClient.Err = errors.New("generic error")
+
+			_, err := client.artistGetInfo(context.Background(), "U2", "123")
+			Expect(err).To(MatchError("generic error"))
+		})
+
+		It("fails if returned body is not a valid JSON", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`<xml>NOT_VALID_JSON</xml>`)),
+				StatusCode: 200,
+			}
+
+			_, err := client.artistGetInfo(context.Background(), "U2", "123")
+			Expect(err).To(MatchError("invalid character '<' looking for beginning of value"))
+		})
+
+	})
+
+	Describe("artistGetSimilar", func() {
+		It("returns an artist for a successful response", func() {
+			f, _ := os.Open("tests/fixtures/lastfm.artist.getsimilar.json")
+			httpClient.Res = http.Response{Body: f, StatusCode: 200}
+
+			similar, err := client.artistGetSimilar(context.Background(), "U2", "123", 2)
+			Expect(err).To(BeNil())
+			Expect(len(similar.Artists)).To(Equal(2))
+			Expect(httpClient.SavedRequest.URL.String()).To(Equal(apiBaseUrl + "?api_key=API_KEY&artist=U2&format=json&limit=2&mbid=123&method=artist.getSimilar"))
+		})
+	})
+
+	Describe("artistGetTopTracks", func() {
+		It("returns top tracks for a successful response", func() {
+			f, _ := os.Open("tests/fixtures/lastfm.artist.gettoptracks.json")
+			httpClient.Res = http.Response{Body: f, StatusCode: 200}
+
+			top, err := client.artistGetTopTracks(context.Background(), "U2", "123", 2)
+			Expect(err).To(BeNil())
+			Expect(len(top.Track)).To(Equal(2))
+			Expect(httpClient.SavedRequest.URL.String()).To(Equal(apiBaseUrl + "?api_key=API_KEY&artist=U2&format=json&limit=2&mbid=123&method=artist.getTopTracks"))
+		})
+	})
+
+	Describe("GetToken", func() {
+		It("returns a token when the request is successful", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`{"token":"TOKEN"}`)),
+				StatusCode: 200,
+			}
+
+			Expect(client.GetToken(context.Background())).To(Equal("TOKEN"))
+			queryParams := httpClient.SavedRequest.URL.Query()
+			Expect(queryParams.Get("method")).To(Equal("auth.getToken"))
+			Expect(queryParams.Get("format")).To(Equal("json"))
+			Expect(queryParams.Get("api_key")).To(Equal("API_KEY"))
+			Expect(queryParams.Get("api_sig")).ToNot(BeEmpty())
+		})
+	})
+
+	Describe("getSession", func() {
+		It("returns a session key when the request is successful", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`{"session":{"name":"Navidrome","key":"SESSION_KEY","subscriber":0}}`)),
+				StatusCode: 200,
+			}
+
+			Expect(client.getSession(context.Background(), "TOKEN")).To(Equal("SESSION_KEY"))
+			queryParams := httpClient.SavedRequest.URL.Query()
+			Expect(queryParams.Get("method")).To(Equal("auth.getSession"))
+			Expect(queryParams.Get("format")).To(Equal("json"))
+			Expect(queryParams.Get("token")).To(Equal("TOKEN"))
+			Expect(queryParams.Get("api_key")).To(Equal("API_KEY"))
+			Expect(queryParams.Get("api_sig")).ToNot(BeEmpty())
+		})
+	})
+
+	Describe("sign", func() {
+		It("adds an api_sig param with the signature", func() {
+			params := url.Values{}
+			params.Add("d", "444")
+			params.Add("callback", "https://myserver.com")
+			params.Add("a", "111")
+			params.Add("format", "json")
+			params.Add("c", "333")
+			params.Add("b", "222")
+			client.sign(params)
+			Expect(params).To(HaveKey("api_sig"))
+			sig := params.Get("api_sig")
+			expected := fmt.Sprintf("%x", md5.Sum([]byte("a111b222c333d444SECRET")))
+			Expect(sig).To(Equal(expected))
+		})
+	})
+})

core/agents/lastfm/lastfm_suite_test.go

@@ -5,13 +5,13 @@ import (
 
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
 
 func TestLastFM(t *testing.T) {
 	tests.Init(t, false)
-	log.SetLevel(log.LevelCritical)
+	log.SetLevel(log.LevelFatal)
 	RegisterFailHandler(Fail)
 	RunSpecs(t, "LastFM Test Suite")
 }

core/agents/lastfm/responses.go

@@ -0,0 +1,119 @@
+package lastfm
+
+type Response struct {
+	Artist         Artist         `json:"artist"`
+	SimilarArtists SimilarArtists `json:"similarartists"`
+	TopTracks      TopTracks      `json:"toptracks"`
+	Album          Album          `json:"album"`
+	Error          int            `json:"error"`
+	Message        string         `json:"message"`
+	Token          string         `json:"token"`
+	Session        Session        `json:"session"`
+	NowPlaying     NowPlaying     `json:"nowplaying"`
+	Scrobbles      Scrobbles      `json:"scrobbles"`
+}
+
+type Album struct {
+	Name        string          `json:"name"`
+	MBID        string          `json:"mbid"`
+	URL         string          `json:"url"`
+	Image       []ExternalImage `json:"image"`
+	Description Description     `json:"wiki"`
+}
+
+type Artist struct {
+	Name  string          `json:"name"`
+	MBID  string          `json:"mbid"`
+	URL   string          `json:"url"`
+	Image []ExternalImage `json:"image"`
+	Bio   Description     `json:"bio"`
+}
+
+type SimilarArtists struct {
+	Artists []Artist `json:"artist"`
+	Attr    Attr     `json:"@attr"`
+}
+
+type Attr struct {
+	Artist string `json:"artist"`
+}
+
+type ExternalImage struct {
+	URL  string `json:"#text"`
+	Size string `json:"size"`
+}
+
+type Description struct {
+	Published string `json:"published"`
+	Summary   string `json:"summary"`
+	Content   string `json:"content"`
+}
+
+type Track struct {
+	Name string `json:"name"`
+	MBID string `json:"mbid"`
+}
+
+type TopTracks struct {
+	Track []Track `json:"track"`
+	Attr  Attr    `json:"@attr"`
+}
+
+type Session struct {
+	Name       string `json:"name"`
+	Key        string `json:"key"`
+	Subscriber int    `json:"subscriber"`
+}
+
+type NowPlaying struct {
+	Artist struct {
+		Corrected string `json:"corrected"`
+		Text      string `json:"#text"`
+	} `json:"artist"`
+	IgnoredMessage struct {
+		Code string `json:"code"`
+		Text string `json:"#text"`
+	} `json:"ignoredMessage"`
+	Album struct {
+		Corrected string `json:"corrected"`
+		Text      string `json:"#text"`
+	} `json:"album"`
+	AlbumArtist struct {
+		Corrected string `json:"corrected"`
+		Text      string `json:"#text"`
+	} `json:"albumArtist"`
+	Track struct {
+		Corrected string `json:"corrected"`
+		Text      string `json:"#text"`
+	} `json:"track"`
+}
+
+type Scrobbles struct {
+	Attr struct {
+		Accepted int `json:"accepted"`
+		Ignored  int `json:"ignored"`
+	} `json:"@attr"`
+	Scrobble struct {
+		Artist struct {
+			Corrected string `json:"corrected"`
+			Text      string `json:"#text"`
+		} `json:"artist"`
+		IgnoredMessage struct {
+			Code string `json:"code"`
+			Text string `json:"#text"`
+		} `json:"ignoredMessage"`
+		AlbumArtist struct {
+			Corrected string `json:"corrected"`
+			Text      string `json:"#text"`
+		} `json:"albumArtist"`
+		Timestamp string `json:"timestamp"`
+		Album     struct {
+			Corrected string `json:"corrected"`
+			Text      string `json:"#text"`
+		} `json:"album"`
+		Track struct {
+			Corrected string `json:"corrected"`
+			Text      string `json:"#text"`
+		} `json:"track"`
+	} `json:"scrobble"`
+}

core/agents/lastfm/responses_test.go

@@ -2,9 +2,9 @@ package lastfm
 
 import (
 	"encoding/json"
-	"io/ioutil"
+	"os"
 
-	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
 
@@ -12,7 +12,7 @@ var _ = Describe("LastFM responses", func() {
 	Describe("Artist", func() {
 		It("parses the response correctly", func() {
 			var resp Response
-			body, _ := ioutil.ReadFile("tests/fixtures/lastfm.artist.getinfo.json")
+			body, _ := os.ReadFile("tests/fixtures/lastfm.artist.getinfo.json")
 			err := json.Unmarshal(body, &resp)
 			Expect(err).To(BeNil())
 
@@ -20,18 +20,13 @@ var _ = Describe("LastFM responses", func() {
 			Expect(resp.Artist.MBID).To(Equal("a3cb23fc-acd3-4ce0-8f36-1e5aa6a18432"))
 			Expect(resp.Artist.URL).To(Equal("https://www.last.fm/music/U2"))
 			Expect(resp.Artist.Bio.Summary).To(ContainSubstring("U2 é uma das mais importantes bandas de rock de todos os tempos"))
-
-			similarArtists := []string{"Passengers", "INXS", "R.E.M.", "Simple Minds", "Bono"}
-			for i, similar := range similarArtists {
-				Expect(resp.Artist.Similar.Artists[i].Name).To(Equal(similar))
-			}
 		})
 	})
 
 	Describe("SimilarArtists", func() {
 		It("parses the response correctly", func() {
 			var resp Response
-			body, _ := ioutil.ReadFile("tests/fixtures/lastfm.artist.getsimilar.json")
+			body, _ := os.ReadFile("tests/fixtures/lastfm.artist.getsimilar.json")
 			err := json.Unmarshal(body, &resp)
 			Expect(err).To(BeNil())
 
@@ -44,7 +39,7 @@ var _ = Describe("LastFM responses", func() {
 	Describe("TopTracks", func() {
 		It("parses the response correctly", func() {
 			var resp Response
-			body, _ := ioutil.ReadFile("tests/fixtures/lastfm.artist.gettoptracks.json")
+			body, _ := os.ReadFile("tests/fixtures/lastfm.artist.gettoptracks.json")
 			err := json.Unmarshal(body, &resp)
 			Expect(err).To(BeNil())
 
@@ -58,12 +53,12 @@ var _ = Describe("LastFM responses", func() {
 
 	Describe("Error", func() {
 		It("parses the error response correctly", func() {
-			var error Error
+			var error Response
 			body := []byte(`{"error":3,"message":"Invalid Method - No method with that name in this package"}`)
 			err := json.Unmarshal(body, &error)
 			Expect(err).To(BeNil())
 
-			Expect(error.Code).To(Equal(3))
+			Expect(error.Error).To(Equal(3))
 			Expect(error.Message).To(Equal("Invalid Method - No method with that name in this package"))
 		})
 	})

core/agents/lastfm/token_received.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Account Linking Success</title>
+  </head>
+  <body>
+    <h2 id="msg"></h2>
+    <script>
+      setTimeout("document.getElementById('msg').innerHTML = 'Success! Your account is linked to Last.fm. You can close this tab now.';",2000)
+      document.addEventListener("DOMContentLoaded", () => {
+        window.close();
+      });
+    </script>
+  </body>
+</html>

core/agents/listenbrainz/agent.go

@@ -0,0 +1,119 @@
+package listenbrainz
+
+import (
+	"context"
+	"errors"
+	"net/http"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/core/scrobbler"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils"
+)
+
+const (
+	listenBrainzAgentName = "listenbrainz"
+	sessionKeyProperty    = "ListenBrainzSessionKey"
+)
+
+type listenBrainzAgent struct {
+	ds          model.DataStore
+	sessionKeys *agents.SessionKeys
+	baseURL     string
+	client      *client
+}
+
+func listenBrainzConstructor(ds model.DataStore) *listenBrainzAgent {
+	l := &listenBrainzAgent{
+		ds:          ds,
+		sessionKeys: &agents.SessionKeys{DataStore: ds, KeyName: sessionKeyProperty},
+		baseURL:     conf.Server.ListenBrainz.BaseURL,
+	}
+	hc := &http.Client{
+		Timeout: consts.DefaultHttpClientTimeOut,
+	}
+	chc := utils.NewCachedHTTPClient(hc, consts.DefaultHttpClientTimeOut)
+	l.client = newClient(l.baseURL, chc)
+	return l
+}
+
+func (l *listenBrainzAgent) AgentName() string {
+	return listenBrainzAgentName
+}
+
+func (l *listenBrainzAgent) formatListen(track *model.MediaFile) listenInfo {
+	li := listenInfo{
+		TrackMetadata: trackMetadata{
+			ArtistName:  track.Artist,
+			TrackName:   track.Title,
+			ReleaseName: track.Album,
+			AdditionalInfo: additionalInfo{
+				SubmissionClient:        consts.AppName,
+				SubmissionClientVersion: consts.Version,
+				TrackNumber:             track.TrackNumber,
+				ArtistMbzIDs:            []string{track.MbzArtistID},
+				TrackMbzID:              track.MbzTrackID,
+				ReleaseMbID:             track.MbzAlbumID,
+			},
+		},
+	}
+	return li
+}
+
+func (l *listenBrainzAgent) NowPlaying(ctx context.Context, userId string, track *model.MediaFile) error {
+	sk, err := l.sessionKeys.Get(ctx, userId)
+	if err != nil || sk == "" {
+		return scrobbler.ErrNotAuthorized
+	}
+
+	li := l.formatListen(track)
+	err = l.client.updateNowPlaying(ctx, sk, li)
+	if err != nil {
+		log.Warn(ctx, "ListenBrainz updateNowPlaying returned error", "track", track.Title, err)
+		return scrobbler.ErrUnrecoverable
+	}
+	return nil
+}
+
+func (l *listenBrainzAgent) Scrobble(ctx context.Context, userId string, s scrobbler.Scrobble) error {
+	sk, err := l.sessionKeys.Get(ctx, userId)
+	if err != nil || sk == "" {
+		return scrobbler.ErrNotAuthorized
+	}
+
+	li := l.formatListen(&s.MediaFile)
+	li.ListenedAt = int(s.TimeStamp.Unix())
+	err = l.client.scrobble(ctx, sk, li)
+
+	if err == nil {
+		return nil
+	}
+	var lbErr *listenBrainzError
+	isListenBrainzError := errors.As(err, &lbErr)
+	if !isListenBrainzError {
+		log.Warn(ctx, "ListenBrainz Scrobble returned HTTP error", "track", s.Title, err)
+		return scrobbler.ErrRetryLater
+	}
+	if lbErr.Code == 500 || lbErr.Code == 503 {
+		return scrobbler.ErrRetryLater
+	}
+	return scrobbler.ErrUnrecoverable
+}
+
+func (l *listenBrainzAgent) IsAuthorized(ctx context.Context, userId string) bool {
+	sk, err := l.sessionKeys.Get(ctx, userId)
+	return err == nil && sk != ""
+}
+
+func init() {
+	conf.AddHook(func() {
+		if conf.Server.ListenBrainz.Enabled {
+			scrobbler.Register(listenBrainzAgentName, func(ds model.DataStore) scrobbler.Scrobbler {
+				return listenBrainzConstructor(ds)
+			})
+		}
+	})
+}

core/agents/listenbrainz/agent_test.go

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

core/agents/listenbrainz/auth_router.go

@@ -0,0 +1,121 @@
+package listenbrainz
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+
+	"github.com/deluan/rest"
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+	"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/model/request"
+	"github.com/navidrome/navidrome/server"
+)
+
+type sessionKeysRepo interface {
+	Put(ctx context.Context, userId, sessionKey string) error
+	Get(ctx context.Context, userId string) (string, error)
+	Delete(ctx context.Context, userId string) error
+}
+
+type Router struct {
+	http.Handler
+	ds          model.DataStore
+	sessionKeys sessionKeysRepo
+	client      *client
+}
+
+func NewRouter(ds model.DataStore) *Router {
+	r := &Router{
+		ds:          ds,
+		sessionKeys: &agents.SessionKeys{DataStore: ds, KeyName: sessionKeyProperty},
+	}
+	r.Handler = r.routes()
+	hc := &http.Client{
+		Timeout: consts.DefaultHttpClientTimeOut,
+	}
+	r.client = newClient(conf.Server.ListenBrainz.BaseURL, hc)
+	return r
+}
+
+func (s *Router) routes() http.Handler {
+	r := chi.NewRouter()
+
+	r.Group(func(r chi.Router) {
+		r.Use(server.Authenticator(s.ds))
+		r.Use(server.JWTRefresher)
+
+		r.Get("/link", s.getLinkStatus)
+		r.Put("/link", s.link)
+		r.Delete("/link", s.unlink)
+	})
+
+	return r
+}
+
+func (s *Router) getLinkStatus(w http.ResponseWriter, r *http.Request) {
+	resp := map[string]interface{}{}
+	u, _ := request.UserFrom(r.Context())
+	key, err := s.sessionKeys.Get(r.Context(), u.ID)
+	if err != nil && !errors.Is(err, model.ErrNotFound) {
+		resp["error"] = err
+		resp["status"] = false
+		_ = rest.RespondWithJSON(w, http.StatusInternalServerError, resp)
+		return
+	}
+	resp["status"] = key != ""
+	_ = rest.RespondWithJSON(w, http.StatusOK, resp)
+}
+
+func (s *Router) link(w http.ResponseWriter, r *http.Request) {
+	type tokenPayload struct {
+		Token string `json:"token"`
+	}
+	var payload tokenPayload
+	err := json.NewDecoder(r.Body).Decode(&payload)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if payload.Token == "" {
+		_ = rest.RespondWithError(w, http.StatusBadRequest, "Token is required")
+		return
+	}
+
+	u, _ := request.UserFrom(r.Context())
+	resp, err := s.client.validateToken(r.Context(), payload.Token)
+	if err != nil {
+		log.Error(r.Context(), "Could not validate ListenBrainz token", "userId", u.ID, "requestId", middleware.GetReqID(r.Context()), err)
+		_ = rest.RespondWithError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if !resp.Valid {
+		_ = rest.RespondWithError(w, http.StatusBadRequest, "Invalid token")
+		return
+	}
+
+	err = s.sessionKeys.Put(r.Context(), u.ID, payload.Token)
+	if err != nil {
+		log.Error("Could not save ListenBrainz token", "userId", u.ID, "requestId", middleware.GetReqID(r.Context()), err)
+		_ = rest.RespondWithError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	_ = rest.RespondWithJSON(w, http.StatusOK, map[string]interface{}{"status": resp.Valid, "user": resp.UserName})
+}
+
+func (s *Router) unlink(w http.ResponseWriter, r *http.Request) {
+	u, _ := request.UserFrom(r.Context())
+	err := s.sessionKeys.Delete(r.Context(), u.ID)
+	if err != nil {
+		_ = rest.RespondWithError(w, http.StatusInternalServerError, err.Error())
+	} else {
+		_ = rest.RespondWithJSON(w, http.StatusOK, map[string]string{})
+	}
+}

core/agents/listenbrainz/auth_router_test.go

@@ -0,0 +1,130 @@
+package listenbrainz
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("ListenBrainz Auth Router", func() {
+	var sk *fakeSessionKeys
+	var httpClient *tests.FakeHttpClient
+	var r Router
+	var req *http.Request
+	var resp *httptest.ResponseRecorder
+
+	BeforeEach(func() {
+		sk = &fakeSessionKeys{KeyName: sessionKeyProperty}
+		httpClient = &tests.FakeHttpClient{}
+		cl := newClient("http://localhost/", httpClient)
+		r = Router{
+			sessionKeys: sk,
+			client:      cl,
+		}
+		resp = httptest.NewRecorder()
+	})
+
+	Describe("getLinkStatus", func() {
+		It("returns false when there is no stored session key", func() {
+			req = httptest.NewRequest("GET", "/listenbrainz/link", nil)
+			r.getLinkStatus(resp, req)
+			Expect(resp.Code).To(Equal(http.StatusOK))
+			var parsed map[string]interface{}
+			Expect(json.Unmarshal(resp.Body.Bytes(), &parsed)).To(BeNil())
+			Expect(parsed["status"]).To(Equal(false))
+		})
+
+		It("returns true when there is a stored session key", func() {
+			sk.KeyValue = "sk-1"
+			req = httptest.NewRequest("GET", "/listenbrainz/link", nil)
+			r.getLinkStatus(resp, req)
+			Expect(resp.Code).To(Equal(http.StatusOK))
+			var parsed map[string]interface{}
+			Expect(json.Unmarshal(resp.Body.Bytes(), &parsed)).To(BeNil())
+			Expect(parsed["status"]).To(Equal(true))
+		})
+	})
+
+	Describe("link", func() {
+		It("returns bad request when no token is sent", func() {
+			req = httptest.NewRequest("PUT", "/listenbrainz/link", strings.NewReader(`{}`))
+			r.link(resp, req)
+			Expect(resp.Code).To(Equal(http.StatusBadRequest))
+		})
+
+		It("returns bad request when the token is invalid", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`{"code": 200, "message": "Token invalid.", "valid": false}`)),
+				StatusCode: 200,
+			}
+
+			req = httptest.NewRequest("PUT", "/listenbrainz/link", strings.NewReader(`{"token": "invalid-tok-1"}`))
+			r.link(resp, req)
+			Expect(resp.Code).To(Equal(http.StatusBadRequest))
+		})
+
+		It("returns true and the username when the token is valid", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`{"code": 200, "message": "Token valid.", "user_name": "ListenBrainzUser", "valid": true}`)),
+				StatusCode: 200,
+			}
+
+			req = httptest.NewRequest("PUT", "/listenbrainz/link", strings.NewReader(`{"token": "tok-1"}`))
+			r.link(resp, req)
+			Expect(resp.Code).To(Equal(http.StatusOK))
+			var parsed map[string]interface{}
+			Expect(json.Unmarshal(resp.Body.Bytes(), &parsed)).To(BeNil())
+			Expect(parsed["status"]).To(Equal(true))
+			Expect(parsed["user"]).To(Equal("ListenBrainzUser"))
+		})
+
+		It("saves the session key when the token is valid", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`{"code": 200, "message": "Token valid.", "user_name": "ListenBrainzUser", "valid": true}`)),
+				StatusCode: 200,
+			}
+
+			req = httptest.NewRequest("PUT", "/listenbrainz/link", strings.NewReader(`{"token": "tok-1"}`))
+			r.link(resp, req)
+			Expect(resp.Code).To(Equal(http.StatusOK))
+			Expect(sk.KeyValue).To(Equal("tok-1"))
+		})
+	})
+
+	Describe("unlink", func() {
+		It("removes the session key when unlinking", func() {
+			sk.KeyValue = "tok-1"
+			req = httptest.NewRequest("DELETE", "/listenbrainz/link", nil)
+			r.unlink(resp, req)
+			Expect(resp.Code).To(Equal(http.StatusOK))
+			Expect(sk.KeyValue).To(Equal(""))
+		})
+	})
+})
+
+type fakeSessionKeys struct {
+	KeyName  string
+	KeyValue string
+}
+
+func (sk *fakeSessionKeys) Put(ctx context.Context, userId, sessionKey string) error {
+	sk.KeyValue = sessionKey
+	return nil
+}
+
+func (sk *fakeSessionKeys) Get(ctx context.Context, userId string) (string, error) {
+	return sk.KeyValue, nil
+}
+
+func (sk *fakeSessionKeys) Delete(ctx context.Context, userId string) error {
+	sk.KeyValue = ""
+	return nil
+}

core/agents/listenbrainz/client.go

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

core/agents/listenbrainz/client_test.go

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

core/agents/listenbrainz/listenbrainz_suite_test.go

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

core/agents/local_agent.go

@@ -0,0 +1,52 @@
+package agents
+
+import (
+	"context"
+
+	"github.com/Masterminds/squirrel"
+	"github.com/navidrome/navidrome/model"
+)
+
+const LocalAgentName = "local"
+
+type localAgent struct {
+	ds model.DataStore
+}
+
+func localsConstructor(ds model.DataStore) Interface {
+	return &localAgent{ds}
+}
+
+func (p *localAgent) AgentName() string {
+	return LocalAgentName
+}
+
+func (p *localAgent) GetArtistTopSongs(ctx context.Context, id, artistName, mbid string, count int) ([]Song, error) {
+	top, err := p.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+		Sort:  "playCount",
+		Order: "desc",
+		Max:   count,
+		Filters: squirrel.And{
+			squirrel.Eq{"artist_id": id},
+			squirrel.Or{
+				squirrel.Eq{"starred": true},
+				squirrel.Eq{"rating": 5},
+			},
+		},
+	})
+	if err != nil {
+		return nil, err
+	}
+	var result []Song
+	for _, s := range top {
+		result = append(result, Song{
+			Name: s.Title,
+			MBID: s.MbzReleaseTrackID,
+		})
+	}
+	return result, nil
+}
+
+func init() {
+	Register(LocalAgentName, localsConstructor)
+}

core/agents/placeholders.go

@@ -1,40 +0,0 @@
-package agents
-
-import (
-	"context"
-)
-
-const PlaceholderAgentName = "placeholder"
-
-const (
-	placeholderArtistImageSmallUrl  = "https://lastfm.freetls.fastly.net/i/u/64s/2a96cbd8b46e442fc41c2b86b821562f.png"
-	placeholderArtistImageMediumUrl = "https://lastfm.freetls.fastly.net/i/u/174s/2a96cbd8b46e442fc41c2b86b821562f.png"
-	placeholderArtistImageLargeUrl  = "https://lastfm.freetls.fastly.net/i/u/300x300/2a96cbd8b46e442fc41c2b86b821562f.png"
-	placeholderBiography            = "Biography not available"
-)
-
-type placeholderAgent struct{}
-
-func placeholdersConstructor(ctx context.Context) Interface {
-	return &placeholderAgent{}
-}
-
-func (p *placeholderAgent) AgentName() string {
-	return PlaceholderAgentName
-}
-
-func (p *placeholderAgent) GetBiography(id, name, mbid string) (string, error) {
-	return placeholderBiography, nil
-}
-
-func (p *placeholderAgent) GetImages(id, name, mbid string) ([]ArtistImage, error) {
-	return []ArtistImage{
-		{placeholderArtistImageLargeUrl, 300},
-		{placeholderArtistImageMediumUrl, 174},
-		{placeholderArtistImageSmallUrl, 64},
-	}, nil
-}
-
-func init() {
-	Register(PlaceholderAgentName, placeholdersConstructor)
-}

core/agents/session_keys.go

@@ -0,0 +1,25 @@
+package agents
+
+import (
+	"context"
+
+	"github.com/navidrome/navidrome/model"
+)
+
+// SessionKeys is a simple wrapper around the UserPropsRepository
+type SessionKeys struct {
+	model.DataStore
+	KeyName string
+}
+
+func (sk *SessionKeys) Put(ctx context.Context, userId, sessionKey string) error {
+	return sk.DataStore.UserProps(ctx).Put(userId, sk.KeyName, sessionKey)
+}
+
+func (sk *SessionKeys) Get(ctx context.Context, userId string) (string, error) {
+	return sk.DataStore.UserProps(ctx).Get(userId, sk.KeyName)
+}
+
+func (sk *SessionKeys) Delete(ctx context.Context, userId string) error {
+	return sk.DataStore.UserProps(ctx).Delete(userId, sk.KeyName)
+}

core/agents/session_keys_test.go

@@ -0,0 +1,37 @@
+package agents
+
+import (
+	"context"
+
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("SessionKeys", func() {
+	ctx := context.Background()
+	user := model.User{ID: "u-1"}
+	ds := &tests.MockDataStore{MockedUserProps: &tests.MockedUserPropsRepo{}}
+	sk := SessionKeys{DataStore: ds, KeyName: "fakeSessionKey"}
+
+	It("uses the assigned key name", func() {
+		Expect(sk.KeyName).To(Equal("fakeSessionKey"))
+	})
+	It("stores a value in the DB", func() {
+		Expect(sk.Put(ctx, user.ID, "test-stored-value")).To(BeNil())
+	})
+	It("fetches the stored value", func() {
+		value, err := sk.Get(ctx, user.ID)
+		Expect(err).ToNot(HaveOccurred())
+		Expect(value).To(Equal("test-stored-value"))
+	})
+	It("deletes the stored value", func() {
+		Expect(sk.Delete(ctx, user.ID)).To(BeNil())
+	})
+	It("handles a not found value", func() {
+		_, err := sk.Get(ctx, "u-2")
+		Expect(err).To(MatchError(model.ErrNotFound))
+	})
+})

core/agents/spotify/client.go

@@ -6,7 +6,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"net/url"
 	"strconv"
@@ -25,17 +25,17 @@ type httpDoer interface {
 	Do(req *http.Request) (*http.Response, error)
 }
 
-func NewClient(id, secret string, hc httpDoer) *Client {
-	return &Client{id, secret, hc}
+func newClient(id, secret string, hc httpDoer) *client {
+	return &client{id, secret, hc}
 }
 
-type Client struct {
+type client struct {
 	id     string
 	secret string
 	hc     httpDoer
 }
 
-func (c *Client) SearchArtists(ctx context.Context, name string, limit int) ([]Artist, error) {
+func (c *client) searchArtists(ctx context.Context, name string, limit int) ([]Artist, error) {
 	token, err := c.authorize(ctx)
 	if err != nil {
 		return nil, err
@@ -46,7 +46,7 @@ func (c *Client) SearchArtists(ctx context.Context, name string, limit int) ([]A
 	params.Add("q", name)
 	params.Add("offset", "0")
 	params.Add("limit", strconv.Itoa(limit))
-	req, _ := http.NewRequest("GET", apiBaseUrl+"search", nil)
+	req, _ := http.NewRequestWithContext(ctx, "GET", apiBaseUrl+"search", nil)
 	req.URL.RawQuery = params.Encode()
 	req.Header.Add("Authorization", "Bearer "+token)
 
@@ -62,12 +62,12 @@ func (c *Client) SearchArtists(ctx context.Context, name string, limit int) ([]A
 	return results.Artists.Items, err
 }
 
-func (c *Client) authorize(ctx context.Context) (string, error) {
+func (c *client) authorize(ctx context.Context) (string, error) {
 	payload := url.Values{}
 	payload.Add("grant_type", "client_credentials")
 
 	encodePayload := payload.Encode()
-	req, _ := http.NewRequest("POST", "https://accounts.spotify.com/api/token", strings.NewReader(encodePayload))
+	req, _ := http.NewRequestWithContext(ctx, "POST", "https://accounts.spotify.com/api/token", strings.NewReader(encodePayload))
 	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
 	req.Header.Add("Content-Length", strconv.Itoa(len(encodePayload)))
 	auth := c.id + ":" + c.secret
@@ -86,14 +86,15 @@ func (c *Client) authorize(ctx context.Context) (string, error) {
 	return "", errors.New("invalid response")
 }
 
-func (c *Client) makeRequest(req *http.Request, response interface{}) error {
+func (c *client) makeRequest(req *http.Request, response interface{}) error {
+	log.Trace(req.Context(), fmt.Sprintf("Sending Spotify %s request", req.Method), "url", req.URL)
 	resp, err := c.hc.Do(req)
 	if err != nil {
 		return err
 	}
 
 	defer resp.Body.Close()
-	data, err := ioutil.ReadAll(resp.Body)
+	data, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return err
 	}
@@ -105,7 +106,7 @@ func (c *Client) makeRequest(req *http.Request, response interface{}) error {
 	return json.Unmarshal(data, response)
 }
 
-func (c *Client) parseError(data []byte) error {
+func (c *client) parseError(data []byte) error {
 	var e Error
 	err := json.Unmarshal(data, &e)
 	if err != nil {

core/agents/spotify/client_test.go

@@ -3,21 +3,21 @@ package spotify
 import (
 	"bytes"
 	"context"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"os"
 
-	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
 
-var _ = Describe("Client", func() {
+var _ = Describe("client", func() {
 	var httpClient *fakeHttpClient
-	var client *Client
+	var client *client
 
 	BeforeEach(func() {
 		httpClient = &fakeHttpClient{}
-		client = NewClient("SPOTIFY_ID", "SPOTIFY_SECRET", httpClient)
+		client = newClient("SPOTIFY_ID", "SPOTIFY_SECRET", httpClient)
 	})
 
 	Describe("ArtistImages", func() {
@@ -26,10 +26,10 @@ var _ = Describe("Client", func() {
 			httpClient.mock("https://api.spotify.com/v1/search", http.Response{Body: f, StatusCode: 200})
 			httpClient.mock("https://accounts.spotify.com/api/token", http.Response{
 				StatusCode: 200,
-				Body:       ioutil.NopCloser(bytes.NewBufferString(`{"access_token": "NEW_ACCESS_TOKEN","token_type": "Bearer","expires_in": 3600}`)),
+				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token": "NEW_ACCESS_TOKEN","token_type": "Bearer","expires_in": 3600}`)),
 			})
 
-			artists, err := client.SearchArtists(context.TODO(), "U2", 10)
+			artists, err := client.searchArtists(context.TODO(), "U2", 10)
 			Expect(err).To(BeNil())
 			Expect(artists).To(HaveLen(20))
 			Expect(artists[0].Popularity).To(Equal(82))
@@ -44,7 +44,7 @@ var _ = Describe("Client", func() {
 		It("fails if artist was not found", func() {
 			httpClient.mock("https://api.spotify.com/v1/search", http.Response{
 				StatusCode: 200,
-				Body: ioutil.NopCloser(bytes.NewBufferString(`{
+				Body: io.NopCloser(bytes.NewBufferString(`{
 						  "artists" : {
 							"href" : "https://api.spotify.com/v1/search?query=dasdasdas%2Cdna&type=artist&offset=0&limit=20",
 							"items" : [ ], "limit" : 20, "next" : null, "offset" : 0, "previous" : null, "total" : 0
@@ -52,10 +52,10 @@ var _ = Describe("Client", func() {
 			})
 			httpClient.mock("https://accounts.spotify.com/api/token", http.Response{
 				StatusCode: 200,
-				Body:       ioutil.NopCloser(bytes.NewBufferString(`{"access_token": "NEW_ACCESS_TOKEN","token_type": "Bearer","expires_in": 3600}`)),
+				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token": "NEW_ACCESS_TOKEN","token_type": "Bearer","expires_in": 3600}`)),
 			})
 
-			_, err := client.SearchArtists(context.TODO(), "U2", 10)
+			_, err := client.searchArtists(context.TODO(), "U2", 10)
 			Expect(err).To(MatchError(ErrNotFound))
 		})
 
@@ -64,10 +64,10 @@ var _ = Describe("Client", func() {
 			httpClient.mock("https://api.spotify.com/v1/search", http.Response{Body: f, StatusCode: 200})
 			httpClient.mock("https://accounts.spotify.com/api/token", http.Response{
 				StatusCode: 400,
-				Body:       ioutil.NopCloser(bytes.NewBufferString(`{"error":"invalid_client","error_description":"Invalid client"}`)),
+				Body:       io.NopCloser(bytes.NewBufferString(`{"error":"invalid_client","error_description":"Invalid client"}`)),
 			})
 
-			_, err := client.SearchArtists(context.TODO(), "U2", 10)
+			_, err := client.searchArtists(context.TODO(), "U2", 10)
 			Expect(err).To(MatchError("spotify error(invalid_client): Invalid client"))
 		})
 	})
@@ -76,7 +76,7 @@ var _ = Describe("Client", func() {
 		It("returns an access_token on successful authorization", func() {
 			httpClient.mock("https://accounts.spotify.com/api/token", http.Response{
 				StatusCode: 200,
-				Body:       ioutil.NopCloser(bytes.NewBufferString(`{"access_token": "NEW_ACCESS_TOKEN","token_type": "Bearer","expires_in": 3600}`)),
+				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token": "NEW_ACCESS_TOKEN","token_type": "Bearer","expires_in": 3600}`)),
 			})
 
 			token, err := client.authorize(context.TODO())
@@ -89,7 +89,7 @@ var _ = Describe("Client", func() {
 		It("fails on unsuccessful authorization", func() {
 			httpClient.mock("https://accounts.spotify.com/api/token", http.Response{
 				StatusCode: 400,
-				Body:       ioutil.NopCloser(bytes.NewBufferString(`{"error":"invalid_client","error_description":"Invalid client"}`)),
+				Body:       io.NopCloser(bytes.NewBufferString(`{"error":"invalid_client","error_description":"Invalid client"}`)),
 			})
 
 			_, err := client.authorize(context.TODO())
@@ -99,7 +99,7 @@ var _ = Describe("Client", func() {
 		It("fails on invalid JSON response", func() {
 			httpClient.mock("https://accounts.spotify.com/api/token", http.Response{
 				StatusCode: 200,
-				Body:       ioutil.NopCloser(bytes.NewBufferString(`{NOT_VALID}`)),
+				Body:       io.NopCloser(bytes.NewBufferString(`{NOT_VALID}`)),
 			})
 
 			_, err := client.authorize(context.TODO())

core/agents/spotify/responses_test.go

@@ -2,9 +2,9 @@ package spotify
 
 import (
 	"encoding/json"
-	"io/ioutil"
+	"os"
 
-	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
 
@@ -12,7 +12,7 @@ var _ = Describe("Responses", func() {
 	Describe("Search type=artist", func() {
 		It("parses the artist search result correctly ", func() {
 			var resp SearchResults
-			body, _ := ioutil.ReadFile("tests/fixtures/spotify.search.artist.json")
+			body, _ := os.ReadFile("tests/fixtures/spotify.search.artist.json")
 			err := json.Unmarshal(body, &resp)
 			Expect(err).To(BeNil())
 

core/agents/spotify/spotify.go

@@ -1,7 +1,8 @@
-package agents
+package spotify
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"net/http"
 	"sort"
@@ -9,29 +10,33 @@ import (
 
 	"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/spotify"
+	"github.com/navidrome/navidrome/utils"
 	"github.com/xrash/smetrics"
 )
 
 const spotifyAgentName = "spotify"
 
 type spotifyAgent struct {
-	ctx    context.Context
+	ds     model.DataStore
 	id     string
 	secret string
-	client *spotify.Client
+	client *client
 }
 
-func spotifyConstructor(ctx context.Context) Interface {
+func spotifyConstructor(ds model.DataStore) agents.Interface {
 	l := &spotifyAgent{
-		ctx:    ctx,
+		ds:     ds,
 		id:     conf.Server.Spotify.ID,
 		secret: conf.Server.Spotify.Secret,
 	}
-	hc := NewCachedHTTPClient(http.DefaultClient, consts.DefaultCachedHttpClientTTL)
-	l.client = spotify.NewClient(l.id, l.secret, hc)
+	hc := &http.Client{
+		Timeout: consts.DefaultHttpClientTimeOut,
+	}
+	chc := utils.NewCachedHTTPClient(hc, consts.DefaultHttpClientTimeOut)
+	l.client = newClient(l.id, l.secret, chc)
 	return l
 }
 
@@ -39,20 +44,20 @@ func (s *spotifyAgent) AgentName() string {
 	return spotifyAgentName
 }
 
-func (s *spotifyAgent) GetImages(id, name, mbid string) ([]ArtistImage, error) {
-	a, err := s.searchArtist(name)
+func (s *spotifyAgent) GetArtistImages(ctx context.Context, id, name, mbid string) ([]agents.ExternalImage, error) {
+	a, err := s.searchArtist(ctx, name)
 	if err != nil {
-		if err == model.ErrNotFound {
-			log.Warn(s.ctx, "Artist not found in Spotify", "artist", name)
+		if errors.Is(err, model.ErrNotFound) {
+			log.Warn(ctx, "Artist not found in Spotify", "artist", name)
 		} else {
-			log.Error(s.ctx, "Error calling Spotify", "artist", name, err)
+			log.Error(ctx, "Error calling Spotify", "artist", name, err)
 		}
 		return nil, err
 	}
 
-	var res []ArtistImage
+	var res []agents.ExternalImage
 	for _, img := range a.Images {
-		res = append(res, ArtistImage{
+		res = append(res, agents.ExternalImage{
 			URL:  img.URL,
 			Size: img.Width,
 		})
@@ -60,8 +65,8 @@ func (s *spotifyAgent) GetImages(id, name, mbid string) ([]ArtistImage, error) {
 	return res, nil
 }
 
-func (s *spotifyAgent) searchArtist(name string) (*spotify.Artist, error) {
-	artists, err := s.client.SearchArtists(s.ctx, name, 40)
+func (s *spotifyAgent) searchArtist(ctx context.Context, name string) (*Artist, error) {
+	artists, err := s.client.searchArtists(ctx, name, 40)
 	if err != nil || len(artists) == 0 {
 		return nil, model.ErrNotFound
 	}
@@ -84,8 +89,7 @@ func (s *spotifyAgent) searchArtist(name string) (*spotify.Artist, error) {
 func init() {
 	conf.AddHook(func() {
 		if conf.Server.Spotify.ID != "" && conf.Server.Spotify.Secret != "" {
-			log.Info("Spotify integration is ENABLED")
-			Register(spotifyAgentName, spotifyConstructor)
+			agents.Register(spotifyAgentName, spotifyConstructor)
 		}
 	})
 }

core/agents/spotify/spotify_suite_test.go

@@ -5,13 +5,13 @@ import (
 
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
 
 func TestSpotify(t *testing.T) {
 	tests.Init(t, false)
-	log.SetLevel(log.LevelCritical)
+	log.SetLevel(log.LevelFatal)
 	RegisterFailHandler(Fail)
 	RunSpecs(t, "Spotify Test Suite")
 }

core/archiver.go

@@ -7,62 +7,116 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"github.com/Masterminds/squirrel"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils/slice"
 )
 
 type Archiver interface {
-	ZipAlbum(ctx context.Context, id string, w io.Writer) error
-	ZipArtist(ctx context.Context, id string, w io.Writer) error
-	ZipPlaylist(ctx context.Context, id string, w io.Writer) error
+	ZipAlbum(ctx context.Context, id string, format string, bitrate int, w io.Writer) error
+	ZipArtist(ctx context.Context, id string, format string, bitrate int, w io.Writer) error
+	ZipShare(ctx context.Context, id string, w io.Writer) error
+	ZipPlaylist(ctx context.Context, id string, format string, bitrate int, w io.Writer) error
 }
 
-func NewArchiver(ds model.DataStore) Archiver {
-	return &archiver{ds: ds}
+func NewArchiver(ms MediaStreamer, ds model.DataStore, shares Share) Archiver {
+	return &archiver{ds: ds, ms: ms, shares: shares}
 }
 
 type archiver struct {
-	ds model.DataStore
+	ds     model.DataStore
+	ms     MediaStreamer
+	shares Share
 }
 
-type createHeader func(idx int, mf model.MediaFile) *zip.FileHeader
-
-func (a *archiver) ZipAlbum(ctx context.Context, id string, out io.Writer) error {
-	mfs, err := a.ds.MediaFile(ctx).FindByAlbum(id)
-	if err != nil {
-		log.Error(ctx, "Error loading mediafiles from album", "id", id, err)
-		return err
-	}
-	return a.zipTracks(ctx, id, out, mfs, a.createHeader)
+func (a *archiver) ZipAlbum(ctx context.Context, id string, format string, bitrate int, out io.Writer) error {
+	return a.zipAlbums(ctx, id, format, bitrate, out, squirrel.Eq{"album_id": id})
 }
 
-func (a *archiver) ZipArtist(ctx context.Context, id string, out io.Writer) error {
-	mfs, err := a.ds.MediaFile(ctx).GetAll(model.QueryOptions{
-		Sort:    "album",
-		Filters: squirrel.Eq{"album_artist_id": id},
-	})
+func (a *archiver) ZipArtist(ctx context.Context, id string, format string, bitrate int, out io.Writer) error {
+	return a.zipAlbums(ctx, id, format, bitrate, out, squirrel.Eq{"album_artist_id": id})
+}
+
+func (a *archiver) zipAlbums(ctx context.Context, id string, format string, bitrate int, out io.Writer, filters squirrel.Sqlizer) error {
+	mfs, err := a.ds.MediaFile(ctx).GetAll(model.QueryOptions{Filters: filters, Sort: "album"})
 	if err != nil {
 		log.Error(ctx, "Error loading mediafiles from artist", "id", id, err)
 		return err
 	}
-	return a.zipTracks(ctx, id, out, mfs, a.createHeader)
+
+	z := createZipWriter(out, format, bitrate)
+	albums := slice.Group(mfs, func(mf model.MediaFile) string {
+		return mf.AlbumID
+	})
+	for _, album := range albums {
+		discs := slice.Group(album, func(mf model.MediaFile) int { return mf.DiscNumber })
+		isMultDisc := len(discs) > 1
+		log.Debug(ctx, "Zipping album", "name", album[0].Album, "artist", album[0].AlbumArtist,
+			"format", format, "bitrate", bitrate, "isMultDisc", isMultDisc, "numTracks", len(album))
+		for _, mf := range album {
+			file := a.albumFilename(mf, format, isMultDisc)
+			_ = a.addFileToZip(ctx, z, mf, format, bitrate, file)
+		}
+	}
+	err = z.Close()
+	if err != nil {
+		log.Error(ctx, "Error closing zip file", "id", id, err)
+	}
+	return err
 }
 
-func (a *archiver) ZipPlaylist(ctx context.Context, id string, out io.Writer) error {
-	pls, err := a.ds.Playlist(ctx).Get(id)
+func createZipWriter(out io.Writer, format string, bitrate int) *zip.Writer {
+	z := zip.NewWriter(out)
+	comment := "Downloaded from Navidrome"
+	if format != "raw" && format != "" {
+		comment = fmt.Sprintf("%s, transcoded to %s %dbps", comment, format, bitrate)
+	}
+	_ = z.SetComment(comment)
+	return z
+}
+
+func (a *archiver) albumFilename(mf model.MediaFile, format string, isMultDisc bool) string {
+	_, file := filepath.Split(mf.Path)
+	if format != "raw" {
+		file = strings.TrimSuffix(file, mf.Suffix) + format
+	}
+	if isMultDisc {
+		file = fmt.Sprintf("Disc %02d/%s", mf.DiscNumber, file)
+	}
+	return fmt.Sprintf("%s/%s", mf.Album, file)
+}
+
+func (a *archiver) ZipShare(ctx context.Context, id string, out io.Writer) error {
+	s, err := a.shares.Load(ctx, id)
+	if !s.Downloadable {
+		return model.ErrNotAuthorized
+	}
+	if err != nil {
+		return err
+	}
+	log.Debug(ctx, "Zipping share", "name", s.ID, "format", s.Format, "bitrate", s.MaxBitRate, "numTracks", len(s.Tracks))
+	return a.zipMediaFiles(ctx, id, s.Format, s.MaxBitRate, out, s.Tracks)
+}
+
+func (a *archiver) ZipPlaylist(ctx context.Context, id string, format string, bitrate int, out io.Writer) error {
+	pls, err := a.ds.Playlist(ctx).GetWithTracks(id, true)
 	if err != nil {
 		log.Error(ctx, "Error loading mediafiles from playlist", "id", id, err)
 		return err
 	}
-	return a.zipTracks(ctx, id, out, pls.Tracks, a.createPlaylistHeader)
+	mfs := pls.MediaFiles()
+	log.Debug(ctx, "Zipping playlist", "name", pls.Name, "format", format, "bitrate", bitrate, "numTracks", len(mfs))
+	return a.zipMediaFiles(ctx, id, format, bitrate, out, mfs)
 }
 
-func (a *archiver) zipTracks(ctx context.Context, id string, out io.Writer, mfs model.MediaFiles, ch createHeader) error {
-	z := zip.NewWriter(out)
+func (a *archiver) zipMediaFiles(ctx context.Context, id string, format string, bitrate int, out io.Writer, mfs model.MediaFiles) error {
+	z := createZipWriter(out, format, bitrate)
 	for idx, mf := range mfs {
-		_ = a.addFileToZip(ctx, z, mf, ch(idx, mf))
+		file := a.playlistFilename(mf, format, idx)
+		_ = a.addFileToZip(ctx, z, mf, format, bitrate, file)
 	}
 	err := z.Close()
 	if err != nil {
@@ -71,40 +125,48 @@ func (a *archiver) zipTracks(ctx context.Context, id string, out io.Writer, mfs
 	return err
 }
 
-func (a *archiver) createHeader(idx int, mf model.MediaFile) *zip.FileHeader {
-	_, file := filepath.Split(mf.Path)
-	return &zip.FileHeader{
-		Name:     fmt.Sprintf("%s/%s", mf.Album, file),
-		Modified: mf.UpdatedAt,
-		Method:   zip.Store,
+func (a *archiver) playlistFilename(mf model.MediaFile, format string, idx int) string {
+	ext := mf.Suffix
+	if format != "" && format != "raw" {
+		ext = format
 	}
+	file := fmt.Sprintf("%02d - %s - %s.%s", idx+1, mf.Artist, mf.Title, ext)
+	return file
 }
 
-func (a *archiver) createPlaylistHeader(idx int, mf model.MediaFile) *zip.FileHeader {
-	_, file := filepath.Split(mf.Path)
-	return &zip.FileHeader{
-		Name:     fmt.Sprintf("%d - %s-%s", idx, mf.AlbumArtist, file),
+func (a *archiver) addFileToZip(ctx context.Context, z *zip.Writer, mf model.MediaFile, format string, bitrate int, filename string) error {
+	w, err := z.CreateHeader(&zip.FileHeader{
+		Name:     filename,
 		Modified: mf.UpdatedAt,
 		Method:   zip.Store,
-	}
-}
-
-func (a *archiver) addFileToZip(ctx context.Context, z *zip.Writer, mf model.MediaFile, zh *zip.FileHeader) error {
-	w, err := z.CreateHeader(zh)
+	})
 	if err != nil {
 		log.Error(ctx, "Error creating zip entry", "file", mf.Path, err)
 		return err
 	}
-	f, err := os.Open(mf.Path)
-	defer func() { _ = f.Close() }()
+
+	var r io.ReadCloser
+	if format != "raw" && format != "" {
+		r, err = a.ms.DoStream(ctx, &mf, format, bitrate)
+	} else {
+		r, err = os.Open(mf.Path)
+	}
 	if err != nil {
-		log.Error(ctx, "Error opening file for zipping", "file", mf.Path, err)
+		log.Error(ctx, "Error opening file for zipping", "file", mf.Path, "format", format, err)
 		return err
 	}
-	_, err = io.Copy(w, f)
+
+	defer func() {
+		if err := r.Close(); err != nil && log.CurrentLevel() >= log.LevelDebug {
+			log.Error(ctx, "Error closing stream", "id", mf.ID, "file", mf.Path, err)
+		}
+	}()
+
+	_, err = io.Copy(w, r)
 	if err != nil {
 		log.Error(ctx, "Error zipping file", "file", mf.Path, err)
 		return err
 	}
+
 	return nil
 }

core/archiver_test.go

@@ -0,0 +1,211 @@
+package core_test
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"io"
+	"strings"
+
+	"github.com/Masterminds/squirrel"
+	"github.com/navidrome/navidrome/core"
+	"github.com/navidrome/navidrome/model"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/stretchr/testify/mock"
+)
+
+var _ = Describe("Archiver", func() {
+	var (
+		arch core.Archiver
+		ms   *mockMediaStreamer
+		ds   *mockDataStore
+		sh   *mockShare
+	)
+
+	BeforeEach(func() {
+		ms = &mockMediaStreamer{}
+		ds = &mockDataStore{}
+		sh = &mockShare{}
+		arch = core.NewArchiver(ms, ds, sh)
+	})
+
+	Context("ZipAlbum", func() {
+		It("zips an album correctly", func() {
+			mfs := model.MediaFiles{
+				{Path: "test_data/01 - track1.mp3", Suffix: "mp3", AlbumID: "1", Album: "Album 1", DiscNumber: 1},
+				{Path: "test_data/02 - track2.mp3", Suffix: "mp3", AlbumID: "1", Album: "Album 1", DiscNumber: 1},
+			}
+
+			mfRepo := &mockMediaFileRepository{}
+			mfRepo.On("GetAll", []model.QueryOptions{{
+				Filters: squirrel.Eq{"album_id": "1"},
+				Sort:    "album",
+			}}).Return(mfs, nil)
+
+			ds.On("MediaFile", mock.Anything).Return(mfRepo)
+			ms.On("DoStream", mock.Anything, mock.Anything, "mp3", 128).Return(io.NopCloser(strings.NewReader("test")), nil).Times(2)
+
+			out := new(bytes.Buffer)
+			err := arch.ZipAlbum(context.Background(), "1", "mp3", 128, out)
+			Expect(err).To(BeNil())
+
+			zr, err := zip.NewReader(bytes.NewReader(out.Bytes()), int64(out.Len()))
+			Expect(err).To(BeNil())
+
+			Expect(len(zr.File)).To(Equal(2))
+			Expect(zr.File[0].Name).To(Equal("Album 1/01 - track1.mp3"))
+			Expect(zr.File[1].Name).To(Equal("Album 1/02 - track2.mp3"))
+		})
+	})
+
+	Context("ZipArtist", func() {
+		It("zips an artist's albums correctly", func() {
+			mfs := model.MediaFiles{
+				{Path: "test_data/01 - track1.mp3", Suffix: "mp3", AlbumArtistID: "1", AlbumID: "1", Album: "Album 1", DiscNumber: 1},
+				{Path: "test_data/02 - track2.mp3", Suffix: "mp3", AlbumArtistID: "1", AlbumID: "1", Album: "Album 1", DiscNumber: 1},
+			}
+
+			mfRepo := &mockMediaFileRepository{}
+			mfRepo.On("GetAll", []model.QueryOptions{{
+				Filters: squirrel.Eq{"album_artist_id": "1"},
+				Sort:    "album",
+			}}).Return(mfs, nil)
+
+			ds.On("MediaFile", mock.Anything).Return(mfRepo)
+			ms.On("DoStream", mock.Anything, mock.Anything, "mp3", 128).Return(io.NopCloser(strings.NewReader("test")), nil).Times(2)
+
+			out := new(bytes.Buffer)
+			err := arch.ZipArtist(context.Background(), "1", "mp3", 128, out)
+			Expect(err).To(BeNil())
+
+			zr, err := zip.NewReader(bytes.NewReader(out.Bytes()), int64(out.Len()))
+			Expect(err).To(BeNil())
+
+			Expect(len(zr.File)).To(Equal(2))
+			Expect(zr.File[0].Name).To(Equal("Album 1/01 - track1.mp3"))
+			Expect(zr.File[1].Name).To(Equal("Album 1/02 - track2.mp3"))
+		})
+	})
+
+	Context("ZipShare", func() {
+		It("zips a share correctly", func() {
+			mfs := model.MediaFiles{
+				{ID: "1", Path: "test_data/01 - track1.mp3", Suffix: "mp3", Artist: "Artist 1", Title: "track1"},
+				{ID: "2", Path: "test_data/02 - track2.mp3", Suffix: "mp3", Artist: "Artist 2", Title: "track2"},
+			}
+
+			share := &model.Share{
+				ID:           "1",
+				Downloadable: true,
+				Format:       "mp3",
+				MaxBitRate:   128,
+				Tracks:       mfs,
+			}
+
+			sh.On("Load", mock.Anything, "1").Return(share, nil)
+			ms.On("DoStream", mock.Anything, mock.Anything, "mp3", 128).Return(io.NopCloser(strings.NewReader("test")), nil).Times(2)
+
+			out := new(bytes.Buffer)
+			err := arch.ZipShare(context.Background(), "1", out)
+			Expect(err).To(BeNil())
+
+			zr, err := zip.NewReader(bytes.NewReader(out.Bytes()), int64(out.Len()))
+			Expect(err).To(BeNil())
+
+			Expect(len(zr.File)).To(Equal(2))
+			Expect(zr.File[0].Name).To(Equal("01 - Artist 1 - track1.mp3"))
+			Expect(zr.File[1].Name).To(Equal("02 - Artist 2 - track2.mp3"))
+
+		})
+	})
+
+	Context("ZipPlaylist", func() {
+		It("zips a playlist correctly", func() {
+			tracks := []model.PlaylistTrack{
+				{MediaFile: model.MediaFile{Path: "test_data/01 - track1.mp3", Suffix: "mp3", AlbumID: "1", Album: "Album 1", DiscNumber: 1, Artist: "Artist 1", Title: "track1"}},
+				{MediaFile: model.MediaFile{Path: "test_data/02 - track2.mp3", Suffix: "mp3", AlbumID: "1", Album: "Album 1", DiscNumber: 1, Artist: "Artist 2", Title: "track2"}},
+			}
+
+			pls := &model.Playlist{
+				ID:     "1",
+				Name:   "Test Playlist",
+				Tracks: tracks,
+			}
+
+			plRepo := &mockPlaylistRepository{}
+			plRepo.On("GetWithTracks", "1", true).Return(pls, nil)
+			ds.On("Playlist", mock.Anything).Return(plRepo)
+			ms.On("DoStream", mock.Anything, mock.Anything, "mp3", 128).Return(io.NopCloser(strings.NewReader("test")), nil).Times(2)
+
+			out := new(bytes.Buffer)
+			err := arch.ZipPlaylist(context.Background(), "1", "mp3", 128, out)
+			Expect(err).To(BeNil())
+
+			zr, err := zip.NewReader(bytes.NewReader(out.Bytes()), int64(out.Len()))
+			Expect(err).To(BeNil())
+
+			Expect(len(zr.File)).To(Equal(2))
+			Expect(zr.File[0].Name).To(Equal("01 - Artist 1 - track1.mp3"))
+			Expect(zr.File[1].Name).To(Equal("02 - Artist 2 - track2.mp3"))
+		})
+	})
+})
+
+type mockDataStore struct {
+	mock.Mock
+	model.DataStore
+}
+
+func (m *mockDataStore) MediaFile(ctx context.Context) model.MediaFileRepository {
+	args := m.Called(ctx)
+	return args.Get(0).(model.MediaFileRepository)
+}
+
+func (m *mockDataStore) Playlist(ctx context.Context) model.PlaylistRepository {
+	args := m.Called(ctx)
+	return args.Get(0).(model.PlaylistRepository)
+}
+
+type mockMediaFileRepository struct {
+	mock.Mock
+	model.MediaFileRepository
+}
+
+func (m *mockMediaFileRepository) GetAll(options ...model.QueryOptions) (model.MediaFiles, error) {
+	args := m.Called(options)
+	return args.Get(0).(model.MediaFiles), args.Error(1)
+}
+
+type mockPlaylistRepository struct {
+	mock.Mock
+	model.PlaylistRepository
+}
+
+func (m *mockPlaylistRepository) GetWithTracks(id string, includeTracks bool) (*model.Playlist, error) {
+	args := m.Called(id, includeTracks)
+	return args.Get(0).(*model.Playlist), args.Error(1)
+}
+
+type mockMediaStreamer struct {
+	mock.Mock
+	core.MediaStreamer
+}
+
+func (m *mockMediaStreamer) DoStream(ctx context.Context, mf *model.MediaFile, format string, bitrate int) (*core.Stream, error) {
+	args := m.Called(ctx, mf, format, bitrate)
+	if args.Error(1) != nil {
+		return nil, args.Error(1)
+	}
+	return &core.Stream{ReadCloser: args.Get(0).(io.ReadCloser)}, nil
+}
+
+type mockShare struct {
+	mock.Mock
+	core.Share
+}
+
+func (m *mockShare) Load(ctx context.Context, id string) (*model.Share, error) {
+	args := m.Called(ctx, id)
+	return args.Get(0).(*model.Share), args.Error(1)
+}

core/artwork.go

@@ -1,221 +0,0 @@
-package core
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"image"
-	_ "image/gif"
-	"image/jpeg"
-	_ "image/png"
-	"io"
-	"io/ioutil"
-	"os"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/dhowden/tag"
-	"github.com/disintegration/imaging"
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/consts"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/resources"
-	"github.com/navidrome/navidrome/utils"
-	"github.com/navidrome/navidrome/utils/cache"
-	_ "golang.org/x/image/webp"
-)
-
-type Artwork interface {
-	Get(ctx context.Context, id string, size int) (io.ReadCloser, error)
-}
-
-type ArtworkCache cache.FileCache
-
-func NewArtwork(ds model.DataStore, cache ArtworkCache) Artwork {
-	return &artwork{ds: ds, cache: cache}
-}
-
-type artwork struct {
-	ds    model.DataStore
-	cache cache.FileCache
-}
-
-type imageInfo struct {
-	a          *artwork
-	id         string
-	path       string
-	size       int
-	lastUpdate time.Time
-}
-
-func (ci *imageInfo) Key() string {
-	return fmt.Sprintf("%s.%d.%s.%d", ci.path, ci.size, ci.lastUpdate.Format(time.RFC3339Nano), conf.Server.CoverJpegQuality)
-}
-
-func (a *artwork) Get(ctx context.Context, id string, size int) (io.ReadCloser, error) {
-	path, lastUpdate, err := a.getImagePath(ctx, id)
-	if err != nil && err != model.ErrNotFound {
-		return nil, err
-	}
-
-	if !conf.Server.DevFastAccessCoverArt {
-		if stat, err := os.Stat(path); err == nil {
-			lastUpdate = stat.ModTime()
-		}
-	}
-
-	info := &imageInfo{
-		a:          a,
-		id:         id,
-		path:       path,
-		size:       size,
-		lastUpdate: lastUpdate,
-	}
-
-	r, err := a.cache.Get(ctx, info)
-	if err != nil {
-		log.Error(ctx, "Error accessing image cache", "path", path, "size", size, err)
-		return nil, err
-	}
-	return r, err
-}
-
-func (a *artwork) getImagePath(ctx context.Context, id string) (path string, lastUpdated time.Time, err error) {
-	// If id is an album cover ID
-	if strings.HasPrefix(id, "al-") {
-		log.Trace(ctx, "Looking for album art", "id", id)
-		id = strings.TrimPrefix(id, "al-")
-		var al *model.Album
-		al, err = a.ds.Album(ctx).Get(id)
-		if err != nil {
-			return
-		}
-		if al.CoverArtId == "" {
-			err = model.ErrNotFound
-		}
-		return al.CoverArtPath, al.UpdatedAt, err
-	}
-
-	log.Trace(ctx, "Looking for media file art", "id", id)
-
-	// Check if id is a mediaFile id
-	var mf *model.MediaFile
-	mf, err = a.ds.MediaFile(ctx).Get(id)
-
-	// If it is not, may be an albumId
-	if err == model.ErrNotFound {
-		return a.getImagePath(ctx, "al-"+id)
-	}
-	if err != nil {
-		return
-	}
-
-	// If it is a mediaFile and it has cover art, return it (if feature is disabled, skip)
-	if !conf.Server.DevFastAccessCoverArt && mf.HasCoverArt {
-		return mf.Path, mf.UpdatedAt, nil
-	}
-
-	// if the mediaFile does not have a coverArt, fallback to the album cover
-	log.Trace(ctx, "Media file does not contain art. Falling back to album art", "id", id, "albumId", "al-"+mf.AlbumID)
-	return a.getImagePath(ctx, "al-"+mf.AlbumID)
-}
-
-func (a *artwork) getArtwork(ctx context.Context, id string, path string, size int) (reader io.ReadCloser, err error) {
-	defer func() {
-		if err != nil {
-			log.Warn(ctx, "Error extracting image", "path", path, "size", size, err)
-			reader, err = resources.Assets().Open(consts.PlaceholderAlbumArt)
-		}
-	}()
-
-	if path == "" {
-		return nil, errors.New("empty path given for artwork")
-	}
-
-	if size == 0 {
-		// If requested original size, just read from the file
-		if utils.IsAudioFile(path) {
-			reader, err = readFromTag(path)
-		} else {
-			reader, err = readFromFile(path)
-		}
-	} else {
-		// If requested a resized image, get the original (possibly from cache) and resize it
-		var r io.ReadCloser
-		r, err = a.Get(ctx, id, 0)
-		if err != nil {
-			return
-		}
-		defer r.Close()
-		reader, err = resizeImage(r, size)
-	}
-
-	return
-}
-
-func resizeImage(reader io.Reader, size int) (io.ReadCloser, error) {
-	img, _, err := image.Decode(reader)
-	if err != nil {
-		return nil, err
-	}
-
-	// Preserve the aspect ratio of the image.
-	var m *image.NRGBA
-	bounds := img.Bounds()
-	if bounds.Max.X > bounds.Max.Y {
-		m = imaging.Resize(img, size, 0, imaging.Lanczos)
-	} else {
-		m = imaging.Resize(img, 0, size, imaging.Lanczos)
-	}
-
-	buf := new(bytes.Buffer)
-	err = jpeg.Encode(buf, m, &jpeg.Options{Quality: conf.Server.CoverJpegQuality})
-	return ioutil.NopCloser(buf), err
-}
-
-func readFromTag(path string) (io.ReadCloser, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-
-	m, err := tag.ReadFrom(f)
-	if err != nil {
-		return nil, err
-	}
-
-	picture := m.Picture()
-	if picture == nil {
-		return nil, errors.New("file does not contain embedded art")
-	}
-	return ioutil.NopCloser(bytes.NewReader(picture.Data)), nil
-}
-
-func readFromFile(path string) (io.ReadCloser, error) {
-	return os.Open(path)
-}
-
-var (
-	onceImageCache     sync.Once
-	instanceImageCache ArtworkCache
-)
-
-func GetImageCache() ArtworkCache {
-	onceImageCache.Do(func() {
-		instanceImageCache = cache.NewFileCache("Image", conf.Server.ImageCacheSize, consts.ImageCacheDir, consts.DefaultImageCacheMaxItems,
-			func(ctx context.Context, arg cache.Item) (io.Reader, error) {
-				info := arg.(*imageInfo)
-				reader, err := info.a.getArtwork(ctx, info.id, info.path, info.size)
-				if err != nil {
-					log.Error(ctx, "Error loading artwork art", "path", info.path, "size", info.size, err)
-					return nil, err
-				}
-				return reader, nil
-			})
-	})
-	return instanceImageCache
-}

core/artwork/artwork.go

@@ -0,0 +1,130 @@
+package artwork
+
+import (
+	"context"
+	"errors"
+	_ "image/gif"
+	"io"
+	"time"
+
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/core"
+	"github.com/navidrome/navidrome/core/ffmpeg"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/resources"
+	"github.com/navidrome/navidrome/utils/cache"
+	_ "golang.org/x/image/webp"
+)
+
+var ErrUnavailable = errors.New("artwork unavailable")
+
+type Artwork interface {
+	Get(ctx context.Context, artID model.ArtworkID, size int) (io.ReadCloser, time.Time, error)
+	GetOrPlaceholder(ctx context.Context, id string, size int) (io.ReadCloser, time.Time, error)
+}
+
+func NewArtwork(ds model.DataStore, cache cache.FileCache, ffmpeg ffmpeg.FFmpeg, em core.ExternalMetadata) Artwork {
+	return &artwork{ds: ds, cache: cache, ffmpeg: ffmpeg, em: em}
+}
+
+type artwork struct {
+	ds     model.DataStore
+	cache  cache.FileCache
+	ffmpeg ffmpeg.FFmpeg
+	em     core.ExternalMetadata
+}
+
+type artworkReader interface {
+	cache.Item
+	LastUpdated() time.Time
+	Reader(ctx context.Context) (io.ReadCloser, string, error)
+}
+
+func (a *artwork) GetOrPlaceholder(ctx context.Context, id string, size int) (reader io.ReadCloser, lastUpdate time.Time, err error) {
+	artID, err := a.getArtworkId(ctx, id)
+	if err == nil {
+		reader, lastUpdate, err = a.Get(ctx, artID, size)
+	}
+	if errors.Is(err, ErrUnavailable) {
+		if artID.Kind == model.KindArtistArtwork {
+			reader, _ = resources.FS().Open(consts.PlaceholderArtistArt)
+		} else {
+			reader, _ = resources.FS().Open(consts.PlaceholderAlbumArt)
+		}
+		return reader, consts.ServerStart, nil
+	}
+	return reader, lastUpdate, err
+}
+
+func (a *artwork) Get(ctx context.Context, artID model.ArtworkID, size int) (reader io.ReadCloser, lastUpdate time.Time, err error) {
+	artReader, err := a.getArtworkReader(ctx, artID, size)
+	if err != nil {
+		return nil, time.Time{}, err
+	}
+
+	r, err := a.cache.Get(ctx, artReader)
+	if err != nil {
+		if !errors.Is(err, context.Canceled) && !errors.Is(err, ErrUnavailable) {
+			log.Error(ctx, "Error accessing image cache", "id", artID, "size", size, err)
+		}
+		return nil, time.Time{}, err
+	}
+	return r, artReader.LastUpdated(), nil
+}
+
+type coverArtGetter interface {
+	CoverArtID() model.ArtworkID
+}
+
+func (a *artwork) getArtworkId(ctx context.Context, id string) (model.ArtworkID, error) {
+	if id == "" {
+		return model.ArtworkID{}, ErrUnavailable
+	}
+	artID, err := model.ParseArtworkID(id)
+	if err == nil {
+		return artID, nil
+	}
+
+	log.Trace(ctx, "ArtworkID invalid. Trying to figure out kind based on the ID", "id", id)
+	entity, err := model.GetEntityByID(ctx, a.ds, id)
+	if err != nil {
+		return model.ArtworkID{}, err
+	}
+	if e, ok := entity.(coverArtGetter); ok {
+		artID = e.CoverArtID()
+	}
+	switch e := entity.(type) {
+	case *model.Artist:
+		log.Trace(ctx, "ID is for an Artist", "id", id, "name", e.Name, "artist", e.Name)
+	case *model.Album:
+		log.Trace(ctx, "ID is for an Album", "id", id, "name", e.Name, "artist", e.AlbumArtist)
+	case *model.MediaFile:
+		log.Trace(ctx, "ID is for a MediaFile", "id", id, "title", e.Title, "album", e.Album)
+	case *model.Playlist:
+		log.Trace(ctx, "ID is for a Playlist", "id", id, "name", e.Name)
+	}
+	return artID, nil
+}
+
+func (a *artwork) getArtworkReader(ctx context.Context, artID model.ArtworkID, size int) (artworkReader, error) {
+	var artReader artworkReader
+	var err error
+	if size > 0 {
+		artReader, err = resizedFromOriginal(ctx, a, artID, size)
+	} else {
+		switch artID.Kind {
+		case model.KindArtistArtwork:
+			artReader, err = newArtistReader(ctx, a, artID, a.em)
+		case model.KindAlbumArtwork:
+			artReader, err = newAlbumArtworkReader(ctx, a, artID, a.em)
+		case model.KindMediaFileArtwork:
+			artReader, err = newMediafileArtworkReader(ctx, a, artID)
+		case model.KindPlaylistArtwork:
+			artReader, err = newPlaylistArtworkReader(ctx, a, artID)
+		default:
+			return nil, ErrUnavailable
+		}
+	}
+	return artReader, err
+}

core/artwork/artwork_internal_test.go

@@ -0,0 +1,243 @@
+package artwork
+
+import (
+	"context"
+	"errors"
+	"image"
+	"io"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/conf/configtest"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Artwork", func() {
+	var aw *artwork
+	var ds model.DataStore
+	var ffmpeg *tests.MockFFmpeg
+	ctx := log.NewContext(context.TODO())
+	var alOnlyEmbed, alEmbedNotFound, alOnlyExternal, alExternalNotFound, alMultipleCovers model.Album
+	var arMultipleCovers model.Artist
+	var mfWithEmbed, mfAnotherWithEmbed, mfWithoutEmbed, mfCorruptedCover model.MediaFile
+
+	BeforeEach(func() {
+		DeferCleanup(configtest.SetupConfig())
+		conf.Server.ImageCacheSize = "0" // Disable cache
+		conf.Server.CoverArtPriority = "folder.*, cover.*, embedded , front.*"
+
+		ds = &tests.MockDataStore{MockedTranscoding: &tests.MockTranscodingRepo{}}
+		alOnlyEmbed = model.Album{ID: "222", Name: "Only embed", EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3"}
+		alEmbedNotFound = model.Album{ID: "333", Name: "Embed not found", EmbedArtPath: "tests/fixtures/NON_EXISTENT.mp3"}
+		alOnlyExternal = model.Album{ID: "444", Name: "Only external", ImageFiles: "tests/fixtures/artist/an-album/front.png"}
+		alExternalNotFound = model.Album{ID: "555", Name: "External not found", ImageFiles: "tests/fixtures/NON_EXISTENT.png"}
+		arMultipleCovers = model.Artist{ID: "777", Name: "All options"}
+		alMultipleCovers = model.Album{
+			ID:           "666",
+			Name:         "All options",
+			EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3",
+			Paths:        "tests/fixtures/artist/an-album",
+			ImageFiles: "tests/fixtures/artist/an-album/cover.jpg" + consts.Zwsp +
+				"tests/fixtures/artist/an-album/front.png" + consts.Zwsp +
+				"tests/fixtures/artist/an-album/artist.png",
+			AlbumArtistID: "777",
+		}
+		mfWithEmbed = model.MediaFile{ID: "22", Path: "tests/fixtures/test.mp3", HasCoverArt: true, AlbumID: "222"}
+		mfAnotherWithEmbed = model.MediaFile{ID: "23", Path: "tests/fixtures/artist/an-album/test.mp3", HasCoverArt: true, AlbumID: "666"}
+		mfWithoutEmbed = model.MediaFile{ID: "44", Path: "tests/fixtures/test.ogg", AlbumID: "444"}
+		mfCorruptedCover = model.MediaFile{ID: "45", Path: "tests/fixtures/test.ogg", HasCoverArt: true, AlbumID: "444"}
+
+		cache := GetImageCache()
+		ffmpeg = tests.NewMockFFmpeg("content from ffmpeg")
+		aw = NewArtwork(ds, cache, ffmpeg, nil).(*artwork)
+	})
+
+	Describe("albumArtworkReader", func() {
+		Context("ID not found", func() {
+			It("returns ErrNotFound if album is not in the DB", func() {
+				_, err := newAlbumArtworkReader(ctx, aw, model.MustParseArtworkID("al-NOT-FOUND"), nil)
+				Expect(err).To(MatchError(model.ErrNotFound))
+			})
+		})
+		Context("Embed images", func() {
+			BeforeEach(func() {
+				ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
+					alOnlyEmbed,
+					alEmbedNotFound,
+				})
+			})
+			It("returns embed cover", func() {
+				aw, err := newAlbumArtworkReader(ctx, aw, alOnlyEmbed.CoverArtID(), nil)
+				Expect(err).ToNot(HaveOccurred())
+				_, path, err := aw.Reader(ctx)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(path).To(Equal("tests/fixtures/artist/an-album/test.mp3"))
+			})
+			It("returns ErrUnavailable if embed path is not available", func() {
+				ffmpeg.Error = errors.New("not available")
+				aw, err := newAlbumArtworkReader(ctx, aw, alEmbedNotFound.CoverArtID(), nil)
+				Expect(err).ToNot(HaveOccurred())
+				_, _, err = aw.Reader(ctx)
+				Expect(err).To(MatchError(ErrUnavailable))
+			})
+		})
+		Context("External images", func() {
+			BeforeEach(func() {
+				ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
+					alOnlyExternal,
+					alExternalNotFound,
+				})
+			})
+			It("returns external cover", func() {
+				aw, err := newAlbumArtworkReader(ctx, aw, alOnlyExternal.CoverArtID(), nil)
+				Expect(err).ToNot(HaveOccurred())
+				_, path, err := aw.Reader(ctx)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(path).To(Equal("tests/fixtures/artist/an-album/front.png"))
+			})
+			It("returns ErrUnavailable if external file is not available", func() {
+				aw, err := newAlbumArtworkReader(ctx, aw, alExternalNotFound.CoverArtID(), nil)
+				Expect(err).ToNot(HaveOccurred())
+				_, _, err = aw.Reader(ctx)
+				Expect(err).To(MatchError(ErrUnavailable))
+			})
+		})
+		Context("Multiple covers", func() {
+			BeforeEach(func() {
+				ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
+					alMultipleCovers,
+				})
+			})
+			DescribeTable("CoverArtPriority",
+				func(priority string, expected string) {
+					conf.Server.CoverArtPriority = priority
+					aw, err := newAlbumArtworkReader(ctx, aw, alMultipleCovers.CoverArtID(), nil)
+					Expect(err).ToNot(HaveOccurred())
+					_, path, err := aw.Reader(ctx)
+					Expect(err).ToNot(HaveOccurred())
+					Expect(path).To(Equal(expected))
+				},
+				Entry(nil, " folder.* , cover.*,embedded,front.*", "tests/fixtures/artist/an-album/cover.jpg"),
+				Entry(nil, "front.* , cover.*, embedded ,folder.*", "tests/fixtures/artist/an-album/front.png"),
+				Entry(nil, " embedded , front.* , cover.*,folder.*", "tests/fixtures/artist/an-album/test.mp3"),
+			)
+		})
+	})
+	Describe("artistArtworkReader", func() {
+		Context("Multiple covers", func() {
+			BeforeEach(func() {
+				ds.Artist(ctx).(*tests.MockArtistRepo).SetData(model.Artists{
+					arMultipleCovers,
+				})
+				ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
+					alMultipleCovers,
+				})
+				ds.MediaFile(ctx).(*tests.MockMediaFileRepo).SetData(model.MediaFiles{
+					mfAnotherWithEmbed,
+				})
+			})
+			DescribeTable("ArtistArtPriority",
+				func(priority string, expected string) {
+					conf.Server.ArtistArtPriority = priority
+					aw, err := newArtistReader(ctx, aw, arMultipleCovers.CoverArtID(), nil)
+					Expect(err).ToNot(HaveOccurred())
+					_, path, err := aw.Reader(ctx)
+					Expect(err).ToNot(HaveOccurred())
+					Expect(path).To(Equal(expected))
+				},
+				Entry(nil, " folder.* , artist.*,album/artist.*", "tests/fixtures/artist/artist.jpg"),
+				Entry(nil, "album/artist.*, folder.*,artist.*", "tests/fixtures/artist/an-album/artist.png"),
+			)
+		})
+	})
+	Describe("mediafileArtworkReader", func() {
+		Context("ID not found", func() {
+			It("returns ErrNotFound if mediafile is not in the DB", func() {
+				_, err := newAlbumArtworkReader(ctx, aw, alMultipleCovers.CoverArtID(), nil)
+				Expect(err).To(MatchError(model.ErrNotFound))
+			})
+		})
+		Context("Embed images", func() {
+			BeforeEach(func() {
+				ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
+					alOnlyEmbed,
+					alOnlyExternal,
+				})
+				ds.MediaFile(ctx).(*tests.MockMediaFileRepo).SetData(model.MediaFiles{
+					mfWithEmbed,
+					mfWithoutEmbed,
+					mfCorruptedCover,
+				})
+			})
+			It("returns embed cover", func() {
+				aw, err := newMediafileArtworkReader(ctx, aw, mfWithEmbed.CoverArtID())
+				Expect(err).ToNot(HaveOccurred())
+				_, path, err := aw.Reader(ctx)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(path).To(Equal("tests/fixtures/test.mp3"))
+			})
+			It("returns embed cover if successfully extracted by ffmpeg", func() {
+				aw, err := newMediafileArtworkReader(ctx, aw, mfCorruptedCover.CoverArtID())
+				Expect(err).ToNot(HaveOccurred())
+				r, path, err := aw.Reader(ctx)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(io.ReadAll(r)).To(Equal([]byte("content from ffmpeg")))
+				Expect(path).To(Equal("tests/fixtures/test.ogg"))
+			})
+			It("returns album cover if cannot read embed artwork", func() {
+				ffmpeg.Error = errors.New("not available")
+				aw, err := newMediafileArtworkReader(ctx, aw, mfCorruptedCover.CoverArtID())
+				Expect(err).ToNot(HaveOccurred())
+				_, path, err := aw.Reader(ctx)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(path).To(Equal("al-444_0"))
+			})
+			It("returns album cover if media file has no cover art", func() {
+				aw, err := newMediafileArtworkReader(ctx, aw, model.MustParseArtworkID("mf-"+mfWithoutEmbed.ID))
+				Expect(err).ToNot(HaveOccurred())
+				_, path, err := aw.Reader(ctx)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(path).To(Equal("al-444_0"))
+			})
+		})
+	})
+	Describe("resizedArtworkReader", func() {
+		BeforeEach(func() {
+			ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
+				alMultipleCovers,
+			})
+		})
+		It("returns a PNG if original image is a PNG", func() {
+			conf.Server.CoverArtPriority = "front.png"
+			r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 15)
+			Expect(err).ToNot(HaveOccurred())
+
+			br, format, err := asImageReader(r)
+			Expect(format).To(Equal("image/png"))
+			Expect(err).ToNot(HaveOccurred())
+
+			img, _, err := image.Decode(br)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(img.Bounds().Size().X).To(Equal(15))
+			Expect(img.Bounds().Size().Y).To(Equal(15))
+		})
+		It("returns a JPEG if original image is not a PNG", func() {
+			conf.Server.CoverArtPriority = "cover.jpg"
+			r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 200)
+			Expect(err).ToNot(HaveOccurred())
+
+			br, format, err := asImageReader(r)
+			Expect(format).To(Equal("image/jpeg"))
+			Expect(err).ToNot(HaveOccurred())
+
+			img, _, err := image.Decode(br)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(img.Bounds().Size().X).To(Equal(200))
+			Expect(img.Bounds().Size().Y).To(Equal(200))
+		})
+	})
+})

core/artwork/artwork_suite_test.go

@@ -1,17 +1,17 @@
-package app
+package artwork
 
 import (
 	"testing"
 
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
 
-func TestApp(t *testing.T) {
+func TestArtwork(t *testing.T) {
 	tests.Init(t, false)
-	log.SetLevel(log.LevelCritical)
+	log.SetLevel(log.LevelFatal)
 	RegisterFailHandler(Fail)
-	RunSpecs(t, "RESTful API Suite")
+	RunSpecs(t, "Artwork Suite")
 }

core/artwork/artwork_test.go

@@ -0,0 +1,57 @@
+package artwork_test
+
+import (
+	"context"
+	"io"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/conf/configtest"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/core/artwork"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/resources"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Artwork", func() {
+	var aw artwork.Artwork
+	var ds model.DataStore
+	var ffmpeg *tests.MockFFmpeg
+
+	BeforeEach(func() {
+		DeferCleanup(configtest.SetupConfig())
+		conf.Server.ImageCacheSize = "0" // Disable cache
+		cache := artwork.GetImageCache()
+		ffmpeg = tests.NewMockFFmpeg("content from ffmpeg")
+		aw = artwork.NewArtwork(ds, cache, ffmpeg, nil)
+	})
+
+	Context("GetOrPlaceholder", func() {
+		Context("Empty ID", func() {
+			It("returns placeholder if album is not in the DB", func() {
+				r, _, err := aw.GetOrPlaceholder(context.Background(), "", 0)
+				Expect(err).ToNot(HaveOccurred())
+
+				ph, err := resources.FS().Open(consts.PlaceholderAlbumArt)
+				Expect(err).ToNot(HaveOccurred())
+				phBytes, err := io.ReadAll(ph)
+				Expect(err).ToNot(HaveOccurred())
+
+				result, err := io.ReadAll(r)
+				Expect(err).ToNot(HaveOccurred())
+
+				Expect(result).To(Equal(phBytes))
+			})
+		})
+	})
+	Context("Get", func() {
+		Context("Empty ID", func() {
+			It("returns an ErrUnavailable error", func() {
+				_, _, err := aw.Get(context.Background(), model.ArtworkID{}, 0)
+				Expect(err).To(MatchError(artwork.ErrUnavailable))
+			})
+		})
+	})
+})

core/artwork/cache_warmer.go

@@ -0,0 +1,146 @@
+package artwork
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"sync"
+	"time"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
+	"github.com/navidrome/navidrome/utils/cache"
+	"github.com/navidrome/navidrome/utils/pl"
+	"golang.org/x/exp/maps"
+)
+
+type CacheWarmer interface {
+	PreCache(artID model.ArtworkID)
+}
+
+func NewCacheWarmer(artwork Artwork, cache cache.FileCache) CacheWarmer {
+	// If image cache is disabled, return a NOOP implementation
+	if conf.Server.ImageCacheSize == "0" || !conf.Server.EnableArtworkPrecache {
+		return &noopCacheWarmer{}
+	}
+
+	a := &cacheWarmer{
+		artwork:    artwork,
+		cache:      cache,
+		buffer:     make(map[model.ArtworkID]struct{}),
+		wakeSignal: make(chan struct{}, 1),
+	}
+
+	// Create a context with a fake admin user, to be able to pre-cache Playlist CoverArts
+	ctx := request.WithUser(context.TODO(), model.User{IsAdmin: true})
+	go a.run(ctx)
+	return a
+}
+
+type cacheWarmer struct {
+	artwork    Artwork
+	buffer     map[model.ArtworkID]struct{}
+	mutex      sync.Mutex
+	cache      cache.FileCache
+	wakeSignal chan struct{}
+}
+
+var ignoredIds = map[string]struct{}{
+	consts.VariousArtistsID: {},
+	consts.UnknownArtistID:  {},
+}
+
+func (a *cacheWarmer) PreCache(artID model.ArtworkID) {
+	if _, shouldIgnore := ignoredIds[artID.ID]; shouldIgnore {
+		return
+	}
+	a.mutex.Lock()
+	defer a.mutex.Unlock()
+	a.buffer[artID] = struct{}{}
+	a.sendWakeSignal()
+}
+
+func (a *cacheWarmer) sendWakeSignal() {
+	// Don't block if the previous signal was not read yet
+	select {
+	case a.wakeSignal <- struct{}{}:
+	default:
+	}
+}
+
+func (a *cacheWarmer) run(ctx context.Context) {
+	for {
+		a.waitSignal(ctx, 10*time.Second)
+		if ctx.Err() != nil {
+			break
+		}
+
+		// 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))
+			}
+			continue
+		}
+
+		a.mutex.Lock()
+
+		// If there's nothing to send, keep waiting
+		if len(a.buffer) == 0 {
+			a.mutex.Unlock()
+			continue
+		}
+
+		batch := maps.Keys(a.buffer)
+		a.buffer = make(map[model.ArtworkID]struct{})
+		a.mutex.Unlock()
+
+		a.processBatch(ctx, batch)
+	}
+}
+
+func (a *cacheWarmer) waitSignal(ctx context.Context, timeout time.Duration) {
+	var to <-chan time.Time
+	if !a.cache.Available(ctx) {
+		tmr := time.NewTimer(timeout)
+		defer tmr.Stop()
+		to = tmr.C
+	}
+	select {
+	case <-to:
+	case <-a.wakeSignal:
+	case <-ctx.Done():
+	}
+}
+
+func (a *cacheWarmer) processBatch(ctx context.Context, batch []model.ArtworkID) {
+	log.Trace(ctx, "PreCaching a new batch of artwork", "batchSize", len(batch))
+	input := pl.FromSlice(ctx, batch)
+	errs := pl.Sink(ctx, 2, input, a.doCacheImage)
+	for err := range errs {
+		log.Warn(ctx, "Error warming cache", err)
+	}
+}
+
+func (a *cacheWarmer) doCacheImage(ctx context.Context, id model.ArtworkID) error {
+	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
+	defer cancel()
+
+	r, _, err := a.artwork.Get(ctx, id, consts.UICoverArtSize)
+	if err != nil {
+		return fmt.Errorf("error cacheing id='%s': %w", id, err)
+	}
+	defer r.Close()
+	_, err = io.Copy(io.Discard, r)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+type noopCacheWarmer struct{}
+
+func (a *noopCacheWarmer) PreCache(model.ArtworkID) {}

core/artwork/image_cache.go

@@ -0,0 +1,44 @@
+package artwork
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"time"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils/cache"
+	"github.com/navidrome/navidrome/utils/singleton"
+)
+
+type cacheKey struct {
+	artID      model.ArtworkID
+	lastUpdate time.Time
+}
+
+func (k *cacheKey) Key() string {
+	return fmt.Sprintf(
+		"%s-%s.%d",
+		k.artID.Kind,
+		k.artID.ID,
+		k.lastUpdate.UnixMilli(),
+	)
+}
+
+type imageCache struct {
+	cache.FileCache
+}
+
+func GetImageCache() cache.FileCache {
+	return singleton.GetInstance(func() *imageCache {
+		return &imageCache{
+			FileCache: cache.NewFileCache("Image", conf.Server.ImageCacheSize, consts.ImageCacheDir, consts.DefaultImageCacheMaxItems,
+				func(ctx context.Context, arg cache.Item) (io.Reader, error) {
+					r, _, err := arg.(artworkReader).Reader(ctx)
+					return r, err
+				}),
+		}
+	})
+}

core/artwork/reader_album.go

@@ -0,0 +1,74 @@
+package artwork
+
+import (
+	"context"
+	"crypto/md5"
+	"fmt"
+	"io"
+	"strings"
+	"time"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/core"
+	"github.com/navidrome/navidrome/core/ffmpeg"
+	"github.com/navidrome/navidrome/model"
+)
+
+type albumArtworkReader struct {
+	cacheKey
+	a     *artwork
+	em    core.ExternalMetadata
+	album model.Album
+}
+
+func newAlbumArtworkReader(ctx context.Context, artwork *artwork, artID model.ArtworkID, em core.ExternalMetadata) (*albumArtworkReader, error) {
+	al, err := artwork.ds.Album(ctx).Get(artID.ID)
+	if err != nil {
+		return nil, err
+	}
+	a := &albumArtworkReader{
+		a:     artwork,
+		em:    em,
+		album: *al,
+	}
+	a.cacheKey.artID = artID
+	a.cacheKey.lastUpdate = al.UpdatedAt
+	return a, nil
+}
+
+func (a *albumArtworkReader) Key() string {
+	var hash [16]byte
+	if conf.Server.EnableExternalServices {
+		hash = md5.Sum([]byte(conf.Server.Agents + conf.Server.CoverArtPriority))
+	}
+	return fmt.Sprintf(
+		"%s.%x.%t",
+		a.cacheKey.Key(),
+		hash,
+		conf.Server.EnableExternalServices,
+	)
+}
+func (a *albumArtworkReader) LastUpdated() time.Time {
+	return a.album.UpdatedAt
+}
+
+func (a *albumArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
+	var ff = a.fromCoverArtPriority(ctx, a.a.ffmpeg, conf.Server.CoverArtPriority)
+	return selectImageReader(ctx, a.artID, ff...)
+}
+
+func (a *albumArtworkReader) fromCoverArtPriority(ctx context.Context, ffmpeg ffmpeg.FFmpeg, priority string) []sourceFunc {
+	var ff []sourceFunc
+	for _, pattern := range strings.Split(strings.ToLower(priority), ",") {
+		pattern = strings.TrimSpace(pattern)
+		switch {
+		case pattern == "embedded":
+			ff = append(ff, fromTag(a.album.EmbedArtPath), fromFFmpegTag(ctx, ffmpeg, a.album.EmbedArtPath))
+		case pattern == "external":
+			ff = append(ff, fromAlbumExternalSource(ctx, a.album, a.em))
+		case a.album.ImageFiles != "":
+			ff = append(ff, fromExternalFile(ctx, a.album.ImageFiles, pattern))
+		}
+	}
+	return ff
+}

core/artwork/reader_artist.go

@@ -0,0 +1,127 @@
+package artwork
+
+import (
+	"context"
+	"crypto/md5"
+	"fmt"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/Masterminds/squirrel"
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/core"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils"
+)
+
+type artistReader struct {
+	cacheKey
+	a            *artwork
+	em           core.ExternalMetadata
+	artist       model.Artist
+	artistFolder string
+	files        string
+}
+
+func newArtistReader(ctx context.Context, artwork *artwork, artID model.ArtworkID, em core.ExternalMetadata) (*artistReader, error) {
+	ar, err := artwork.ds.Artist(ctx).Get(artID.ID)
+	if err != nil {
+		return nil, err
+	}
+	als, err := artwork.ds.Album(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"album_artist_id": artID.ID}})
+	if err != nil {
+		return nil, err
+	}
+	a := &artistReader{
+		a:      artwork,
+		em:     em,
+		artist: *ar,
+	}
+	// TODO Find a way to factor in the ExternalUpdateInfoAt in the cache key. Problem is that it can
+	// change _after_ retrieving from external sources, making the key invalid
+	//a.cacheKey.lastUpdate = ar.ExternalInfoUpdatedAt
+	var files []string
+	var paths []string
+	for _, al := range als {
+		files = append(files, al.ImageFiles)
+		paths = append(paths, splitList(al.Paths)...)
+		if a.cacheKey.lastUpdate.Before(al.UpdatedAt) {
+			a.cacheKey.lastUpdate = al.UpdatedAt
+		}
+	}
+	a.files = strings.Join(files, consts.Zwsp)
+	a.artistFolder = utils.LongestCommonPrefix(paths)
+	if !strings.HasSuffix(a.artistFolder, string(filepath.Separator)) {
+		a.artistFolder, _ = filepath.Split(a.artistFolder)
+	}
+	a.cacheKey.artID = artID
+	return a, nil
+}
+
+func (a *artistReader) Key() string {
+	hash := md5.Sum([]byte(conf.Server.Agents + conf.Server.Spotify.ID))
+	return fmt.Sprintf(
+		"%s.%t.%x",
+		a.cacheKey.Key(),
+		conf.Server.EnableExternalServices,
+		hash,
+	)
+}
+
+func (a *artistReader) LastUpdated() time.Time {
+	return a.lastUpdate
+}
+
+func (a *artistReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
+	var ff = a.fromArtistArtPriority(ctx, conf.Server.ArtistArtPriority)
+	return selectImageReader(ctx, a.artID, ff...)
+}
+
+func (a *artistReader) fromArtistArtPriority(ctx context.Context, priority string) []sourceFunc {
+	var ff []sourceFunc
+	for _, pattern := range strings.Split(strings.ToLower(priority), ",") {
+		pattern = strings.TrimSpace(pattern)
+		switch {
+		case pattern == "external":
+			ff = append(ff, fromArtistExternalSource(ctx, a.artist, a.em))
+		case strings.HasPrefix(pattern, "album/"):
+			ff = append(ff, fromExternalFile(ctx, a.files, strings.TrimPrefix(pattern, "album/")))
+		default:
+			ff = append(ff, fromArtistFolder(ctx, a.artistFolder, pattern))
+		}
+	}
+	return ff
+}
+
+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
+			}
+			f, err := os.Open(filePath)
+			if err != nil {
+				log.Warn(ctx, "Could not open cover art file", "file", filePath, err)
+				return nil, "", err
+			}
+			return f, filePath, nil
+		}
+		return nil, "", nil
+	}
+}

core/artwork/reader_mediafile.go

@@ -0,0 +1,64 @@
+package artwork
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"time"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/model"
+)
+
+type mediafileArtworkReader struct {
+	cacheKey
+	a         *artwork
+	mediafile model.MediaFile
+	album     model.Album
+}
+
+func newMediafileArtworkReader(ctx context.Context, artwork *artwork, artID model.ArtworkID) (*mediafileArtworkReader, error) {
+	mf, err := artwork.ds.MediaFile(ctx).Get(artID.ID)
+	if err != nil {
+		return nil, err
+	}
+	al, err := artwork.ds.Album(ctx).Get(mf.AlbumID)
+	if err != nil {
+		return nil, err
+	}
+	a := &mediafileArtworkReader{
+		a:         artwork,
+		mediafile: *mf,
+		album:     *al,
+	}
+	a.cacheKey.artID = artID
+	if al.UpdatedAt.After(mf.UpdatedAt) {
+		a.cacheKey.lastUpdate = al.UpdatedAt
+	} else {
+		a.cacheKey.lastUpdate = mf.UpdatedAt
+	}
+	return a, nil
+}
+
+func (a *mediafileArtworkReader) Key() string {
+	return fmt.Sprintf(
+		"%s.%t",
+		a.cacheKey.Key(),
+		conf.Server.EnableMediaFileCoverArt,
+	)
+}
+func (a *mediafileArtworkReader) LastUpdated() time.Time {
+	return a.lastUpdate
+}
+
+func (a *mediafileArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
+	var ff []sourceFunc
+	if a.mediafile.CoverArtID().Kind == model.KindMediaFileArtwork {
+		ff = []sourceFunc{
+			fromTag(a.mediafile.Path),
+			fromFFmpegTag(ctx, a.a.ffmpeg, a.mediafile.Path),
+		}
+	}
+	ff = append(ff, fromAlbum(ctx, a.a, a.mediafile.AlbumCoverArtID()))
+	return selectImageReader(ctx, a.artID, ff...)
+}

core/artwork/reader_playlist.go

@@ -0,0 +1,150 @@
+package artwork
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"image"
+	"image/draw"
+	"image/png"
+	"io"
+	"time"
+
+	"github.com/disintegration/imaging"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils/slice"
+)
+
+type playlistArtworkReader struct {
+	cacheKey
+	a  *artwork
+	pl model.Playlist
+}
+
+const tileSize = 600
+
+func newPlaylistArtworkReader(ctx context.Context, artwork *artwork, artID model.ArtworkID) (*playlistArtworkReader, error) {
+	pl, err := artwork.ds.Playlist(ctx).Get(artID.ID)
+	if err != nil {
+		return nil, err
+	}
+	a := &playlistArtworkReader{
+		a:  artwork,
+		pl: *pl,
+	}
+	a.cacheKey.artID = artID
+	a.cacheKey.lastUpdate = pl.UpdatedAt
+	return a, nil
+}
+
+func (a *playlistArtworkReader) LastUpdated() time.Time {
+	return a.lastUpdate
+}
+
+func (a *playlistArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
+	ff := []sourceFunc{
+		a.fromGeneratedTiledCover(ctx),
+		fromAlbumPlaceholder(),
+	}
+	return selectImageReader(ctx, a.artID, ff...)
+}
+
+func (a *playlistArtworkReader) fromGeneratedTiledCover(ctx context.Context) sourceFunc {
+	return func() (io.ReadCloser, string, error) {
+		tiles, err := a.loadTiles(ctx)
+		if err != nil {
+			return nil, "", err
+		}
+		r, err := a.createTiledImage(ctx, tiles)
+		return r, "", err
+	}
+}
+
+func toArtworkIDs(albumIDs []string) []model.ArtworkID {
+	return slice.Map(albumIDs, func(id string) model.ArtworkID {
+		al := model.Album{ID: id}
+		return al.CoverArtID()
+	})
+}
+
+func (a *playlistArtworkReader) loadTiles(ctx context.Context) ([]image.Image, error) {
+	tracksRepo := a.a.ds.Playlist(ctx).Tracks(a.pl.ID, false)
+	albumIds, err := tracksRepo.GetAlbumIDs(model.QueryOptions{Max: 4, Sort: "random()"})
+	if err != nil {
+		log.Error(ctx, "Error getting album IDs for playlist", "id", a.pl.ID, "name", a.pl.Name, err)
+		return nil, err
+	}
+	ids := toArtworkIDs(albumIds)
+
+	var tiles []image.Image
+	for len(tiles) < 4 {
+		if len(ids) == 0 {
+			break
+		}
+		id := ids[len(ids)-1]
+		ids = ids[0 : len(ids)-1]
+		r, _, err := fromAlbum(ctx, a.a, id)()
+		if err != nil {
+			continue
+		}
+		tile, err := a.createTile(ctx, r)
+		if err == nil {
+			tiles = append(tiles, tile)
+		}
+		_ = r.Close()
+	}
+	switch len(tiles) {
+	case 0:
+		return nil, errors.New("could not find any eligible cover")
+	case 2:
+		tiles = append(tiles, tiles[1], tiles[0])
+	case 3:
+		tiles = append(tiles, tiles[0])
+	}
+	return tiles, nil
+}
+
+func (a *playlistArtworkReader) createTile(_ context.Context, r io.ReadCloser) (image.Image, error) {
+	img, _, err := image.Decode(r)
+	if err != nil {
+		return nil, err
+	}
+	return imaging.Fill(img, tileSize/2, tileSize/2, imaging.Center, imaging.Lanczos), nil
+}
+
+func (a *playlistArtworkReader) createTiledImage(_ context.Context, tiles []image.Image) (io.ReadCloser, error) {
+	buf := new(bytes.Buffer)
+	var rgba draw.Image
+	var err error
+	if len(tiles) == 4 {
+		rgba = image.NewRGBA(image.Rectangle{Max: image.Point{X: tileSize - 1, Y: tileSize - 1}})
+		draw.Draw(rgba, rect(0), tiles[0], image.Point{}, draw.Src)
+		draw.Draw(rgba, rect(1), tiles[1], image.Point{}, draw.Src)
+		draw.Draw(rgba, rect(2), tiles[2], image.Point{}, draw.Src)
+		draw.Draw(rgba, rect(3), tiles[3], image.Point{}, draw.Src)
+		err = png.Encode(buf, rgba)
+	} else {
+		err = png.Encode(buf, tiles[0])
+	}
+	if err != nil {
+		return nil, err
+	}
+	return io.NopCloser(buf), nil
+}
+
+func rect(pos int) image.Rectangle {
+	r := image.Rectangle{}
+	switch pos {
+	case 1:
+		r.Min.X = tileSize / 2
+	case 2:
+		r.Min.Y = tileSize / 2
+	case 3:
+		r.Min.X = tileSize / 2
+		r.Min.Y = tileSize / 2
+	}
+	r.Max.X = r.Min.X + tileSize/2
+	r.Max.Y = r.Min.Y + tileSize/2
+	return r
+}

core/artwork/reader_resized.go

@@ -0,0 +1,137 @@
+package artwork
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"fmt"
+	"image"
+	"image/jpeg"
+	"image/png"
+	"io"
+	"net/http"
+	"time"
+
+	"github.com/disintegration/imaging"
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils/number"
+)
+
+type resizedArtworkReader struct {
+	artID      model.ArtworkID
+	cacheKey   string
+	lastUpdate time.Time
+	size       int
+	a          *artwork
+}
+
+func resizedFromOriginal(ctx context.Context, a *artwork, artID model.ArtworkID, size int) (*resizedArtworkReader, error) {
+	r := &resizedArtworkReader{a: a}
+	r.artID = artID
+	r.size = size
+
+	// Get lastUpdated and cacheKey from original artwork
+	original, err := a.getArtworkReader(ctx, artID, 0)
+	if err != nil {
+		return nil, err
+	}
+	r.cacheKey = original.Key()
+	r.lastUpdate = original.LastUpdated()
+	return r, nil
+}
+
+func (a *resizedArtworkReader) Key() string {
+	return fmt.Sprintf(
+		"%s.%d.%d",
+		a.cacheKey,
+		a.size,
+		conf.Server.CoverJpegQuality,
+	)
+}
+
+func (a *resizedArtworkReader) LastUpdated() time.Time {
+	return a.lastUpdate
+}
+
+func (a *resizedArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
+	// Get artwork in original size, possibly from cache
+	orig, _, err := a.a.Get(ctx, a.artID, 0)
+	if err != nil {
+		return nil, "", err
+	}
+
+	// Keep a copy of the original data. In case we can't resize it, send it as is
+	buf := new(bytes.Buffer)
+	r := io.TeeReader(orig, buf)
+	defer orig.Close()
+
+	resized, origSize, err := resizeImage(r, a.size)
+	if resized == nil {
+		log.Trace(ctx, "Image smaller than requested size", "artID", a.artID, "original", origSize, "resized", a.size)
+	} else {
+		log.Trace(ctx, "Resizing artwork", "artID", a.artID, "original", origSize, "resized", a.size)
+	}
+	if err != nil {
+		log.Warn(ctx, "Could not resize image. Will return image as is", "artID", a.artID, "size", a.size, err)
+	}
+	if err != nil || resized == nil {
+		// Force finish reading any remaining data
+		_, _ = io.Copy(io.Discard, r)
+		return io.NopCloser(buf), "", nil //nolint:nilerr
+	}
+	return io.NopCloser(resized), fmt.Sprintf("%s@%d", a.artID, a.size), nil
+}
+
+func asImageReader(r io.Reader) (io.Reader, string, error) {
+	br := bufio.NewReader(r)
+	buf, err := br.Peek(512)
+	if err == io.EOF && len(buf) > 0 {
+		// Check if there are enough bytes to detect type
+		typ := http.DetectContentType(buf)
+		if typ != "" {
+			return br, typ, nil
+		}
+	}
+	if err != nil {
+		return nil, "", err
+	}
+	return br, http.DetectContentType(buf), nil
+}
+
+func resizeImage(reader io.Reader, size int) (io.Reader, int, error) {
+	r, format, err := asImageReader(reader)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	img, _, err := image.Decode(r)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	// Don't upscale the image
+	bounds := img.Bounds()
+	originalSize := number.Max(bounds.Max.X, bounds.Max.Y)
+	if originalSize <= size {
+		return nil, originalSize, nil
+	}
+
+	var m *image.NRGBA
+	// Preserve the aspect ratio of the image.
+	if bounds.Max.X > bounds.Max.Y {
+		m = imaging.Resize(img, size, 0, imaging.Lanczos)
+	} else {
+		m = imaging.Resize(img, 0, size, imaging.Lanczos)
+	}
+
+	buf := new(bytes.Buffer)
+	buf.Reset()
+	if format == "image/png" {
+		err = png.Encode(buf, m)
+	} else {
+		err = jpeg.Encode(buf, m, &jpeg.Options{Quality: conf.Server.CoverJpegQuality})
+	}
+	return buf, originalSize, err
+}

core/artwork/sources.go

@@ -0,0 +1,175 @@
+package artwork
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/dhowden/tag"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/core"
+	"github.com/navidrome/navidrome/core/ffmpeg"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/resources"
+)
+
+func selectImageReader(ctx context.Context, artID model.ArtworkID, extractFuncs ...sourceFunc) (io.ReadCloser, string, error) {
+	for _, f := range extractFuncs {
+		if ctx.Err() != nil {
+			return nil, "", ctx.Err()
+		}
+		start := time.Now()
+		r, path, err := f()
+		if r != nil {
+			msg := fmt.Sprintf("Found %s artwork", artID.Kind)
+			log.Debug(ctx, msg, "artID", artID, "path", path, "source", f, "elapsed", time.Since(start))
+			return r, path, nil
+		}
+		log.Trace(ctx, "Failed trying to extract artwork", "artID", artID, "source", f, "elapsed", time.Since(start), err)
+	}
+	return nil, "", fmt.Errorf("could not get a cover art for %s: %w", artID, ErrUnavailable)
+}
+
+type sourceFunc func() (r io.ReadCloser, path string, err error)
+
+func (f sourceFunc) String() string {
+	name := runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name()
+	name = strings.TrimPrefix(name, "github.com/navidrome/navidrome/core/artwork.")
+	if _, after, found := strings.Cut(name, ")."); found {
+		name = after
+	}
+	name = strings.TrimSuffix(name, ".func1")
+	return name
+}
+
+func splitList(s string) []string {
+	return strings.Split(s, consts.Zwsp)
+}
+
+func fromExternalFile(ctx context.Context, files string, pattern string) sourceFunc {
+	return func() (io.ReadCloser, string, error) {
+		for _, file := range splitList(files) {
+			_, name := filepath.Split(file)
+			match, err := filepath.Match(pattern, strings.ToLower(name))
+			if err != nil {
+				log.Warn(ctx, "Error matching cover art file to pattern", "pattern", pattern, "file", file)
+				continue
+			}
+			if !match {
+				continue
+			}
+			f, err := os.Open(file)
+			if err != nil {
+				log.Warn(ctx, "Could not open cover art file", "file", file, err)
+				continue
+			}
+			return f, file, err
+		}
+		return nil, "", fmt.Errorf("pattern '%s' not matched by files %v", pattern, files)
+	}
+}
+
+func fromTag(path string) sourceFunc {
+	return func() (io.ReadCloser, string, error) {
+		if path == "" {
+			return nil, "", nil
+		}
+		f, err := os.Open(path)
+		if err != nil {
+			return nil, "", err
+		}
+		defer f.Close()
+
+		m, err := tag.ReadFrom(f)
+		if err != nil {
+			return nil, "", err
+		}
+
+		picture := m.Picture()
+		if picture == nil {
+			return nil, "", fmt.Errorf("no embedded image found in %s", path)
+		}
+		return io.NopCloser(bytes.NewReader(picture.Data)), path, nil
+	}
+}
+
+func fromFFmpegTag(ctx context.Context, ffmpeg ffmpeg.FFmpeg, path string) sourceFunc {
+	return func() (io.ReadCloser, string, error) {
+		if path == "" {
+			return nil, "", nil
+		}
+		r, err := ffmpeg.ExtractImage(ctx, path)
+		if err != nil {
+			return nil, "", err
+		}
+		defer r.Close()
+		buf := new(bytes.Buffer)
+		_, err = io.Copy(buf, r)
+		if err != nil {
+			return nil, "", err
+		}
+		return io.NopCloser(buf), path, nil
+	}
+}
+
+func fromAlbum(ctx context.Context, a *artwork, id model.ArtworkID) sourceFunc {
+	return func() (io.ReadCloser, string, error) {
+		r, _, err := a.Get(ctx, id, 0)
+		if err != nil {
+			return nil, "", err
+		}
+		return r, id.String(), nil
+	}
+}
+
+func fromAlbumPlaceholder() sourceFunc {
+	return func() (io.ReadCloser, string, error) {
+		r, _ := resources.FS().Open(consts.PlaceholderAlbumArt)
+		return r, consts.PlaceholderAlbumArt, nil
+	}
+}
+func fromArtistExternalSource(ctx context.Context, ar model.Artist, em core.ExternalMetadata) sourceFunc {
+	return func() (io.ReadCloser, string, error) {
+		imageUrl, err := em.ArtistImage(ctx, ar.ID)
+		if err != nil {
+			return nil, "", err
+		}
+
+		return fromURL(ctx, imageUrl)
+	}
+}
+
+func fromAlbumExternalSource(ctx context.Context, al model.Album, em core.ExternalMetadata) sourceFunc {
+	return func() (io.ReadCloser, string, error) {
+		imageUrl, err := em.AlbumImage(ctx, al.ID)
+		if err != nil {
+			return nil, "", err
+		}
+
+		return fromURL(ctx, imageUrl)
+	}
+}
+
+func fromURL(ctx context.Context, imageUrl *url.URL) (io.ReadCloser, string, error) {
+	hc := http.Client{Timeout: 5 * time.Second}
+	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, imageUrl.String(), nil)
+	resp, err := hc.Do(req)
+	if err != nil {
+		return nil, "", err
+	}
+	if resp.StatusCode != http.StatusOK {
+		resp.Body.Close()
+		return nil, "", fmt.Errorf("error retrieveing artwork from %s: %s", imageUrl, resp.Status)
+	}
+	return resp.Body, imageUrl.String(), nil
+}

core/artwork/wire_providers.go

@@ -0,0 +1,11 @@
+package artwork
+
+import (
+	"github.com/google/wire"
+)
+
+var Set = wire.NewSet(
+	NewArtwork,
+	GetImageCache,
+	NewCacheWarmer,
+)

core/artwork_test.go

@@ -1,141 +0,0 @@
-package core
-
-import (
-	"context"
-	"image"
-	"io/ioutil"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Artwork", func() {
-	var artwork Artwork
-	var ds model.DataStore
-	ctx := log.NewContext(context.TODO())
-
-	BeforeEach(func() {
-		ds = &tests.MockDataStore{MockedTranscoding: &tests.MockTranscodingRepository{}}
-		ds.Album(ctx).(*tests.MockAlbum).SetData(model.Albums{
-			{ID: "222", CoverArtId: "123", CoverArtPath: "tests/fixtures/test.mp3"},
-			{ID: "333", CoverArtId: ""},
-			{ID: "444", CoverArtId: "444", CoverArtPath: "tests/fixtures/cover.jpg"},
-		})
-		ds.MediaFile(ctx).(*tests.MockMediaFile).SetData(model.MediaFiles{
-			{ID: "123", AlbumID: "222", Path: "tests/fixtures/test.mp3", HasCoverArt: true},
-			{ID: "456", AlbumID: "222", Path: "tests/fixtures/test.ogg", HasCoverArt: false},
-		})
-	})
-
-	Context("Cache is configured", func() {
-		BeforeEach(func() {
-			conf.Server.DataFolder, _ = ioutil.TempDir("", "file_caches")
-			conf.Server.ImageCacheSize = "100MB"
-			cache := GetImageCache()
-			Eventually(func() bool { return cache.Ready(context.TODO()) }).Should(BeTrue())
-			artwork = NewArtwork(ds, cache)
-		})
-
-		It("retrieves the external artwork art for an album", func() {
-			r, err := artwork.Get(ctx, "al-444", 0)
-			Expect(err).To(BeNil())
-
-			_, format, err := image.Decode(r)
-			Expect(err).To(BeNil())
-			Expect(format).To(Equal("jpeg"))
-			Expect(r.Close()).To(BeNil())
-		})
-
-		It("retrieves the embedded artwork art for an album", func() {
-			r, err := artwork.Get(ctx, "al-222", 0)
-			Expect(err).To(BeNil())
-
-			_, format, err := image.Decode(r)
-			Expect(err).To(BeNil())
-			Expect(format).To(Equal("jpeg"))
-			Expect(r.Close()).To(BeNil())
-		})
-
-		It("returns the default artwork if album does not have artwork", func() {
-			r, err := artwork.Get(ctx, "al-333", 0)
-			Expect(err).To(BeNil())
-
-			_, format, err := image.Decode(r)
-			Expect(err).To(BeNil())
-			Expect(format).To(Equal("png"))
-			Expect(r.Close()).To(BeNil())
-		})
-
-		It("returns the default artwork if album is not found", func() {
-			r, err := artwork.Get(ctx, "al-0101", 0)
-			Expect(err).To(BeNil())
-
-			_, format, err := image.Decode(r)
-			Expect(err).To(BeNil())
-			Expect(format).To(Equal("png"))
-			Expect(r.Close()).To(BeNil())
-		})
-
-		It("retrieves the original artwork art from a media_file", func() {
-			r, err := artwork.Get(ctx, "123", 0)
-			Expect(err).To(BeNil())
-
-			img, format, err := image.Decode(r)
-			Expect(err).To(BeNil())
-			Expect(format).To(Equal("jpeg"))
-			Expect(img.Bounds().Size().X).To(Equal(600))
-			Expect(img.Bounds().Size().Y).To(Equal(600))
-			Expect(r.Close()).To(BeNil())
-		})
-
-		It("retrieves the album artwork art if media_file does not have one", func() {
-			r, err := artwork.Get(ctx, "456", 0)
-			Expect(err).To(BeNil())
-
-			_, format, err := image.Decode(r)
-			Expect(err).To(BeNil())
-			Expect(format).To(Equal("jpeg"))
-			Expect(r.Close()).To(BeNil())
-		})
-
-		It("retrieves the album artwork by album id", func() {
-			r, err := artwork.Get(ctx, "222", 0)
-			Expect(err).To(BeNil())
-
-			_, format, err := image.Decode(r)
-			Expect(err).To(BeNil())
-			Expect(format).To(Equal("jpeg"))
-			Expect(r.Close()).To(BeNil())
-		})
-
-		It("resized artwork art as requested", func() {
-			r, err := artwork.Get(ctx, "123", 200)
-			Expect(err).To(BeNil())
-
-			img, format, err := image.Decode(r)
-			Expect(err).To(BeNil())
-			Expect(format).To(Equal("jpeg"))
-			Expect(img.Bounds().Size().X).To(Equal(200))
-			Expect(img.Bounds().Size().Y).To(Equal(200))
-			Expect(r.Close()).To(BeNil())
-		})
-
-		Context("Errors", func() {
-			It("returns err if gets error from album table", func() {
-				ds.Album(ctx).(*tests.MockAlbum).SetError(true)
-				_, err := artwork.Get(ctx, "al-222", 0)
-				Expect(err).To(MatchError("Error!"))
-			})
-
-			It("returns err if gets error from media_file table", func() {
-				ds.MediaFile(ctx).(*tests.MockMediaFile).SetError(true)
-				_, err := artwork.Get(ctx, "123", 0)
-				Expect(err).To(MatchError("Error!"))
-			})
-		})
-	})
-})

core/auth/auth.go

@@ -2,75 +2,111 @@ package auth
 
 import (
 	"context"
-	"fmt"
 	"sync"
 	"time"
 
-	"github.com/dgrijalva/jwt-go"
-	"github.com/go-chi/jwtauth"
+	"github.com/go-chi/jwtauth/v5"
+	"github.com/lestrrat-go/jwx/v2/jwt"
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
 )
 
 var (
-	once           sync.Once
-	JwtSecret      []byte
-	TokenAuth      *jwtauth.JWTAuth
-	sessionTimeOut time.Duration
+	once      sync.Once
+	Secret    []byte
+	TokenAuth *jwtauth.JWTAuth
 )
 
-func InitTokenAuth(ds model.DataStore) {
+func Init(ds model.DataStore) {
 	once.Do(func() {
+		log.Info("Setting Session Timeout", "value", conf.Server.SessionTimeout)
 		secret, err := ds.Property(context.TODO()).DefaultGet(consts.JWTSecretKey, "not so secret")
 		if err != nil {
 			log.Error("No JWT secret found in DB. Setting a temp one, but please report this error", err)
 		}
-		JwtSecret = []byte(secret)
-		TokenAuth = jwtauth.New("HS256", JwtSecret, nil)
+		Secret = []byte(secret)
+		TokenAuth = jwtauth.New("HS256", Secret, nil)
 	})
 }
 
+func createBaseClaims() map[string]any {
+	tokenClaims := map[string]any{}
+	tokenClaims[jwt.IssuerKey] = consts.JWTIssuer
+	return tokenClaims
+}
+
+func CreatePublicToken(claims map[string]any) (string, error) {
+	tokenClaims := createBaseClaims()
+	for k, v := range claims {
+		tokenClaims[k] = v
+	}
+	_, token, err := TokenAuth.Encode(tokenClaims)
+
+	return token, err
+}
+
+func CreateExpiringPublicToken(exp time.Time, claims map[string]any) (string, error) {
+	tokenClaims := createBaseClaims()
+	if !exp.IsZero() {
+		tokenClaims[jwt.ExpirationKey] = exp.UTC().Unix()
+	}
+	for k, v := range claims {
+		tokenClaims[k] = v
+	}
+	_, token, err := TokenAuth.Encode(tokenClaims)
+
+	return token, err
+}
+
 func CreateToken(u *model.User) (string, error) {
-	token := jwt.New(jwt.SigningMethodHS256)
-	claims := token.Claims.(jwt.MapClaims)
-	claims["iss"] = consts.JWTIssuer
-	claims["sub"] = u.UserName
+	claims := createBaseClaims()
+	claims[jwt.SubjectKey] = u.UserName
+	claims[jwt.IssuedAtKey] = time.Now().UTC().Unix()
+	claims["uid"] = u.ID
 	claims["adm"] = u.IsAdmin
+	token, _, err := TokenAuth.Encode(claims)
+	if err != nil {
+		return "", err
+	}
 
 	return TouchToken(token)
 }
 
-func getSessionTimeOut() time.Duration {
-	if sessionTimeOut == 0 {
-		sessionTimeOut = conf.Server.SessionTimeout
-		log.Info("Setting Session Timeout", "value", sessionTimeOut)
+func TouchToken(token jwt.Token) (string, error) {
+	claims, err := token.AsMap(context.Background())
+	if err != nil {
+		return "", err
 	}
-	return sessionTimeOut
+
+	claims[jwt.ExpirationKey] = time.Now().UTC().Add(conf.Server.SessionTimeout).Unix()
+	_, newToken, err := TokenAuth.Encode(claims)
+
+	return newToken, err
 }
 
-func TouchToken(token *jwt.Token) (string, error) {
-	timeout := getSessionTimeOut()
-	expireIn := time.Now().Add(timeout).Unix()
-	claims := token.Claims.(jwt.MapClaims)
-	claims["exp"] = expireIn
-
-	return token.SignedString(JwtSecret)
-}
-
-func Validate(tokenStr string) (jwt.MapClaims, error) {
-	token, err := jwt.Parse(tokenStr, func(token *jwt.Token) (interface{}, error) {
-		// Don't forget to validate the alg is what you expect:
-		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
-			return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
-		}
-
-		// hmacSampleSecret is a []byte containing your secret, e.g. []byte("my_secret_key")
-		return JwtSecret, nil
-	})
+func Validate(tokenStr string) (map[string]interface{}, error) {
+	token, err := jwtauth.VerifyToken(TokenAuth, tokenStr)
 	if err != nil {
 		return nil, err
 	}
-	return token.Claims.(jwt.MapClaims), err
+	return token.AsMap(context.Background())
+}
+
+func WithAdminUser(ctx context.Context, ds model.DataStore) context.Context {
+	u, err := ds.User(ctx).FindFirstAdmin()
+	if err != nil {
+		c, err := ds.User(ctx).CountAll()
+		if c == 0 && err == nil {
+			log.Debug(ctx, "Scanner: No admin user yet!", err)
+		} else {
+			log.Error(ctx, "Scanner: No admin user found!", err)
+		}
+		u = &model.User{}
+	}
+
+	ctx = request.WithUsername(ctx, u.UserName)
+	return request.WithUser(ctx, *u)
 }

core/auth/auth_test.go

@@ -4,52 +4,106 @@ import (
 	"testing"
 	"time"
 
-	"github.com/dgrijalva/jwt-go"
+	"github.com/go-chi/jwtauth/v5"
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/core/auth"
 	"github.com/navidrome/navidrome/log"
-	. "github.com/onsi/ginkgo"
+	"github.com/navidrome/navidrome/model"
+	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
 
 func TestAuth(t *testing.T) {
-	log.SetLevel(log.LevelCritical)
+	log.SetLevel(log.LevelFatal)
 	RegisterFailHandler(Fail)
 	RunSpecs(t, "Auth Test Suite")
 }
 
-const testJWTSecret = "not so secret"
+const (
+	testJWTSecret = "not so secret"
+	oneDay        = 24 * time.Hour
+)
+
+var _ = BeforeSuite(func() {
+	conf.Server.SessionTimeout = 2 * oneDay
+})
 
 var _ = Describe("Auth", func() {
+
 	BeforeEach(func() {
-		auth.JwtSecret = []byte(testJWTSecret)
+		auth.Secret = []byte(testJWTSecret)
+		auth.TokenAuth = jwtauth.New("HS256", auth.Secret, nil)
 	})
-	Context("Validate", func() {
+
+	Describe("Validate", func() {
 		It("returns error with an invalid JWT token", func() {
 			_, err := auth.Validate("invalid.token")
-			Expect(err).To(Not(BeNil()))
+			Expect(err).To(HaveOccurred())
 		})
 
 		It("returns the claims from a valid JWT token", func() {
-			token := jwt.New(jwt.SigningMethodHS256)
-			claims := token.Claims.(jwt.MapClaims)
+			claims := map[string]interface{}{}
 			claims["iss"] = "issuer"
+			claims["iat"] = time.Now().Unix()
 			claims["exp"] = time.Now().Add(1 * time.Minute).Unix()
-			tokenStr, _ := token.SignedString(auth.JwtSecret)
+			_, tokenStr, err := auth.TokenAuth.Encode(claims)
+			Expect(err).NotTo(HaveOccurred())
 
 			decodedClaims, err := auth.Validate(tokenStr)
-			Expect(err).To(BeNil())
+			Expect(err).NotTo(HaveOccurred())
 			Expect(decodedClaims["iss"]).To(Equal("issuer"))
 		})
 
 		It("returns ErrExpired if the `exp` field is in the past", func() {
-			token := jwt.New(jwt.SigningMethodHS256)
-			claims := token.Claims.(jwt.MapClaims)
+			claims := map[string]interface{}{}
 			claims["iss"] = "issuer"
 			claims["exp"] = time.Now().Add(-1 * time.Minute).Unix()
-			tokenStr, _ := token.SignedString(auth.JwtSecret)
+			_, tokenStr, err := auth.TokenAuth.Encode(claims)
+			Expect(err).NotTo(HaveOccurred())
 
-			_, err := auth.Validate(tokenStr)
-			Expect(err).To(MatchError("Token is expired"))
+			_, err = auth.Validate(tokenStr)
+			Expect(err).To(MatchError("token is expired"))
+		})
+	})
+
+	Describe("CreateToken", func() {
+		It("creates a valid token", func() {
+			u := &model.User{
+				ID:       "123",
+				UserName: "johndoe",
+				IsAdmin:  true,
+			}
+			tokenStr, err := auth.CreateToken(u)
+			Expect(err).NotTo(HaveOccurred())
+
+			claims, err := auth.Validate(tokenStr)
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(claims["iss"]).To(Equal(consts.JWTIssuer))
+			Expect(claims["sub"]).To(Equal("johndoe"))
+			Expect(claims["uid"]).To(Equal("123"))
+			Expect(claims["adm"]).To(Equal(true))
+			Expect(claims["exp"]).To(BeTemporally(">", time.Now()))
+		})
+	})
+
+	Describe("TouchToken", func() {
+		It("updates the expiration time", func() {
+			yesterday := time.Now().Add(-oneDay)
+			claims := map[string]interface{}{}
+			claims["iss"] = "issuer"
+			claims["exp"] = yesterday.Unix()
+			token, _, err := auth.TokenAuth.Encode(claims)
+			Expect(err).NotTo(HaveOccurred())
+
+			touched, err := auth.TouchToken(token)
+			Expect(err).NotTo(HaveOccurred())
+
+			decodedClaims, err := auth.Validate(touched)
+			Expect(err).NotTo(HaveOccurred())
+			exp := decodedClaims["exp"].(time.Time)
+			Expect(exp.Sub(yesterday)).To(BeNumerically(">=", oneDay))
 		})
 	})
 })

core/cache_warmer.go

@@ -1,93 +0,0 @@
-package core
-
-import (
-	"context"
-	"io"
-	"io/ioutil"
-	"time"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/utils/pool"
-)
-
-type CacheWarmer interface {
-	AddAlbum(ctx context.Context, albumID string)
-	Flush(ctx context.Context)
-}
-
-func NewCacheWarmer(artwork Artwork, artworkCache ArtworkCache) CacheWarmer {
-	w := &warmer{
-		artwork:      artwork,
-		artworkCache: artworkCache,
-		albums:       map[string]struct{}{},
-	}
-	p, err := pool.NewPool("artwork", 3, w.execute)
-	if err != nil {
-		log.Error(context.Background(), "Error creating pool for Album Artwork Cache Warmer", err)
-	} else {
-		w.pool = p
-	}
-
-	return w
-}
-
-type warmer struct {
-	pool         *pool.Pool
-	artwork      Artwork
-	artworkCache ArtworkCache
-	albums       map[string]struct{}
-}
-
-func (w *warmer) AddAlbum(ctx context.Context, albumID string) {
-	if albumID == "" {
-		return
-	}
-	w.albums[albumID] = struct{}{}
-}
-
-func (w *warmer) waitForCacheReady(ctx context.Context) {
-	tick := time.NewTicker(time.Second)
-	defer tick.Stop()
-	for {
-		<-tick.C
-		if w.artworkCache.Ready(ctx) {
-			return
-		}
-	}
-}
-
-func (w *warmer) Flush(ctx context.Context) {
-	if conf.Server.DevPreCacheAlbumArtwork {
-		w.waitForCacheReady(ctx)
-		if w.artworkCache.Available(ctx) {
-			if w.pool == nil || len(w.albums) == 0 {
-				return
-			}
-			log.Info(ctx, "Pre-caching album artworks", "numAlbums", len(w.albums))
-			for id := range w.albums {
-				w.pool.Submit(artworkItem{albumID: id})
-			}
-		} else {
-			log.Warn(ctx, "Cache warmer is not available as ImageCache is DISABLED")
-		}
-	}
-	w.albums = map[string]struct{}{}
-}
-
-func (w *warmer) execute(workload interface{}) {
-	ctx := context.Background()
-	item := workload.(artworkItem)
-	log.Trace(ctx, "Pre-caching album artwork", "albumID", item.albumID)
-	r, err := w.artwork.Get(ctx, item.albumID, 0)
-	if err != nil {
-		log.Warn("Error pre-caching artwork from album", "id", item.albumID, err)
-		return
-	}
-	defer r.Close()
-	_, _ = io.Copy(ioutil.Discard, r)
-}
-
-type artworkItem struct {
-	albumID string
-}

core/core_suite_test.go

@@ -5,13 +5,13 @@ import (
 
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
 
 func TestCore(t *testing.T) {
 	tests.Init(t, false)
-	log.SetLevel(log.LevelCritical)
+	log.SetLevel(log.LevelFatal)
 	RegisterFailHandler(Fail)
 	RunSpecs(t, "Core Suite")
 }

core/external_metadata.go

@@ -2,30 +2,53 @@ package core
 
 import (
 	"context"
+	"errors"
+	"net/url"
 	"sort"
 	"strings"
-	"sync"
 	"time"
 
 	"github.com/Masterminds/squirrel"
-	"github.com/microcosm-cc/bluemonday"
+	"github.com/deluan/sanitize"
 	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/core/agents"
+	_ "github.com/navidrome/navidrome/core/agents/lastfm"
+	_ "github.com/navidrome/navidrome/core/agents/listenbrainz"
+	_ "github.com/navidrome/navidrome/core/agents/spotify"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils"
+	"github.com/navidrome/navidrome/utils/number"
+	"golang.org/x/sync/errgroup"
 )
 
-const unavailableArtistID = "-1"
+const (
+	unavailableArtistID = "-1"
+	maxSimilarArtists   = 100
+	refreshDelay        = 5 * time.Second
+	refreshTimeout      = 15 * time.Second
+	refreshQueueLength  = 2000
+)
 
 type ExternalMetadata 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)
 	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)
 }
 
 type externalMetadata struct {
-	ds model.DataStore
+	ds          model.DataStore
+	ag          *agents.Agents
+	artistQueue chan<- *auxArtist
+	albumQueue  chan<- *auxAlbum
+}
+
+type auxAlbum struct {
+	model.Album
+	Name string
 }
 
 type auxArtist struct {
@@ -33,30 +56,105 @@ type auxArtist struct {
 	Name string
 }
 
-func NewExternalMetadata(ds model.DataStore) ExternalMetadata {
-	return &externalMetadata{ds: ds}
+func NewExternalMetadata(ds model.DataStore, agents *agents.Agents) ExternalMetadata {
+	e := &externalMetadata{ds: ds, ag: agents}
+	e.artistQueue = startRefreshQueue(context.TODO(), e.populateArtistInfo)
+	e.albumQueue = startRefreshQueue(context.TODO(), e.populateAlbumInfo)
+	return e
 }
 
-func (e *externalMetadata) initAgents(ctx context.Context) []agents.Interface {
-	order := strings.Split(conf.Server.Agents, ",")
-	order = append(order, agents.PlaceholderAgentName)
-	var res []agents.Interface
-	for _, name := range order {
-		init, ok := agents.Map[name]
-		if !ok {
-			log.Error(ctx, "Agent not available. Check configuration", "name", name)
-			continue
-		}
-
-		res = append(res, init(ctx))
+func (e *externalMetadata) getAlbum(ctx context.Context, id string) (*auxAlbum, error) {
+	var entity interface{}
+	entity, err := model.GetEntityByID(ctx, e.ds, id)
+	if err != nil {
+		return nil, err
 	}
 
-	return res
+	var album auxAlbum
+	switch v := entity.(type) {
+	case *model.Album:
+		album.Album = *v
+		album.Name = clearName(v.Name)
+	case *model.MediaFile:
+		return e.getAlbum(ctx, v.AlbumID)
+	default:
+		return nil, model.ErrNotFound
+	}
+	return &album, nil
+}
+
+func (e *externalMetadata) UpdateAlbumInfo(ctx context.Context, id string) (*model.Album, error) {
+	album, err := e.getAlbum(ctx, id)
+	if err != nil {
+		log.Info(ctx, "Not found", "id", id)
+		return nil, err
+	}
+
+	if album.ExternalInfoUpdatedAt.IsZero() {
+		log.Debug(ctx, "AlbumInfo not cached. Retrieving it now", "updatedAt", album.ExternalInfoUpdatedAt, "id", id, "name", album.Name)
+		err = e.populateAlbumInfo(ctx, album)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if time.Since(album.ExternalInfoUpdatedAt) > conf.Server.DevAlbumInfoTimeToLive {
+		log.Debug("Found expired cached AlbumInfo, refreshing in the background", "updatedAt", album.ExternalInfoUpdatedAt, "name", album.Name)
+		enqueueRefresh(e.albumQueue, album)
+	}
+
+	return &album.Album, nil
+}
+
+func (e *externalMetadata) populateAlbumInfo(ctx context.Context, album *auxAlbum) error {
+	start := time.Now()
+	info, err := e.ag.GetAlbumInfo(ctx, album.Name, album.AlbumArtist, album.MbzAlbumID)
+	if errors.Is(err, agents.ErrNotFound) {
+		return nil
+	}
+	if err != nil {
+		log.Error("Error refreshing AlbumInfo", "id", album.ID, "name", album.Name, "artist", album.AlbumArtist,
+			"elapsed", time.Since(start), err)
+		return err
+	}
+
+	album.ExternalInfoUpdatedAt = time.Now()
+	album.ExternalUrl = info.URL
+
+	if info.Description != "" {
+		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
+		})
+
+		album.LargeImageUrl = info.Images[0].URL
+
+		if len(info.Images) >= 2 {
+			album.MediumImageUrl = info.Images[1].URL
+		}
+
+		if len(info.Images) >= 3 {
+			album.SmallImageUrl = info.Images[2].URL
+		}
+	}
+
+	err = e.ds.Album(ctx).Put(&album.Album)
+	if err != nil {
+		log.Error(ctx, "Error trying to update album external information", "id", album.ID, "name", album.Name,
+			"elapsed", time.Since(start), err)
+	} else {
+		log.Trace(ctx, "AlbumInfo collected", "album", album, "elapsed", time.Since(start))
+	}
+
+	return nil
 }
 
 func (e *externalMetadata) getArtist(ctx context.Context, id string) (*auxArtist, error) {
 	var entity interface{}
-	entity, err := GetEntityByID(ctx, e.ds, id)
+	entity, err := model.GetEntityByID(ctx, e.ds, id)
 	if err != nil {
 		return nil, err
 	}
@@ -88,102 +186,193 @@ func clearName(name string) string {
 }
 
 func (e *externalMetadata) UpdateArtistInfo(ctx context.Context, id string, similarCount int, includeNotPresent bool) (*model.Artist, error) {
-	allAgents := e.initAgents(ctx)
+	artist, err := e.refreshArtistInfo(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+
+	err = e.loadSimilar(ctx, artist, similarCount, includeNotPresent)
+	return &artist.Artist, err
+}
+
+func (e *externalMetadata) refreshArtistInfo(ctx context.Context, id string) (*auxArtist, error) {
 	artist, err := e.getArtist(ctx, id)
 	if err != nil {
 		return nil, err
 	}
 
-	// If we have fresh info, just return it
-	if time.Since(artist.ExternalInfoUpdatedAt) < consts.ArtistInfoTimeToLive {
-		log.Debug("Found cached ArtistInfo", "updatedAt", artist.ExternalInfoUpdatedAt, "name", artist.Name)
-		err := e.loadSimilar(ctx, artist, includeNotPresent)
-		return &artist.Artist, err
-	}
-	log.Debug(ctx, "ArtistInfo not cached or expired", "updatedAt", artist.ExternalInfoUpdatedAt, "id", id, "name", artist.Name)
-
-	// Get MBID first, if it is not yet available
-	if artist.MbzArtistID == "" {
-		e.callGetMBID(ctx, allAgents, artist)
-	}
-
-	// Call all registered agents and collect information
-	wg := &sync.WaitGroup{}
-	e.callGetBiography(ctx, allAgents, artist, wg)
-	e.callGetURL(ctx, allAgents, artist, wg)
-	e.callGetImage(ctx, allAgents, artist, wg)
-	e.callGetSimilar(ctx, allAgents, artist, similarCount, wg)
-	wg.Wait()
-
-	if isDone(ctx) {
-		log.Warn(ctx, "ArtistInfo update canceled", ctx.Err())
-		return nil, ctx.Err()
-	}
-
-	artist.ExternalInfoUpdatedAt = time.Now()
-	err = e.ds.Artist(ctx).Put(&artist.Artist)
-	if err != nil {
-		log.Error(ctx, "Error trying to update artist external information", "id", id, "name", artist.Name, err)
-	}
-
-	if !includeNotPresent {
-		similar := artist.SimilarArtists
-		artist.SimilarArtists = nil
-		for _, s := range similar {
-			if s.ID == unavailableArtistID {
-				continue
-			}
-			artist.SimilarArtists = append(artist.SimilarArtists, s)
+	// If we don't have any info, retrieves it now
+	if artist.ExternalInfoUpdatedAt.IsZero() {
+		log.Debug(ctx, "ArtistInfo not cached. Retrieving it now", "updatedAt", artist.ExternalInfoUpdatedAt, "id", id, "name", artist.Name)
+		err := e.populateArtistInfo(ctx, artist)
+		if err != nil {
+			return nil, err
 		}
 	}
 
-	log.Trace(ctx, "ArtistInfo collected", "artist", artist)
-	return &artist.Artist, nil
+	// If info is expired, trigger a populateArtistInfo in the background
+	if time.Since(artist.ExternalInfoUpdatedAt) > conf.Server.DevArtistInfoTimeToLive {
+		log.Debug("Found expired cached ArtistInfo, refreshing in the background", "updatedAt", artist.ExternalInfoUpdatedAt, "name", artist.Name)
+		enqueueRefresh(e.artistQueue, artist)
+	}
+	return artist, nil
+}
+
+func (e *externalMetadata) populateArtistInfo(ctx context.Context, artist *auxArtist) error {
+	start := time.Now()
+	// Get MBID first, if it is not yet available
+	if artist.MbzArtistID == "" {
+		mbid, err := e.ag.GetArtistMBID(ctx, artist.ID, artist.Name)
+		if mbid != "" && err == nil {
+			artist.MbzArtistID = mbid
+		}
+	}
+
+	// Call all registered agents and collect information
+	g := errgroup.Group{}
+	g.SetLimit(2)
+	g.Go(func() error { e.callGetImage(ctx, e.ag, artist); return nil })
+	g.Go(func() error { e.callGetBiography(ctx, e.ag, artist); return nil })
+	g.Go(func() error { e.callGetURL(ctx, e.ag, artist); return nil })
+	g.Go(func() error { e.callGetSimilar(ctx, e.ag, artist, maxSimilarArtists, true); return nil })
+	_ = g.Wait()
+
+	if utils.IsCtxDone(ctx) {
+		log.Warn(ctx, "ArtistInfo update canceled", "elapsed", "id", artist.ID, "name", artist.Name, time.Since(start), ctx.Err())
+		return ctx.Err()
+	}
+
+	artist.ExternalInfoUpdatedAt = time.Now()
+	err := e.ds.Artist(ctx).Put(&artist.Artist)
+	if err != nil {
+		log.Error(ctx, "Error trying to update artist external information", "id", artist.ID, "name", artist.Name,
+			"elapsed", time.Since(start), err)
+	} else {
+		log.Trace(ctx, "ArtistInfo collected", "artist", artist, "elapsed", time.Since(start))
+	}
+	return nil
 }
 
 func (e *externalMetadata) SimilarSongs(ctx context.Context, id string, count int) (model.MediaFiles, error) {
-	allAgents := e.initAgents(ctx)
 	artist, err := e.getArtist(ctx, id)
 	if err != nil {
 		return nil, err
 	}
 
-	wg := &sync.WaitGroup{}
-	e.callGetSimilar(ctx, allAgents, artist, count, wg)
-	wg.Wait()
-
-	if isDone(ctx) {
+	e.callGetSimilar(ctx, e.ag, artist, 15, false)
+	if utils.IsCtxDone(ctx) {
 		log.Warn(ctx, "SimilarSongs call canceled", ctx.Err())
 		return nil, ctx.Err()
 	}
 
-	if len(artist.SimilarArtists) == 0 {
-		return nil, nil
+	weightedSongs := utils.NewWeightedRandomChooser()
+	addArtist := func(a model.Artist, weightedSongs *utils.WeightedChooser, count, artistWeight int) error {
+		if utils.IsCtxDone(ctx) {
+			log.Warn(ctx, "SimilarSongs call canceled", ctx.Err())
+			return ctx.Err()
+		}
+
+		topCount := number.Max(count, 20)
+		topSongs, err := e.getMatchingTopSongs(ctx, e.ag, &auxArtist{Name: a.Name, Artist: a}, topCount)
+		if err != nil {
+			log.Warn(ctx, "Error getting artist's top songs", "artist", a.Name, err)
+			return nil
+		}
+
+		weight := topCount * (4 + artistWeight)
+		for _, mf := range topSongs {
+			weightedSongs.Add(mf, weight)
+			weight -= 4
+		}
+		return nil
 	}
 
-	var ids = []string{artist.ID}
+	err = addArtist(artist.Artist, weightedSongs, count, 10)
+	if err != nil {
+		return nil, err
+	}
 	for _, a := range artist.SimilarArtists {
-		if a.ID != unavailableArtistID {
-			ids = append(ids, a.ID)
+		err := addArtist(a, weightedSongs, count, 0)
+		if err != nil {
+			return nil, err
 		}
 	}
 
-	return e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
-		Filters: squirrel.Eq{"artist_id": ids},
-		Max:     count,
-		Sort:    "random()",
-	})
+	var similarSongs model.MediaFiles
+	for len(similarSongs) < count && weightedSongs.Size() > 0 {
+		s, err := weightedSongs.GetAndRemove()
+		if err != nil {
+			log.Warn(ctx, "Error getting weighted song", err)
+			continue
+		}
+		similarSongs = append(similarSongs, s.(model.MediaFile))
+	}
+
+	return similarSongs, nil
+}
+
+func (e *externalMetadata) ArtistImage(ctx context.Context, id string) (*url.URL, error) {
+	artist, err := e.getArtist(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+
+	e.callGetImage(ctx, e.ag, artist)
+	if utils.IsCtxDone(ctx) {
+		log.Warn(ctx, "ArtistImage call canceled", ctx.Err())
+		return nil, ctx.Err()
+	}
+
+	imageUrl := artist.ArtistImageUrl()
+	if imageUrl == "" {
+		return nil, agents.ErrNotFound
+	}
+	return url.Parse(imageUrl)
+}
+
+func (e *externalMetadata) AlbumImage(ctx context.Context, id string) (*url.URL, error) {
+	album, err := e.getAlbum(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+
+	info, err := e.ag.GetAlbumInfo(ctx, album.Name, album.AlbumArtist, album.MbzAlbumID)
+	if errors.Is(err, agents.ErrNotFound) {
+		return nil, err
+	}
+	if utils.IsCtxDone(ctx) {
+		log.Warn(ctx, "AlbumImage call canceled", ctx.Err())
+		return nil, ctx.Err()
+	}
+
+	// Return the biggest image
+	var img agents.ExternalImage
+	for _, i := range info.Images {
+		if img.Size <= i.Size {
+			img = i
+		}
+	}
+	if img.URL == "" {
+		return nil, agents.ErrNotFound
+	}
+	return url.Parse(img.URL)
 }
 
 func (e *externalMetadata) TopSongs(ctx context.Context, artistName string, count int) (model.MediaFiles, error) {
-	allAgents := e.initAgents(ctx)
 	artist, err := e.findArtistByName(ctx, artistName)
 	if err != nil {
 		log.Error(ctx, "Artist not found", "name", artistName, err)
 		return nil, nil
 	}
 
-	songs, err := e.callGetTopSongs(ctx, allAgents, artist, count)
+	return e.getMatchingTopSongs(ctx, e.ag, artist, count)
+}
+
+func (e *externalMetadata) 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 errors.Is(err, agents.ErrNotFound) {
+		return nil, nil
+	}
 	if err != nil {
 		return nil, err
 	}
@@ -195,6 +384,14 @@ func (e *externalMetadata) TopSongs(ctx context.Context, artistName string, coun
 			continue
 		}
 		mfs = append(mfs, *mf)
+		if len(mfs) == count {
+			break
+		}
+	}
+	if len(mfs) == 0 {
+		log.Debug(ctx, "No matching top songs found", "name", artist.Name)
+	} else {
+		log.Debug(ctx, "Found matching top songs", "name", artist.Name, "numSongs", len(mfs))
 	}
 	return mfs, nil
 }
@@ -207,6 +404,7 @@ func (e *externalMetadata) findMatchingTrack(ctx context.Context, mbid string, a
 		if err == nil && len(mfs) > 0 {
 			return &mfs[0], nil
 		}
+		return e.findMatchingTrack(ctx, "", artistID, title)
 	}
 	mfs, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
 		Filters: squirrel.And{
@@ -214,9 +412,10 @@ func (e *externalMetadata) findMatchingTrack(ctx context.Context, mbid string, a
 				squirrel.Eq{"artist_id": artistID},
 				squirrel.Eq{"album_artist_id": artistID},
 			},
-			squirrel.Like{"title": title},
+			squirrel.Like{"order_title": strings.TrimSpace(sanitize.Accents(title))},
 		},
 		Sort: "starred desc, rating desc, year asc",
+		Max:  1,
 	})
 	if err != nil || len(mfs) == 0 {
 		return nil, model.ErrNotFound
@@ -224,162 +423,55 @@ func (e *externalMetadata) findMatchingTrack(ctx context.Context, mbid string, a
 	return &mfs[0], nil
 }
 
-func isDone(ctx context.Context) bool {
-	select {
-	case <-ctx.Done():
-		return true
-	default:
-		return false
+func (e *externalMetadata) callGetURL(ctx context.Context, agent agents.ArtistURLRetriever, artist *auxArtist) {
+	artisURL, err := agent.GetArtistURL(ctx, artist.ID, artist.Name, artist.MbzArtistID)
+	if err != nil {
+		return
+	}
+	artist.ExternalUrl = artisURL
+}
+
+func (e *externalMetadata) callGetBiography(ctx context.Context, agent agents.ArtistBiographyRetriever, artist *auxArtist) {
+	bio, err := agent.GetArtistBiography(ctx, artist.ID, clearName(artist.Name), artist.MbzArtistID)
+	if err != nil {
+		return
+	}
+	bio = utils.SanitizeText(bio)
+	bio = strings.ReplaceAll(bio, "\n", " ")
+	artist.Biography = strings.ReplaceAll(bio, "<a ", "<a target='_blank' ")
+}
+
+func (e *externalMetadata) callGetImage(ctx context.Context, agent agents.ArtistImageRetriever, artist *auxArtist) {
+	images, err := agent.GetArtistImages(ctx, artist.ID, artist.Name, artist.MbzArtistID)
+	if err != nil {
+		return
+	}
+	sort.Slice(images, func(i, j int) bool { return images[i].Size > images[j].Size })
+
+	if len(images) >= 1 {
+		artist.LargeImageUrl = images[0].URL
+	}
+	if len(images) >= 2 {
+		artist.MediumImageUrl = images[1].URL
+	}
+	if len(images) >= 3 {
+		artist.SmallImageUrl = images[2].URL
 	}
 }
 
-func (e *externalMetadata) callGetMBID(ctx context.Context, allAgents []agents.Interface, artist *auxArtist) {
+func (e *externalMetadata) callGetSimilar(ctx context.Context, agent agents.ArtistSimilarRetriever, artist *auxArtist,
+	limit int, includeNotPresent bool) {
+	similar, err := agent.GetSimilarArtists(ctx, artist.ID, artist.Name, artist.MbzArtistID, limit)
+	if len(similar) == 0 || err != nil {
+		return
+	}
 	start := time.Now()
-	for _, a := range allAgents {
-		if isDone(ctx) {
-			break
-		}
-		agent, ok := a.(agents.ArtistMBIDRetriever)
-		if !ok {
-			continue
-		}
-		mbid, err := agent.GetMBID(artist.ID, artist.Name)
-		if mbid != "" && err == nil {
-			artist.MbzArtistID = mbid
-			log.Debug(ctx, "Got MBID", "agent", a.AgentName(), "artist", artist.Name, "mbid", mbid, "elapsed", time.Since(start))
-			break
-		}
+	sa, err := e.mapSimilarArtists(ctx, similar, includeNotPresent)
+	log.Debug(ctx, "Mapped Similar Artists", "artist", artist.Name, "numSimilar", len(sa), "elapsed", time.Since(start))
+	if err != nil {
+		return
 	}
-}
-
-func (e *externalMetadata) callGetTopSongs(ctx context.Context, allAgents []agents.Interface, artist *auxArtist,
-	count int) ([]agents.Song, error) {
-	start := time.Now()
-	for _, a := range allAgents {
-		if isDone(ctx) {
-			break
-		}
-		agent, ok := a.(agents.ArtistTopSongsRetriever)
-		if !ok {
-			continue
-		}
-		songs, err := agent.GetTopSongs(artist.ID, artist.Name, artist.MbzArtistID, count)
-		if len(songs) > 0 && err == nil {
-			log.Debug(ctx, "Got Top Songs", "agent", a.AgentName(), "artist", artist.Name, "songs", songs, "elapsed", time.Since(start))
-			return songs, err
-		}
-	}
-	return nil, nil
-}
-
-func (e *externalMetadata) callGetURL(ctx context.Context, allAgents []agents.Interface, artist *auxArtist, wg *sync.WaitGroup) {
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		start := time.Now()
-		for _, a := range allAgents {
-			if isDone(ctx) {
-				break
-			}
-			agent, ok := a.(agents.ArtistURLRetriever)
-			if !ok {
-				continue
-			}
-			url, err := agent.GetURL(artist.ID, artist.Name, artist.MbzArtistID)
-			if url != "" && err == nil {
-				artist.ExternalUrl = url
-				log.Debug(ctx, "Got External Url", "agent", a.AgentName(), "artist", artist.Name, "url", url, "elapsed", time.Since(start))
-				break
-			}
-		}
-	}()
-}
-
-func (e *externalMetadata) callGetBiography(ctx context.Context, allAgents []agents.Interface, artist *auxArtist, wg *sync.WaitGroup) {
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		start := time.Now()
-		for _, a := range allAgents {
-			if isDone(ctx) {
-				break
-			}
-			agent, ok := a.(agents.ArtistBiographyRetriever)
-			if !ok {
-				continue
-			}
-			bio, err := agent.GetBiography(artist.ID, clearName(artist.Name), artist.MbzArtistID)
-			if bio != "" && err == nil {
-				policy := bluemonday.UGCPolicy()
-				bio = policy.Sanitize(bio)
-				bio = strings.ReplaceAll(bio, "\n", " ")
-				artist.Biography = strings.ReplaceAll(bio, "<a ", "<a target='_blank' ")
-				log.Debug(ctx, "Got Biography", "agent", a.AgentName(), "artist", artist.Name, "len", len(bio), "elapsed", time.Since(start))
-				break
-			}
-		}
-	}()
-}
-
-func (e *externalMetadata) callGetImage(ctx context.Context, allAgents []agents.Interface, artist *auxArtist, wg *sync.WaitGroup) {
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		start := time.Now()
-		for _, a := range allAgents {
-			if isDone(ctx) {
-				break
-			}
-			agent, ok := a.(agents.ArtistImageRetriever)
-			if !ok {
-				continue
-			}
-			images, err := agent.GetImages(artist.ID, artist.Name, artist.MbzArtistID)
-			if len(images) == 0 || err != nil {
-				continue
-			}
-			log.Debug(ctx, "Got Images", "agent", a.AgentName(), "artist", artist.Name, "images", images, "elapsed", time.Since(start))
-			sort.Slice(images, func(i, j int) bool { return images[i].Size > images[j].Size })
-			if len(images) >= 1 {
-				artist.LargeImageUrl = images[0].URL
-			}
-			if len(images) >= 2 {
-				artist.MediumImageUrl = images[1].URL
-			}
-			if len(images) >= 3 {
-				artist.SmallImageUrl = images[2].URL
-			}
-			break
-		}
-	}()
-}
-
-func (e *externalMetadata) callGetSimilar(ctx context.Context, allAgents []agents.Interface, artist *auxArtist, limit int, wg *sync.WaitGroup) {
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		start := time.Now()
-		for _, a := range allAgents {
-			if isDone(ctx) {
-				break
-			}
-			agent, ok := a.(agents.ArtistSimilarRetriever)
-			if !ok {
-				continue
-			}
-			similar, err := agent.GetSimilar(artist.ID, artist.Name, artist.MbzArtistID, limit)
-			if len(similar) == 0 || err != nil {
-				continue
-			}
-			sa, err := e.mapSimilarArtists(ctx, similar, true)
-			if err != nil {
-				continue
-			}
-			log.Debug(ctx, "Got Similar Artists", "agent", a.AgentName(), "artist", artist.Name, "similar", similar, "elapsed", time.Since(start))
-			artist.SimilarArtists = sa
-			break
-		}
-	}()
+	artist.SimilarArtists = sa
 }
 
 func (e *externalMetadata) mapSimilarArtists(ctx context.Context, similar []agents.Artist, includeNotPresent bool) (model.Artists, error) {
@@ -409,7 +501,7 @@ func (e *externalMetadata) mapSimilarArtists(ctx context.Context, similar []agen
 
 func (e *externalMetadata) findArtistByName(ctx context.Context, artistName string) (*auxArtist, error) {
 	artists, err := e.ds.Artist(ctx).GetAll(model.QueryOptions{
-		Filters: squirrel.Like{"name": artistName},
+		Filters: squirrel.Like{"artist.name": artistName},
 		Max:     1,
 	})
 	if err != nil {
@@ -425,7 +517,7 @@ func (e *externalMetadata) findArtistByName(ctx context.Context, artistName stri
 	return artist, nil
 }
 
-func (e *externalMetadata) loadSimilar(ctx context.Context, artist *auxArtist, includeNotPresent bool) error {
+func (e *externalMetadata) loadSimilar(ctx context.Context, artist *auxArtist, count int, includeNotPresent bool) error {
 	var ids []string
 	for _, sa := range artist.SimilarArtists {
 		if sa.ID == unavailableArtistID {
@@ -435,9 +527,10 @@ func (e *externalMetadata) loadSimilar(ctx context.Context, artist *auxArtist, i
 	}
 
 	similar, err := e.ds.Artist(ctx).GetAll(model.QueryOptions{
-		Filters: squirrel.Eq{"id": ids},
+		Filters: squirrel.Eq{"artist.id": ids},
 	})
 	if err != nil {
+		log.Error("Error loading similar artists", "id", artist.ID, "name", artist.Name, err)
 		return err
 	}
 
@@ -449,6 +542,9 @@ func (e *externalMetadata) loadSimilar(ctx context.Context, artist *auxArtist, i
 
 	var loaded model.Artists
 	for _, sa := range artist.SimilarArtists {
+		if len(loaded) >= count {
+			break
+		}
 		la, ok := artistMap[sa.ID]
 		if !ok {
 			if !includeNotPresent {
@@ -462,3 +558,29 @@ func (e *externalMetadata) loadSimilar(ctx context.Context, artist *auxArtist, i
 	artist.SimilarArtists = loaded
 	return nil
 }
+
+func startRefreshQueue[T any](ctx context.Context, processFn func(context.Context, T) error) chan<- T {
+	queue := make(chan T, refreshQueueLength)
+	go func() {
+		for {
+			time.Sleep(refreshDelay)
+			ctx, cancel := context.WithTimeout(ctx, refreshTimeout)
+			select {
+			case a := <-queue:
+				_ = processFn(ctx, a)
+				cancel()
+			case <-ctx.Done():
+				cancel()
+				break
+			}
+		}
+	}()
+	return queue
+}
+
+func enqueueRefresh[T any](queue chan<- T, item T) {
+	select {
+	case queue <- item:
+	default: // It is ok to miss a refresh
+	}
+}

core/ffmpeg/ffmpeg.go

@@ -0,0 +1,181 @@
+package ffmpeg
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/log"
+)
+
+type FFmpeg interface {
+	Transcode(ctx context.Context, command, path string, maxBitRate int) (io.ReadCloser, error)
+	ExtractImage(ctx context.Context, path string) (io.ReadCloser, error)
+	Probe(ctx context.Context, files []string) (string, error)
+	CmdPath() (string, error)
+}
+
+func New() FFmpeg {
+	return &ffmpeg{}
+}
+
+const (
+	extractImageCmd = "ffmpeg -i %s -an -vcodec copy -f image2pipe -"
+	probeCmd        = "ffmpeg %s -f ffmetadata"
+)
+
+type ffmpeg struct{}
+
+func (e *ffmpeg) Transcode(ctx context.Context, command, path string, maxBitRate int) (io.ReadCloser, error) {
+	if _, err := ffmpegCmd(); err != nil {
+		return nil, err
+	}
+	args := createFFmpegCommand(command, path, maxBitRate)
+	return e.start(ctx, args)
+}
+
+func (e *ffmpeg) ExtractImage(ctx context.Context, path string) (io.ReadCloser, error) {
+	if _, err := ffmpegCmd(); err != nil {
+		return nil, err
+	}
+	args := createFFmpegCommand(extractImageCmd, path, 0)
+	return e.start(ctx, args)
+}
+
+func (e *ffmpeg) Probe(ctx context.Context, files []string) (string, error) {
+	if _, err := ffmpegCmd(); err != nil {
+		return "", err
+	}
+	args := createProbeCommand(probeCmd, files)
+	log.Trace(ctx, "Executing ffmpeg command", "args", args)
+	cmd := exec.CommandContext(ctx, args[0], args[1:]...) // #nosec
+	output, _ := cmd.CombinedOutput()
+	return string(output), nil
+}
+
+func (e *ffmpeg) CmdPath() (string, error) {
+	return ffmpegCmd()
+}
+
+func (e *ffmpeg) start(ctx context.Context, args []string) (io.ReadCloser, error) {
+	log.Trace(ctx, "Executing ffmpeg command", "cmd", args)
+	j := &ffCmd{args: args}
+	j.PipeReader, j.out = io.Pipe()
+	err := j.start()
+	if err != nil {
+		return nil, err
+	}
+	go j.wait()
+	return j, nil
+}
+
+type ffCmd struct {
+	*io.PipeReader
+	out  *io.PipeWriter
+	args []string
+	cmd  *exec.Cmd
+}
+
+func (j *ffCmd) start() error {
+	cmd := exec.Command(j.args[0], j.args[1:]...) // #nosec
+	cmd.Stdout = j.out
+	if log.CurrentLevel() >= log.LevelTrace {
+		cmd.Stderr = os.Stderr
+	} else {
+		cmd.Stderr = io.Discard
+	}
+	j.cmd = cmd
+
+	if err := cmd.Start(); err != nil {
+		return fmt.Errorf("starting cmd: %w", err)
+	}
+	return nil
+}
+
+func (j *ffCmd) wait() {
+	if err := j.cmd.Wait(); err != nil {
+		var exitErr *exec.ExitError
+		if errors.As(err, &exitErr) {
+			_ = j.out.CloseWithError(fmt.Errorf("%s exited with non-zero status code: %d", j.args[0], exitErr.ExitCode()))
+		} else {
+			_ = j.out.CloseWithError(fmt.Errorf("waiting %s cmd: %w", j.args[0], err))
+		}
+		return
+	}
+	_ = j.out.Close()
+}
+
+// Path will always be an absolute path
+func createFFmpegCommand(cmd, path string, maxBitRate int) []string {
+	split := strings.Split(fixCmd(cmd), " ")
+	for i, s := range split {
+		s = strings.ReplaceAll(s, "%s", path)
+		s = strings.ReplaceAll(s, "%b", strconv.Itoa(maxBitRate))
+		split[i] = s
+	}
+
+	return split
+}
+
+func createProbeCommand(cmd string, inputs []string) []string {
+	split := strings.Split(fixCmd(cmd), " ")
+	var args []string
+
+	for _, s := range split {
+		if s == "%s" {
+			for _, inp := range inputs {
+				args = append(args, "-i", inp)
+			}
+		} else {
+			args = append(args, s)
+		}
+	}
+	return args
+}
+
+func fixCmd(cmd string) string {
+	split := strings.Split(cmd, " ")
+	var result []string
+	cmdPath, _ := ffmpegCmd()
+	for _, s := range split {
+		if s == "ffmpeg" || s == "ffmpeg.exe" {
+			result = append(result, cmdPath)
+		} else {
+			result = append(result, s)
+		}
+	}
+	return strings.Join(result, " ")
+}
+
+func ffmpegCmd() (string, error) {
+	ffOnce.Do(func() {
+		if conf.Server.FFmpegPath != "" {
+			ffmpegPath = conf.Server.FFmpegPath
+			ffmpegPath, ffmpegErr = exec.LookPath(ffmpegPath)
+		} else {
+			ffmpegPath, ffmpegErr = exec.LookPath("ffmpeg")
+			if errors.Is(ffmpegErr, exec.ErrDot) {
+				log.Trace("ffmpeg found in current folder '.'")
+				ffmpegPath, ffmpegErr = exec.LookPath("./ffmpeg")
+			}
+		}
+		if ffmpegErr == nil {
+			log.Info("Found ffmpeg", "path", ffmpegPath)
+			return
+		}
+	})
+	return ffmpegPath, ffmpegErr
+}
+
+var (
+	ffOnce     sync.Once
+	ffmpegPath string
+	ffmpegErr  error
+)