New service worker (#952)

- add check to see if cache is defined before deleting

.devcontainer/Dockerfile

@@ -2,7 +2,7 @@
 
 # [Choice] Go version: 1, 1.15, 1.14
 ARG VARIANT="1"
-FROM mcr.microsoft.com/vscode/devcontainers/go:${VARIANT}
+FROM mcr.microsoft.com/vscode/devcontainers/go:0-${VARIANT}
 
 # [Option] Install Node.js
 ARG INSTALL_NODE="true"
@@ -17,4 +17,4 @@ RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
 # RUN go get -x <your-dependency-or-tool>
 
 # [Optional] Uncomment this line to install global node packages.
-# RUN su vscode -c "source /usr/local/share/nvm/nvm.sh && npm install -g <your-package-here>" 2>&1
+# RUN su vscode -c "source /usr/local/share/nvm/nvm.sh && npm install -g <your-package-here>" 2>&1

.devcontainer/devcontainer.json

@@ -4,51 +4,45 @@
 		"dockerfile": "Dockerfile",
 		"args": {
 			// Update the VARIANT arg to pick a version of Go: 1, 1.15, 1.14
-			"VARIANT": "1.24",
+			"VARIANT": "1.16",
 			// Options
 			"INSTALL_NODE": "true",
-			"NODE_VERSION": "v20"
+			"NODE_VERSION": "v14"
 		}
 	},
-	"workspaceMount": "",
 	"runArgs": [
 		"--cap-add=SYS_PTRACE",
 		"--security-opt",
-		"seccomp=unconfined",
-		"--volume=${localWorkspaceFolder}:/workspaces/${localWorkspaceFolderBasename}:Z"
+		"seccomp=unconfined"
 	],
 	// Set *default* container specific settings.json values on container create.
-	"customizations": {
-		"vscode": {
-			"settings": {
-				"terminal.integrated.shell.linux": "/bin/bash",
-				"go.useGoProxyToCheckForToolUpdates": false,
-				"go.useLanguageServer": true,
-				"go.gopath": "/go",
-				"go.goroot": "/usr/local/go",
-				"go.toolsGopath": "/go/bin",
-				"go.formatTool": "goimports",
-				"go.lintOnSave": "package",
-				"go.lintTool": "golangci-lint",
-				"editor.formatOnSave": true,
-				"[javascript]": {
-					"editor.defaultFormatter": "esbenp.prettier-vscode"
-				},
-				"[json]": {
-					"editor.defaultFormatter": "esbenp.prettier-vscode"
-				},
-				"[jsonc]": {
-					"editor.defaultFormatter": "vscode.json-language-features"
-				}
-			},
-			// Add the IDs of extensions you want installed when the container is created.
-			"extensions": [
-				"golang.Go",
-				"esbenp.prettier-vscode",
-				"tamasfe.even-better-toml"
-			]
+	"settings": {
+		"terminal.integrated.shell.linux": "/bin/bash",
+		"go.useGoProxyToCheckForToolUpdates": false,
+		"go.useLanguageServer": true,
+		"go.gopath": "/go",
+		"go.goroot": "/usr/local/go",
+		"go.toolsGopath": "/go/bin",
+		"go.formatTool": "goimports",
+		"go.lintOnSave": "package",
+		"go.lintTool": "golangci-lint",
+		"editor.formatOnSave": true,
+		"[javascript]": {
+			"editor.defaultFormatter": "esbenp.prettier-vscode"
+		},
+		"[json]": {
+			"editor.defaultFormatter": "esbenp.prettier-vscode"
+		},
+		"[jsonc]": {
+			"editor.defaultFormatter": "vscode.json-language-features"
 		}
 	},
+	// Add the IDs of extensions you want installed when the container is created.
+	"extensions": [
+		"golang.Go",
+		"esbenp.prettier-vscode",
+		"tamasfe.even-better-toml"
+	],
 	// Use 'forwardPorts' to make a list of ports inside the container available locally.
 	"forwardPorts": [
 		4533,

.dockerignore

@@ -1,18 +1,10 @@
 .DS_Store
 ui/node_modules
-ui/build
-!ui/build/.gitkeep
 Dockerfile
 docker-compose*.yml
 data
 *.db
 testDB
 navidrome
+navidrome.db
 navidrome.toml
-tmp
-!tmp/taglib
-dist
-binaries
-cache
-music
-!Dockerfile

.github/ISSUE_TEMPLATE/bug_report.yml

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

@@ -1,8 +0,0 @@
-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/actions/download-taglib/action.yml

@@ -1,23 +0,0 @@
-name: 'Download TagLib'
-description: 'Downloads and extracts the TagLib library, adding it to PKG_CONFIG_PATH'
-inputs:
-  version:
-    description: 'Version of TagLib to download'
-    required: true
-  platform:
-    description: 'Platform to download TagLib for'
-    default: 'linux-amd64'
-runs:
-  using: 'composite'
-  steps:
-    - name: Download TagLib
-      shell: bash
-      run: |
-        mkdir -p /tmp/taglib
-        cd /tmp
-        FILE=taglib-${{ inputs.platform }}.tar.gz
-        wget https://github.com/navidrome/cross-taglib/releases/download/v${{ inputs.version }}/${FILE}
-        tar -xzf ${FILE} -C taglib
-        PKG_CONFIG_PREFIX=/tmp/taglib
-        echo "PKG_CONFIG_PREFIX=${PKG_CONFIG_PREFIX}" >> $GITHUB_ENV
-        echo "PKG_CONFIG_PATH=${PKG_CONFIG_PATH}:${PKG_CONFIG_PREFIX}/lib/pkgconfig" >> $GITHUB_ENV

.github/actions/prepare-docker/action.yml

@@ -1,84 +0,0 @@
-name: 'Prepare Docker Buildx environment'
-description: 'Downloads and extracts the TagLib library, adding it to PKG_CONFIG_PATH'
-inputs:
-  github_token:
-    description: 'GitHub token'
-    required: true
-    default: ''
-  hub_repository:
-    description: 'Docker Hub repository to push images to'
-    required: false
-    default: ''
-  hub_username:
-    description: 'Docker Hub username'
-    required: false
-    default: ''
-  hub_password:
-    description: 'Docker Hub password'
-    required: false
-    default: ''
-outputs:
-  tags:
-    description: 'Docker image tags'
-    value: ${{ steps.meta.outputs.tags }}
-  labels:
-    description: 'Docker image labels'
-    value: ${{ steps.meta.outputs.labels }}
-  annotations:
-    description: 'Docker image annotations'
-    value: ${{ steps.meta.outputs.annotations }}
-  version:
-    description: 'Docker image version'
-    value: ${{ steps.meta.outputs.version }}
-  hub_repository:
-    description: 'Docker Hub repository'
-    value: ${{ env.DOCKER_HUB_REPO }}
-  hub_enabled:
-    description: 'Is Docker Hub enabled'
-    value: ${{ env.DOCKER_HUB_ENABLED }}
-
-runs:
-  using: 'composite'
-  steps:
-    - name: Check Docker Hub configuration
-      shell: bash
-      run: |
-        if [ -z "${{inputs.hub_repository}}" ]; then
-          echo "DOCKER_HUB_REPO=none" >> $GITHUB_ENV
-          echo "DOCKER_HUB_ENABLED=false" >> $GITHUB_ENV
-        else
-          echo "DOCKER_HUB_REPO=${{inputs.hub_repository}}" >> $GITHUB_ENV
-          echo "DOCKER_HUB_ENABLED=true" >> $GITHUB_ENV
-        fi
-
-    - name: Login to Docker Hub
-      if: inputs.hub_username != '' && inputs.hub_password != ''
-      uses: docker/login-action@v3
-      with:
-        username: ${{ inputs.hub_username }}
-        password: ${{ inputs.hub_password }}
-
-    - name: Login to GitHub Container Registry
-      uses: docker/login-action@v3
-      with:
-        registry: ghcr.io
-        username: ${{ github.actor }}
-        password: ${{ inputs.github_token }}
-
-    - name: Set up Docker Buildx
-      id: buildx
-      uses: docker/setup-buildx-action@v3
-
-    - name: Extract metadata for Docker image
-      id: meta
-      uses: docker/metadata-action@v5
-      with:
-        labels: |
-          maintainer=deluan@navidrome.org
-        images: |
-          name=${{env.DOCKER_HUB_REPO}},enable=${{env.DOCKER_HUB_ENABLED}}
-          name=ghcr.io/${{ github.repository }}
-        tags: |
-          type=ref,event=pr
-          type=semver,pattern={{version}}
-          type=raw,value=develop,enable={{is_default_branch}}

.github/dependabot.yml

@@ -10,13 +10,3 @@ updates:
   schedule:
     interval: weekly
   open-pull-requests-limit: 10
-- package-ecosystem: docker
-  directory: "/"
-  schedule:
-    interval: weekly
-  open-pull-requests-limit: 10
-- package-ecosystem: github-actions
-  directory: "/.github/workflows"
-  schedule:
-    interval: weekly
-  open-pull-requests-limit: 10

.github/workflows/docker-tags.sh

@@ -0,0 +1,22 @@
+#!/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

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

@@ -0,0 +1,37 @@
+#####################################################
+### Copy platform specific binary
+FROM bash as copy-binary
+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/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
+RUN chmod +x /navidrome
+
+
+#####################################################
+### Build Final Image
+FROM alpine as release
+LABEL maintainer="deluan@navidrome.org"
+
+# Install ffmpeg and output build config
+RUN apk add --no-cache ffmpeg
+RUN ffmpeg -buildconf
+
+COPY --from=copy-binary /navidrome /app/
+
+VOLUME ["/data", "/music"]
+ENV ND_MUSICFOLDER /music
+ENV ND_DATAFOLDER /data
+ENV ND_PORT 4533
+ENV GODEBUG "asyncpreemptoff=1"
+
+EXPOSE ${ND_PORT}
+HEALTHCHECK CMD wget -O- http://localhost:${ND_PORT}/ping || exit 1
+WORKDIR /app
+
+ENTRYPOINT ["/app/navidrome"]

.github/workflows/pipeline.yml

@@ -1,4 +1,4 @@
-name: "Pipeline: Test, Lint, Build"
+name: Pipeline
 on:
   push:
     branches:
@@ -8,128 +8,87 @@ on:
   pull_request:
     branches:
       - master
-
-concurrency:
-  group: ${{ startsWith(github.ref, 'refs/tags/v') && 'tag' || 'branch' }}-${{ github.ref }}
-  cancel-in-progress: true
-
-env:
-  CROSS_TAGLIB_VERSION: "2.0.2-1"
-  IS_RELEASE: ${{ startsWith(github.ref, 'refs/tags/') && 'true' || 'false' }}
-
 jobs:
-  git-version:
-    name: Get version info
-    runs-on: ubuntu-latest
-    outputs:
-      git_tag: ${{ steps.git-version.outputs.GIT_TAG }}
-      git_sha: ${{ steps.git-version.outputs.GIT_SHA }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          fetch-tags: true
-
-      - name: Show git version info
-        run: |
-          echo "git describe (dirty): $(git describe --dirty --always --tags)"
-          echo "git describe --tags: $(git describe --tags `git rev-list --tags --max-count=1`)"
-          echo "git tag: $(git tag --sort=-committerdate | head -n 1)"
-          echo "github_ref: $GITHUB_REF"
-          echo "github_head_sha: ${{ github.event.pull_request.head.sha }}"
-          git tag -l
-      - name: Determine git current SHA and latest tag
-        id: git-version
-        run: |
-          GIT_TAG=$(git tag --sort=-committerdate | head -n 1)
-          if [ -n "$GIT_TAG" ]; then
-            if [[ "$GITHUB_REF" != refs/tags/* ]]; then
-              GIT_TAG=${GIT_TAG}-SNAPSHOT
-            fi
-            echo "GIT_TAG=$GIT_TAG" >> $GITHUB_OUTPUT
-          fi
-          GIT_SHA=$(git rev-parse --short HEAD)
-          PR_NUM=$(jq --raw-output .pull_request.number "$GITHUB_EVENT_PATH")
-          if [[ $PR_NUM != "null" ]]; then
-            GIT_SHA=$(echo "${{ github.event.pull_request.head.sha }}" | cut -c1-8)
-            GIT_SHA="pr-${PR_NUM}/${GIT_SHA}"
-          fi
-          echo "GIT_SHA=$GIT_SHA" >> $GITHUB_OUTPUT
-          
-          echo "GIT_TAG=$GIT_TAG"
-          echo "GIT_SHA=$GIT_SHA"
-
-  go-lint:
-    name: Lint Go code
+  golangci-lint:
+    name: Lint Server
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - name: Install taglib
+        run: sudo apt-get install libtag1-dev
 
-      - name: Download TagLib
-        uses: ./.github/actions/download-taglib
-        with:
-          version: ${{ env.CROSS_TAGLIB_VERSION }}
+      - uses: actions/checkout@v2
 
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v7
+        uses: golangci/golangci-lint-action@v2
         with:
-          version: latest
-          problem-matchers: true
+          version: v1.38
+          github-token: ${{ secrets.GITHUB_TOKEN }}
           args: --timeout 2m
 
-      - name: Run go goimports
-        run: go run golang.org/x/tools/cmd/goimports@latest -w `find . -name '*.go' | grep -v '_gen.go$'`
-      - run: go 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 "make format" and commit the changes'
-            exit 1
-          fi
-
   go:
-    name: Test Go code
+    name: Test Server with Go ${{ matrix.go_version }}
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go_version: [1.16.x]
     steps:
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v4
+      - name: Install taglib
+        run: sudo apt-get install libtag1-dev
 
-      - name: Download TagLib
-        uses: ./.github/actions/download-taglib
+      - name: Set up Go ${{ matrix.go_version }}
+        uses: actions/setup-go@v2
         with:
-          version: ${{ env.CROSS_TAGLIB_VERSION }}
+          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/cache@v2
+        id: cache-go
+        with:
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ matrix.go_version }}-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-${{ matrix.go_version }}-
 
       - name: Download dependencies
+        if: steps.cache-go.outputs.cache-hit != 'true'
+        continue-on-error: ${{contains(matrix.go_version, 'beta') || contains(matrix.go_version, 'rc')}}
         run: go mod download
 
       - name: Test
-        run: |
-          pkg-config --define-prefix --cflags --libs taglib # for debugging
-          go test -shuffle=on -tags netgo -race -cover ./... -v
-
+        continue-on-error: ${{contains(matrix.go_version, 'beta') || contains(matrix.go_version, 'rc')}}
+        run: go test -cover ./... -v
   js:
-    name: Test JS code
+    name: Build JS bundle
     runs-on: ubuntu-latest
     env:
-      NODE_OPTIONS: "--max_old_space_size=4096"
+      NODE_OPTIONS: '--max_old_space_size=4096'
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
         with:
-          node-version: 20
-          cache: "npm"
-          cache-dependency-path: "**/package-lock.json"
+          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-
 
       - name: npm install dependencies
         run: |
           cd ui
           npm ci
 
-      - name: npm lint
+      - name: npm check-formatting
         run: |
           cd ui
-          npm run check-formatting && npm run lint
+          npm run check-formatting
 
       - name: npm test
         run: |
@@ -141,289 +100,87 @@ jobs:
           cd ui
           npm run build
 
-  i18n-lint:
-    name: Lint i18n files
+      - uses: actions/upload-artifact@v2
+        with:
+          name: js-bundle
+          path: ui/build
+
+  binaries:
+    name: Binaries
+    needs: [js, go, golangci-lint]
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - run: |
-          set -e
-          for file in resources/i18n/*.json; do
-            echo "Validating $file"
-            if ! jq empty "$file" 2>error.log; then
-              error_message=$(cat error.log)
-              line_number=$(echo "$error_message" | grep -oP 'line \K[0-9]+')
-              echo "::error file=$file,line=$line_number::$error_message"
-              exit 1
-            fi
-          done
-
-  check-push-enabled:
-    name: Check Docker configuration
-    runs-on: ubuntu-latest
-    outputs:
-      is_enabled: ${{ steps.check.outputs.is_enabled }}
-    steps:
-      - name: Check if Docker push is configured
-        id: check
-        run: echo "is_enabled=${{ secrets.DOCKER_HUB_USERNAME != '' }}" >> $GITHUB_OUTPUT
-
-  build:
-    name: Build
-    needs: [js, go, go-lint, i18n-lint, git-version, check-push-enabled]
-    strategy:
-      matrix:
-        platform: [ linux/amd64, linux/arm64, linux/arm/v5, linux/arm/v6, linux/arm/v7, linux/386, darwin/amd64, darwin/arm64, windows/amd64, windows/386 ]
-    runs-on: ubuntu-latest
-    env:
-      IS_LINUX: ${{ startsWith(matrix.platform, 'linux/') && 'true' || 'false' }}
-      IS_ARMV5: ${{ matrix.platform == 'linux/arm/v5' && 'true' || 'false' }}
-      IS_DOCKER_PUSH_CONFIGURED: ${{ needs.check-push-enabled.outputs.is_enabled == 'true' }}
-      DOCKER_BUILD_SUMMARY: false
-      GIT_SHA: ${{ needs.git-version.outputs.git_sha }}
-      GIT_TAG: ${{ needs.git-version.outputs.git_tag }}
-    steps:
-      - name: Sanitize platform name
-        id: set-platform
-        run: |
-          PLATFORM=$(echo ${{ matrix.platform }} | tr '/' '_')
-          echo "PLATFORM=$PLATFORM" >> $GITHUB_ENV
-
-      - uses: actions/checkout@v4
-
-      - name: Prepare Docker Buildx
-        uses: ./.github/actions/prepare-docker
-        id: docker
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          hub_repository: ${{ vars.DOCKER_HUB_REPO }}
-          hub_username: ${{ secrets.DOCKER_HUB_USERNAME }}
-          hub_password: ${{ secrets.DOCKER_HUB_PASSWORD }}
-
-      - name: Build Binaries
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: Dockerfile
-          platforms: ${{ matrix.platform }}
-          outputs: |
-            type=local,dest=./output/${{ env.PLATFORM }}
-          target: binary
-          build-args: |
-            GIT_SHA=${{ env.GIT_SHA }}
-            GIT_TAG=${{ env.GIT_TAG }}
-            CROSS_TAGLIB_VERSION=${{ env.CROSS_TAGLIB_VERSION }}
-
-      - name: Upload Binaries
-        uses: actions/upload-artifact@v4
-        with:
-          name: navidrome-${{ env.PLATFORM }}
-          path: ./output
-          retention-days: 7
-
-      - name: Build and push image by digest
-        id: push-image
-        if: env.IS_LINUX == 'true' && env.IS_DOCKER_PUSH_CONFIGURED == 'true' && env.IS_ARMV5 == 'false'
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: Dockerfile
-          platforms: ${{ matrix.platform }}
-          labels: ${{ steps.docker.outputs.labels }}
-          build-args: |
-            GIT_SHA=${{ env.GIT_SHA }}
-            GIT_TAG=${{ env.GIT_TAG }}
-            CROSS_TAGLIB_VERSION=${{ env.CROSS_TAGLIB_VERSION }}
-          outputs: |
-            type=image,name=${{ steps.docker.outputs.hub_repository }},push-by-digest=true,name-canonical=true,push=${{ steps.docker.outputs.hub_enabled }}
-            type=image,name=ghcr.io/${{ github.repository }},push-by-digest=true,name-canonical=true,push=true
-
-      - name: Export digest
-        if: env.IS_LINUX == 'true' && env.IS_DOCKER_PUSH_CONFIGURED == 'true' && env.IS_ARMV5 == 'false'
-        run: |
-          mkdir -p /tmp/digests
-          digest="${{ steps.push-image.outputs.digest }}"
-          touch "/tmp/digests/${digest#sha256:}"          
-
-      - name: Upload digest
-        uses: actions/upload-artifact@v4
-        if: env.IS_LINUX == 'true' && env.IS_DOCKER_PUSH_CONFIGURED == 'true' && env.IS_ARMV5 == 'false'
-        with:
-          name: digests-${{ env.PLATFORM }}
-          path: /tmp/digests/*
-          if-no-files-found: error
-          retention-days: 1
-
-  push-manifest:
-    name: Push Docker manifest
-    runs-on: ubuntu-latest
-    needs: [build, check-push-enabled]
-    if: needs.check-push-enabled.outputs.is_enabled == 'true'
-    env:
-      REGISTRY_IMAGE: ghcr.io/${{ github.repository }}
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Download digests
-        uses: actions/download-artifact@v4
-        with:
-          path: /tmp/digests
-          pattern: digests-*
-          merge-multiple: true
-
-      - name: Prepare Docker Buildx
-        uses: ./.github/actions/prepare-docker
-        id: docker
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          hub_repository: ${{ vars.DOCKER_HUB_REPO }}
-          hub_username: ${{ secrets.DOCKER_HUB_USERNAME }}
-          hub_password: ${{ secrets.DOCKER_HUB_PASSWORD }}
-
-      - name: Create manifest list and push to ghcr.io
-        working-directory: /tmp/digests
-        run: |
-          docker buildx imagetools create $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-            $(printf '${{ env.REGISTRY_IMAGE }}@sha256:%s ' *)          
-
-      - name: Create manifest list and push to Docker Hub
-        working-directory: /tmp/digests
-        if: vars.DOCKER_HUB_REPO != ''
-        run: |
-          docker buildx imagetools create $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-            $(printf '${{ vars.DOCKER_HUB_REPO }}@sha256:%s ' *)          
-
-      - name: Inspect image in ghcr.io
-        run: |
-          docker buildx imagetools inspect ${{ env.REGISTRY_IMAGE }}:${{ steps.docker.outputs.version }}
-
-      - name: Inspect image in Docker Hub
-        if: vars.DOCKER_HUB_REPO != ''
-        run: |
-          docker buildx imagetools inspect ${{ vars.DOCKER_HUB_REPO }}:${{ steps.docker.outputs.version }}
-
-      - name: Delete unnecessary digest artifacts
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          for artifact in $(gh api repos/${{ github.repository }}/actions/artifacts | jq -r '.artifacts[] | select(.name | startswith("digests-")) | .id'); do
-            gh api --method DELETE repos/${{ github.repository }}/actions/artifacts/$artifact
-          done
-
-  msi:
-    name: Build Windows installers
-    needs: [build, git-version]
-    runs-on: ubuntu-24.04
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/download-artifact@v4
-        with:
-          path: ./binaries
-          pattern: navidrome-windows*
-          merge-multiple: true
-
-      - name: Install Wix
-        run: sudo apt-get install -y wixl jq
-
-      - name: Build MSI
-        env:
-          GIT_TAG: ${{ needs.git-version.outputs.git_tag }}
-        run: |
-          rm -rf binaries/msi
-          sudo GIT_TAG=$GIT_TAG release/wix/build_msi.sh ${GITHUB_WORKSPACE} 386
-          sudo GIT_TAG=$GIT_TAG release/wix/build_msi.sh ${GITHUB_WORKSPACE} amd64
-          du -h binaries/msi/*.msi
-
-      - name: Upload MSI files
-        uses: actions/upload-artifact@v4
-        with:
-          name: navidrome-windows-installers
-          path: binaries/msi/*.msi
-          retention-days: 7
-
-  release:
-    name: Package/Release
-    needs: [build, msi]
-    runs-on: ubuntu-latest
-    outputs:
-      package_list: ${{ steps.set-package-list.outputs.package_list }}
-    steps:
-      - uses: actions/checkout@v4
+      - name: Checkout Code
+        uses: actions/checkout@v2
         with:
           fetch-depth: 0
-          fetch-tags: true
 
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v2
         with:
-          path: ./binaries
-          pattern: navidrome-*
-          merge-multiple: true
+          name: js-bundle
+          path: ui/build
 
-      - run: ls -lR ./binaries
+      - name: Show Tags
+        run: git tag
 
-      - name: Set RELEASE_FLAGS for snapshot releases
-        if: env.IS_RELEASE == 'false'
-        run: echo 'RELEASE_FLAGS=--skip=publish --snapshot' >> $GITHUB_ENV
+      - name: Show Version
+        run: git describe --tags
 
-      - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v6
-        with:
-          version: '~> v2'
-          args: "release --clean -f release/goreleaser.yml ${{ env.RELEASE_FLAGS }}"
+      - name: Run GoReleaser - SNAPSHOT
+        if: startsWith(github.ref, 'refs/tags/') != true
+        uses: docker://deluan/ci-goreleaser:1.16.2-1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Remove build artifacts
-        run: |
-          ls -l ./dist
-          rm ./dist/*.tar.gz ./dist/*.zip
-
-      - name: Upload all-packages artifact
-        uses: actions/upload-artifact@v4
         with:
-          name: packages
-          path: dist/navidrome_0*
+          args: goreleaser release --rm-dist --skip-publish --snapshot
 
-      - id: set-package-list
-        name: Export list of generated packages
-        run: |
-          cd dist
-          set +x
-          ITEMS=$(ls navidrome_0* | sed 's/^navidrome_0[^_]*_linux_//' | jq -R -s -c 'split("\n")[:-1]')
-          echo $ITEMS
-          echo "package_list=${ITEMS}" >> $GITHUB_OUTPUT
+      - name: Run GoReleaser - RELEASE
+        if: startsWith(github.ref, 'refs/tags/')
+        uses: docker://deluan/ci-goreleaser:1.16.2-1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          args: goreleaser release --rm-dist
 
-  upload-packages:
-    name: Upload Linux PKG
+      - uses: actions/upload-artifact@v2
+        with:
+          name: binaries
+          path: |
+            dist
+            !dist/*.tar.gz
+            !dist/*.zip
+
+  docker:
+    name: Docker images
+    needs: [binaries]
     runs-on: ubuntu-latest
-    needs: [release]
-    strategy:
-      matrix:
-        item: ${{ fromJson(needs.release.outputs.package_list) }}
+    env:
+      DOCKER_IMAGE: ${{secrets.DOCKER_IMAGE}}
     steps:
-      - name: Download all-packages artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: packages
-          path: ./dist
+      - name: Set up QEMU
+        id: qemu
+        uses: docker/setup-qemu-action@v1
+        if: env.DOCKER_IMAGE != ''
 
-      - name: Upload all-packages artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: navidrome_linux_${{ matrix.item }}
-          path: dist/navidrome_0*_linux_${{ matrix.item }}
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v1
+        if: env.DOCKER_IMAGE != ''
 
-#  delete-artifacts:
-#    name: Delete unused artifacts
-#    runs-on: ubuntu-latest
-#    needs: [upload-packages]
-#    steps:
-#      - name: Delete all-packages artifact
-#        env:
-#          GH_TOKEN: ${{ github.token }}
-#        run: |
-#          for artifact in $(gh api repos/${{ github.repository }}/actions/artifacts | jq -r '.artifacts[] | select(.name | startswith("packages")) | .id'); do
-#            gh api --method DELETE repos/${{ github.repository }}/actions/artifacts/$artifact
-#          done
+      - uses: actions/checkout@v2
+        if: env.DOCKER_IMAGE != ''
+
+      - uses: actions/download-artifact@v2
+        if: env.DOCKER_IMAGE != ''
+        with:
+          name: binaries
+          path: dist
+
+      - name: Build the Docker image and push
+        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 .

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

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

@@ -1,56 +0,0 @@
-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@v5
-        with:
-          process-only: 'issues, prs'
-          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@v9
-        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.sh

@@ -1,93 +0,0 @@
-#!/bin/sh
-
-set -e
-
-I18N_DIR=resources/i18n
-
-# Function to process JSON: remove empty attributes and sort
-process_json() {
-  jq 'walk(if type == "object" then with_entries(select(.value != null and .value != "" and .value != [] and .value != {})) | to_entries | sort_by(.key) | from_entries else . end)' "$1"
-}
-
-# Function to check differences between local and remote translations
-check_lang_diff() {
-  filename=${I18N_DIR}/"$1".json
-  url=$(curl -s -X POST https://poeditor.com/api/ \
-    -d api_token="${POEDITOR_APIKEY}" \
-    -d action="export" \
-    -d id="${POEDITOR_PROJECTID}" \
-    -d language="$1" \
-    -d type="key_value_json" | jq -r .item)
-  if [ -z "$url" ]; then
-    echo "Failed to export $1"
-    return 1
-  fi
-  curl -sSL "$url" > poeditor.json
-
-  process_json "$filename" > "$filename".tmp
-  process_json poeditor.json > poeditor.tmp
-  
-  diff=$(diff -u "$filename".tmp poeditor.tmp) || true
-  if [ -n "$diff" ]; then
-    echo "$diff"
-    mv poeditor.json "$filename"
-  fi
-  
-  rm -f poeditor.json poeditor.tmp "$filename".tmp
-}
-
-# Function to get the list of languages
-get_language_list() {
-  response=$(curl -s -X POST https://api.poeditor.com/v2/languages/list \
-    -d api_token="${POEDITOR_APIKEY}" \
-    -d id="${POEDITOR_PROJECTID}")
-
-  echo $response
-}
-
-# Function to get the language name from the language code
-get_language_name() {
-  lang_code="$1"
-  lang_list="$2"
-
-  lang_name=$(echo "$lang_list" | jq -r ".result.languages[] | select(.code == \"$lang_code\") | .name")
-
-  if [ -z "$lang_name" ]; then
-    echo "Error: Language code '$lang_code' not found" >&2
-    return 1
-  fi
-
-  echo "$lang_name"
-}
-
-# Function to get the language code from the file path
-get_lang_code() {
-  filepath="$1"
-  # Extract just the filename
-  filename=$(basename "$filepath")
-
-  # Remove the extension
-  lang_code="${filename%.*}"
-
-  echo "$lang_code"
-}
-
-lang_list=$(get_language_list)
-
-# Check differences for each language
-for file in ${I18N_DIR}/*.json; do
-  code=$(get_lang_code "$file")
-  lang=$(jq -r .languageName < "$file")
-  lang_name=$(get_language_name "$code" "$lang_list")
-  echo "Downloading $lang_name - $lang ($code)"
-  check_lang_diff "$code"
-done
-
-# List changed languages to stderr
-languages=""
-for file in $(git diff --name-only --exit-code | grep json); do
-  lang_code=$(get_lang_code "$file")
-  lang_name=$(get_language_name "$lang_code" "$lang_list")
-  languages="${languages}$(echo "$lang_name" | tr -d '\n'), "
-done
-echo "${languages%??}" 1>&2

.github/workflows/update-translations.yml

@@ -1,33 +0,0 @@
-name: POEditor import
-on:
-  workflow_dispatch:
-  schedule:
-    - cron:  '0 10 * * *'
-jobs:
-  update-translations:
-    runs-on: ubuntu-latest
-    if: ${{ github.repository_owner == 'navidrome' }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: Get updated translations
-        id: poeditor
-        env:
-          POEDITOR_PROJECTID: ${{ secrets.POEDITOR_PROJECTID }}
-          POEDITOR_APIKEY: ${{ secrets.POEDITOR_APIKEY }}
-        run: |
-          .github/workflows/update-translations.sh 2> title.tmp
-          title=$(cat title.tmp)
-          echo "::set-output name=title::$title"
-          rm title.tmp
-      - name: Show changes, if any
-        run: |
-          git status --porcelain
-          git diff
-      - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v7
-        with:
-          token: ${{ secrets.PAT }}
-          author: "navidrome-bot <navidrome-bot@navidrome.org>"
-          commit-message: "fix(ui): update ${{ steps.poeditor.outputs.title }} translations from POEditor"
-          title: "fix(ui): update ${{ steps.poeditor.outputs.title }} translations from POEditor"
-          branch: update-translations

.gitignore

@@ -11,17 +11,15 @@ wiki
 TODO.md
 var
 navidrome.toml
-!release/linux/navidrome.toml
 master.zip
 testDB
-cache/*
+navidrome.db
 *.swp
+embedded_gen.go
 dist
 music
-*.db*
-.gitinfo
 docker-compose.yml
-!contrib/docker-compose.yml
-binaries
-navidrome-master
-*.exe
+navidrome.db-shm
+navidrome.db-wal
+tags
+

.golangci.yml

@@ -1,58 +1,29 @@
-version: "2"
-run:
-  build-tags:
-    - netgo
 linters:
   enable:
-    - asasalint
-    - asciicheck
-    - bidichk
     - bodyclose
-    - copyloopvar
+    - deadcode
     - dogsled
-    - durationcheck
-    - errorlint
-    - gocritic
+    - errcheck
     - gocyclo
+    - goimports
     - goprintffuncname
     - gosec
+    - gosimple
+    - govet
+    - ineffassign
+    - interfacer
     - misspell
-    - nakedret
-    - nilerr
     - rowserrcheck
-    - unconvert
-    - whitespace
-  disable:
     - staticcheck
-  settings:
-    gocritic:
-      disable-all: true
-      enabled-checks:
-        - deprecatedComment
-    gosec:
-      excludes:
-        - G501
-        - G401
-        - G505
-        - G115
-    govet:
-      enable:
-        - nilness
-  exclusions:
-    generated: lax
-    presets:
-      - comments
-      - common-false-positives
-      - legacy
-      - std-error-handling
-    paths:
-      - third_party$
-      - builtin$
-      - examples$
-formatters:
-  exclusions:
-    generated: lax
-    paths:
-      - third_party$
-      - builtin$
-      - examples$
+    - structcheck
+    - typecheck
+    - unconvert
+    - unused
+    - varcheck
+    - whitespace
+
+issues:
+  exclude-rules:
+    - linters:
+        - gosec
+      text: "(G501|G401|G505):"

.goreleaser.yml

@@ -0,0 +1,136 @@
+# GoReleaser config
+project_name: navidrome
+
+builds:
+  - id: navidrome_linux_amd64
+    env:
+      - CGO_ENABLED=1
+    goos:
+      - linux
+    goarch:
+      - amd64
+    flags:
+      - -tags=embed,netgo
+    ldflags:
+      - "-extldflags '-static -lz'"
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
+
+  - id: navidrome_linux_386
+    env:
+      - CGO_ENABLED=1
+    goos:
+      - linux
+    goarch:
+      - 386
+    flags:
+      - -tags=embed,netgo
+    ldflags:
+      - "-extldflags '-static'"
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
+
+  - id: navidrome_linux_arm
+    env:
+      - CGO_ENABLED=1
+      - CC=arm-linux-gnueabi-gcc
+      - CXX=arm-linux-gnueabi-g++
+    goos:
+      - linux
+    goarch:
+      - arm
+    goarm:
+      - 5
+      - 6
+      - 7
+    flags:
+      - -tags=embed,netgo
+    ldflags:
+      - "-extldflags '-static'"
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
+
+  - id: navidrome_linux_arm64
+    env:
+      - CGO_ENABLED=1
+      - CC=aarch64-linux-gnu-gcc
+      - CXX=aarch64-linux-gnu-g++
+    goos:
+      - linux
+    goarch:
+      - arm64
+    flags:
+      - -tags=embed,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
+    env:
+      - CGO_ENABLED=1
+      - CC=i686-w64-mingw32-gcc
+      - CXX=i686-w64-mingw32-g++
+      - PKG_CONFIG_PATH=/mingw32/lib/pkgconfig
+    goos:
+      - windows
+    goarch:
+      - 386
+    flags:
+      - -tags=embed,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
+    env:
+      - CGO_ENABLED=1
+      - CC=x86_64-w64-mingw32-gcc
+      - CXX=x86_64-w64-mingw32-g++
+      - PKG_CONFIG_PATH=/mingw64/lib/pkgconfig
+    goos:
+      - windows
+    goarch:
+      - amd64
+    flags:
+      - -tags=embed,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
+    env:
+      - CGO_ENABLED=1
+      - CC=o64-clang
+      - CXX=o64-clang++
+      - PKG_CONFIG_PATH=/darwin/lib/pkgconfig
+    goos:
+      - darwin
+    goarch:
+      - amd64
+    flags:
+      - -tags=embed,netgo
+    ldflags:
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
+
+archives:
+  - format_overrides:
+      - goos: windows
+        format: zip
+    replacements:
+      darwin: macOS
+      linux: Linux
+      windows: Windows
+      386: i386
+      amd64: x86_64
+
+checksum:
+  name_template: "{{ .ProjectName }}_checksums.txt"
+
+snapshot:
+  name_template: "{{ .Tag }}-SNAPSHOT"
+
+release:
+  draft: true
+
+changelog:
+  # sort: asc
+  filters:
+    exclude:
+      - "^docs:"

.nvmrc

@@ -1 +1 @@
-v20
+v14

CONTRIBUTING.md

@@ -1,93 +0,0 @@
-# Navidrome Contribution Guide
-
-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)
-- [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. 
-
-**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)**
-
-## 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)
-- Ensure that there is no open or closed Pull Request corresponding to your submission to avoid duplication of effort.
-- Setup the [development environment](https://www.navidrome.org/docs/developers/dev-environment/)
-- Create a new branch on your forked repo and make the changes in it. Naming conventions for branch are: `<Issue Title>/<Issue Number>`. Example:
-```
-    git checkout -b adding-docs/834 master
-```
-- The commits should follow a [specific convention](#commit-conventions)
-- Ensure that a DCO sign-off for commits is provided via `--signoff` option of git commit
-- Provide a link to the issue that will be closed via your Pull request.
-
-### Commit Conventions
-Each commit message must adhere to the following format:
-```
-<type>(scope): <description> - <issue number>
-
-[optional body]
-```
-This improves the readability of the messages
-
-#### Type
-It can be one of the following:
-1. **feat**: Addition of a new feature
-2. **fix**: Bug fix
-3. **sec**: Fixing security issues
-4. **docs**: Documentation Changes
-5. **style**: Changes to styling
-6. **refactor**: Refactoring of code
-7. **perf**: Code that affects performance
-8. **test**: Updating or improving the current tests
-9. **build**: Changes to Build process
-10. **revert**: Reverting to a previous commit
-11. **chore** : updating grunt tasks etc
-
-If there is a breaking change in your Pull Request, please add `BREAKING CHANGE` in the optional body section
-
-#### Scope
-The file or folder where the changes are made. If there are more than one, you can mention any
-
-#### Description
-A short description of the issue
-
-#### Issue number
-The issue fixed by this Pull Request.
-
-The body is optional. It may contain short description of changes made.
-
-Following all the guidelines an ideal commit will look like:
-```
-    git commit --signoff -m "feat(themes): New-theme - #834"
-```
-
-After committing, push your commits to your forked branch and create a Pull Request from there.
-The Pull Request Title can be the same as `<type>(scope): <description> - <issue number>`
-A demo layout of how the Pull request body can look:
-```
-Closes <Issue number along with link>
-
-Description (What does the pull request do)
-
-Changes (What changes were made )
-
-Screenshots or Videos
-
-Related Issues and Pull Requests(if any)
-
-```

Dockerfile

@@ -1,145 +0,0 @@
-FROM --platform=$BUILDPLATFORM ghcr.io/crazy-max/osxcross:14.5-debian AS osxcross
-
-########################################################################################################################
-### Build xx (orignal image: tonistiigi/xx)
-FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/alpine:3.21 AS xx-build
-
-# v1.5.0
-ENV XX_VERSION=b4e4c451c778822e6742bfc9d9a91d7c7d885c8a
-
-RUN apk add -U --no-cache git
-RUN git clone https://github.com/tonistiigi/xx && \
-    cd xx && \
-    git checkout ${XX_VERSION} && \
-    mkdir -p /out && \
-    cp src/xx-* /out/
-
-RUN cd /out && \
-    ln -s xx-cc /out/xx-clang && \
-    ln -s xx-cc /out/xx-clang++ && \
-    ln -s xx-cc /out/xx-c++ && \
-    ln -s xx-apt /out/xx-apt-get
-
-# xx mimics the original tonistiigi/xx image
-FROM scratch AS xx
-COPY --from=xx-build /out/ /usr/bin/
-
-########################################################################################################################
-### Get TagLib
-FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/alpine:3.21 AS taglib-build
-ARG TARGETPLATFORM
-ARG CROSS_TAGLIB_VERSION=2.0.2-1
-ENV CROSS_TAGLIB_RELEASES_URL=https://github.com/navidrome/cross-taglib/releases/download/v${CROSS_TAGLIB_VERSION}/
-
-RUN <<EOT
-    PLATFORM=$(echo ${TARGETPLATFORM} | tr '/' '-')
-    FILE=taglib-${PLATFORM}.tar.gz
-
-    DOWNLOAD_URL=${CROSS_TAGLIB_RELEASES_URL}${FILE}
-    wget ${DOWNLOAD_URL}
-
-    mkdir /taglib
-    tar -xzf ${FILE} -C /taglib
-EOT
-
-########################################################################################################################
-### Build Navidrome UI
-FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/node:lts-alpine AS ui
-WORKDIR /app
-
-# Install node dependencies
-COPY ui/package.json ui/package-lock.json ./
-COPY ui/bin/ ./bin/
-RUN npm ci
-
-# Build bundle
-COPY ui/ ./
-RUN npm run build -- --outDir=/build
-
-FROM scratch AS ui-bundle
-COPY --from=ui /build /build
-
-########################################################################################################################
-### Build Navidrome binary
-FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.24-bookworm AS base
-RUN apt-get update && apt-get install -y clang lld
-COPY --from=xx / /
-WORKDIR /workspace
-
-FROM --platform=$BUILDPLATFORM base AS build
-
-# Install build dependencies for the target platform
-ARG TARGETPLATFORM
-
-RUN xx-apt install -y binutils gcc g++ libc6-dev zlib1g-dev
-RUN xx-verify --setup
-
-RUN --mount=type=bind,source=. \
-    --mount=type=cache,target=/root/.cache \
-    --mount=type=cache,target=/go/pkg/mod \
-    go mod download
-
-ARG GIT_SHA
-ARG GIT_TAG
-
-RUN --mount=type=bind,source=. \
-    --mount=from=ui,source=/build,target=./ui/build,ro \
-    --mount=from=osxcross,src=/osxcross/SDK,target=/xx-sdk,ro \
-    --mount=type=cache,target=/root/.cache \
-    --mount=type=cache,target=/go/pkg/mod \
-    --mount=from=taglib-build,target=/taglib,src=/taglib,ro <<EOT
-
-    # Setup CGO cross-compilation environment
-    xx-go --wrap
-    export CGO_ENABLED=1
-    export PKG_CONFIG_PATH=/taglib/lib/pkgconfig
-    cat $(go env GOENV)
-
-    # Only Darwin (macOS) requires clang (default), Windows requires gcc, everything else can use any compiler.
-    # So let's use gcc for everything except Darwin.
-    if [ "$(xx-info os)" != "darwin" ]; then
-        export CC=$(xx-info)-gcc
-        export CXX=$(xx-info)-g++
-        export LD_EXTRA="-extldflags '-static -latomic'"
-    fi
-    if [ "$(xx-info os)" = "windows" ]; then
-        export EXT=".exe"
-    fi
-
-    go build -tags=netgo -ldflags="${LD_EXTRA} -w -s \
-        -X github.com/navidrome/navidrome/consts.gitSha=${GIT_SHA} \
-        -X github.com/navidrome/navidrome/consts.gitTag=${GIT_TAG}" \
-        -o /out/navidrome${EXT} .
-EOT
-
-# Verify if the binary was built for the correct platform and it is statically linked
-RUN xx-verify --static /out/navidrome*
-
-FROM scratch AS binary
-COPY --from=build /out /
-
-########################################################################################################################
-### Build Final Image
-FROM public.ecr.aws/docker/library/alpine:3.21 AS final
-LABEL maintainer="deluan@navidrome.org"
-LABEL org.opencontainers.image.source="https://github.com/navidrome/navidrome"
-
-# Install ffmpeg and mpv
-RUN apk add -U --no-cache ffmpeg mpv sqlite
-
-# Copy navidrome binary
-COPY --from=build /out/navidrome /app/
-
-VOLUME ["/data", "/music"]
-ENV ND_MUSICFOLDER=/music
-ENV ND_DATAFOLDER=/data
-ENV ND_CONFIGFILE=/data/navidrome.toml
-ENV ND_PORT=4533
-ENV GODEBUG="asyncpreemptoff=1"
-RUN touch /.nddockerenv
-
-EXPOSE ${ND_PORT}
-WORKDIR /app
-
-ENTRYPOINT ["/app/navidrome"]
-

Makefile

@@ -1,177 +1,118 @@
 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`)-SNAPSHOT
-else
-GIT_SHA=source_archive
-GIT_TAG=$(patsubst navidrome-%,v%,$(notdir $(PWD)))-SNAPSHOT
-endif
+GIT_TAG=$(shell git describe --tags `git rev-list --tags --max-count=1`)
 
-SUPPORTED_PLATFORMS ?= linux/amd64,linux/arm64,linux/arm/v5,linux/arm/v6,linux/arm/v7,linux/386,darwin/amd64,darwin/arm64,windows/amd64,windows/386
-IMAGE_PLATFORMS ?= $(shell echo $(SUPPORTED_PLATFORMS) | tr ',' '\n' | grep "linux" | grep -v "arm/v5" | tr '\n' ',' | sed 's/,$$//')
-PLATFORMS ?= $(SUPPORTED_PLATFORMS)
-DOCKER_TAG ?= deluan/navidrome:develop
+## 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
 
-# Taglib version to use in cross-compilation, from https://github.com/navidrome/cross-taglib
-CROSS_TAGLIB_VERSION ?= 2.0.2-1
-
-UI_SRC_FILES := $(shell find ui -type f -not -path "ui/build/*" -not -path "ui/node_modules/*")
-
-setup: check_env download-deps 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
-	ND_ENABLEINSIGHTSCOLLECTOR="false" npx foreman -j Procfile.dev -p 4533 start
+dev: check_dev_env
+	npx foreman -j Procfile.dev -p 4533 start
 .PHONY: dev
 
-server: check_go_env buildjs ##@Development Start the backend in development mode
-	@ND_ENABLEINSIGHTSCOLLECTOR="false" go tool reflex -d none -c reflex.conf
+server: check_go_dev_env
+	@go run github.com/cespare/reflex -d none -c reflex.conf
 .PHONY: server
 
-watch: ##@Development Start Go tests in watch mode (re-run when code changes)
-	go tool ginkgo watch -tags=netgo -notify ./...
-.PHONY: watch
-
-test: ##@Development Run Go tests
-	go test -tags netgo ./...
-.PHONY: test
-
-testrace: ##@Development Run Go tests with race detector
-	go test -tags netgo -race -shuffle=on ./...
-.PHONY: test
-
-testall: testrace ##@Development Run Go and JS tests
-	@(cd ./ui && npm run test:ci)
-.PHONY: testall
-
-lint: ##@Development Lint Go code
-	go run github.com/golangci/golangci-lint/v2/cmd/golangci-lint@latest run -v --timeout 5m
-.PHONY: lint
-
-lintall: lint ##@Development Lint Go and JS code
-	@(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
-
-format: ##@Development Format code
-	@(cd ./ui && npm run prettier)
-	@go tool goimports -w `find . -name '*.go' | grep -v _gen.go$$`
-	@go mod tidy
-.PHONY: format
-
-wire: check_go_env ##@Development Update Dependency Injection
-	go tool wire gen -tags=netgo ./...
+wire: check_go_env
+	go run github.com/google/wire/cmd/wire ./...
 .PHONY: wire
 
-snapshots: ##@Development Update (GoLang) Snapshot tests
-	UPDATE_SNAPSHOTS=true go tool ginkgo ./server/subsonic/responses/...
-.PHONY: snapshots
+watch: check_go_env
+	go run github.com/onsi/ginkgo/ginkgo watch -notify ./...
+.PHONY: watch
 
-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/migrations create ${name} sql
+test: check_go_env
+	go test ./... -v
+.PHONY: test
+
+testall: check_go_env test
+	@(cd ./ui && npm test -- --watchAll=false)
+.PHONY: testall
+
+lint:
+	go run github.com/golangci/golangci-lint/cmd/golangci-lint run -v
+.PHONY: lint
+
+update-snapshots: check_go_env
+	UPDATE_SNAPSHOTS=true go run github.com/onsi/ginkgo/ginkgo ./server/subsonic/...
+.PHONY: update-snapshots
+
+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}
 .PHONY: migration
 
-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/migrations create ${name}
-.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
 
-setup-dev: setup
+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
 .PHONY: setup-dev
 
-setup-git: ##@Development Setup Git hooks (pre-commit and pre-push)
+setup-git:
 	@echo Setting up git hooks
 	@mkdir -p .git/hooks
 	@(cd .git/hooks && ln -sf ../../git/* .)
 .PHONY: setup-git
 
-build: check_go_env buildjs ##@Build Build the project
-	go build -ldflags="-X github.com/navidrome/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/navidrome/navidrome/consts.gitTag=$(GIT_TAG)" -tags=netgo
+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: deprecated 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
 .PHONY: buildall
 
-debug-build: check_go_env buildjs ##@Build Build the project (with remote debug on)
-	go build -gcflags="all=-N -l" -ldflags="-X github.com/navidrome/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/navidrome/navidrome/consts.gitTag=$(GIT_TAG)" -tags=netgo
-.PHONY: debug-build
-
-buildjs: check_node_env ui/build/index.html ##@Build Build only frontend
-.PHONY: buildjs
-
-docker-buildjs: ##@Build Build only frontend using Docker
-	docker build --output "./ui" --target ui-bundle .
-.PHONY: docker-buildjs
-
-ui/build/index.html: $(UI_SRC_FILES)
-	@(cd ./ui && npm run build)
-
-docker-platforms: ##@Cross_Compilation List supported platforms
-	@echo "Supported platforms:"
-	@echo "$(SUPPORTED_PLATFORMS)" | tr ',' '\n' | sort | sed 's/^/    /'
-	@echo "\nUsage: make PLATFORMS=\"linux/amd64\" docker-build"
-	@echo "       make IMAGE_PLATFORMS=\"linux/amd64\" docker-image"
-.PHONY: docker-platforms
-
-docker-build: ##@Cross_Compilation Cross-compile for any supported platform (check `make docker-platforms`)
-	docker buildx build \
-		--platform $(PLATFORMS) \
-		--build-arg GIT_TAG=${GIT_TAG} \
-		--build-arg GIT_SHA=${GIT_SHA} \
-		--build-arg CROSS_TAGLIB_VERSION=${CROSS_TAGLIB_VERSION} \
-		--output "./binaries" --target binary .
-.PHONY: docker-build
-
-docker-image: ##@Cross_Compilation Build Docker image, tagged as `deluan/navidrome:develop`, override with DOCKER_TAG var. Use IMAGE_PLATFORMS to specify target platforms
-	@echo $(IMAGE_PLATFORMS) | grep -q "windows" && echo "ERROR: Windows is not supported for Docker builds" && exit 1 || true
-	@echo $(IMAGE_PLATFORMS) | grep -q "darwin" && echo "ERROR: macOS is not supported for Docker builds" && exit 1 || true
-	@echo $(IMAGE_PLATFORMS) | grep -q "arm/v5" && echo "ERROR: Linux ARMv5 is not supported for Docker builds" && exit 1 || true
-	docker buildx build \
-		--platform $(IMAGE_PLATFORMS) \
-		--build-arg GIT_TAG=${GIT_TAG} \
-		--build-arg GIT_SHA=${GIT_SHA} \
-		--build-arg CROSS_TAGLIB_VERSION=${CROSS_TAGLIB_VERSION} \
-		--tag $(DOCKER_TAG) .
-.PHONY: docker-image
-
-docker-msi: ##@Cross_Compilation Build MSI installer for Windows
-	make docker-build PLATFORMS=windows/386,windows/amd64
-	DOCKER_CLI_HINTS=false docker build -q -t navidrome-msi-builder -f release/wix/msitools.dockerfile .
-	@rm -rf binaries/msi
-	docker run -it --rm -v $(PWD):/workspace -v $(PWD)/binaries:/workspace/binaries -e GIT_TAG=${GIT_TAG} \
-		navidrome-msi-builder sh -c "release/wix/build_msi.sh /workspace 386 && release/wix/build_msi.sh /workspace amd64"
-	@du -h binaries/msi/*.msi
-.PHONY: docker-msi
-
-package: docker-build ##@Cross_Compilation Create binaries and packages for ALL supported platforms
-	@if [ -z `which goreleaser` ]; then echo "Please install goreleaser first: https://goreleaser.com/install/"; exit 1; fi
-	goreleaser release -f release/goreleaser.yml --clean --skip=publish --snapshot
-.PHONY: package
-
-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=dev_download&id=b376eeb4652d2498aa2b25ba0696725e" > back_on_earth.zip; \
-	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=e49c609b542fc51899ee8b53aa858cb4" > ugress.zip; \
-	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=350bcab3a4c1d93869e39ce496464f03" > voodoocuts.zip; \
-	for file in *.zip; do unzip -n $${file}; done )
-	@echo "Done. Remember to set your MusicFolder to ./music"
-.PHONY: get-music
-
-
-##########################################
-#### Miscellaneous
-
-clean:
-	@rm -rf ./binaries ./dist ./ui/build/*
-	@touch ./ui/build/.gitkeep
-.PHONY: clean
+pre-push: lint test
+.PHONY: pre-push
 
 release:
 	@if [[ ! "${V}" =~ ^[0-9]+\.[0-9]+\.[0-9]+.*$$ ]]; then echo "Usage: make release V=X.X.X"; exit 1; fi
@@ -182,48 +123,6 @@ release:
 	git push origin v${V} --no-verify
 .PHONY: release
 
-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
-
-deprecated:
-	@echo "WARNING: This target is deprecated and will be removed in future releases. Use 'make build' instead."
-.PHONY: deprecated
-
-.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)
+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

Procfile.dev

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

README.md

@@ -1,26 +1,18 @@
-<a href="https://www.navidrome.org"><img src="resources/logo-192x192.png" alt="Navidrome logo" title="navidrome" align="right" height="60px" /></a>
+# Navidrome Music Server
 
-# 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)
-[![Gurubase](https://img.shields.io/badge/Gurubase-Ask%20Navidrome%20Guru-006BFF?style=flat-square)](https://gurubase.io/g/navidrome)
-
-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.
+[![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/)
+[![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 
+music collection from any browser or mobile device. It's like your personal Spotify!
+
 __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 
@@ -31,15 +23,7 @@ please file a [GitHub issue](https://github.com/navidrome/navidrome/issues) or j
 
 ## 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)
+See instructions in the [project's website](https://www.navidrome.org/docs/installation/)
 
 ## Features
  
@@ -57,15 +41,6 @@ A share of the revenue helps fund the development of Navidrome at no additional
  - **Transcoding** on the fly. Can be set per user/player. **Opus encoding is supported**
  - Translated to **various languages**
 
-## Translations
-
-Navidrome uses [POEditor](https://poeditor.com/) for translations, and we are always looking 
-for [more contributors](https://www.navidrome.org/docs/developers/translations/)
-
-<a href="https://poeditor.com/"> 
-<img height="32" src="https://github.com/user-attachments/assets/c19b1d2b-01e1-4682-a007-12356c42147c">
-</a>
-
 ## Documentation
 All documentation can be found in the project's website: https://www.navidrome.org/docs. 
 Here are some useful direct links:

adapters/taglib/end_to_end_test.go

@@ -1,154 +0,0 @@
-package taglib
-
-import (
-	"io/fs"
-	"os"
-	"time"
-
-	"github.com/djherbis/times"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/model/metadata"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-type testFileInfo struct {
-	fs.FileInfo
-}
-
-func (t testFileInfo) BirthTime() time.Time {
-	if ts := times.Get(t.FileInfo); ts.HasBirthTime() {
-		return ts.BirthTime()
-	}
-	return t.FileInfo.ModTime()
-}
-
-var _ = Describe("Extractor", func() {
-	toP := func(name, sortName, mbid string) model.Participant {
-		return model.Participant{
-			Artist: model.Artist{Name: name, SortArtistName: sortName, MbzArtistID: mbid},
-		}
-	}
-
-	roles := []struct {
-		model.Role
-		model.ParticipantList
-	}{
-		{model.RoleComposer, model.ParticipantList{
-			toP("coma a", "a, coma", "bf13b584-f27c-43db-8f42-32898d33d4e2"),
-			toP("comb", "comb", "924039a2-09c6-4d29-9b4f-50cc54447d36"),
-		}},
-		{model.RoleLyricist, model.ParticipantList{
-			toP("la a", "a, la", "c84f648f-68a6-40a2-a0cb-d135b25da3c2"),
-			toP("lb", "lb", "0a7c582d-143a-4540-b4e9-77200835af65"),
-		}},
-		{model.RoleArranger, model.ParticipantList{
-			toP("aa", "", "4605a1d4-8d15-42a3-bd00-9c20e42f71e6"),
-			toP("ab", "", "002f0ff8-77bf-42cc-8216-61a9c43dc145"),
-		}},
-		{model.RoleConductor, model.ParticipantList{
-			toP("cona", "", "af86879b-2141-42af-bad2-389a4dc91489"),
-			toP("conb", "", "3dfa3c70-d7d3-4b97-b953-c298dd305e12"),
-		}},
-		{model.RoleDirector, model.ParticipantList{
-			toP("dia", "", "f943187f-73de-4794-be47-88c66f0fd0f4"),
-			toP("dib", "", "bceb75da-1853-4b3d-b399-b27f0cafc389"),
-		}},
-		{model.RoleEngineer, model.ParticipantList{
-			toP("ea", "", "f634bf6d-d66a-425d-888a-28ad39392759"),
-			toP("eb", "", "243d64ae-d514-44e1-901a-b918d692baee"),
-		}},
-		{model.RoleProducer, model.ParticipantList{
-			toP("pra", "", "d971c8d7-999c-4a5f-ac31-719721ab35d6"),
-			toP("prb", "", "f0a09070-9324-434f-a599-6d25ded87b69"),
-		}},
-		{model.RoleRemixer, model.ParticipantList{
-			toP("ra", "", "c7dc6095-9534-4c72-87cc-aea0103462cf"),
-			toP("rb", "", "8ebeef51-c08c-4736-992f-c37870becedd"),
-		}},
-		{model.RoleDJMixer, model.ParticipantList{
-			toP("dja", "", "d063f13b-7589-4efc-ab7f-c60e6db17247"),
-			toP("djb", "", "3636670c-385f-4212-89c8-0ff51d6bc456"),
-		}},
-		{model.RoleMixer, model.ParticipantList{
-			toP("ma", "", "53fb5a2d-7016-427e-a563-d91819a5f35a"),
-			toP("mb", "", "64c13e65-f0da-4ab9-a300-71ee53b0376a"),
-		}},
-	}
-
-	var e *extractor
-
-	BeforeEach(func() {
-		e = &extractor{}
-	})
-
-	Describe("Participants", func() {
-		DescribeTable("test tags consistent across formats", func(format string) {
-			path := "tests/fixtures/test." + format
-			mds, err := e.Parse(path)
-			Expect(err).ToNot(HaveOccurred())
-
-			info := mds[path]
-			fileInfo, _ := os.Stat(path)
-			info.FileInfo = testFileInfo{FileInfo: fileInfo}
-
-			metadata := metadata.New(path, info)
-			mf := metadata.ToMediaFile(1, "folderID")
-
-			for _, data := range roles {
-				role := data.Role
-				artists := data.ParticipantList
-
-				actual := mf.Participants[role]
-				Expect(actual).To(HaveLen(len(artists)))
-
-				for i := range artists {
-					actualArtist := actual[i]
-					expectedArtist := artists[i]
-
-					Expect(actualArtist.Name).To(Equal(expectedArtist.Name))
-					Expect(actualArtist.SortArtistName).To(Equal(expectedArtist.SortArtistName))
-					Expect(actualArtist.MbzArtistID).To(Equal(expectedArtist.MbzArtistID))
-				}
-			}
-
-			if format != "m4a" {
-				performers := mf.Participants[model.RolePerformer]
-				Expect(performers).To(HaveLen(8))
-
-				rules := map[string][]string{
-					"pgaa": {"2fd0b311-9fa8-4ff9-be5d-f6f3d16b835e", "Guitar"},
-					"pgbb": {"223d030b-bf97-4c2a-ad26-b7f7bbe25c93", "Guitar", ""},
-					"pvaa": {"cb195f72-448f-41c8-b962-3f3c13d09d38", "Vocals"},
-					"pvbb": {"60a1f832-8ca2-49f6-8660-84d57f07b520", "Vocals", "Flute"},
-					"pfaa": {"51fb40c-0305-4bf9-a11b-2ee615277725", "", "Flute"},
-				}
-
-				for name, rule := range rules {
-					mbid := rule[0]
-					for i := 1; i < len(rule); i++ {
-						found := false
-
-						for _, mapped := range performers {
-							if mapped.Name == name && mapped.MbzArtistID == mbid && mapped.SubRole == rule[i] {
-								found = true
-								break
-							}
-						}
-
-						Expect(found).To(BeTrue(), "Could not find matching artist")
-					}
-				}
-			}
-		},
-			Entry("FLAC format", "flac"),
-			Entry("M4a format", "m4a"),
-			Entry("OGG format", "ogg"),
-			Entry("WMA format", "wv"),
-
-			Entry("MP3 format", "mp3"),
-			Entry("WAV format", "wav"),
-			Entry("AIFF format", "aiff"),
-		)
-	})
-})

adapters/taglib/get_filename.go

@@ -1,9 +0,0 @@
-//go:build !windows
-
-package taglib
-
-import "C"
-
-func getFilename(s string) *C.char {
-	return C.CString(s)
-}

adapters/taglib/get_filename_win.go

@@ -1,96 +0,0 @@
-//go:build windows
-
-package taglib
-
-// From https://github.com/orofarne/gowchar
-
-/*
-#include <wchar.h>
-
-const size_t SIZEOF_WCHAR_T = sizeof(wchar_t);
-
-void gowchar_set (wchar_t *arr, int pos, wchar_t val)
-{
-	arr[pos] = val;
-}
-
-wchar_t gowchar_get (wchar_t *arr, int pos)
-{
-	return arr[pos];
-}
-*/
-import "C"
-
-import (
-	"fmt"
-	"unicode/utf16"
-	"unicode/utf8"
-)
-
-var SIZEOF_WCHAR_T C.size_t = C.size_t(C.SIZEOF_WCHAR_T)
-
-func getFilename(s string) *C.wchar_t {
-	wstr, _ := StringToWcharT(s)
-	return wstr
-}
-
-func StringToWcharT(s string) (*C.wchar_t, C.size_t) {
-	switch SIZEOF_WCHAR_T {
-	case 2:
-		return stringToWchar2(s) // Windows
-	case 4:
-		return stringToWchar4(s) // Unix
-	default:
-		panic(fmt.Sprintf("Invalid sizeof(wchar_t) = %v", SIZEOF_WCHAR_T))
-	}
-	panic("?!!")
-}
-
-// Windows
-func stringToWchar2(s string) (*C.wchar_t, C.size_t) {
-	var slen int
-	s1 := s
-	for len(s1) > 0 {
-		r, size := utf8.DecodeRuneInString(s1)
-		if er, _ := utf16.EncodeRune(r); er == '\uFFFD' {
-			slen += 1
-		} else {
-			slen += 2
-		}
-		s1 = s1[size:]
-	}
-	slen++ // \0
-	res := C.malloc(C.size_t(slen) * SIZEOF_WCHAR_T)
-	var i int
-	for len(s) > 0 {
-		r, size := utf8.DecodeRuneInString(s)
-		if r1, r2 := utf16.EncodeRune(r); r1 != '\uFFFD' {
-			C.gowchar_set((*C.wchar_t)(res), C.int(i), C.wchar_t(r1))
-			i++
-			C.gowchar_set((*C.wchar_t)(res), C.int(i), C.wchar_t(r2))
-			i++
-		} else {
-			C.gowchar_set((*C.wchar_t)(res), C.int(i), C.wchar_t(r))
-			i++
-		}
-		s = s[size:]
-	}
-	C.gowchar_set((*C.wchar_t)(res), C.int(slen-1), C.wchar_t(0)) // \0
-	return (*C.wchar_t)(res), C.size_t(slen)
-}
-
-// Unix
-func stringToWchar4(s string) (*C.wchar_t, C.size_t) {
-	slen := utf8.RuneCountInString(s)
-	slen++ // \0
-	res := C.malloc(C.size_t(slen) * SIZEOF_WCHAR_T)
-	var i int
-	for len(s) > 0 {
-		r, size := utf8.DecodeRuneInString(s)
-		C.gowchar_set((*C.wchar_t)(res), C.int(i), C.wchar_t(r))
-		s = s[size:]
-		i++
-	}
-	C.gowchar_set((*C.wchar_t)(res), C.int(slen-1), C.wchar_t(0)) // \0
-	return (*C.wchar_t)(res), C.size_t(slen)
-}

adapters/taglib/taglib.go

@@ -1,151 +0,0 @@
-package taglib
-
-import (
-	"io/fs"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/navidrome/navidrome/core/storage/local"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model/metadata"
-)
-
-type extractor struct {
-	baseDir string
-}
-
-func (e extractor) Parse(files ...string) (map[string]metadata.Info, error) {
-	results := make(map[string]metadata.Info)
-	for _, path := range files {
-		props, err := e.extractMetadata(path)
-		if err != nil {
-			continue
-		}
-		results[path] = *props
-	}
-	return results, nil
-}
-
-func (e extractor) Version() string {
-	return Version()
-}
-
-func (e extractor) extractMetadata(filePath string) (*metadata.Info, error) {
-	fullPath := filepath.Join(e.baseDir, filePath)
-	tags, err := Read(fullPath)
-	if err != nil {
-		log.Warn("extractor: Error reading metadata from file. Skipping", "filePath", fullPath, err)
-		return nil, err
-	}
-
-	// Parse audio properties
-	ap := metadata.AudioProperties{}
-	if length, ok := tags["_lengthinmilliseconds"]; ok && len(length) > 0 {
-		millis, _ := strconv.Atoi(length[0])
-		if millis > 0 {
-			ap.Duration = (time.Millisecond * time.Duration(millis)).Round(time.Millisecond * 10)
-		}
-		delete(tags, "_lengthinmilliseconds")
-	}
-	parseProp := func(prop string, target *int) {
-		if value, ok := tags[prop]; ok && len(value) > 0 {
-			*target, _ = strconv.Atoi(value[0])
-			delete(tags, prop)
-		}
-	}
-	parseProp("_bitrate", &ap.BitRate)
-	parseProp("_channels", &ap.Channels)
-	parseProp("_samplerate", &ap.SampleRate)
-	parseProp("_bitspersample", &ap.BitDepth)
-
-	// Parse track/disc totals
-	parseTuple := func(prop string) {
-		tagName := prop + "number"
-		tagTotal := prop + "total"
-		if value, ok := tags[tagName]; ok && len(value) > 0 {
-			parts := strings.Split(value[0], "/")
-			tags[tagName] = []string{parts[0]}
-			if len(parts) == 2 {
-				tags[tagTotal] = []string{parts[1]}
-			}
-		}
-	}
-	parseTuple("track")
-	parseTuple("disc")
-
-	// Adjust some ID3 tags
-	parseLyrics(tags)
-	parseTIPL(tags)
-	delete(tags, "tmcl") // TMCL is already parsed by TagLib
-
-	return &metadata.Info{
-		Tags:            tags,
-		AudioProperties: ap,
-		HasPicture:      tags["has_picture"] != nil && len(tags["has_picture"]) > 0 && tags["has_picture"][0] == "true",
-	}, nil
-}
-
-// parseLyrics make sure lyrics tags have language
-func parseLyrics(tags map[string][]string) {
-	lyrics := tags["lyrics"]
-	if len(lyrics) > 0 {
-		tags["lyrics:xxx"] = lyrics
-		delete(tags, "lyrics")
-	}
-}
-
-// These are the only roles we support, based on Picard's tag map:
-// https://picard-docs.musicbrainz.org/downloads/MusicBrainz_Picard_Tag_Map.html
-var tiplMapping = map[string]string{
-	"arranger": "arranger",
-	"engineer": "engineer",
-	"producer": "producer",
-	"mix":      "mixer",
-	"DJ-mix":   "djmixer",
-}
-
-// parseTIPL parses the ID3v2.4 TIPL frame string, which is received from TagLib in the format:
-//
-//	"arranger Andrew Powell engineer Chris Blair engineer Pat Stapley producer Eric Woolfson".
-//
-// and breaks it down into a map of roles and names, e.g.:
-//
-//	{"arranger": ["Andrew Powell"], "engineer": ["Chris Blair", "Pat Stapley"], "producer": ["Eric Woolfson"]}.
-func parseTIPL(tags map[string][]string) {
-	tipl := tags["tipl"]
-	if len(tipl) == 0 {
-		return
-	}
-
-	addRole := func(currentRole string, currentValue []string) {
-		if currentRole != "" && len(currentValue) > 0 {
-			role := tiplMapping[currentRole]
-			tags[role] = append(tags[role], strings.Join(currentValue, " "))
-		}
-	}
-
-	var currentRole string
-	var currentValue []string
-	for _, part := range strings.Split(tipl[0], " ") {
-		if _, ok := tiplMapping[part]; ok {
-			addRole(currentRole, currentValue)
-			currentRole = part
-			currentValue = nil
-			continue
-		}
-		currentValue = append(currentValue, part)
-	}
-	addRole(currentRole, currentValue)
-	delete(tags, "tipl")
-}
-
-var _ local.Extractor = (*extractor)(nil)
-
-func init() {
-	local.RegisterExtractor("taglib", func(_ fs.FS, baseDir string) local.Extractor {
-		// ignores fs, as taglib extractor only works with local files
-		return &extractor{baseDir}
-	})
-}

adapters/taglib/taglib_suite_test.go

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

adapters/taglib/taglib_test.go

@@ -1,296 +0,0 @@
-package taglib
-
-import (
-	"io/fs"
-	"os"
-	"strings"
-
-	"github.com/navidrome/navidrome/utils"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Extractor", func() {
-	var e *extractor
-
-	BeforeEach(func() {
-		e = &extractor{}
-	})
-
-	Describe("Parse", func() {
-		It("correctly parses metadata from all files in folder", func() {
-			mds, err := e.Parse(
-				"tests/fixtures/test.mp3",
-				"tests/fixtures/test.ogg",
-			)
-			Expect(err).NotTo(HaveOccurred())
-			Expect(mds).To(HaveLen(2))
-
-			// Test MP3
-			m := mds["tests/fixtures/test.mp3"]
-			Expect(m.Tags).To(HaveKeyWithValue("title", []string{"Song"}))
-			Expect(m.Tags).To(HaveKeyWithValue("album", []string{"Album"}))
-			Expect(m.Tags).To(HaveKeyWithValue("artist", []string{"Artist"}))
-			Expect(m.Tags).To(HaveKeyWithValue("albumartist", []string{"Album Artist"}))
-
-			Expect(m.HasPicture).To(BeTrue())
-			Expect(m.AudioProperties.Duration.String()).To(Equal("1.02s"))
-			Expect(m.AudioProperties.BitRate).To(Equal(192))
-			Expect(m.AudioProperties.Channels).To(Equal(2))
-			Expect(m.AudioProperties.SampleRate).To(Equal(44100))
-
-			Expect(m.Tags).To(Or(
-				HaveKeyWithValue("compilation", []string{"1"}),
-				HaveKeyWithValue("tcmp", []string{"1"})),
-			)
-			Expect(m.Tags).To(HaveKeyWithValue("genre", []string{"Rock"}))
-			Expect(m.Tags).To(HaveKeyWithValue("date", []string{"2014-05-21"}))
-			Expect(m.Tags).To(HaveKeyWithValue("originaldate", []string{"1996-11-21"}))
-			Expect(m.Tags).To(HaveKeyWithValue("releasedate", []string{"2020-12-31"}))
-			Expect(m.Tags).To(HaveKeyWithValue("discnumber", []string{"1"}))
-			Expect(m.Tags).To(HaveKeyWithValue("disctotal", []string{"2"}))
-			Expect(m.Tags).To(HaveKeyWithValue("comment", []string{"Comment1\nComment2"}))
-			Expect(m.Tags).To(HaveKeyWithValue("bpm", []string{"123"}))
-			Expect(m.Tags).To(HaveKeyWithValue("replaygain_album_gain", []string{"+3.21518 dB"}))
-			Expect(m.Tags).To(HaveKeyWithValue("replaygain_album_peak", []string{"0.9125"}))
-			Expect(m.Tags).To(HaveKeyWithValue("replaygain_track_gain", []string{"-1.48 dB"}))
-			Expect(m.Tags).To(HaveKeyWithValue("replaygain_track_peak", []string{"0.4512"}))
-
-			Expect(m.Tags).To(HaveKeyWithValue("tracknumber", []string{"2"}))
-			Expect(m.Tags).To(HaveKeyWithValue("tracktotal", []string{"10"}))
-
-			Expect(m.Tags).ToNot(HaveKey("lyrics"))
-			Expect(m.Tags).To(Or(HaveKeyWithValue("lyrics:eng", []string{
-				"[00:00.00]This is\n[00:02.50]English SYLT\n",
-				"[00:00.00]This is\n[00:02.50]English",
-			}), HaveKeyWithValue("lyrics:eng", []string{
-				"[00:00.00]This is\n[00:02.50]English",
-				"[00:00.00]This is\n[00:02.50]English SYLT\n",
-			})))
-			Expect(m.Tags).To(Or(HaveKeyWithValue("lyrics:xxx", []string{
-				"[00:00.00]This is\n[00:02.50]unspecified SYLT\n",
-				"[00:00.00]This is\n[00:02.50]unspecified",
-			}), HaveKeyWithValue("lyrics:xxx", []string{
-				"[00:00.00]This is\n[00:02.50]unspecified",
-				"[00:00.00]This is\n[00:02.50]unspecified SYLT\n",
-			})))
-
-			// Test OGG
-			m = mds["tests/fixtures/test.ogg"]
-			Expect(err).To(BeNil())
-			Expect(m.Tags).To(HaveKeyWithValue("fbpm", []string{"141.7"}))
-
-			// TabLib 1.12 returns 18, previous versions return 39.
-			// See https://github.com/taglib/taglib/commit/2f238921824741b2cfe6fbfbfc9701d9827ab06b
-			Expect(m.AudioProperties.BitRate).To(BeElementOf(18, 39, 40, 43, 49))
-			Expect(m.AudioProperties.Channels).To(BeElementOf(2))
-			Expect(m.AudioProperties.SampleRate).To(BeElementOf(8000))
-			Expect(m.AudioProperties.SampleRate).To(BeElementOf(8000))
-			Expect(m.HasPicture).To(BeFalse())
-		})
-
-		DescribeTable("Format-Specific tests",
-			func(file, duration string, channels, samplerate, bitdepth int, albumGain, albumPeak, trackGain, trackPeak string, id3Lyrics bool) {
-				file = "tests/fixtures/" + file
-				mds, err := e.Parse(file)
-				Expect(err).NotTo(HaveOccurred())
-				Expect(mds).To(HaveLen(1))
-
-				m := mds[file]
-
-				Expect(m.HasPicture).To(BeFalse())
-				Expect(m.AudioProperties.Duration.String()).To(Equal(duration))
-				Expect(m.AudioProperties.Channels).To(Equal(channels))
-				Expect(m.AudioProperties.SampleRate).To(Equal(samplerate))
-				Expect(m.AudioProperties.BitDepth).To(Equal(bitdepth))
-
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("replaygain_album_gain", []string{albumGain}),
-					HaveKeyWithValue("----:com.apple.itunes:replaygain_track_gain", []string{albumGain}),
-				))
-
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("replaygain_album_peak", []string{albumPeak}),
-					HaveKeyWithValue("----:com.apple.itunes:replaygain_album_peak", []string{albumPeak}),
-				))
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("replaygain_track_gain", []string{trackGain}),
-					HaveKeyWithValue("----:com.apple.itunes:replaygain_track_gain", []string{trackGain}),
-				))
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("replaygain_track_peak", []string{trackPeak}),
-					HaveKeyWithValue("----:com.apple.itunes:replaygain_track_peak", []string{trackPeak}),
-				))
-
-				Expect(m.Tags).To(HaveKeyWithValue("title", []string{"Title"}))
-				Expect(m.Tags).To(HaveKeyWithValue("album", []string{"Album"}))
-				Expect(m.Tags).To(HaveKeyWithValue("artist", []string{"Artist"}))
-				Expect(m.Tags).To(HaveKeyWithValue("albumartist", []string{"Album Artist"}))
-				Expect(m.Tags).To(HaveKeyWithValue("genre", []string{"Rock"}))
-				Expect(m.Tags).To(HaveKeyWithValue("date", []string{"2014"}))
-
-				Expect(m.Tags).To(HaveKeyWithValue("bpm", []string{"123"}))
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("tracknumber", []string{"3"}),
-					HaveKeyWithValue("tracknumber", []string{"3/10"}),
-				))
-				if !strings.HasSuffix(file, "test.wma") {
-					// TODO Not sure why this is not working for WMA
-					Expect(m.Tags).To(HaveKeyWithValue("tracktotal", []string{"10"}))
-				}
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("discnumber", []string{"1"}),
-					HaveKeyWithValue("discnumber", []string{"1/2"}),
-				))
-				Expect(m.Tags).To(HaveKeyWithValue("disctotal", []string{"2"}))
-
-				// WMA does not have a "compilation" tag, but "wm/iscompilation"
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("compilation", []string{"1"}),
-					HaveKeyWithValue("wm/iscompilation", []string{"1"})),
-				)
-
-				if id3Lyrics {
-					Expect(m.Tags).To(HaveKeyWithValue("lyrics:eng", []string{
-						"[00:00.00]This is\n[00:02.50]English",
-					}))
-					Expect(m.Tags).To(HaveKeyWithValue("lyrics:xxx", []string{
-						"[00:00.00]This is\n[00:02.50]unspecified",
-					}))
-				} else {
-					Expect(m.Tags).To(HaveKeyWithValue("lyrics:xxx", []string{
-						"[00:00.00]This is\n[00:02.50]unspecified",
-						"[00:00.00]This is\n[00:02.50]English",
-					}))
-				}
-
-				Expect(m.Tags).To(HaveKeyWithValue("comment", []string{"Comment1\nComment2"}))
-			},
-
-			// ffmpeg -f lavfi -i "sine=frequency=1200:duration=1" test.flac
-			Entry("correctly parses flac tags", "test.flac", "1s", 1, 44100, 16, "+4.06 dB", "0.12496948", "+4.06 dB", "0.12496948", false),
-
-			Entry("correctly parses m4a (aac) gain tags", "01 Invisible (RED) Edit Version.m4a", "1.04s", 2, 44100, 16, "0.37", "0.48", "0.37", "0.48", false),
-			Entry("correctly parses m4a (aac) gain tags (uppercase)", "test.m4a", "1.04s", 2, 44100, 16, "0.37", "0.48", "0.37", "0.48", false),
-			Entry("correctly parses ogg (vorbis) tags", "test.ogg", "1.04s", 2, 8000, 0, "+7.64 dB", "0.11772506", "+7.64 dB", "0.11772506", false),
-
-			// ffmpeg -f lavfi -i "sine=frequency=900:duration=1" test.wma
-			// Weird note: for the tag parsing to work, the lyrics are actually stored in the reverse order
-			Entry("correctly parses wma/asf tags", "test.wma", "1.02s", 1, 44100, 16, "3.27 dB", "0.132914", "3.27 dB", "0.132914", false),
-
-			// ffmpeg -f lavfi -i "sine=frequency=800:duration=1" test.wv
-			Entry("correctly parses wv (wavpak) tags", "test.wv", "1s", 1, 44100, 16, "3.43 dB", "0.125061", "3.43 dB", "0.125061", false),
-
-			// ffmpeg -f lavfi -i "sine=frequency=1000:duration=1" test.wav
-			Entry("correctly parses wav tags", "test.wav", "1s", 1, 44100, 16, "3.06 dB", "0.125056", "3.06 dB", "0.125056", true),
-
-			// ffmpeg -f lavfi -i "sine=frequency=1400:duration=1" test.aiff
-			Entry("correctly parses aiff tags", "test.aiff", "1s", 1, 44100, 16, "2.00 dB", "0.124972", "2.00 dB", "0.124972", true),
-		)
-
-		// Skip these tests when running as root
-		Context("Access Forbidden", func() {
-			var accessForbiddenFile string
-			var RegularUserContext = XContext
-			var isRegularUser = os.Getuid() != 0
-			if isRegularUser {
-				RegularUserContext = Context
-			}
-
-			// Only run permission tests if we are not root
-			RegularUserContext("when run without root privileges", func() {
-				BeforeEach(func() {
-					accessForbiddenFile = utils.TempFileName("access_forbidden-", ".mp3")
-
-					f, err := os.OpenFile(accessForbiddenFile, os.O_WRONLY|os.O_CREATE, 0222)
-					Expect(err).ToNot(HaveOccurred())
-
-					DeferCleanup(func() {
-						Expect(f.Close()).To(Succeed())
-						Expect(os.Remove(accessForbiddenFile)).To(Succeed())
-					})
-				})
-
-				It("correctly handle unreadable file due to insufficient read permission", func() {
-					_, err := e.extractMetadata(accessForbiddenFile)
-					Expect(err).To(MatchError(os.ErrPermission))
-				})
-
-				It("skips the file if it cannot be read", func() {
-					files := []string{
-						"tests/fixtures/test.mp3",
-						"tests/fixtures/test.ogg",
-						accessForbiddenFile,
-					}
-					mds, err := e.Parse(files...)
-					Expect(err).NotTo(HaveOccurred())
-					Expect(mds).To(HaveLen(2))
-					Expect(mds).ToNot(HaveKey(accessForbiddenFile))
-				})
-			})
-		})
-
-	})
-
-	Describe("Error Checking", func() {
-		It("returns a generic ErrPath if file does not exist", func() {
-			testFilePath := "tests/fixtures/NON_EXISTENT.ogg"
-			_, err := e.extractMetadata(testFilePath)
-			Expect(err).To(MatchError(fs.ErrNotExist))
-		})
-		It("does not throw a SIGSEGV error when reading a file with an invalid frame", func() {
-			// File has an empty TDAT frame
-			md, err := e.extractMetadata("tests/fixtures/invalid-files/test-invalid-frame.mp3")
-			Expect(err).ToNot(HaveOccurred())
-			Expect(md.Tags).To(HaveKeyWithValue("albumartist", []string{"Elvis Presley"}))
-		})
-	})
-
-	Describe("parseTIPL", func() {
-		var tags map[string][]string
-
-		BeforeEach(func() {
-			tags = make(map[string][]string)
-		})
-
-		Context("when the TIPL string is populated", func() {
-			It("correctly parses roles and names", func() {
-				tags["tipl"] = []string{"arranger Andrew Powell DJ-mix François Kevorkian DJ-mix Jane Doe engineer Chris Blair"}
-				parseTIPL(tags)
-				Expect(tags["arranger"]).To(ConsistOf("Andrew Powell"))
-				Expect(tags["engineer"]).To(ConsistOf("Chris Blair"))
-				Expect(tags["djmixer"]).To(ConsistOf("François Kevorkian", "Jane Doe"))
-			})
-
-			It("handles multiple names for a single role", func() {
-				tags["tipl"] = []string{"engineer Pat Stapley producer Eric Woolfson engineer Chris Blair"}
-				parseTIPL(tags)
-				Expect(tags["producer"]).To(ConsistOf("Eric Woolfson"))
-				Expect(tags["engineer"]).To(ConsistOf("Pat Stapley", "Chris Blair"))
-			})
-
-			It("discards roles without names", func() {
-				tags["tipl"] = []string{"engineer Pat Stapley producer engineer Chris Blair"}
-				parseTIPL(tags)
-				Expect(tags).ToNot(HaveKey("producer"))
-				Expect(tags["engineer"]).To(ConsistOf("Pat Stapley", "Chris Blair"))
-			})
-		})
-
-		Context("when the TIPL string is empty", func() {
-			It("does nothing", func() {
-				tags["tipl"] = []string{""}
-				parseTIPL(tags)
-				Expect(tags).To(BeEmpty())
-			})
-		})
-
-		Context("when the TIPL is not present", func() {
-			It("does nothing", func() {
-				parseTIPL(tags)
-				Expect(tags).To(BeEmpty())
-			})
-		})
-	})
-
-})

adapters/taglib/taglib_wrapper.cpp

@@ -1,242 +0,0 @@
-#include <stdlib.h>
-#include <string.h>
-#include <typeinfo>
-
-#define TAGLIB_STATIC
-#include <apeproperties.h>
-#include <apetag.h>
-#include <aifffile.h>
-#include <asffile.h>
-#include <dsffile.h>
-#include <fileref.h>
-#include <flacfile.h>
-#include <id3v2tag.h>
-#include <unsynchronizedlyricsframe.h>
-#include <synchronizedlyricsframe.h>
-#include <mp4file.h>
-#include <mpegfile.h>
-#include <opusfile.h>
-#include <tpropertymap.h>
-#include <vorbisfile.h>
-#include <wavfile.h>
-#include <wavfile.h>
-#include <wavpackfile.h>
-
-#include "taglib_wrapper.h"
-
-char has_cover(const TagLib::FileRef f);
-
-static char TAGLIB_VERSION[16];
-
-char* taglib_version() {
-    snprintf((char *)TAGLIB_VERSION, 16, "%d.%d.%d", TAGLIB_MAJOR_VERSION, TAGLIB_MINOR_VERSION, TAGLIB_PATCH_VERSION);
-    return (char *)TAGLIB_VERSION;
-}
-
-int taglib_read(const FILENAME_CHAR_T *filename, unsigned long id) {
-  TagLib::FileRef f(filename, true, TagLib::AudioProperties::Fast);
-
-  if (f.isNull()) {
-    return TAGLIB_ERR_PARSE;
-  }
-
-  if (!f.audioProperties()) {
-    return TAGLIB_ERR_AUDIO_PROPS;
-  }
-
-  // Add audio properties to the tags
-  const TagLib::AudioProperties *props(f.audioProperties());
-  goPutInt(id, (char *)"_lengthinmilliseconds", props->lengthInMilliseconds());
-  goPutInt(id, (char *)"_bitrate", props->bitrate());
-  goPutInt(id, (char *)"_channels", props->channels());
-  goPutInt(id, (char *)"_samplerate", props->sampleRate());
-
-  if (const auto* apeProperties{ dynamic_cast<const TagLib::APE::Properties*>(props) })
-      goPutInt(id, (char *)"_bitspersample",  apeProperties->bitsPerSample());
-  if (const auto* asfProperties{ dynamic_cast<const TagLib::ASF::Properties*>(props) })
-      goPutInt(id, (char *)"_bitspersample",  asfProperties->bitsPerSample());
-  else if (const auto* flacProperties{ dynamic_cast<const TagLib::FLAC::Properties*>(props) })
-      goPutInt(id, (char *)"_bitspersample",  flacProperties->bitsPerSample());
-  else if (const auto* mp4Properties{ dynamic_cast<const TagLib::MP4::Properties*>(props) })
-      goPutInt(id, (char *)"_bitspersample",  mp4Properties->bitsPerSample());
-  else if (const auto* wavePackProperties{ dynamic_cast<const TagLib::WavPack::Properties*>(props) })
-      goPutInt(id, (char *)"_bitspersample",  wavePackProperties->bitsPerSample());
-  else if (const auto* aiffProperties{ dynamic_cast<const TagLib::RIFF::AIFF::Properties*>(props) })
-      goPutInt(id, (char *)"_bitspersample",  aiffProperties->bitsPerSample());
-  else if (const auto* wavProperties{ dynamic_cast<const TagLib::RIFF::WAV::Properties*>(props) })
-      goPutInt(id, (char *)"_bitspersample",  wavProperties->bitsPerSample());
-  else if (const auto* dsfProperties{ dynamic_cast<const TagLib::DSF::Properties*>(props) })
-      goPutInt(id, (char *)"_bitspersample",  dsfProperties->bitsPerSample());
-
-  // Send all properties to the Go map
-  TagLib::PropertyMap tags = f.file()->properties();
-
-  TagLib::ID3v2::Tag *id3Tags = NULL;
-
-  // Get some extended/non-standard ID3-only tags (ex: iTunes extended frames)
-  TagLib::MPEG::File *mp3File(dynamic_cast<TagLib::MPEG::File *>(f.file()));
-  if (mp3File != NULL) {
-    id3Tags = mp3File->ID3v2Tag();
-  }
-
-  if (id3Tags == NULL) {
-    TagLib::RIFF::WAV::File *wavFile(dynamic_cast<TagLib::RIFF::WAV::File *>(f.file()));
-    if (wavFile != NULL && wavFile->hasID3v2Tag()) {
-      id3Tags = wavFile->ID3v2Tag();
-    }
-  }
-
-  if (id3Tags == NULL) {
-    TagLib::RIFF::AIFF::File *aiffFile(dynamic_cast<TagLib::RIFF::AIFF::File *>(f.file()));
-    if (aiffFile && aiffFile->hasID3v2Tag()) {
-      id3Tags = aiffFile->tag();
-    }
-  }
-
-  // Yes, it is possible to have ID3v2 tags in FLAC. However, that can cause problems
-  // with many players, so they will not be parsed
-
-  if (id3Tags != NULL) {
-    const auto &frames = id3Tags->frameListMap();
-
-    for (const auto &kv: frames) {
-      if (kv.first == "USLT") {
-        for (const auto &tag: kv.second) {
-          TagLib::ID3v2::UnsynchronizedLyricsFrame *frame = dynamic_cast<TagLib::ID3v2::UnsynchronizedLyricsFrame *>(tag);
-          if (frame == NULL) continue;
-
-          tags.erase("LYRICS");
-
-          const auto bv = frame->language();
-          char language[4] = {'x', 'x', 'x', '\0'};
-          if (bv.size() == 3) {
-            strncpy(language, bv.data(), 3);
-          }
-
-          char *val = (char *)frame->text().toCString(true);
-
-          goPutLyrics(id, language, val);
-        }
-      } else if (kv.first == "SYLT") {
-        for (const auto &tag: kv.second) {
-          TagLib::ID3v2::SynchronizedLyricsFrame *frame = dynamic_cast<TagLib::ID3v2::SynchronizedLyricsFrame *>(tag);
-          if (frame == NULL) continue;
-
-          const auto bv = frame->language();
-          char language[4] = {'x', 'x', 'x', '\0'};
-          if (bv.size() == 3) {
-            strncpy(language, bv.data(), 3);
-          }
-
-          const auto format = frame->timestampFormat();
-          if (format == TagLib::ID3v2::SynchronizedLyricsFrame::AbsoluteMilliseconds) {
-
-            for (const auto &line: frame->synchedText()) {
-              char *text = (char *)line.text.toCString(true);
-              goPutLyricLine(id, language, text, line.time);
-            }
-          } else if (format == TagLib::ID3v2::SynchronizedLyricsFrame::AbsoluteMpegFrames) {
-            const int sampleRate = props->sampleRate();
-
-            if (sampleRate != 0) {
-              for (const auto &line: frame->synchedText()) {
-                const int timeInMs = (line.time * 1000) / sampleRate;
-                char *text = (char *)line.text.toCString(true);
-                goPutLyricLine(id, language, text, timeInMs);
-              }
-            }
-          }
-        }
-      } else if (kv.first == "TIPL"){
-        if (!kv.second.isEmpty()) {
-          tags.insert(kv.first, kv.second.front()->toString());
-        }
-      }
-    }
-  }
-
-  // M4A may have some iTunes specific tags not captured by the PropertyMap interface
-  TagLib::MP4::File *m4afile(dynamic_cast<TagLib::MP4::File *>(f.file()));
-  if (m4afile != NULL) {
-    const auto itemListMap = m4afile->tag()->itemMap();
-    for (const auto item: itemListMap) {
-      char *key = (char *)item.first.toCString(true);
-      for (const auto value: item.second.toStringList()) {
-        char *val = (char *)value.toCString(true);
-        goPutM4AStr(id, key, val);
-      }
-    }
-  }
-
-  // WMA/ASF files may have additional tags not captured by the PropertyMap interface
-  TagLib::ASF::File *asfFile(dynamic_cast<TagLib::ASF::File *>(f.file()));
-  if (asfFile != NULL) {
-    const TagLib::ASF::Tag *asfTags{asfFile->tag()};
-    const auto itemListMap = asfTags->attributeListMap();
-    for (const auto item : itemListMap) {
-      tags.insert(item.first, item.second.front().toString());
-    }
-  }
-
-  // Send all collected tags to the Go map
-  for (TagLib::PropertyMap::ConstIterator i = tags.begin(); i != tags.end();
-       ++i) {
-    char *key = (char *)i->first.toCString(true);
-    for (TagLib::StringList::ConstIterator j = i->second.begin();
-         j != i->second.end(); ++j) {
-      char *val = (char *)(*j).toCString(true);
-      goPutStr(id, key, val);
-    }
-  }
-
-  // Cover art has to be handled separately
-  if (has_cover(f)) {
-    goPutStr(id, (char *)"has_picture", (char *)"true");
-  }
-
-  return 0;
-}
-
-// Detect if the file has cover art. Returns 1 if the file has cover art, 0 otherwise.
-char has_cover(const TagLib::FileRef f) {
-  char hasCover = 0;
-  // ----- MP3
-  if (TagLib::MPEG::File * mp3File{dynamic_cast<TagLib::MPEG::File *>(f.file())}) {
-    if (mp3File->ID3v2Tag()) {
-      const auto &frameListMap{mp3File->ID3v2Tag()->frameListMap()};
-      hasCover = !frameListMap["APIC"].isEmpty();
-    }
-  }
-  // ----- FLAC
-  else if (TagLib::FLAC::File * flacFile{dynamic_cast<TagLib::FLAC::File *>(f.file())}) {
-    hasCover = !flacFile->pictureList().isEmpty();
-  }
-  // ----- MP4
-  else if (TagLib::MP4::File * mp4File{dynamic_cast<TagLib::MP4::File *>(f.file())}) {
-    auto &coverItem{mp4File->tag()->itemMap()["covr"]};
-    TagLib::MP4::CoverArtList coverArtList{coverItem.toCoverArtList()};
-    hasCover = !coverArtList.isEmpty();
-  }
-  // ----- Ogg
-  else if (TagLib::Ogg::Vorbis::File * vorbisFile{dynamic_cast<TagLib::Ogg::Vorbis::File *>(f.file())}) {
-    hasCover = !vorbisFile->tag()->pictureList().isEmpty();
-  }
-  // ----- Opus
-  else if (TagLib::Ogg::Opus::File * opusFile{dynamic_cast<TagLib::Ogg::Opus::File *>(f.file())}) {
-    hasCover = !opusFile->tag()->pictureList().isEmpty();
-  }
-  // ----- WMA
-  else if (TagLib::ASF::File * asfFile{dynamic_cast<TagLib::ASF::File *>(f.file())}) {
-    const TagLib::ASF::Tag *tag{asfFile->tag()};
-    hasCover = tag && tag->attributeListMap().contains("WM/Picture");
-  }
-  // ----- WAV
-  else if (TagLib::RIFF::WAV::File * wavFile{ dynamic_cast<TagLib::RIFF::WAV::File*>(f.file()) }) {
-    if (wavFile->hasID3v2Tag()) {
-        const auto& frameListMap{ wavFile->ID3v2Tag()->frameListMap() };
-        hasCover = !frameListMap["APIC"].isEmpty();
-    }
-  }
-
-  return hasCover;
-}

adapters/taglib/taglib_wrapper.go

@@ -1,157 +0,0 @@
-package taglib
-
-/*
-#cgo !windows pkg-config: --define-prefix taglib
-#cgo windows pkg-config: taglib
-#cgo illumos LDFLAGS: -lstdc++ -lsendfile
-#cgo linux darwin CXXFLAGS: -std=c++11
-#cgo darwin LDFLAGS: -L/opt/homebrew/opt/taglib/lib
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "taglib_wrapper.h"
-*/
-import "C"
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"runtime/debug"
-	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"unsafe"
-
-	"github.com/navidrome/navidrome/log"
-)
-
-const iTunesKeyPrefix = "----:com.apple.itunes:"
-
-func Version() string {
-	return C.GoString(C.taglib_version())
-}
-
-func Read(filename string) (tags map[string][]string, err error) {
-	// Do not crash on failures in the C code/library
-	debug.SetPanicOnFault(true)
-	defer func() {
-		if r := recover(); r != nil {
-			log.Error("extractor: recovered from panic when reading tags", "file", filename, "error", r)
-			err = fmt.Errorf("extractor: recovered from panic: %s", r)
-		}
-	}()
-
-	fp := getFilename(filename)
-	defer C.free(unsafe.Pointer(fp))
-	id, m, release := newMap()
-	defer release()
-
-	log.Trace("extractor: reading tags", "filename", filename, "map_id", id)
-	res := C.taglib_read(fp, C.ulong(id))
-	switch res {
-	case C.TAGLIB_ERR_PARSE:
-		// Check additional case whether the file is unreadable due to permission
-		file, fileErr := os.OpenFile(filename, os.O_RDONLY, 0600)
-		defer file.Close()
-
-		if os.IsPermission(fileErr) {
-			return nil, fmt.Errorf("navidrome does not have permission: %w", fileErr)
-		} else if fileErr != nil {
-			return nil, fmt.Errorf("cannot parse file media file: %w", fileErr)
-		} else {
-			return nil, fmt.Errorf("cannot parse file media file")
-		}
-	case C.TAGLIB_ERR_AUDIO_PROPS:
-		return nil, fmt.Errorf("can't get audio properties from file")
-	}
-	if log.IsGreaterOrEqualTo(log.LevelDebug) {
-		j, _ := json.Marshal(m)
-		log.Trace("extractor: read tags", "tags", string(j), "filename", filename, "id", id)
-	} else {
-		log.Trace("extractor: read tags", "tags", m, "filename", filename, "id", id)
-	}
-
-	return m, nil
-}
-
-type tagMap map[string][]string
-
-var allMaps sync.Map
-var mapsNextID atomic.Uint32
-
-func newMap() (uint32, tagMap, func()) {
-	id := mapsNextID.Add(1)
-
-	m := tagMap{}
-	allMaps.Store(id, m)
-
-	return id, m, func() {
-		allMaps.Delete(id)
-	}
-}
-
-func doPutTag(id C.ulong, key string, val *C.char) {
-	if key == "" {
-		return
-	}
-
-	r, _ := allMaps.Load(uint32(id))
-	m := r.(tagMap)
-	k := strings.ToLower(key)
-	v := strings.TrimSpace(C.GoString(val))
-	m[k] = append(m[k], v)
-}
-
-//export goPutM4AStr
-func goPutM4AStr(id C.ulong, key *C.char, val *C.char) {
-	k := C.GoString(key)
-
-	// Special for M4A, do not catch keys that have no actual name
-	k = strings.TrimPrefix(k, iTunesKeyPrefix)
-	doPutTag(id, k, val)
-}
-
-//export goPutStr
-func goPutStr(id C.ulong, key *C.char, val *C.char) {
-	doPutTag(id, C.GoString(key), val)
-}
-
-//export goPutInt
-func goPutInt(id C.ulong, key *C.char, val C.int) {
-	valStr := strconv.Itoa(int(val))
-	vp := C.CString(valStr)
-	defer C.free(unsafe.Pointer(vp))
-	goPutStr(id, key, vp)
-}
-
-//export goPutLyrics
-func goPutLyrics(id C.ulong, lang *C.char, val *C.char) {
-	doPutTag(id, "lyrics:"+C.GoString(lang), val)
-}
-
-//export goPutLyricLine
-func goPutLyricLine(id C.ulong, lang *C.char, text *C.char, time C.int) {
-	language := C.GoString(lang)
-	line := C.GoString(text)
-	timeGo := int64(time)
-
-	ms := timeGo % 1000
-	timeGo /= 1000
-	sec := timeGo % 60
-	timeGo /= 60
-	minimum := timeGo % 60
-	formattedLine := fmt.Sprintf("[%02d:%02d.%02d]%s\n", minimum, sec, ms/10, line)
-
-	key := "lyrics:" + language
-
-	r, _ := allMaps.Load(uint32(id))
-	m := r.(tagMap)
-	k := strings.ToLower(key)
-	existing, ok := m[k]
-	if ok {
-		existing[0] += formattedLine
-	} else {
-		m[k] = []string{formattedLine}
-	}
-}

adapters/taglib/taglib_wrapper.h

@@ -1,24 +0,0 @@
-#define TAGLIB_ERR_PARSE -1
-#define TAGLIB_ERR_AUDIO_PROPS -2
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef WIN32
-#define FILENAME_CHAR_T wchar_t
-#else
-#define FILENAME_CHAR_T char
-#endif
-
-extern void goPutM4AStr(unsigned long id, char *key, char *val);
-extern void goPutStr(unsigned long id, char *key, char *val);
-extern void goPutInt(unsigned long id, char *key, int val);
-extern void goPutLyrics(unsigned long id, char *lang, char *val);
-extern void goPutLyricLine(unsigned long id, char *lang, char *text, int time);
-int taglib_read(const FILENAME_CHAR_T *filename, unsigned long id);
-char* taglib_version();
-
-#ifdef __cplusplus
-}
-#endif

cmd/backup.go

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

cmd/inspect.go

@@ -1,79 +0,0 @@
-package cmd
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-
-	"github.com/navidrome/navidrome/core"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
-	"github.com/pelletier/go-toml/v2"
-	"github.com/spf13/cobra"
-	"gopkg.in/yaml.v3"
-)
-
-var (
-	format string
-)
-
-func init() {
-	inspectCmd.Flags().StringVarP(&format, "format", "f", "jsonindent", "output format (pretty, toml, yaml, json, jsonindent)")
-	rootCmd.AddCommand(inspectCmd)
-}
-
-var inspectCmd = &cobra.Command{
-	Use:   "inspect [files to inspect]",
-	Short: "Inspect tags",
-	Long:  "Show file tags as seen by Navidrome",
-	Args:  cobra.MinimumNArgs(1),
-	Run: func(cmd *cobra.Command, args []string) {
-		runInspector(args)
-	},
-}
-
-var marshalers = map[string]func(interface{}) ([]byte, error){
-	"pretty": prettyMarshal,
-	"toml":   toml.Marshal,
-	"yaml":   yaml.Marshal,
-	"json":   json.Marshal,
-	"jsonindent": func(v interface{}) ([]byte, error) {
-		return json.MarshalIndent(v, "", "  ")
-	},
-}
-
-func prettyMarshal(v interface{}) ([]byte, error) {
-	out := v.([]core.InspectOutput)
-	var res strings.Builder
-	for i := range out {
-		res.WriteString(fmt.Sprintf("====================\nFile: %s\n\n", out[i].File))
-		t, _ := toml.Marshal(out[i].RawTags)
-		res.WriteString(fmt.Sprintf("Raw tags:\n%s\n\n", t))
-		t, _ = toml.Marshal(out[i].MappedTags)
-		res.WriteString(fmt.Sprintf("Mapped tags:\n%s\n\n", t))
-	}
-	return []byte(res.String()), nil
-}
-
-func runInspector(args []string) {
-	marshal := marshalers[format]
-	if marshal == nil {
-		log.Fatal("Invalid format", "format", format)
-	}
-	var out []core.InspectOutput
-	for _, filePath := range args {
-		if !model.IsAudioFile(filePath) {
-			log.Warn("Not an audio file", "file", filePath)
-			continue
-		}
-		output, err := core.Inspect(filePath, 1, "")
-		if err != nil {
-			log.Warn("Unable to process file", "file", filePath, "error", err)
-			continue
-		}
-
-		out = append(out, *output)
-	}
-	data, _ := marshal(out)
-	fmt.Println(string(data))
-}

cmd/pls.go

@@ -1,156 +0,0 @@
-package cmd
-
-import (
-	"context"
-	"encoding/csv"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"strconv"
-
-	"github.com/Masterminds/squirrel"
-	"github.com/navidrome/navidrome/core/auth"
-	"github.com/navidrome/navidrome/db"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/persistence"
-	"github.com/spf13/cobra"
-)
-
-var (
-	playlistID   string
-	outputFile   string
-	userID       string
-	outputFormat string
-)
-
-type displayPlaylist struct {
-	Id        string `json:"id"`
-	Name      string `json:"name"`
-	OwnerName string `json:"ownerName"`
-	OwnerId   string `json:"ownerId"`
-	Public    bool   `json:"public"`
-}
-
-type displayPlaylists []displayPlaylist
-
-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)
-
-	listCommand.Flags().StringVarP(&userID, "user", "u", "", "username or ID")
-	listCommand.Flags().StringVarP(&outputFormat, "format", "f", "csv", "output format [supported values: csv, json]")
-	plsCmd.AddCommand(listCommand)
-}
-
-var (
-	plsCmd = &cobra.Command{
-		Use:   "pls",
-		Short: "Export playlists",
-		Long:  "Export Navidrome playlists to M3U files",
-		Run: func(cmd *cobra.Command, args []string) {
-			runExporter()
-		},
-	}
-
-	listCommand = &cobra.Command{
-		Use:   "list",
-		Short: "List playlists",
-		Run: func(cmd *cobra.Command, args []string) {
-			runList()
-		},
-	}
-)
-
-func runExporter() {
-	sqlDB := db.Db()
-	ds := persistence.New(sqlDB)
-	ctx := auth.WithAdminUser(context.Background(), ds)
-	playlist, err := ds.Playlist(ctx).GetWithTracks(playlistID, true, false)
-	if err != nil && !errors.Is(err, model.ErrNotFound) {
-		log.Fatal("Error retrieving playlist", "name", playlistID, err)
-	}
-	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, false)
-			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)
-	}
-}
-
-func runList() {
-	if outputFormat != "csv" && outputFormat != "json" {
-		log.Fatal("Invalid output format. Must be one of csv, json", "format", outputFormat)
-	}
-
-	sqlDB := db.Db()
-	ds := persistence.New(sqlDB)
-	ctx := auth.WithAdminUser(context.Background(), ds)
-
-	options := model.QueryOptions{Sort: "owner_name"}
-
-	if userID != "" {
-		user, err := ds.User(ctx).FindByUsername(userID)
-
-		if err != nil && !errors.Is(err, model.ErrNotFound) {
-			log.Fatal("Error retrieving user by name", "name", userID, err)
-		}
-
-		if errors.Is(err, model.ErrNotFound) {
-			user, err = ds.User(ctx).Get(userID)
-			if err != nil {
-				log.Fatal("Error retrieving user by id", "id", userID, err)
-			}
-		}
-
-		options.Filters = squirrel.Eq{"owner_id": user.ID}
-	}
-
-	playlists, err := ds.Playlist(ctx).GetAll(options)
-	if err != nil {
-		log.Fatal(ctx, "Failed to retrieve playlists", err)
-	}
-
-	if outputFormat == "csv" {
-		w := csv.NewWriter(os.Stdout)
-		_ = w.Write([]string{"playlist id", "playlist name", "owner id", "owner name", "public"})
-		for _, playlist := range playlists {
-			_ = w.Write([]string{playlist.ID, playlist.Name, playlist.OwnerID, playlist.OwnerName, strconv.FormatBool(playlist.Public)})
-		}
-		w.Flush()
-	} else {
-		display := make(displayPlaylists, len(playlists))
-		for idx, playlist := range playlists {
-			display[idx].Id = playlist.ID
-			display[idx].Name = playlist.Name
-			display[idx].OwnerId = playlist.OwnerID
-			display[idx].OwnerName = playlist.OwnerName
-			display[idx].Public = playlist.Public
-		}
-
-		j, _ := json.Marshal(display)
-		fmt.Printf("%s\n", j)
-	}
-}

cmd/root.go

@@ -2,26 +2,17 @@ package cmd
 
 import (
 	"context"
+	"fmt"
 	"os"
-	"os/signal"
-	"strings"
-	"syscall"
 	"time"
 
-	"github.com/go-chi/chi/v5/middleware"
-	_ "github.com/navidrome/navidrome/adapters/taglib"
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/db"
 	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/resources"
-	"github.com/navidrome/navidrome/scanner"
-	"github.com/navidrome/navidrome/scheduler"
-	"github.com/navidrome/navidrome/server/backgrounds"
+	"github.com/oklog/run"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	"golang.org/x/sync/errgroup"
 )
 
 var (
@@ -37,292 +28,78 @@ Complete documentation is available at https://www.navidrome.org/docs`,
 			preRun()
 		},
 		Run: func(cmd *cobra.Command, args []string) {
-			runNavidrome(cmd.Context())
+			runNavidrome()
 		},
-		PostRun: func(cmd *cobra.Command, args []string) {
-			postRun()
-		},
-		Version: consts.Version,
+		Version: consts.Version(),
 	}
 )
 
-// Execute runs the root cobra command, which will start the Navidrome server by calling the runNavidrome function.
 func Execute() {
-	ctx, cancel := mainContext(context.Background())
-	defer cancel()
-
 	rootCmd.SetVersionTemplate(`{{println .Version}}`)
-	if err := rootCmd.ExecuteContext(ctx); err != nil {
-		log.Fatal(err)
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
 	}
 }
 
 func preRun() {
 	if !noBanner {
-		println(resources.Banner())
+		println(consts.Banner())
 	}
-	conf.Load(noBanner)
+	conf.Load()
 }
 
-func postRun() {
-	log.Info("Navidrome stopped, bye.")
-}
+func runNavidrome() {
+	db.EnsureLatestVersion()
 
-// runNavidrome is the main entry point for the Navidrome server. It starts all the services and blocks.
-// If any of the services returns an error, it will log it and exit. If the process receives a signal to exit,
-// it will cancel the context and exit gracefully.
-func runNavidrome(ctx context.Context) {
-	defer db.Init(ctx)()
+	var g run.Group
+	g.Add(startServer())
+	g.Add(startScanner())
 
-	g, ctx := errgroup.WithContext(ctx)
-	g.Go(startServer(ctx))
-	g.Go(startSignaller(ctx))
-	g.Go(startScheduler(ctx))
-	g.Go(startPlaybackServer(ctx))
-	g.Go(schedulePeriodicBackup(ctx))
-	g.Go(startInsightsCollector(ctx))
-	g.Go(scheduleDBOptimizer(ctx))
-	if conf.Server.Scanner.Enabled {
-		g.Go(runInitialScan(ctx))
-		g.Go(startScanWatcher(ctx))
-		g.Go(schedulePeriodicScan(ctx))
-	} else {
-		log.Warn(ctx, "Automatic Scanning is DISABLED")
-	}
-
-	if err := g.Wait(); err != nil {
+	if err := g.Run(); err != nil {
 		log.Error("Fatal error in Navidrome. Aborting", err)
 	}
 }
 
-// mainContext returns a context that is cancelled when the process receives a signal to exit.
-func mainContext(ctx context.Context) (context.Context, context.CancelFunc) {
-	return signal.NotifyContext(ctx,
-		os.Interrupt,
-		syscall.SIGHUP,
-		syscall.SIGTERM,
-		syscall.SIGABRT,
-	)
-}
-
-// startServer starts the Navidrome web server, adding all the necessary routers.
-func startServer(ctx context.Context) func() error {
+func startServer() (func() error, func(err error)) {
 	return func() error {
-		a := CreateServer()
-		a.MountRouter("Native API", consts.URLPathNativeAPI, CreateNativeAPIRouter())
-		a.MountRouter("Subsonic API", consts.URLPathSubsonicAPI, CreateSubsonicAPIRouter(ctx))
-		a.MountRouter("Public Endpoints", consts.URLPathPublic, CreatePublicRouter())
-		if conf.Server.LastFM.Enabled {
-			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 {
-			p := CreatePrometheus()
-			// blocking call because takes <100ms but useful if fails
-			p.WriteInitialMetrics(ctx)
-			a.MountRouter("Prometheus metrics", conf.Server.Prometheus.MetricsPath, p.GetHandler())
-		}
-		if conf.Server.DevEnableProfiler {
-			a.MountRouter("Profiling", "/debug", middleware.Profiler())
-		}
-		if strings.HasPrefix(conf.Server.UILoginBackgroundURL, "/") {
-			a.MountRouter("Background images", conf.Server.UILoginBackgroundURL, backgrounds.NewHandler())
-		}
-		return a.Run(ctx, conf.Server.Address, conf.Server.Port, conf.Server.TLSCert, conf.Server.TLSKey)
-	}
-}
-
-// schedulePeriodicScan schedules a periodic scan of the music library, if configured.
-func schedulePeriodicScan(ctx context.Context) func() error {
-	return func() error {
-		schedule := conf.Server.Scanner.Schedule
-		if schedule == "" {
-			log.Info(ctx, "Periodic scan is DISABLED")
-			return nil
-		}
-
-		s := CreateScanner(ctx)
-		schedulerInstance := scheduler.GetInstance()
-
-		log.Info("Scheduling periodic scan", "schedule", schedule)
-		err := schedulerInstance.Add(schedule, func() {
-			_, err := s.ScanAll(ctx, false)
+			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(ctx, "Error executing periodic scan", err)
-			}
-		})
-		if err != nil {
-			log.Error(ctx, "Error scheduling periodic scan", err)
-		}
-		return nil
-	}
-}
-
-func pidHashChanged(ds model.DataStore) (bool, error) {
-	pidAlbum, err := ds.Property(context.Background()).DefaultGet(consts.PIDAlbumKey, "")
-	if err != nil {
-		return false, err
-	}
-	pidTrack, err := ds.Property(context.Background()).DefaultGet(consts.PIDTrackKey, "")
-	if err != nil {
-		return false, err
-	}
-	return !strings.EqualFold(pidAlbum, conf.Server.PID.Album) || !strings.EqualFold(pidTrack, conf.Server.PID.Track), nil
-}
-
-func runInitialScan(ctx context.Context) func() error {
-	return func() error {
-		ds := CreateDataStore()
-		fullScanRequired, err := ds.Property(ctx).DefaultGet(consts.FullScanAfterMigrationFlagKey, "0")
-		if err != nil {
-			return err
-		}
-		inProgress, err := ds.Library(ctx).ScanInProgress()
-		if err != nil {
-			return err
-		}
-		pidHasChanged, err := pidHashChanged(ds)
-		if err != nil {
-			return err
-		}
-		scanNeeded := conf.Server.Scanner.ScanOnStartup || inProgress || fullScanRequired == "1" || pidHasChanged
-		time.Sleep(2 * time.Second) // Wait 2 seconds before the initial scan
-		if scanNeeded {
-			scanner := CreateScanner(ctx)
-			switch {
-			case fullScanRequired == "1":
-				log.Warn(ctx, "Full scan required after migration")
-				_ = ds.Property(ctx).Delete(consts.FullScanAfterMigrationFlagKey)
-			case pidHasChanged:
-				log.Warn(ctx, "PID config changed, performing full scan")
-				fullScanRequired = "1"
-			case inProgress:
-				log.Warn(ctx, "Resuming interrupted scan")
-			default:
-				log.Info("Executing initial scan")
-			}
-
-			_, err = scanner.ScanAll(ctx, fullScanRequired == "1")
-			if err != nil {
-				log.Error(ctx, "Scan failed", err)
+				log.Error("Shutting down Server due to error", err)
 			} else {
-				log.Info(ctx, "Scan completed")
+				log.Info("Shutting down Server")
 			}
-		} else {
-			log.Debug(ctx, "Initial scan not needed")
 		}
-		return nil
-	}
 }
 
-func startScanWatcher(ctx context.Context) func() error {
+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())
+
 	return func() error {
-		if conf.Server.Scanner.WatcherWait == 0 {
-			log.Debug("Folder watcher is DISABLED")
-			return nil
-		}
-		w := CreateScanWatcher(ctx)
-		err := w.Run(ctx)
-		if err != nil {
-			log.Error("Error starting watcher", err)
-		}
-		return nil
-	}
-}
-
-func schedulePeriodicBackup(ctx context.Context) func() error {
-	return func() error {
-		schedule := conf.Server.Backup.Schedule
-		if schedule == "" {
-			log.Info(ctx, "Periodic backup is DISABLED")
-			return nil
-		}
-
-		schedulerInstance := scheduler.GetInstance()
-
-		log.Info("Scheduling periodic backup", "schedule", schedule)
-		err := schedulerInstance.Add(schedule, func() {
-			start := time.Now()
-			path, err := db.Backup(ctx)
-			elapsed := time.Since(start)
-			if err != nil {
-				log.Error(ctx, "Error backing up database", "elapsed", elapsed, err)
-				return
-			}
-			log.Info(ctx, "Backup complete", "elapsed", elapsed, "path", path)
-
-			count, err := db.Prune(ctx)
-			if err != nil {
-				log.Error(ctx, "Error pruning database", "error", err)
-			} else if count > 0 {
-				log.Info(ctx, "Successfully pruned old files", "count", count)
+			if interval != 0 {
+				time.Sleep(2 * time.Second) // Wait 2 seconds before the first scan
+				scanner.Run(ctx, interval)
 			} else {
-				log.Info(ctx, "No backups pruned")
+				log.Warn("Periodic scan is DISABLED", "interval", interval)
+				<-ctx.Done()
 			}
-		})
 
-		return err
-	}
-}
-
-func scheduleDBOptimizer(ctx context.Context) func() error {
-	return func() error {
-		log.Info(ctx, "Scheduling DB optimizer", "schedule", consts.OptimizeDBSchedule)
-		schedulerInstance := scheduler.GetInstance()
-		err := schedulerInstance.Add(consts.OptimizeDBSchedule, func() {
-			if scanner.IsScanning() {
-				log.Debug(ctx, "Skipping DB optimization because a scan is in progress")
-				return
+			return nil
+		}, func(err error) {
+			cancel()
+			if err != nil {
+				log.Error("Shutting down Scanner due to error", err)
+			} else {
+				log.Info("Shutting down Scanner")
 			}
-			db.Optimize(ctx)
-		})
-		return err
-	}
-}
-
-// startScheduler starts the Navidrome scheduler, which is used to run periodic tasks.
-func startScheduler(ctx context.Context) func() error {
-	return func() error {
-		log.Info(ctx, "Starting scheduler")
-		schedulerInstance := scheduler.GetInstance()
-		schedulerInstance.Run(ctx)
-		return nil
-	}
-}
-
-// startInsightsCollector starts the Navidrome Insight Collector, if configured.
-func startInsightsCollector(ctx context.Context) func() error {
-	return func() error {
-		if !conf.Server.EnableInsightsCollector {
-			log.Info(ctx, "Insight Collector is DISABLED")
-			return nil
 		}
-		log.Info(ctx, "Starting Insight Collector")
-		select {
-		case <-time.After(conf.Server.DevInsightsInitialDelay):
-		case <-ctx.Done():
-			return nil
-		}
-		ic := CreateInsights()
-		ic.Run(ctx)
-		return nil
-	}
-}
-
-// startPlaybackServer starts the Navidrome playback server, if configured.
-// It is responsible for the Jukebox functionality
-func startPlaybackServer(ctx context.Context) func() error {
-	return func() error {
-		if !conf.Server.Jukebox.Enabled {
-			log.Debug("Jukebox is DISABLED")
-			return nil
-		}
-		log.Info(ctx, "Starting Jukebox service")
-		playbackInstance := GetPlaybackServer()
-		return playbackInstance.Run(ctx)
-	}
 }
 
 // TODO: Implement some struct tags to map flags to viper
@@ -334,50 +111,30 @@ func init() {
 	rootCmd.PersistentFlags().StringVarP(&cfgFile, "configfile", "c", "", `config file (default "./navidrome.toml")`)
 	rootCmd.PersistentFlags().BoolVarP(&noBanner, "nobanner", "n", false, `don't show banner`)
 	rootCmd.PersistentFlags().String("musicfolder", viper.GetString("musicfolder"), "folder where your music is stored")
-	rootCmd.PersistentFlags().String("datafolder", viper.GetString("datafolder"), "folder to store application data (DB), needs write access")
-	rootCmd.PersistentFlags().String("cachefolder", viper.GetString("cachefolder"), "folder to store cache data (transcoding, images...), needs write access")
+	rootCmd.PersistentFlags().String("datafolder", viper.GetString("datafolder"), "folder to store application data (DB, cache...), needs write access")
 	rootCmd.PersistentFlags().StringP("loglevel", "l", viper.GetString("loglevel"), "log level, possible values: error, info, debug, trace")
-	rootCmd.PersistentFlags().String("logfile", viper.GetString("logfile"), "log file path, if not set logs will be printed to stderr")
 
 	_ = viper.BindPFlag("musicfolder", rootCmd.PersistentFlags().Lookup("musicfolder"))
 	_ = viper.BindPFlag("datafolder", rootCmd.PersistentFlags().Lookup("datafolder"))
-	_ = viper.BindPFlag("cachefolder", rootCmd.PersistentFlags().Lookup("cachefolder"))
 	_ = viper.BindPFlag("loglevel", rootCmd.PersistentFlags().Lookup("loglevel"))
-	_ = viper.BindPFlag("logfile", rootCmd.PersistentFlags().Lookup("logfile"))
-
-	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("unixsocketperm", viper.GetString("unixsocketperm"), "optional file permission for the unix socket")
-	rootCmd.Flags().String("tlskey", viper.GetString("tlskey"), "optional path to a TLS key file (enables HTTPS listening)")
 
+	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().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().String("albumplaycountmode", viper.GetString("albumplaycountmode"), "how to compute playcount for albums. absolute (default) or normalized")
 	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("unixsocketperm", rootCmd.Flags().Lookup("unixsocketperm"))
-	_ = 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,29 +1,16 @@
 package cmd
 
 import (
-	"context"
-	"encoding/gob"
-	"os"
-
-	"github.com/navidrome/navidrome/core"
-	"github.com/navidrome/navidrome/core/artwork"
-	"github.com/navidrome/navidrome/core/metrics"
-	"github.com/navidrome/navidrome/db"
+	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/persistence"
-	"github.com/navidrome/navidrome/scanner"
-	"github.com/navidrome/navidrome/utils/pl"
 	"github.com/spf13/cobra"
+	"golang.org/x/net/context"
 )
 
-var (
-	fullScan   bool
-	subprocess bool
-)
+var fullRescan bool
 
 func init() {
-	scanCmd.Flags().BoolVarP(&fullScan, "full", "f", false, "check all subfolders, ignoring timestamps")
-	scanCmd.Flags().BoolVarP(&subprocess, "subprocess", "", false, "run as subprocess (internal use)")
+	scanCmd.Flags().BoolVarP(&fullRescan, "full", "f", false, "check all subfolders, ignoring timestamps")
 	rootCmd.AddCommand(scanCmd)
 }
 
@@ -32,53 +19,18 @@ var scanCmd = &cobra.Command{
 	Short: "Scan music folder",
 	Long:  "Scan music folder for updates",
 	Run: func(cmd *cobra.Command, args []string) {
-		runScanner(cmd.Context())
+		runScanner()
 	},
 }
 
-func trackScanInteractively(ctx context.Context, progress <-chan *scanner.ProgressInfo) {
-	for status := range pl.ReadOrDone(ctx, progress) {
-		if status.Warning != "" {
-			log.Warn(ctx, "Scan warning", "error", status.Warning)
-		}
-		if status.Error != "" {
-			log.Error(ctx, "Scan error", "error", status.Error)
-		}
-		// Discard the progress status, we only care about errors
-	}
+func runScanner() {
+	conf.Server.DevPreCacheAlbumArtwork = false
 
-	if fullScan {
+	scanner := GetScanner()
+	_ = scanner.RescanAll(context.Background(), fullRescan)
+	if fullRescan {
 		log.Info("Finished full rescan")
 	} else {
 		log.Info("Finished rescan")
 	}
 }
-
-func trackScanAsSubprocess(ctx context.Context, progress <-chan *scanner.ProgressInfo) {
-	encoder := gob.NewEncoder(os.Stdout)
-	for status := range pl.ReadOrDone(ctx, progress) {
-		err := encoder.Encode(status)
-		if err != nil {
-			log.Error(ctx, "Failed to encode status", err)
-		}
-	}
-}
-
-func runScanner(ctx context.Context) {
-	sqlDB := db.Db()
-	defer db.Db().Close()
-	ds := persistence.New(sqlDB)
-	pls := core.NewPlaylists(ds)
-
-	progress, err := scanner.CallScan(ctx, ds, artwork.NoopCacheWarmer(), pls, metrics.NewNoopInstance(), fullScan)
-	if err != nil {
-		log.Fatal(ctx, "Failed to scan", err)
-	}
-
-	// Wait for the scanner to finish
-	if subprocess {
-		trackScanAsSubprocess(ctx, progress)
-	} else {
-		trackScanInteractively(ctx, progress)
-	}
-}

cmd/signaller_nounix.go

@@ -1,14 +0,0 @@
-//go:build windows || plan9
-
-package cmd
-
-import (
-	"context"
-)
-
-// Windows and Plan9 don't support SIGUSR1, so we don't need to start a signaler
-func startSignaller(ctx context.Context) func() error {
-	return func() error {
-		return nil
-	}
-}

cmd/signaller_unix.go

@@ -1,40 +0,0 @@
-//go:build !windows && !plan9
-
-package cmd
-
-import (
-	"context"
-	"os"
-	"os/signal"
-	"syscall"
-	"time"
-
-	"github.com/navidrome/navidrome/log"
-)
-
-const triggerScanSignal = syscall.SIGUSR1
-
-func startSignaller(ctx context.Context) func() error {
-	log.Info(ctx, "Starting signaler")
-	scanner := CreateScanner(ctx)
-
-	return func() error {
-		var sigChan = make(chan os.Signal, 1)
-		signal.Notify(sigChan, triggerScanSignal)
-
-		for {
-			select {
-			case sig := <-sigChan:
-				log.Info(ctx, "Received signal, triggering a new scan", "signal", sig)
-				start := time.Now()
-				_, err := scanner.ScanAll(ctx, false)
-				if err != nil {
-					log.Error(ctx, "Error scanning", err)
-				}
-				log.Info(ctx, "Triggered scan complete", "elapsed", time.Since(start))
-			case <-ctx.Done():
-				return nil
-			}
-		}
-	}
-}

cmd/svc.go

@@ -1,267 +0,0 @@
-package cmd
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-	"sync"
-	"time"
-
-	"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",
-	}
-
-	installUser      string
-	workingDirectory string
-)
-
-func init() {
-	svcCmd.AddCommand(buildInstallCmd())
-	svcCmd.AddCommand(buildUninstallCmd())
-	svcCmd.AddCommand(buildStartCmd())
-	svcCmd.AddCommand(buildStopCmd())
-	svcCmd.AddCommand(buildStatusCmd())
-	svcCmd.AddCommand(buildExecuteCmd())
-	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
-	done   chan struct{}
-}
-
-func (p *svcControl) Start(service.Service) error {
-	p.done = make(chan struct{})
-	p.ctx, p.cancel = context.WithCancel(context.Background())
-	go func() {
-		runNavidrome(p.ctx)
-		close(p.done)
-	}()
-	return nil
-}
-
-func (p *svcControl) Stop(service.Service) error {
-	log.Info("Stopping service")
-	p.cancel()
-	select {
-	case <-p.done:
-		log.Info("Service stopped gracefully")
-	case <-time.After(10 * time.Second):
-		log.Error("Service did not stop in time. Killing it.")
-	}
-	return nil
-}
-
-var svcInstance = sync.OnceValue(func() service.Service {
-	options := make(service.KeyValue)
-	options["Restart"] = "on-failure"
-	options["SuccessExitStatus"] = "1 2 8 SIGKILL"
-	options["UserService"] = false
-	options["LogDirectory"] = conf.Server.DataFolder
-	options["SystemdScript"] = systemdScript
-	if conf.Server.LogFile != "" {
-		options["LogOutput"] = false
-	} else {
-		options["LogOutput"] = true
-		options["LogDirectory"] = conf.Server.DataFolder
-	}
-	svcConfig := &service.Config{
-		UserName:    installUser,
-		Name:        "navidrome",
-		DisplayName: "Navidrome",
-		Description: "Your Personal Streaming Service",
-		Dependencies: []string{
-			"After=remote-fs.target network.target",
-		},
-		WorkingDirectory: executablePath(),
-		Option:           options,
-	}
-	arguments := []string{"service", "execute"}
-	if conf.Server.ConfigFile != "" {
-		arguments = append(arguments, "-c", conf.Server.ConfigFile)
-	}
-	svcConfig.Arguments = arguments
-
-	prg := &svcControl{}
-	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 {
-	if workingDirectory != "" {
-		return workingDirectory
-	}
-
-	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 conf.Server.LogFile != "" {
-			println("  log file:          " + conf.Server.LogFile)
-		} else {
-			println("  logs 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.")
-	}
-
-	cmd := &cobra.Command{
-		Use:   "install",
-		Short: "Install Navidrome service.",
-		Run:   runInstallCmd,
-	}
-	cmd.Flags().StringVarP(&installUser, "user", "u", "", "user to run service")
-	cmd.Flags().StringVarP(&workingDirectory, "working-directory", "w", "", "working directory of service")
-
-	return cmd
-}
-
-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])
-		},
-	}
-}
-
-func buildExecuteCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:   "execute",
-		Short: "Run navidrome as a service in the foreground (it is very unlikely you want to run this, you are better off running just navidrome)",
-		Run: func(cmd *cobra.Command, args []string) {
-			err := svcInstance().Run()
-			if err != nil {
-				log.Fatal(err)
-			}
-		},
-	}
-}
-
-const systemdScript = `[Unit]
-Description={{.Description}}
-ConditionFileIsExecutable={{.Path|cmdEscape}}
-{{range $i, $dep := .Dependencies}} 
-{{$dep}} {{end}}
-
-[Service]
-StartLimitInterval=5
-StartLimitBurst=10
-ExecStart={{.Path|cmdEscape}}{{range .Arguments}} {{.|cmd}}{{end}}
-{{if .WorkingDirectory}}WorkingDirectory={{.WorkingDirectory|cmdEscape}}{{end}}
-{{if .UserName}}User={{.UserName}}{{end}}
-{{if .Restart}}Restart={{.Restart}}{{end}}
-{{if .SuccessExitStatus}}SuccessExitStatus={{.SuccessExitStatus}}{{end}}
-TimeoutStopSec=20
-RestartSec=120
-EnvironmentFile=-/etc/sysconfig/{{.Name}}
-
-DevicePolicy=closed
-NoNewPrivileges=yes
-PrivateTmp=yes
-ProtectControlGroups=yes
-ProtectKernelModules=yes
-ProtectKernelTunables=yes
-RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
-RestrictNamespaces=yes
-RestrictRealtime=yes
-SystemCallFilter=~@clock @debug @module @mount @obsolete @reboot @setuid @swap
-{{if .WorkingDirectory}}ReadWritePaths={{.WorkingDirectory|cmdEscape}}{{end}}
-ProtectSystem=full
-
-[Install]
-WantedBy=multi-user.target
-`

cmd/wire_gen.go

@@ -1,174 +1,94 @@
 // Code generated by Wire. DO NOT EDIT.
 
-//go:generate go run -mod=mod github.com/google/wire/cmd/wire gen -tags "netgo"
-//go:build !wireinject
-// +build !wireinject
+//go:generate go run github.com/google/wire/cmd/wire
+//+build !wireinject
 
 package cmd
 
 import (
-	"context"
 	"github.com/google/wire"
 	"github.com/navidrome/navidrome/core"
-	"github.com/navidrome/navidrome/core/agents"
-	"github.com/navidrome/navidrome/core/agents/lastfm"
-	"github.com/navidrome/navidrome/core/agents/listenbrainz"
-	"github.com/navidrome/navidrome/core/artwork"
-	"github.com/navidrome/navidrome/core/external"
-	"github.com/navidrome/navidrome/core/ffmpeg"
-	"github.com/navidrome/navidrome/core/metrics"
-	"github.com/navidrome/navidrome/core/playback"
-	"github.com/navidrome/navidrome/core/scrobbler"
-	"github.com/navidrome/navidrome/db"
-	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/core/transcoder"
 	"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"
-)
-
-import (
-	_ "github.com/navidrome/navidrome/adapters/taglib"
+	"sync"
 )
 
 // Injectors from wire_injectors.go:
 
-func CreateDataStore() model.DataStore {
-	sqlDB := db.Db()
-	dataStore := persistence.New(sqlDB)
-	return dataStore
-}
-
-func CreateServer() *server.Server {
-	sqlDB := db.Db()
-	dataStore := persistence.New(sqlDB)
-	broker := events.GetBroker()
-	insights := metrics.GetInstance(dataStore)
-	serverServer := server.New(dataStore, broker, insights)
+func CreateServer(musicFolder string) *server.Server {
+	dataStore := persistence.New()
+	serverServer := server.New(dataStore)
 	return serverServer
 }
 
-func CreateNativeAPIRouter() *nativeapi.Router {
-	sqlDB := db.Db()
-	dataStore := persistence.New(sqlDB)
-	share := core.NewShare(dataStore)
-	playlists := core.NewPlaylists(dataStore)
-	insights := metrics.GetInstance(dataStore)
-	router := nativeapi.New(dataStore, share, playlists, insights)
+func CreateAppRouter() *app.Router {
+	dataStore := persistence.New()
+	broker := GetBroker()
+	router := app.New(dataStore, broker)
 	return router
 }
 
-func CreateSubsonicAPIRouter(ctx context.Context) *subsonic.Router {
-	sqlDB := db.Db()
-	dataStore := persistence.New(sqlDB)
-	fileCache := artwork.GetImageCache()
-	fFmpeg := ffmpeg.New()
-	agentsAgents := agents.GetAgents(dataStore)
-	provider := external.NewProvider(dataStore, agentsAgents)
-	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
+func CreateSubsonicAPIRouter() *subsonic.Router {
+	dataStore := persistence.New()
+	artworkCache := core.GetImageCache()
+	artwork := core.NewArtwork(dataStore, artworkCache)
+	transcoderTranscoder := transcoder.New()
 	transcodingCache := core.GetTranscodingCache()
-	mediaStreamer := core.NewMediaStreamer(dataStore, fFmpeg, transcodingCache)
-	share := core.NewShare(dataStore)
-	archiver := core.NewArchiver(mediaStreamer, dataStore, share)
+	mediaStreamer := core.NewMediaStreamer(dataStore, transcoderTranscoder, transcodingCache)
+	archiver := core.NewArchiver(dataStore)
 	players := core.NewPlayers(dataStore)
-	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
-	broker := events.GetBroker()
-	playlists := core.NewPlaylists(dataStore)
-	metricsMetrics := metrics.NewPrometheusInstance(dataStore)
-	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
-	playTracker := scrobbler.GetPlayTracker(dataStore, broker)
-	playbackServer := playback.GetInstance(dataStore)
-	router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, scannerScanner, broker, playlists, playTracker, share, playbackServer)
+	externalMetadata := core.NewExternalMetadata(dataStore)
+	scanner := GetScanner()
+	router := subsonic.New(dataStore, artwork, mediaStreamer, archiver, players, externalMetadata, scanner)
 	return router
 }
 
-func CreatePublicRouter() *public.Router {
-	sqlDB := db.Db()
-	dataStore := persistence.New(sqlDB)
-	fileCache := artwork.GetImageCache()
-	fFmpeg := ffmpeg.New()
-	agentsAgents := agents.GetAgents(dataStore)
-	provider := external.NewProvider(dataStore, agentsAgents)
-	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
-	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 CreateInsights() metrics.Insights {
-	sqlDB := db.Db()
-	dataStore := persistence.New(sqlDB)
-	insights := metrics.GetInstance(dataStore)
-	return insights
-}
-
-func CreatePrometheus() metrics.Metrics {
-	sqlDB := db.Db()
-	dataStore := persistence.New(sqlDB)
-	metricsMetrics := metrics.NewPrometheusInstance(dataStore)
-	return metricsMetrics
-}
-
-func CreateScanner(ctx context.Context) scanner.Scanner {
-	sqlDB := db.Db()
-	dataStore := persistence.New(sqlDB)
-	fileCache := artwork.GetImageCache()
-	fFmpeg := ffmpeg.New()
-	agentsAgents := agents.GetAgents(dataStore)
-	provider := external.NewProvider(dataStore, agentsAgents)
-	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
-	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
-	broker := events.GetBroker()
-	playlists := core.NewPlaylists(dataStore)
-	metricsMetrics := metrics.NewPrometheusInstance(dataStore)
-	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
+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)
 	return scannerScanner
 }
 
-func CreateScanWatcher(ctx context.Context) scanner.Watcher {
-	sqlDB := db.Db()
-	dataStore := persistence.New(sqlDB)
-	fileCache := artwork.GetImageCache()
-	fFmpeg := ffmpeg.New()
-	agentsAgents := agents.GetAgents(dataStore)
-	provider := external.NewProvider(dataStore, agentsAgents)
-	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
-	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
-	broker := events.GetBroker()
-	playlists := core.NewPlaylists(dataStore)
-	metricsMetrics := metrics.NewPrometheusInstance(dataStore)
-	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
-	watcher := scanner.NewWatcher(dataStore, scannerScanner)
-	return watcher
-}
-
-func GetPlaybackServer() playback.PlaybackServer {
-	sqlDB := db.Db()
-	dataStore := persistence.New(sqlDB)
-	playbackServer := playback.GetInstance(dataStore)
-	return playbackServer
+func createBroker() events.Broker {
+	broker := events.NewBroker()
+	return broker
 }
 
 // wire_injectors.go:
 
-var allProviders = wire.NewSet(core.Set, artwork.Set, server.New, subsonic.New, nativeapi.New, public.New, persistence.New, lastfm.NewRouter, listenbrainz.NewRouter, events.GetBroker, scanner.New, scanner.NewWatcher, metrics.NewPrometheusInstance, db.Db)
+var allProviders = wire.NewSet(core.Set, subsonic.New, app.New, persistence.New)
+
+// Scanner must be a Singleton
+var (
+	onceScanner     sync.Once
+	scannerInstance scanner.Scanner
+)
+
+func GetScanner() scanner.Scanner {
+	onceScanner.Do(func() {
+		scannerInstance = createScanner()
+	})
+	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,113 +1,84 @@
-//go:build wireinject
+//+build wireinject
 
 package cmd
 
 import (
-	"context"
+	"sync"
 
 	"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/core/metrics"
-	"github.com/navidrome/navidrome/core/playback"
-	"github.com/navidrome/navidrome/db"
-	"github.com/navidrome/navidrome/model"
 	"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,
-	server.New,
 	subsonic.New,
-	nativeapi.New,
-	public.New,
+	app.New,
 	persistence.New,
-	lastfm.NewRouter,
-	listenbrainz.NewRouter,
-	events.GetBroker,
-	scanner.New,
-	scanner.NewWatcher,
-	metrics.NewPrometheusInstance,
-	db.Db,
 )
 
-func CreateDataStore() model.DataStore {
+func CreateServer(musicFolder string) *server.Server {
 	panic(wire.Build(
+		server.New,
 		allProviders,
 	))
 }
 
-func CreateServer() *server.Server {
+func CreateAppRouter() *app.Router {
 	panic(wire.Build(
 		allProviders,
+		GetBroker,
 	))
 }
 
-func CreateNativeAPIRouter() *nativeapi.Router {
+func CreateSubsonicAPIRouter() *subsonic.Router {
 	panic(wire.Build(
 		allProviders,
+		GetScanner,
 	))
 }
 
-func CreateSubsonicAPIRouter(ctx context.Context) *subsonic.Router {
+// Scanner must be a Singleton
+var (
+	onceScanner     sync.Once
+	scannerInstance scanner.Scanner
+)
+
+func GetScanner() scanner.Scanner {
+	onceScanner.Do(func() {
+		scannerInstance = createScanner()
+	})
+	return scannerInstance
+}
+
+func createScanner() scanner.Scanner {
 	panic(wire.Build(
 		allProviders,
+		GetBroker,
+		scanner.New,
 	))
 }
 
-func CreatePublicRouter() *public.Router {
-	panic(wire.Build(
-		allProviders,
-	))
+// Broker must be a Singleton
+var (
+	onceBroker     sync.Once
+	brokerInstance events.Broker
+)
+
+func GetBroker() events.Broker {
+	onceBroker.Do(func() {
+		brokerInstance = createBroker()
+	})
+	return brokerInstance
 }
 
-func CreateLastFMRouter() *lastfm.Router {
+func createBroker() events.Broker {
 	panic(wire.Build(
-		allProviders,
-	))
-}
-
-func CreateListenBrainzRouter() *listenbrainz.Router {
-	panic(wire.Build(
-		allProviders,
-	))
-}
-
-func CreateInsights() metrics.Insights {
-	panic(wire.Build(
-		allProviders,
-	))
-}
-
-func CreatePrometheus() metrics.Metrics {
-	panic(wire.Build(
-		allProviders,
-	))
-}
-
-func CreateScanner(ctx context.Context) scanner.Scanner {
-	panic(wire.Build(
-		allProviders,
-	))
-}
-
-func CreateScanWatcher(ctx context.Context) scanner.Watcher {
-	panic(wire.Build(
-		allProviders,
-	))
-}
-
-func GetPlaybackServer() playback.PlaybackServer {
-	panic(wire.Build(
-		allProviders,
+		events.NewBroker,
 	))
 }

conf/buildtags/buildtags.go

@@ -1,4 +0,0 @@
-package buildtags
-
-// This file is left intentionally empty. It is used to make sure the package is not empty, in the case all
-// required build tags are disabled.

conf/buildtags/netgo.go

@@ -1,11 +0,0 @@
-//go:build netgo
-
-package buildtags
-
-// NOTICE: This file was created to force the inclusion of the `netgo` tag when compiling the project.
-// If the tag is not included, the compilation will fail because this variable won't be defined, and the `main.go`
-// file requires it.
-
-// Why this tag is required? See https://github.com/navidrome/navidrome/issues/700
-
-var NETGO = true

conf/configtest/configtest.go

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

conf/configuration.go

@@ -2,156 +2,68 @@ package conf
 
 import (
 	"fmt"
-	"net/url"
 	"os"
 	"path/filepath"
-	"runtime"
 	"strings"
 	"time"
 
-	"github.com/bmatcuk/doublestar/v4"
-	"github.com/go-viper/encoding/ini"
 	"github.com/kr/pretty"
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/utils/chain"
-	"github.com/robfig/cron/v3"
 	"github.com/spf13/viper"
 )
 
 type configOptions struct {
-	ConfigFile                      string
-	Address                         string
-	Port                            int
-	UnixSocketPerm                  string
-	MusicFolder                     string
-	DataFolder                      string
-	CacheFolder                     string
-	DbPath                          string
-	LogLevel                        string
-	LogFile                         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
-	EnableInsightsCollector         bool
-	EnableMediaFileCoverArt         bool
-	TranscodingCacheSize            string
-	ImageCacheSize                  string
-	AlbumPlayCountMode              string
-	EnableArtworkPrecache           bool
-	AutoImportPlaylists             bool
-	DefaultPlaylistPublicVisibility bool
-	PlaylistsPath                   string
-	SmartPlaylistRefreshDelay       time.Duration
-	AutoTranscodeDownload           bool
-	DefaultDownsamplingFormat       string
-	SearchFullString                bool
-	RecentlyAddedByModTime          bool
-	PreferSortTags                  bool
-	IgnoredArticles                 string
-	IndexGroups                     string
-	FFmpegPath                      string
-	MPVPath                         string
-	MPVCmdTemplate                  string
-	CoverArtPriority                string
-	CoverJpegQuality                int
-	ArtistArtPriority               string
-	EnableGravatar                  bool
-	EnableFavourites                bool
-	EnableStarRating                bool
-	EnableUserEditing               bool
-	EnableSharing                   bool
-	ShareURL                        string
-	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
-	HTTPSecurityHeaders             secureOptions
-	Prometheus                      prometheusOptions
-	Scanner                         scannerOptions
-	Jukebox                         jukeboxOptions
-	Backup                          backupOptions
-	PID                             pidOptions
-	Inspect                         inspectOptions
-	Subsonic                        subsonicOptions
+	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
 
-	Agents       string
-	LastFM       lastfmOptions
-	Spotify      spotifyOptions
-	ListenBrainz listenBrainzOptions
-	Tags         map[string]TagConf
+	SearchFullString       bool
+	RecentlyAddedByModTime bool
+	IgnoredArticles        string
+	IndexGroups            string
+	ProbeCommand           string
+	CoverArtPriority       string
+	CoverJpegQuality       int
+	UIWelcomeMessage       string
+	EnableGravatar         bool
+	GATrackingID           string
+	AuthRequestLimit       int
+	AuthWindowLength       time.Duration
+
+	Scanner scannerOptions
+
+	Agents  string
+	LastFM  lastfmOptions
+	Spotify spotifyOptions
 
 	// DevFlags. These are used to enable/disable debugging and incomplete features
-	DevLogSourceLine                 bool
-	DevLogLevels                     map[string]string
-	DevEnableProfiler                bool
-	DevAutoCreateAdminPassword       string
-	DevAutoLoginUsername             string
-	DevActivityPanel                 bool
-	DevActivityPanelUpdateRate       time.Duration
-	DevSidebarPlaylists              bool
-	DevEnableBufferedScrobble        bool
-	DevShowArtistPage                bool
-	DevOffsetOptimize                int
-	DevArtworkMaxRequests            int
-	DevArtworkThrottleBacklogLimit   int
-	DevArtworkThrottleBacklogTimeout time.Duration
-	DevArtistInfoTimeToLive          time.Duration
-	DevAlbumInfoTimeToLive           time.Duration
-	DevExternalScanner               bool
-	DevScannerThreads                uint
-	DevInsightsInitialDelay          time.Duration
-	DevEnablePlayerInsights          bool
+	DevLogSourceLine           bool
+	DevAutoCreateAdminPassword string
+	DevPreCacheAlbumArtwork    bool
+	DevFastAccessCoverArt      bool
+	DevOldCacheLayout          bool
+	DevActivityPanel           bool
 }
 
 type scannerOptions struct {
-	Enabled            bool
-	Schedule           string
-	WatcherWait        time.Duration
-	ScanOnStartup      bool
-	Extractor          string
-	ArtistJoiner       string
-	GenreSeparators    string // Deprecated: Use Tags.genre.Split instead
-	GroupAlbumReleases bool   // Deprecated: Use PID.Album instead
-}
-
-type subsonicOptions struct {
-	AppendSubtitle        bool
-	ArtistParticipations  bool
-	DefaultReportRealPath bool
-	LegacyClients         string
-}
-
-type TagConf struct {
-	Ignore    bool     `yaml:"ignore"`
-	Aliases   []string `yaml:"aliases"`
-	Type      string   `yaml:"type"`
-	MaxLength int      `yaml:"maxLength"`
-	Split     []string `yaml:"split"`
-	Album     bool     `yaml:"album"`
+	Extractor string
 }
 
 type lastfmOptions struct {
-	Enabled  bool
 	ApiKey   string
 	Secret   string
 	Language string
@@ -162,48 +74,6 @@ type spotifyOptions struct {
 	Secret string
 }
 
-type listenBrainzOptions struct {
-	Enabled bool
-	BaseURL string
-}
-
-type secureOptions struct {
-	CustomFrameOptionsValue string
-}
-
-type prometheusOptions struct {
-	Enabled     bool
-	MetricsPath string
-	Password    string
-}
-
-type AudioDeviceDefinition []string
-
-type jukeboxOptions struct {
-	Enabled   bool
-	Devices   []AudioDeviceDefinition
-	Default   string
-	AdminOnly bool
-}
-
-type backupOptions struct {
-	Count    int
-	Path     string
-	Schedule string
-}
-
-type pidOptions struct {
-	Track string
-	Album string
-}
-
-type inspectOptions struct {
-	Enabled        bool
-	MaxRequests    int
-	BacklogLimit   int
-	BacklogTimeout int
-}
-
 var (
 	Server = &configOptions{}
 	hooks  []func()
@@ -211,208 +81,37 @@ var (
 
 func LoadFromFile(confFile string) {
 	viper.SetConfigFile(confFile)
-	err := viper.ReadInConfig()
-	if err != nil {
-		_, _ = fmt.Fprintln(os.Stderr, "FATAL: Error reading config file:", err)
-		os.Exit(1)
-	}
-	Load(true)
+	Load()
 }
 
-func Load(noConfigDump bool) {
-	parseIniFileConfiguration()
-
+func Load() {
 	err := viper.Unmarshal(&Server)
 	if err != nil {
-		_, _ = fmt.Fprintln(os.Stderr, "FATAL: Error parsing config:", err)
+		fmt.Println("Error parsing config:", err)
 		os.Exit(1)
 	}
-
 	err = os.MkdirAll(Server.DataFolder, os.ModePerm)
 	if err != nil {
-		_, _ = fmt.Fprintln(os.Stderr, "FATAL: Error creating data path:", err)
+		fmt.Println("Error creating data path:", "path", Server.DataFolder, err)
 		os.Exit(1)
 	}
-
-	if Server.CacheFolder == "" {
-		Server.CacheFolder = filepath.Join(Server.DataFolder, "cache")
-	}
-	err = os.MkdirAll(Server.CacheFolder, os.ModePerm)
-	if err != nil {
-		_, _ = fmt.Fprintln(os.Stderr, "FATAL: Error creating cache path:", err)
-		os.Exit(1)
-	}
-
 	Server.ConfigFile = viper.GetViper().ConfigFileUsed()
 	if Server.DbPath == "" {
 		Server.DbPath = filepath.Join(Server.DataFolder, consts.DefaultDbPath)
 	}
 
-	if Server.Backup.Path != "" {
-		err = os.MkdirAll(Server.Backup.Path, os.ModePerm)
-		if err != nil {
-			_, _ = fmt.Fprintln(os.Stderr, "FATAL: Error creating backup path:", err)
-			os.Exit(1)
-		}
-	}
-
-	out := os.Stderr
-	if Server.LogFile != "" {
-		out, err = os.OpenFile(Server.LogFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-		if err != nil {
-			_, _ = fmt.Fprintf(os.Stderr, "FATAL: Error opening log file %s: %s\n", Server.LogFile, err.Error())
-			os.Exit(1)
-		}
-		log.SetOutput(out)
-	}
-
 	log.SetLevelString(Server.LogLevel)
-	log.SetLogLevels(Server.DevLogLevels)
 	log.SetLogSourceLine(Server.DevLogSourceLine)
-	log.SetRedacting(Server.EnableLogRedacting)
-
-	err = chain.RunSequentially(
-		validateScanSchedule,
-		validateBackupSchedule,
-		validatePlaylistsPath,
-	)
-	if err != nil {
-		os.Exit(1)
+	if log.CurrentLevel() >= log.LevelDebug {
+		pretty.Printf("Loaded configuration from '%s': %# v\n", Server.ConfigFile, Server)
 	}
 
-	if Server.BaseURL != "" {
-		u, err := url.Parse(Server.BaseURL)
-		if err != nil {
-			_, _ = fmt.Fprintln(os.Stderr, "FATAL: Invalid BaseURL:", err)
-			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.IsGreaterOrEqualTo(log.LevelDebug) && !noConfigDump {
-		prettyConf := pretty.Sprintf("Loaded configuration from '%s': %# v", Server.ConfigFile, Server)
-		if Server.EnableLogRedacting {
-			prettyConf = log.Redact(prettyConf)
-		}
-		_, _ = fmt.Fprintln(out, prettyConf)
-	}
-
-	if !Server.EnableExternalServices {
-		disableExternalServices()
-	}
-
-	if Server.Scanner.Extractor != consts.DefaultScannerExtractor {
-		log.Warn(fmt.Sprintf("Extractor '%s' is not implemented, using 'taglib'", Server.Scanner.Extractor))
-		Server.Scanner.Extractor = consts.DefaultScannerExtractor
-	}
-	logDeprecatedOptions("Scanner.GenreSeparators")
-	logDeprecatedOptions("Scanner.GroupAlbumReleases")
-
 	// Call init hooks
 	for _, hook := range hooks {
 		hook()
 	}
 }
 
-func logDeprecatedOptions(options ...string) {
-	for _, option := range options {
-		envVar := "ND_" + strings.ToUpper(strings.ReplaceAll(option, ".", "_"))
-		if os.Getenv(envVar) != "" {
-			log.Warn(fmt.Sprintf("Option '%s' is deprecated and will be ignored in a future release", envVar))
-		}
-		if viper.InConfig(option) {
-			log.Warn(fmt.Sprintf("Option '%s' is deprecated and will be ignored in a future release", option))
-		}
-	}
-}
-
-// parseIniFileConfiguration is used to parse the config file when it is in INI format. For INI files, it
-// would require a nested structure, so instead we unmarshal it to a map and then merge the nested [default]
-// section into the root level.
-func parseIniFileConfiguration() {
-	cfgFile := viper.ConfigFileUsed()
-	if strings.ToLower(filepath.Ext(cfgFile)) == ".ini" {
-		var iniConfig map[string]interface{}
-		err := viper.Unmarshal(&iniConfig)
-		if err != nil {
-			_, _ = fmt.Fprintln(os.Stderr, "FATAL: Error parsing config:", err)
-			os.Exit(1)
-		}
-		cfg, ok := iniConfig["default"].(map[string]any)
-		if !ok {
-			_, _ = fmt.Fprintln(os.Stderr, "FATAL: Error parsing config: missing [default] section:", iniConfig)
-			os.Exit(1)
-		}
-		err = viper.MergeConfigMap(cfg)
-		if err != nil {
-			_, _ = fmt.Fprintln(os.Stderr, "FATAL: Error parsing config:", err)
-			os.Exit(1)
-		}
-	}
-}
-
-func disableExternalServices() {
-	log.Info("All external integrations are DISABLED!")
-	Server.EnableInsightsCollector = false
-	Server.LastFM.Enabled = false
-	Server.Spotify.ID = ""
-	Server.ListenBrainz.Enabled = false
-	Server.Agents = ""
-	if Server.UILoginBackgroundURL == consts.DefaultUILoginBackgroundURL {
-		Server.UILoginBackgroundURL = consts.DefaultUILoginBackgroundURLOffline
-	}
-}
-
-func validatePlaylistsPath() error {
-	for _, path := range strings.Split(Server.PlaylistsPath, string(filepath.ListSeparator)) {
-		_, err := doublestar.Match(path, "")
-		if err != nil {
-			log.Error("Invalid PlaylistsPath", "path", path, err)
-			return err
-		}
-	}
-	return nil
-}
-
-func validateScanSchedule() error {
-	if Server.Scanner.Schedule == "0" || Server.Scanner.Schedule == "" {
-		Server.Scanner.Schedule = ""
-		return nil
-	}
-	var err error
-	Server.Scanner.Schedule, err = validateSchedule(Server.Scanner.Schedule, "Scanner.Schedule")
-	return err
-}
-
-func validateBackupSchedule() error {
-	if Server.Backup.Path == "" || Server.Backup.Schedule == "" || Server.Backup.Count == 0 {
-		Server.Backup.Schedule = ""
-		return nil
-	}
-	var err error
-	Server.Backup.Schedule, err = validateSchedule(Server.Backup.Schedule, "Backup.Schedule")
-	return err
-}
-
-func validateSchedule(schedule, field string) (string, error) {
-	if _, err := time.ParseDuration(schedule); err == nil {
-		schedule = "@every " + schedule
-	}
-	c := cron.New()
-	id, err := c.AddFunc(schedule, func() {})
-	if err != nil {
-		log.Error(fmt.Sprintf("Invalid %s. Please read format spec at https://pkg.go.dev/github.com/robfig/cron#hdr-CRON_Expression_Format", field), "schedule", schedule, err)
-	} else {
-		c.Remove(id)
-	}
-	return schedule, 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)
@@ -420,141 +119,52 @@ func AddHook(hook func()) {
 
 func init() {
 	viper.SetDefault("musicfolder", filepath.Join(".", "music"))
-	viper.SetDefault("cachefolder", "")
 	viper.SetDefault("datafolder", ".")
 	viper.SetDefault("loglevel", "info")
-	viper.SetDefault("logfile", "")
 	viper.SetDefault("address", "0.0.0.0")
 	viper.SetDefault("port", 4533)
-	viper.SetDefault("unixsocketperm", "0660")
 	viper.SetDefault("sessiontimeout", consts.DefaultSessionTimeout)
+	viper.SetDefault("scaninterval", time.Minute)
 	viper.SetDefault("baseurl", "")
-	viper.SetDefault("tlscert", "")
-	viper.SetDefault("tlskey", "")
-	viper.SetDefault("uiloginbackgroundurl", consts.DefaultUILoginBackgroundURL)
-	viper.SetDefault("uiwelcomemessage", "")
-	viper.SetDefault("maxsidebarplaylists", consts.DefaultMaxSidebarPlaylists)
+	viper.SetDefault("uiloginbackgroundurl", "https://source.unsplash.com/random/1600x900?music")
 	viper.SetDefault("enabletranscodingconfig", false)
 	viper.SetDefault("transcodingcachesize", "100MB")
 	viper.SetDefault("imagecachesize", "100MB")
-	viper.SetDefault("albumplaycountmode", consts.AlbumPlayCountModeAbsolute)
-	viper.SetDefault("enableartworkprecache", true)
 	viper.SetDefault("autoimportplaylists", true)
-	viper.SetDefault("defaultplaylistpublicvisibility", false)
-	viper.SetDefault("playlistspath", "")
-	viper.SetDefault("smartPlaylistRefreshDelay", 5*time.Second)
 	viper.SetDefault("enabledownloads", true)
-	viper.SetDefault("enableexternalservices", true)
-	viper.SetDefault("enablemediafilecoverart", true)
-	viper.SetDefault("autotranscodedownload", false)
-	viper.SetDefault("defaultdownsamplingformat", consts.DefaultDownsamplingFormat)
+
+	// Config options only valid for file/env configuration
 	viper.SetDefault("searchfullstring", false)
 	viper.SetDefault("recentlyaddedbymodtime", false)
-	viper.SetDefault("prefersorttags", 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("ffmpegpath", "")
-	viper.SetDefault("mpvcmdtemplate", "mpv --audio-device=%d --no-audio-display --pause %f --input-ipc-server=%s")
-
-	viper.SetDefault("coverartpriority", "cover.*, folder.*, front.*, embedded, external")
+	viper.SetDefault("probecommand", "ffmpeg %s -f ffmetadata")
+	viper.SetDefault("coverartpriority", "embedded, cover.*, folder.*, front.*")
 	viper.SetDefault("coverjpegquality", 75)
-	viper.SetDefault("artistartpriority", "artist.*, album/artist.*, external")
+	viper.SetDefault("uiwelcomemessage", "")
 	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("enablesharing", false)
-	viper.SetDefault("shareurl", "")
-	viper.SetDefault("defaultdownloadableshare", false)
 	viper.SetDefault("gatrackingid", "")
-	viper.SetDefault("enableinsightscollector", true)
-	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", consts.PrometheusDefaultPath)
-	viper.SetDefault("prometheus.password", "")
-
-	viper.SetDefault("jukebox.enabled", false)
-	viper.SetDefault("jukebox.devices", []AudioDeviceDefinition{})
-	viper.SetDefault("jukebox.default", "")
-	viper.SetDefault("jukebox.adminonly", true)
-
-	viper.SetDefault("scanner.enabled", true)
-	viper.SetDefault("scanner.schedule", "0")
-	viper.SetDefault("scanner.extractor", consts.DefaultScannerExtractor)
-	viper.SetDefault("scanner.watcherwait", consts.DefaultWatcherWait)
-	viper.SetDefault("scanner.scanonstartup", true)
-	viper.SetDefault("scanner.artistjoiner", consts.ArtistJoiner)
-	viper.SetDefault("scanner.genreseparators", "")
-	viper.SetDefault("scanner.groupalbumreleases", false)
-
-	viper.SetDefault("subsonic.appendsubtitle", true)
-	viper.SetDefault("subsonic.artistparticipations", false)
-	viper.SetDefault("subsonic.defaultreportrealpath", false)
-	viper.SetDefault("subsonic.legacyclients", "DSub")
 
+	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("spotify.id", "")
 	viper.SetDefault("spotify.secret", "")
-	viper.SetDefault("listenbrainz.enabled", true)
-	viper.SetDefault("listenbrainz.baseurl", "https://api.listenbrainz.org/1/")
-
-	viper.SetDefault("httpsecurityheaders.customframeoptionsvalue", "DENY")
-
-	viper.SetDefault("backup.path", "")
-	viper.SetDefault("backup.schedule", "")
-	viper.SetDefault("backup.count", 0)
-
-	viper.SetDefault("pid.track", consts.DefaultTrackPID)
-	viper.SetDefault("pid.album", consts.DefaultAlbumPID)
-
-	viper.SetDefault("inspect.enabled", true)
-	viper.SetDefault("inspect.maxrequests", 1)
-	viper.SetDefault("inspect.backloglimit", consts.RequestThrottleBacklogLimit)
-	viper.SetDefault("inspect.backlogtimeout", consts.RequestThrottleBacklogTimeout)
 
 	// DevFlags. These are used to enable/disable debugging and incomplete features
 	viper.SetDefault("devlogsourceline", false)
-	viper.SetDefault("devenableprofiler", false)
 	viper.SetDefault("devautocreateadminpassword", "")
-	viper.SetDefault("devautologinusername", "")
+	viper.SetDefault("devprecachealbumartwork", false)
+	viper.SetDefault("devoldcachelayout", false)
+	viper.SetDefault("devFastAccessCoverArt", false)
 	viper.SetDefault("devactivitypanel", true)
-	viper.SetDefault("devactivitypanelupdaterate", 300*time.Millisecond)
-	viper.SetDefault("devenablebufferedscrobble", true)
-	viper.SetDefault("devsidebarplaylists", true)
-	viper.SetDefault("devshowartistpage", true)
-	viper.SetDefault("devoffsetoptimize", 50000)
-	viper.SetDefault("devartworkmaxrequests", 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)
-	viper.SetDefault("devexternalscanner", true)
-	viper.SetDefault("devscannerthreads", 5)
-	viper.SetDefault("devinsightsinitialdelay", consts.InsightsInitialDelay)
-	viper.SetDefault("devenableplayerinsights", true)
 }
 
 func InitConfig(cfgFile string) {
-	codecRegistry := viper.NewCodecRegistry()
-	_ = codecRegistry.RegisterCodec("ini", ini.Codec{})
-	viper.SetOptions(viper.WithCodecRegistry(codecRegistry))
-
 	cfgFile = getConfigFile(cfgFile)
 	if cfgFile != "" {
 		// Use config file from the flag.
@@ -572,23 +182,15 @@ func InitConfig(cfgFile string) {
 	viper.AutomaticEnv()
 
 	err := viper.ReadInConfig()
-	if viper.ConfigFileUsed() != "" && err != nil {
-		_, _ = fmt.Fprintln(os.Stderr, "FATAL: Navidrome could not open config file: ", err)
+	if cfgFile != "" && err != nil {
+		fmt.Println("Navidrome could not open config file: ", err)
 		os.Exit(1)
 	}
 }
 
-// getConfigFile returns the path to the config file, either from the flag or from the environment variable.
-// If it is defined in the environment variable, it will check if the file exists.
 func getConfigFile(cfgFile string) string {
 	if cfgFile != "" {
 		return cfgFile
 	}
-	cfgFile = os.Getenv("ND_CONFIGFILE")
-	if cfgFile != "" {
-		if _, err := os.Stat(cfgFile); err == nil {
-			return cfgFile
-		}
-	}
-	return ""
+	return os.Getenv("ND_CONFIGFILE")
 }

conf/configuration_test.go

@@ -1,50 +0,0 @@
-package conf_test
-
-import (
-	"fmt"
-	"path/filepath"
-	"testing"
-
-	. "github.com/navidrome/navidrome/conf"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-	"github.com/spf13/viper"
-)
-
-func TestConfiguration(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Configuration Suite")
-}
-
-var _ = Describe("Configuration", func() {
-	BeforeEach(func() {
-		// Reset viper configuration
-		viper.Reset()
-		viper.SetDefault("datafolder", GinkgoT().TempDir())
-		viper.SetDefault("loglevel", "error")
-		ResetConf()
-	})
-
-	DescribeTable("should load configuration from",
-		func(format string) {
-			filename := filepath.Join("testdata", "cfg."+format)
-
-			// Initialize config with the test file
-			InitConfig(filename)
-			// Load the configuration (with noConfigDump=true)
-			Load(true)
-
-			// Execute the format-specific assertions
-			Expect(Server.MusicFolder).To(Equal(fmt.Sprintf("/%s/music", format)))
-			Expect(Server.UIWelcomeMessage).To(Equal("Welcome " + format))
-			Expect(Server.Tags["custom"].Aliases).To(Equal([]string{format, "test"}))
-
-			// The config file used should be the one we created
-			Expect(Server.ConfigFile).To(Equal(filename))
-		},
-		Entry("TOML format", "toml"),
-		Entry("YAML format", "yaml"),
-		Entry("INI format", "ini"),
-		Entry("JSON format", "json"),
-	)
-})

conf/export_test.go

@@ -1,5 +0,0 @@
-package conf
-
-func ResetConf() {
-	Server = &configOptions{}
-}

conf/mime/mime_types.go

@@ -1,48 +0,0 @@
-package mime
-
-import (
-	"mime"
-	"strings"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/resources"
-	"gopkg.in/yaml.v3"
-)
-
-type mimeConf struct {
-	Types    map[string]string `yaml:"types"`
-	Lossless []string          `yaml:"lossless"`
-}
-
-var LosslessFormats []string
-
-func initMimeTypes() {
-	// In some circumstances, Windows sets JS mime-type to `text/plain`!
-	_ = mime.AddExtensionType(".js", "text/javascript")
-	_ = mime.AddExtensionType(".css", "text/css")
-	_ = mime.AddExtensionType(".webmanifest", "application/manifest+json")
-
-	f, err := resources.FS().Open("mime_types.yaml")
-	if err != nil {
-		log.Fatal("Fatal error opening mime_types.yaml", err)
-	}
-	defer f.Close()
-
-	var mimeConf mimeConf
-	err = yaml.NewDecoder(f).Decode(&mimeConf)
-	if err != nil {
-		log.Fatal("Fatal error parsing mime_types.yaml", err)
-	}
-	for ext, typ := range mimeConf.Types {
-		_ = mime.AddExtensionType(ext, typ)
-	}
-
-	for _, ext := range mimeConf.Lossless {
-		LosslessFormats = append(LosslessFormats, strings.TrimPrefix(ext, "."))
-	}
-}
-
-func init() {
-	conf.AddHook(initMimeTypes)
-}

conf/testdata/cfg.ini

@@ -1,6 +0,0 @@
-[default]
-MusicFolder = /ini/music
-UIWelcomeMessage = Welcome ini
-
-[Tags]
-Custom.Aliases = ini,test

conf/testdata/cfg.json

@@ -1,12 +0,0 @@
-{
-  "musicFolder": "/json/music",
-  "uiWelcomeMessage": "Welcome json",
-  "Tags": {
-    "custom": {
-      "aliases": [
-        "json",
-        "test"
-      ]
-    }
-  }
-}

conf/testdata/cfg.toml

@@ -1,5 +0,0 @@
-musicFolder = "/toml/music"
-uiWelcomeMessage = "Welcome toml"
-
-[Tags.custom]
-aliases = ["toml", "test"]

conf/testdata/cfg.yaml

@@ -1,7 +0,0 @@
-musicFolder: "/yaml/music"
-uiWelcomeMessage: "Welcome yaml"
-Tags:
-  custom:
-    aliases:
-      - yaml
-      - test

consts/banner.go

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

@@ -1,167 +1,76 @@
 package consts
 
 import (
-	"os"
+	"crypto/md5"
+	"fmt"
 	"strings"
 	"time"
-
-	"github.com/navidrome/navidrome/model/id"
 )
 
 const (
 	AppName = "navidrome"
 
-	DefaultDbPath                 = "navidrome.db?cache=shared&_busy_timeout=15000&_journal_mode=WAL&_foreign_keys=on&synchronous=normal"
-	InitialSetupFlagKey           = "InitialSetup"
-	FullScanAfterMigrationFlagKey = "FullScanAfterMigration"
+	DefaultDbPath       = "navidrome.db?cache=shared&_busy_timeout=15000&_journal_mode=WAL&_foreign_keys=on"
+	InitialSetupFlagKey = "InitialSetup"
 
-	UIAuthorizationHeader  = "X-ND-Authorization"
-	UIClientUniqueIDHeader = "X-ND-Client-Unique-Id"
-	JWTSecretKey           = "JWTSecret"
-	JWTIssuer              = "ND"
-	DefaultSessionTimeout  = 48 * time.Hour
-	CookieExpiry           = 365 * 24 * 3600 // One year
-
-	OptimizeDBSchedule = "@every 24h"
-
-	// 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
+	UIAuthorizationHeader = "X-ND-Authorization"
+	JWTSecretKey          = "JWTSecret"
+	JWTIssuer             = "ND"
+	DefaultSessionTimeout = 24 * time.Hour
 
 	DevInitialUserName = "admin"
 	DevInitialName     = "Dev Admin"
 
-	URLPathUI           = "/app"
-	URLPathNativeAPI    = "/api"
-	URLPathSubsonicAPI  = "/rest"
-	URLPathPublic       = "/share"
-	URLPathPublicImages = URLPathPublic + "/img"
-
-	// 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
+	URLPathUI          = "/app"
+	URLPathSubsonicAPI = "/rest"
 
 	RequestThrottleBacklogLimit   = 100
 	RequestThrottleBacklogTimeout = time.Minute
 
-	ServerReadHeaderTimeout = 3 * time.Second
+	ArtistInfoTimeToLive = 1 * time.Hour
 
-	ArtistInfoTimeToLive      = 24 * time.Hour
-	AlbumInfoTimeToLive       = 7 * 24 * time.Hour
-	UpdateLastAccessFrequency = time.Minute
-	UpdatePlayerFrequency     = time.Minute
+	I18nFolder   = "i18n"
+	SkipScanFile = ".ndignore"
 
-	I18nFolder     = "i18n"
-	ScanIgnoreFile = ".ndignore"
+	PlaceholderAlbumArt = "navidrome-600x600.png"
+	PlaceholderAvatar   = "logo-192x192.png"
 
-	PlaceholderArtistArt = "artist-placeholder.webp"
-	PlaceholderAlbumArt  = "album-placeholder.webp"
-	PlaceholderAvatar    = "logo-192x192.png"
-	UICoverArtSize       = 300
-	DefaultUIVolume      = 100
-
-	DefaultHttpClientTimeOut = 10 * time.Second
-
-	DefaultScannerExtractor = "taglib"
-	DefaultWatcherWait      = 5 * time.Second
-	Zwsp                    = string('\u200b')
-)
-
-// Prometheus options
-const (
-	PrometheusDefaultPath = "/metrics"
-	PrometheusAuthUser    = "navidrome"
+	DefaultCachedHttpClientTTL = 10 * time.Second
 )
 
 // Cache options
 const (
-	TranscodingCacheDir             = "transcoding"
+	TranscodingCacheDir             = "cache/transcoding"
 	DefaultTranscodingCacheMaxItems = 0 // Unlimited
 
-	ImageCacheDir             = "images"
+	ImageCacheDir             = "cache/images"
 	DefaultImageCacheMaxItems = 0 // Unlimited
 
 	DefaultCacheSize            = 100 * 1024 * 1024 // 100MB
 	DefaultCacheCleanUpInterval = 10 * time.Minute
 )
 
-const (
-	AlbumPlayCountModeAbsolute   = "absolute"
-	AlbumPlayCountModeNormalized = "normalized"
-)
-
-const (
-	//DefaultAlbumPID = "album_legacy"
-	DefaultAlbumPID = "musicbrainz_albumid|albumartistid,album,albumversion,releasedate"
-	DefaultTrackPID = "musicbrainz_trackid|albumid,discnumber,tracknumber,title"
-	PIDAlbumKey     = "PIDAlbum"
-	PIDTrackKey     = "PIDTrack"
-)
-
-const (
-	InsightsIDKey          = "InsightsID"
-	InsightsEndpoint       = "https://insights.navidrome.org/collect"
-	InsightsUpdateInterval = 24 * time.Hour
-	InsightsInitialDelay   = 30 * time.Minute
-)
-
 var (
-	DefaultDownsamplingFormat = "opus"
-	DefaultTranscodings       = []struct {
-		Name           string
-		TargetFormat   string
-		DefaultBitRate int
-		Command        string
-	}{
+	DefaultTranscodings = []map[string]interface{}{
 		{
-			Name:           "mp3 audio",
-			TargetFormat:   "mp3",
-			DefaultBitRate: 192,
-			Command:        "ffmpeg -i %s -ss %t -map 0:a:0 -b:a %bk -v 0 -f mp3 -",
+			"name":           "mp3 audio",
+			"targetFormat":   "mp3",
+			"defaultBitRate": 192,
+			"command":        "ffmpeg -i %s -map 0:0 -b:a %bk -v 0 -f mp3 -",
 		},
 		{
-			Name:           "opus audio",
-			TargetFormat:   "opus",
-			DefaultBitRate: 128,
-			Command:        "ffmpeg -i %s -ss %t -map 0:a:0 -b:a %bk -v 0 -c:a libopus -f opus -",
-		},
-		{
-			Name:           "aac audio",
-			TargetFormat:   "aac",
-			DefaultBitRate: 256,
-			Command:        "ffmpeg -i %s -ss %t -map 0:a:0 -b:a %bk -v 0 -c:a aac -f adts -",
+			"name":           "opus audio",
+			"targetFormat":   "opus",
+			"defaultBitRate": 128,
+			"command":        "ffmpeg -i %s -map 0:0 -b:a %bk -v 0 -c:a libopus -f opus -",
 		},
 	}
 )
 
 var (
-	VariousArtists = "Various Artists"
-	// TODO This will be dynamic when using disambiguation
-	VariousArtistsID = "63sqASlAfjbGMuLP4JhnZU"
-	UnknownAlbum     = "[Unknown Album]"
+	VariousArtists   = "Various Artists"
+	VariousArtistsID = fmt.Sprintf("%x", md5.Sum([]byte(strings.ToLower(VariousArtists))))
 	UnknownArtist    = "[Unknown Artist]"
-	// TODO This will be dynamic when using disambiguation
-	UnknownArtistID     = id.NewHash(strings.ToLower(UnknownArtist))
-	VariousArtistsMbzId = "89ad4ac3-39f7-470e-963a-56509c546377"
 
-	ArtistJoiner = " • "
-)
-
-var (
 	ServerStart = time.Now()
-
-	InContainer = func() bool {
-		// Check if the /.nddockerenv file exists
-		if _, err := os.Stat("/.nddockerenv"); err == nil {
-			return true
-		}
-		return false
-	}()
 )

consts/mime_types.go

@@ -0,0 +1,38 @@
+package consts
+
+import "mime"
+
+func init() {
+	mt := map[string]string{
+		".mp3":  "audio/mpeg",
+		".ogg":  "audio/ogg",
+		".oga":  "audio/ogg",
+		".opus": "audio/ogg",
+		".aac":  "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, typ := range mt {
+		_ = mime.AddExtensionType(ext, typ)
+	}
+}

consts/version.go

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

contrib/docker-compose/Caddyfile

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

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

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

@@ -1,18 +0,0 @@
-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/freebsd_rc

@@ -11,7 +11,7 @@
 #
 # navidrome_enable (bool):              Set to YES to enable navidrome
 #                                       Default: NO
-# navidrome_config (str):               navidrome configuration file
+# navidrome_config (str):               navidrome configration file
 #                                       Default: /usr/local/etc/navidrome/config.toml
 # navidrome_datafolder (str):   navidrome Folder to store application data 
 #                                       Default: www

contrib/k8s/README.md

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

@@ -1,111 +0,0 @@
----
-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,6 +3,7 @@
 [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
@@ -11,34 +12,27 @@ WantedBy=multi-user.target
 User=navidrome
 Group=navidrome
 Type=simple
-ExecStart=/usr/bin/navidrome --configfile "/etc/navidrome/navidrome.toml"
-StateDirectory=navidrome
+ExecStart=/usr/bin/navidrome
 WorkingDirectory=/var/lib/navidrome
 TimeoutStopSec=20
 KillMode=process
 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=@system-service
-SystemCallFilter=~@privileged @resources
-SystemCallFilter=setrlimit
-SystemCallArchitectures=native
-UMask=0066
+SystemCallFilter=~@clock @debug @module @mount @obsolete @privileged @reboot @setuid @swap
+ReadWritePaths=/var/lib/navidrome
 
 # 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 [local_agent](local_agent.go) agent source code.
+For a simple Agent example, look at the [placeholders.go](placeholders.go) agent source code.

core/agents/agents.go

@@ -1,243 +0,0 @@
-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"
-	"github.com/navidrome/navidrome/utils/singleton"
-)
-
-type Agents struct {
-	ds     model.DataStore
-	agents []Interface
-}
-
-func GetAgents(ds model.DataStore) *Agents {
-	return singleton.GetInstance(func() *Agents {
-		return createAgents(ds)
-	})
-}
-
-func createAgents(ds model.DataStore) *Agents {
-	var order []string
-	if conf.Server.Agents != "" {
-		order = strings.Split(conf.Server.Agents, ",")
-	}
-	order = append(order, LocalAgentName)
-	var res []Interface
-	var enabled []string
-	for _, name := range order {
-		init, ok := Map[name]
-		if !ok {
-			log.Error("Invalid agent. Check `Agents` configuration", "name", name, "conf", conf.Server.Agents)
-			continue
-		}
-
-		agent := init(ds)
-		if agent == nil {
-			log.Debug("Agent not available. Missing configuration?", "name", name)
-			continue
-		}
-		enabled = append(enabled, name)
-		res = append(res, agent)
-	}
-	log.Debug("List of agents enabled", "names", enabled)
-
-	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.IsGreaterOrEqualTo(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/v2"
+	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
 
 func TestAgents(t *testing.T) {
 	tests.Init(t, false)
-	log.SetLevel(log.LevelFatal)
+	log.SetLevel(log.LevelCritical)
 	RegisterFailHandler(Fail)
 	RunSpecs(t, "Agents Test Suite")
 }

core/agents/agents_test.go

@@ -1,357 +0,0 @@
-package agents
-
-import (
-	"context"
-	"errors"
-
-	"github.com/navidrome/navidrome/consts"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
-	"github.com/navidrome/navidrome/utils/slice"
-
-	"github.com/navidrome/navidrome/conf"
-	. "github.com/onsi/ginkgo/v2"
-	. "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 = createAgents(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(model.DataStore) Interface { return mock })
-			Register("disabled", func(model.DataStore) Interface { return nil })
-			Register("empty", func(model.DataStore) Interface { return &emptyAgent{} })
-			conf.Server.Agents = "empty,fake,disabled"
-			ag = createAgents(ds)
-			Expect(ag.AgentName()).To(Equal("agents"))
-		})
-
-		It("does not register disabled agents", func() {
-			ags := slice.Map(ag.agents, func(a Interface) string { return a.AgentName() })
-			// local agent is always appended to the end of the agents list
-			Expect(ags).To(HaveExactElements("empty", "fake", "local"))
-			Expect(ags).ToNot(ContainElement("disabled"))
-		})
-
-		Describe("GetArtistMBID", func() {
-			It("returns on first match", func() {
-				Expect(ag.GetArtistMBID(ctx, "123", "test")).To(Equal("mbid"))
-				Expect(mock.Args).To(HaveExactElements("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(HaveExactElements("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(HaveExactElements("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(HaveExactElements("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(HaveExactElements("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(HaveExactElements("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(HaveExactElements("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(HaveExactElements("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(HaveExactElements("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(HaveExactElements("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(HaveExactElements("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(HaveExactElements("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(HaveExactElements("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(HaveExactElements("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
-}
-
-type emptyAgent struct {
-	Interface
-}
-
-func (e *emptyAgent) AgentName() string {
-	return "empty"
-}

core/agents/cached_http_client.go

@@ -1,4 +1,4 @@
-package cache
+package agents
 
 import (
 	"bufio"
@@ -6,19 +6,20 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"io"
+	"io/ioutil"
 	"net/http"
 	"strings"
 	"time"
 
+	"github.com/ReneKroon/ttlcache/v2"
 	"github.com/navidrome/navidrome/log"
 )
 
 const cacheSizeLimit = 100
 
-type HTTPClient struct {
-	cache SimpleCache[string, string]
+type CachedHTTPClient struct {
+	cache *ttlcache.Cache
 	hc    httpDoer
-	ttl   time.Duration
 }
 
 type httpDoer interface {
@@ -32,49 +33,45 @@ type requestData struct {
 	Body   *string
 }
 
-func NewHTTPClient(wrapped httpDoer, ttl time.Duration) *HTTPClient {
-	c := &HTTPClient{hc: wrapped, ttl: ttl}
-	c.cache = NewSimpleCache[string, string](Options{
-		SizeLimit:  cacheSizeLimit,
-		DefaultTTL: ttl,
+func NewCachedHTTPClient(wrapped httpDoer, ttl time.Duration) *CachedHTTPClient {
+	c := &CachedHTTPClient{hc: wrapped}
+	c.cache = ttlcache.NewCache()
+	c.cache.SetCacheSizeLimit(cacheSizeLimit)
+	c.cache.SkipTTLExtensionOnHit(true)
+	c.cache.SetLoaderFunction(func(key string) (interface{}, time.Duration, error) {
+		req, err := c.deserializeReq(key)
+		if err != nil {
+			return nil, 0, err
+		}
+		resp, err := c.hc.Do(req)
+		if err != nil {
+			return nil, 0, err
+		}
+		return c.serializeResponse(resp), ttl, nil
+	})
+	c.cache.SetNewItemCallback(func(key string, value interface{}) {
+		log.Trace("New request cached", "req", key, "resp", value)
 	})
 	return c
 }
 
-func (c *HTTPClient) Do(req *http.Request) (*http.Response, error) {
+func (c *CachedHTTPClient) Do(req *http.Request) (*http.Response, error) {
 	key := c.serializeReq(req)
-	cached := true
-	start := time.Now()
-	respStr, err := c.cache.GetWithLoader(key, func(key string) (string, time.Duration, error) {
-		cached = false
-		req, err := c.deserializeReq(key)
-		if err != nil {
-			log.Trace(req.Context(), "CachedHTTPClient.Do", "key", key, err)
-			return "", 0, err
-		}
-		resp, err := c.hc.Do(req)
-		if err != nil {
-			log.Trace(req.Context(), "CachedHTTPClient.Do", "req", req, err)
-			return "", 0, err
-		}
-		defer resp.Body.Close()
-		return c.serializeResponse(resp), c.ttl, nil
-	})
-	log.Trace(req.Context(), "CachedHTTPClient.Do", "key", key, "cached", cached, "elapsed", time.Since(start), err)
+	respStr, err := c.cache.Get(key)
 	if err != nil {
 		return nil, err
 	}
-	return c.deserializeResponse(req, respStr)
+	return c.deserializeResponse(req, respStr.(string))
 }
 
-func (c *HTTPClient) serializeReq(req *http.Request) string {
+func (c *CachedHTTPClient) serializeReq(req *http.Request) string {
 	data := requestData{
 		Method: req.Method,
 		Header: req.Header,
 		URL:    req.URL.String(),
 	}
 	if req.Body != nil {
-		bodyData, _ := io.ReadAll(req.Body)
+		bodyData, _ := ioutil.ReadAll(req.Body)
 		bodyStr := base64.StdEncoding.EncodeToString(bodyData)
 		data.Body = &bodyStr
 	}
@@ -82,7 +79,7 @@ func (c *HTTPClient) serializeReq(req *http.Request) string {
 	return string(j)
 }
 
-func (c *HTTPClient) deserializeReq(reqStr string) (*http.Request, error) {
+func (c *CachedHTTPClient) deserializeReq(reqStr string) (*http.Request, error) {
 	var data requestData
 	_ = json.Unmarshal([]byte(reqStr), &data)
 	var body io.Reader
@@ -98,13 +95,13 @@ func (c *HTTPClient) deserializeReq(reqStr string) (*http.Request, error) {
 	return req, nil
 }
 
-func (c *HTTPClient) serializeResponse(resp *http.Response) string {
+func (c *CachedHTTPClient) serializeResponse(resp *http.Response) string {
 	var b = &bytes.Buffer{}
 	_ = resp.Write(b)
 	return b.String()
 }
 
-func (c *HTTPClient) deserializeResponse(req *http.Request, respStr string) (*http.Response, error) {
+func (c *CachedHTTPClient) deserializeResponse(req *http.Request, respStr string) (*http.Response, error) {
 	r := bufio.NewReader(strings.NewReader(respStr))
 	return http.ReadResponse(r, req)
 }

core/agents/cached_http_client_test.go

@@ -1,20 +1,20 @@
-package cache
+package agents
 
 import (
 	"fmt"
-	"io"
+	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
 	"time"
 
 	"github.com/navidrome/navidrome/consts"
-	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
 
-var _ = Describe("HTTPClient", func() {
+var _ = Describe("CachedHttpClient", func() {
 	Context("GET", func() {
-		var chc *HTTPClient
+		var chc *CachedHTTPClient
 		var ts *httptest.Server
 		var requestsReceived int
 		var header string
@@ -25,7 +25,7 @@ var _ = Describe("HTTPClient", func() {
 				header = r.Header.Get("head")
 				_, _ = fmt.Fprintf(w, "Hello, %s", r.URL.Query()["name"])
 			}))
-			chc = NewHTTPClient(http.DefaultClient, consts.DefaultHttpClientTimeOut)
+			chc = NewCachedHTTPClient(http.DefaultClient, consts.DefaultCachedHttpClientTTL)
 		})
 
 		AfterEach(func() {
@@ -36,7 +36,7 @@ var _ = Describe("HTTPClient", func() {
 			r, _ := http.NewRequest("GET", ts.URL+"?name=doe", nil)
 			resp, err := chc.Do(r)
 			Expect(err).To(BeNil())
-			body, err := io.ReadAll(resp.Body)
+			body, err := ioutil.ReadAll(resp.Body)
 			Expect(err).To(BeNil())
 			Expect(string(body)).To(Equal("Hello, [doe]"))
 			Expect(requestsReceived).To(Equal(1))
@@ -45,7 +45,7 @@ var _ = Describe("HTTPClient", func() {
 			r, _ = http.NewRequest("GET", ts.URL+"?name=doe", nil)
 			resp, err = chc.Do(r)
 			Expect(err).To(BeNil())
-			body, err = io.ReadAll(resp.Body)
+			body, err = ioutil.ReadAll(resp.Body)
 			Expect(err).To(BeNil())
 			Expect(string(body)).To(Equal("Hello, [doe]"))
 			Expect(requestsReceived).To(Equal(1))
@@ -54,7 +54,7 @@ var _ = Describe("HTTPClient", func() {
 			r, _ = http.NewRequest("GET", ts.URL, nil)
 			resp, err = chc.Do(r)
 			Expect(err).To(BeNil())
-			body, err = io.ReadAll(resp.Body)
+			body, err = ioutil.ReadAll(resp.Body)
 			Expect(err).To(BeNil())
 			Expect(string(body)).To(Equal("Hello, []"))
 			Expect(requestsReceived).To(Equal(2))
@@ -64,7 +64,7 @@ var _ = Describe("HTTPClient", func() {
 			r.Header.Add("head", "this is a header")
 			resp, err = chc.Do(r)
 			Expect(err).To(BeNil())
-			body, err = io.ReadAll(resp.Body)
+			body, err = ioutil.ReadAll(resp.Body)
 			Expect(err).To(BeNil())
 			Expect(string(body)).To(Equal("Hello, []"))
 			Expect(header).To(Equal("this is a header"))
@@ -73,7 +73,7 @@ var _ = Describe("HTTPClient", func() {
 
 		It("expires responses after TTL", func() {
 			requestsReceived = 0
-			chc = NewHTTPClient(http.DefaultClient, 10*time.Millisecond)
+			chc = NewCachedHTTPClient(http.DefaultClient, 10*time.Millisecond)
 
 			r, _ := http.NewRequest("GET", ts.URL+"?name=doe", nil)
 			_, err := chc.Do(r)

core/agents/interfaces.go

@@ -3,30 +3,20 @@ package agents
 import (
 	"context"
 	"errors"
-
-	"github.com/navidrome/navidrome/model"
 )
 
-type Constructor func(ds model.DataStore) Interface
+type Constructor func(ctx context.Context) 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 ExternalImage struct {
+type ArtistImage struct {
 	URL  string
 	Size int
 }
@@ -40,33 +30,28 @@ 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 {
-	GetArtistMBID(ctx context.Context, id string, name string) (string, error)
+	GetMBID(id string, name string) (string, error)
 }
 
 type ArtistURLRetriever interface {
-	GetArtistURL(ctx context.Context, id, name, mbid string) (string, error)
+	GetURL(id, name, mbid string) (string, error)
 }
 
 type ArtistBiographyRetriever interface {
-	GetArtistBiography(ctx context.Context, id, name, mbid string) (string, error)
+	GetBiography(id, name, mbid string) (string, error)
 }
 
 type ArtistSimilarRetriever interface {
-	GetSimilarArtists(ctx context.Context, id, name, mbid string, limit int) ([]Artist, error)
+	GetSimilar(id, name, mbid string, limit int) ([]Artist, error)
 }
 
 type ArtistImageRetriever interface {
-	GetArtistImages(ctx context.Context, id, name, mbid string) ([]ExternalImage, error)
+	GetImages(id, name, mbid string) ([]ArtistImage, error)
 }
 
 type ArtistTopSongsRetriever interface {
-	GetArtistTopSongs(ctx context.Context, id, artistName, mbid string, count int) ([]Song, error)
+	GetTopSongs(id, artistName, mbid string, count int) ([]Song, error)
 }
 
 var Map map[string]Constructor

core/agents/lastfm.go

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

@@ -1,361 +0,0 @@
-package lastfm
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"regexp"
-	"strconv"
-	"strings"
-	"sync"
-
-	"github.com/andybalholm/cascadia"
-	"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/cache"
-	"golang.org/x/net/html"
-)
-
-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
-	getInfoMutex sync.Mutex
-}
-
-func lastFMConstructor(ds model.DataStore) *lastfmAgent {
-	if !conf.Server.LastFM.Enabled || conf.Server.LastFM.ApiKey == "" || conf.Server.LastFM.Secret == "" {
-		return nil
-	}
-	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 := cache.NewHTTPClient(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)
-	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)
-	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, 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, 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
-}
-
-var artistOpenGraphQuery = cascadia.MustCompile(`html > head > meta[property="og:image"]`)
-
-func (l *lastfmAgent) GetArtistImages(ctx context.Context, _, name, mbid string) ([]agents.ExternalImage, error) {
-	log.Debug(ctx, "Getting artist images from Last.fm", "name", name)
-	hc := http.Client{
-		Timeout: consts.DefaultHttpClientTimeOut,
-	}
-	a, err := l.callArtistGetInfo(ctx, name)
-	if err != nil {
-		return nil, fmt.Errorf("get artist info: %w", err)
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, a.URL, nil)
-	if err != nil {
-		return nil, fmt.Errorf("create artist image request: %w", err)
-	}
-	resp, err := hc.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("get artist url: %w", err)
-	}
-	defer resp.Body.Close()
-
-	node, err := html.Parse(resp.Body)
-	if err != nil {
-		return nil, fmt.Errorf("parse html: %w", err)
-	}
-
-	var res []agents.ExternalImage
-	n := cascadia.Query(node, artistOpenGraphQuery)
-	if n == nil {
-		return res, nil
-	}
-	for _, attr := range n.Attr {
-		if attr.Key == "content" {
-			res = []agents.ExternalImage{
-				{URL: attr.Val},
-			}
-			break
-		}
-	}
-	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.Debug(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) (*Artist, error) {
-	l.getInfoMutex.Lock()
-	defer l.getInfoMutex.Unlock()
-
-	a, err := l.client.artistGetInfo(ctx, name)
-	if err != nil {
-		log.Error(ctx, "Error calling LastFM/artist.getInfo", "artist", name, err)
-		return nil, err
-	}
-	return a, nil
-}
-
-func (l *lastfmAgent) callArtistGetSimilar(ctx context.Context, name string, limit int) ([]Artist, error) {
-	s, err := l.client.artistGetSimilar(ctx, name, limit)
-	if err != nil {
-		log.Error(ctx, "Error calling LastFM/artist.getSimilar", "artist", name, err)
-		return nil, err
-	}
-	return s.Artists, nil
-}
-
-func (l *lastfmAgent) callArtistGetTopTracks(ctx context.Context, artistName string, count int) ([]Track, error) {
-	t, err := l.client.artistGetTopTracks(ctx, artistName, count)
-	if err != nil {
-		log.Error(ctx, "Error calling LastFM/artist.getTopTracks", "artist", artistName, 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.MbzRecordingID,
-		duration:    int(track.Duration),
-		albumArtist: track.AlbumArtist,
-	})
-	if err != nil {
-		log.Warn(ctx, "Last.fm client.updateNowPlaying returned error", "track", track.Title, err)
-		return errors.Join(err, 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 errors.Join(err, 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.MbzRecordingID,
-		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 errors.Join(err, scrobbler.ErrRetryLater)
-	}
-	if lfErr.Code == 11 || lfErr.Code == 16 {
-		return errors.Join(err, scrobbler.ErrRetryLater)
-	}
-	return errors.Join(err, 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() {
-		agents.Register(lastFMAgentName, func(ds model.DataStore) agents.Interface {
-			a := lastFMConstructor(ds)
-			if a != nil {
-				return a
-			}
-			return nil
-		})
-		scrobbler.Register(lastFMAgentName, func(ds model.DataStore) scrobbler.Scrobbler {
-			a := lastFMConstructor(ds)
-			if a != nil {
-				return a
-			}
-			return nil
-		})
-	})
-}

core/agents/lastfm/agent_test.go

@@ -1,392 +0,0 @@
-package lastfm
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"io"
-	"net/http"
-	"os"
-	"strconv"
-	"time"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/conf/configtest"
-	"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()
-		DeferCleanup(configtest.SetupConfig())
-		conf.Server.LastFM.Enabled = true
-		conf.Server.LastFM.ApiKey = "123"
-		conf.Server.LastFM.Secret = "secret"
-	})
-	Describe("lastFMConstructor", func() {
-		When("Agent is properly configured", func() {
-			It("uses configured api key and language", func() {
-				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"))
-			})
-		})
-		When("Agent is disabled", func() {
-			It("returns nil", func() {
-				conf.Server.LastFM.Enabled = false
-				Expect(lastFMConstructor(ds)).To(BeNil())
-			})
-		})
-		When("ApiKey is empty", func() {
-			It("returns nil", func() {
-				conf.Server.LastFM.ApiKey = ""
-				Expect(lastFMConstructor(ds)).To(BeNil())
-			})
-		})
-		When("Secret is empty", func() {
-			It("returns nil", func() {
-				conf.Server.LastFM.Secret = ""
-				Expect(lastFMConstructor(ds)).To(BeNil())
-			})
-		})
-	})
-
-	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", "")).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("artist")).To(Equal("U2"))
-		})
-
-		It("returns an error if Last.fm call fails", func() {
-			httpClient.Err = errors.New("error")
-			_, err := agent.GetArtistBiography(ctx, "123", "U2", "")
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Query().Get("artist")).To(Equal("U2"))
-		})
-
-		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", "")
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Query().Get("artist")).To(Equal("U2"))
-		})
-	})
-
-	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", "", 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("artist")).To(Equal("U2"))
-		})
-
-		It("returns an error if Last.fm call fails", func() {
-			httpClient.Err = errors.New("error")
-			_, err := agent.GetSimilarArtists(ctx, "123", "U2", "", 2)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Query().Get("artist")).To(Equal("U2"))
-		})
-
-		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", "", 2)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Query().Get("artist")).To(Equal("U2"))
-		})
-	})
-
-	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", "", 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("artist")).To(Equal("U2"))
-		})
-
-		It("returns an error if Last.fm call fails", func() {
-			httpClient.Err = errors.New("error")
-			_, err := agent.GetArtistTopSongs(ctx, "123", "U2", "", 2)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Query().Get("artist")).To(Equal("U2"))
-		})
-
-		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", "", 2)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Query().Get("artist")).To(Equal("U2"))
-		})
-	})
-
-	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,
-				MbzRecordingID: "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.MbzRecordingID))
-			})
-
-			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.MbzRecordingID))
-				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

@@ -1,132 +0,0 @@
-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/req"
-)
-
-//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{}{
-		"apiKey": s.apiKey,
-	}
-	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) {
-	p := req.Params(r)
-	token, err := p.String("token")
-	if err != nil {
-		_ = rest.RespondWithError(w, http.StatusBadRequest, "token not received")
-		return
-	}
-	uid, err := p.String("uid")
-	if err != nil {
-		_ = 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

@@ -1,233 +0,0 @@
-package lastfm
-
-import (
-	"context"
-	"crypto/md5"
-	"encoding/hex"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/url"
-	"slices"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/navidrome/navidrome/log"
-)
-
-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) (*Artist, error) {
-	params := url.Values{}
-	params.Add("method", "artist.getInfo")
-	params.Add("artist", name)
-	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, limit int) (*SimilarArtists, error) {
-	params := url.Values{}
-	params.Add("method", "artist.getSimilar")
-	params.Add("artist", name)
-	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, limit int) (*TopTracks, error) {
-	params := url.Values{}
-	params.Add("method", "artist.getTopTracks")
-	params.Add("artist", name)
-	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

@@ -1,173 +0,0 @@
-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")
-			Expect(err).To(BeNil())
-			Expect(artist.Name).To(Equal("U2"))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(apiBaseUrl + "?api_key=API_KEY&artist=U2&format=json&lang=pt&method=artist.getInfo"))
-		})
-
-		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")
-			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")
-			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")
-			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")
-			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")
-			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", 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&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", 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&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/responses.go

@@ -1,119 +0,0 @@
-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/token_received.html

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

@@ -1,129 +0,0 @@
-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/cache"
-	"github.com/navidrome/navidrome/utils/slice"
-)
-
-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 := cache.NewHTTPClient(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 {
-	artistMBIDs := slice.Map(track.Participants[model.RoleArtist], func(p model.Participant) string {
-		return p.MbzArtistID
-	})
-	artistNames := slice.Map(track.Participants[model.RoleArtist], func(p model.Participant) string {
-		return p.Name
-	})
-	li := listenInfo{
-		TrackMetadata: trackMetadata{
-			ArtistName:  track.Artist,
-			TrackName:   track.Title,
-			ReleaseName: track.Album,
-			AdditionalInfo: additionalInfo{
-				SubmissionClient:        consts.AppName,
-				SubmissionClientVersion: consts.Version,
-				TrackNumber:             track.TrackNumber,
-				ArtistNames:             artistNames,
-				ArtistMBIDs:             artistMBIDs,
-				RecordingMBID:           track.MbzRecordingID,
-				ReleaseMBID:             track.MbzAlbumID,
-				ReleaseGroupMBID:        track.MbzReleaseGroupID,
-				DurationMs:              int(track.Duration * 1000),
-			},
-		},
-	}
-	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 errors.Join(err, 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 errors.Join(err, 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 errors.Join(err, 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 errors.Join(err, scrobbler.ErrRetryLater)
-	}
-	if lbErr.Code == 500 || lbErr.Code == 503 {
-		return errors.Join(err, scrobbler.ErrRetryLater)
-	}
-	return errors.Join(err, 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

@@ -1,165 +0,0 @@
-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,
-			MbzRecordingID:    "mbz-123",
-			MbzAlbumID:        "mbz-456",
-			MbzReleaseGroupID: "mbz-789",
-			Duration:          142.2,
-			Participants: map[model.Role]model.ParticipantList{
-				model.RoleArtist: []model.Participant{
-					{Artist: model.Artist{ID: "ar-1", Name: "Artist 1", MbzArtistID: "mbz-111"}},
-					{Artist: model.Artist{ID: "ar-2", Name: "Artist 2", MbzArtistID: "mbz-222"}},
-				},
-			},
-		}
-	})
-
-	Describe("formatListen", func() {
-		It("constructs the listenInfo properly", func() {
-			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),
-						"RecordingMBID":           Equal(track.MbzRecordingID),
-						"ReleaseMBID":             Equal(track.MbzAlbumID),
-						"ReleaseGroupMBID":        Equal(track.MbzReleaseGroupID),
-						"ArtistNames":             ConsistOf("Artist 1", "Artist 2"),
-						"ArtistMBIDs":             ConsistOf("mbz-111", "mbz-222"),
-						"DurationMs":              Equal(142200),
-					}),
-				}),
-			}))
-		})
-	})
-
-	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

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

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

@@ -1,179 +0,0 @@
-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"`
-	ArtistNames             []string `json:"artist_names,omitempty"`
-	ArtistMBIDs             []string `json:"artist_mbids,omitempty"`
-	RecordingMBID           string   `json:"recording_mbid,omitempty"`
-	ReleaseMBID             string   `json:"release_mbid,omitempty"`
-	ReleaseGroupMBID        string   `json:"release_group_mbid,omitempty"`
-	DurationMs              int      `json:"duration_ms,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

@@ -1,120 +0,0 @@
-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,
-						ArtistNames:   []string{"Artist 1", "Artist 2"},
-						ArtistMBIDs:   []string{"mbz-789", "mbz-012"},
-						RecordingMBID: "mbz-123",
-						ReleaseMBID:   "mbz-456",
-						DurationMs:    142200,
-					},
-				},
-			}
-		})
-
-		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

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

@@ -1,52 +0,0 @@
-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/mcp/mcp-server/.gitignore

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

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

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

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

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

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

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

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

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

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

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