Skip to content

[MAYBE A BUG] Issue with search : not precise as subsonic using octo-fiesta #14

@Leiasticot

Description

@Leiasticot

Describe the bug
Hello, I don't know if it's a bug or not.. But whenever I search with Allstarr I don't have results as precise as the ones I get with Octo-Fiesta.
Here's an example : when I search for BTS, I have the song "We are bulletproof" in my local library, with Octo-Fiesta I found it but not with Allstarr.

Screenshots
Jellyfin with Allstarr :
Image

Subsonic with octo-fiesta :
Image

Details (please complete the following information):

  • Version 1.4.3
  • Client Feishin
docker-compose.yaml
services:
  jellyfin:
    image: lscr.io/linuxserver/jellyfin:latest
    container_name: jellyfin
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Etc/UTC
      - DOCKER_MODS=linuxserver/mods:jellyfin-opencl-intel
    devices:
      - /dev/dri/renderD128:/dev/dri/renderD128
      - /dev/dri/card0:/dev/dri/card0
    group_add:
      - "992"
    volumes:
      - /srv/app/services/jellyfin:/config
      - /mnt/blackpearl/seedbox/music:/music:ro
      - /srv/app/services/allstarr/data/cache:/cache:ro # Le cache Allstarr (Lecture seule)
    ports:
      - 8096:8096
      - 8920:8920 #optional
      - 7359:7359/udp #optional
      - 1900:1900/udp #optional
    restart: unless-stopped

  feishin_test:
    container_name: feishin_test
    image: 'ghcr.io/jeffvli/feishin:latest'
    restart: unless-stopped
    environment:
      - SERVER_NAME=k8 # pre-defined server name
      - SERVER_LOCK=true
      - SERVER_URL=http://10.10.20.100:5276 # http://address:port or https://address:port
      - SERVER_TYPE=jellyfin # the allowed types are: jellyfin, navidrome, subsonic. These values are case insensitive
      - LEGACY_AUTHENTICATION=false # When SERVER_LOCK is true, sets the legacy (plaintext) authentication flag for Subsonic/OpenSubsonic s>
      - ANALYTICS_DISABLED=true # Set to true to disable Umami analytics tracking
    ports:
      - 9182:9180
  valkey:
    image: valkey/valkey:8
    container_name: allstarr-valkey
    restart: unless-stopped
    # Valkey is only accessible internally - no external port exposure
    expose:
      - "6379"
    command: valkey-server --maxmemory 1gb --maxmemory-policy allkeys-lru --save 60 1 --appendonly yes
    healthcheck:
      # Use CMD-SHELL for broader compatibility in some environments
      test: ["CMD-SHELL", "valkey-cli ping || exit 1"]
      interval: 10s
      timeout: 3s
      retries: 5
      start_period: 20s
    volumes:
      - ${REDIS_DATA_PATH:-./redis-data}:/data

  # Spotify Lyrics API sidecar service
  # Note: This image only supports AMD64. On ARM64 systems, Docker will use emulation.
  spotify-lyrics:
    image: akashrchandran/spotify-lyrics-api:latest
    platform: linux/amd64
    container_name: allstarr-spotify-lyrics
    restart: unless-stopped
    ports:
      - "8365:8080"
    environment:
      - SP_DC=${SPOTIFY_API_SESSION_COOKIE:-}

  allstarr:
    image: ghcr.io/sopat712/allstarr:latest
    container_name: allstarr
    user: "1000:1000"
    group_add:
      - "991"
    restart: unless-stopped
    ports:
      - "5276:8080"
      # Admin UI on port 5275 - for local/Tailscale access only
      - "5275:5275"
    depends_on:
      valkey:
        condition: service_healthy
      spotify-lyrics:
        condition: service_started
      jellyfin:
        condition: service_started
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    environment:
      - ASPNETCORE_ENVIRONMENT=Production
      # Backend type: Subsonic or Jellyfin (default: Subsonic)
      - Backend__Type=${BACKEND_TYPE:-Jellyfin}

      - Admin__BindAnyIp=${ADMIN_BIND_ANY_IP:-false}
      - Admin__TrustedSubnets=${ADMIN_TRUSTED_SUBNETS:-}

      # ===== REDIS CACHE =====
      - Redis__ConnectionString=valkey:6379
      - Redis__Enabled=${REDIS_ENABLED:-true}

      # ===== CACHE TTL SETTINGS =====
      - Cache__SearchResultsMinutes=${CACHE_SEARCH_RESULTS_MINUTES:-1}
      - Cache__PlaylistImagesHours=${CACHE_PLAYLIST_IMAGES_HOURS:-168}
      - Cache__SpotifyPlaylistItemsHours=${CACHE_SPOTIFY_PLAYLIST_ITEMS_HOURS:-168}
      - Cache__SpotifyMatchedTracksDays=${CACHE_SPOTIFY_MATCHED_TRACKS_DAYS:-30}
      - Cache__LyricsDays=${CACHE_LYRICS_DAYS:-14}
      - Cache__GenreDays=${CACHE_GENRE_DAYS:-30}
      - Cache__MetadataDays=${CACHE_METADATA_DAYS:-7}
      - Cache__OdesliLookupDays=${CACHE_ODESLI_LOOKUP_DAYS:-60}
      - Cache__ProxyImagesDays=${CACHE_PROXY_IMAGES_DAYS:-14}
      - Cache__TranscodeCacheMinutes=${CACHE_TRANSCODE_MINUTES:-60}

      # ===== JELLYFIN BACKEND =====
      - Jellyfin__Url=${JELLYFIN_URL:-http://localhost:8096}
      - Jellyfin__ApiKey=${JELLYFIN_API_KEY:-}
      - Jellyfin__UserId=${JELLYFIN_USER_ID:-}
      - Jellyfin__LibraryId=${JELLYFIN_LIBRARY_ID:-}
      - Jellyfin__ClientUsername=${JELLYFIN_CLIENT_USERNAME:-}
      - Jellyfin__ExplicitFilter=${EXPLICIT_FILTER:-ExplicitOnly}
      - Jellyfin__DownloadMode=${DOWNLOAD_MODE:-Track}
      - Jellyfin__MusicService=${MUSIC_SERVICE:-SquidWTF}
      - Jellyfin__StorageMode=${STORAGE_MODE:-Permanent}
      - Jellyfin__CacheDurationHours=${CACHE_DURATION_HOURS:-1}
      - Jellyfin__EnableExternalPlaylists=${ENABLE_EXTERNAL_PLAYLISTS:-true}
      - Jellyfin__PlaylistsDirectory=${PLAYLISTS_DIRECTORY:-playlists}

      # ===== SPOTIFY DIRECT API (for lyrics, ISRC matching, track ordering) =====
      - SpotifyApi__Enabled=${SPOTIFY_API_ENABLED:-false}
      - SpotifyApi__SessionCookie=${SPOTIFY_API_SESSION_COOKIE:-}
      - SpotifyApi__SessionCookieSetDate=${SPOTIFY_API_SESSION_COOKIE_SET_DATE:-}
      - SpotifyApi__CacheDurationMinutes=${SPOTIFY_API_CACHE_DURATION_MINUTES:-60}
      - SpotifyApi__RateLimitDelayMs=${SPOTIFY_API_RATE_LIMIT_DELAY_MS:-100}
      - SpotifyApi__PreferIsrcMatching=${SPOTIFY_API_PREFER_ISRC_MATCHING:-true}
      # Spotify Lyrics API sidecar service URL (internal)
      - SpotifyApi__LyricsApiUrl=${SPOTIFY_LYRICS_API_URL:-http://spotify-lyrics:8080}

      # ===== SCROBBLING (LAST.FM, LISTENBRAINZ) =====
      - Scrobbling__Enabled=${SCROBBLING_ENABLED:-false}
      - Scrobbling__LocalTracksEnabled=${SCROBBLING_LOCAL_TRACKS_ENABLED:-false}
      - Scrobbling__SyntheticLocalPlayedSignalEnabled=${SCROBBLING_SYNTHETIC_LOCAL_PLAYED_SIGNAL_ENABLED:-false}
      - Scrobbling__ListenBrainz__Enabled=${SCROBBLING_LISTENBRAINZ_ENABLED:-false}
      - Scrobbling__ListenBrainz__UserToken=${SCROBBLING_LISTENBRAINZ_USER_TOKEN:-}

      # ===== DEBUG SETTINGS =====
      - Debug__LogAllRequests=${DEBUG_LOG_ALL_REQUESTS:-false}
      - Debug__RedactSensitiveRequestValues=${DEBUG_REDACT_SENSITIVE_REQUEST_VALUES:-false}

      # ===== SHARED =====
      - Library__DownloadPath=/app/downloads
      - SquidWTF__Quality=${SQUIDWTF_QUALITY:-FLAC}
      - MusicBrainz__Enabled=${MUSICBRAINZ_ENABLED:-true}
      - MusicBrainz__Username=${MUSICBRAINZ_USERNAME:-}
      - MusicBrainz__Password=${MUSICBRAINZ_PASSWORD:-}
    volumes:
      - ${DOWNLOAD_PATH:-./downloads}:/app/downloads
      - ${KEPT_PATH:-./kept}:/app/kept
      - ${CACHE_PATH:-./cache}:/app/cache
      - ./.env:/app/.env
      # Docker socket for self-restart capability (admin UI only)
      - /var/run/docker.sock:/var/run/docker.sock:ro
.env
# ===== BACKEND SELECTION =====
# Choose which media server backend to use: Subsonic or Jellyfin
BACKEND_TYPE=Jellyfin

# ===== ADMIN NETWORK ACCESS (PORT 5275) =====
# Keep false to bind admin UI to localhost only (recommended)
# Set true only if you need LAN access from another device
ADMIN_BIND_ANY_IP=true

# Comma-separated trusted CIDR ranges allowed to access admin port when bind is enabled
# Examples: 192.168.1.0/24,10.0.0.0/8
ADMIN_TRUSTED_SUBNETS=10.0.0.0/8,10.99.99.0/24

# ===== CORS POLICY =====
# Cross-origin requests are disabled by default.
# Set explicit origins if you need browser access from another host.
# Example: https://my-jellyfin.example.com,http://localhost:3000
CORS_ALLOWED_ORIGINS=http://10.10.20.100:3000

# Explicit allowed methods and headers for CORS preflight.
# Keep these restrictive unless you have a concrete requirement.
CORS_ALLOWED_METHODS=GET,POST,PUT,PATCH,DELETE,OPTIONS,HEAD
CORS_ALLOWED_HEADERS=Accept,Authorization,Content-Type,Range,X-Requested-With,X-Emby-Authorization,X-MediaBrowser-Token

# Set true only when your allowed origins require cookies/auth credentials.
CORS_ALLOW_CREDENTIALS=false

# ===== REDIS CACHE (REQUIRED) =====
# Redis is the primary cache for all runtime data (search results, playlists, lyrics, etc.)
# File cache (/app/cache) acts as a persistence layer for cold starts
# Redis snapshots to disk every 60 seconds + AOF for durability

# Redis data persistence directory (default: ./redis-data)
# Contains Redis RDB snapshots and AOF logs for crash recovery
# Keep this separate from CACHE_PATH / ./cache. It should only contain Valkey persistence files.
REDIS_DATA_PATH=/srv/app/services/allstarr/valkey

# ===== CACHE TTL SETTINGS =====
# Configure how long different types of data are cached
# Longer durations reduce API calls but may show stale data
# All values are configurable via Web UI (Configuration tab > Cache Settings)
# Changes require container restart to apply

# Search results cache duration in minutes (default: 1)
CACHE_SEARCH_RESULTS_MINUTES=1

# Playlist cover images cache duration in hours (default: 168 = 1 week)
CACHE_PLAYLIST_IMAGES_HOURS=168

# Spotify playlist items cache duration in hours (default: 168 = 1 week)
CACHE_SPOTIFY_PLAYLIST_ITEMS_HOURS=168
# Spotify matched tracks cache duration in days (default: 30 days)
# This is the mapping of Spotify IDs to local/external tracks
CACHE_SPOTIFY_MATCHED_TRACKS_DAYS=30

# Lyrics cache duration in days (default: 14 = 2 weeks)
CACHE_LYRICS_DAYS=14

# Genre data cache duration in days (default: 30 days)
CACHE_GENRE_DAYS=30

# External metadata (SquidWTF/Deezer/Qobuz) cache duration in days (default: 7 days)
CACHE_METADATA_DAYS=7

# Odesli URL conversion cache duration in days (default: 60 days)
CACHE_ODESLI_LOOKUP_DAYS=60

# Jellyfin proxy images cache duration in days (default: 14 = 2 weeks)
CACHE_PROXY_IMAGES_DAYS=14

# Transcoded audio file cache duration in minutes (default: 60 = 1 hour)
# Quality-override files (lower quality streams for cellular/transcoding)
# are cached in {downloads}/transcoded/ and cleaned up after this duration
CACHE_TRANSCODE_MINUTES=60


# ===== SUBSONIC/NAVIDROME CONFIGURATION =====
# Server URL (required if using Subsonic backend)
SUBSONIC_URL=http://localhost:4533

# ===== JELLYFIN CONFIGURATION =====
# Server URL (required if using Jellyfin backend)
JELLYFIN_URL=http://jellyfin:8096

# API key for SERVER-SIDE operations only (get from Jellyfin Dashboard > API Keys)
# This is used by Allstarr to query Jellyfin's library on behalf of the server
# CLIENT authentication is handled transparently - clients authenticate directly with Jellyfin
JELLYFIN_API_KEY=CENSORED

# User ID for SERVER-SIDE library queries (get from Jellyfin Dashboard > Users > click user > check URL)
# This determines which user's library Allstarr queries when searching/browsing
JELLYFIN_USER_ID=CENSORED

# Music library ID (optional, auto-detected if not set)
# If you have multiple libraries, set this to filter to music only
JELLYFIN_LIBRARY_ID=CENSORED

# ===== MUSIC SOURCE SELECTION =====
# Music service to use: SquidWTF, Deezer, or Qobuz (default: SquidWTF)
MUSIC_SERVICE=SquidWTF
Note: Temporarily cached tracks are stored in {DOWNLOAD_PATH}/cache. Favorited 
# tracks are stored separately in KEPT_PATH (default: ./kept)
DOWNLOAD_PATH=/mnt/blackpearl/seedbox/music

# ===== SQUIDWTF CONFIGURATION =====
# Preferred audio quality (optional, default: LOSSLESS)
# - HI_RES or HI_RES_LOSSLESS: 24-bit/192kHz FLAC (highest quality)
# - FLAC or LOSSLESS: 16-bit/44.1kHz FLAC (CD quality, recommended)
# - HIGH: 320kbps AAC (high quality, smaller files)
# - LOW: 96kbps AAC (low quality, smallest files)
# If not specified, LOSSLESS (16-bit FLAC) will be used
SQUIDWTF_QUALITY=HI_RES_LOSSLESS

# Minimum interval between requests in milliseconds (default: 200)
SQUIDWTF_MIN_REQUEST_INTERVAL_MS=200

# ===== DEEZER CONFIGURATION =====
# Deezer ARL token (required if using Deezer)
# See README.md for instructions on how to get this token
DEEZER_ARL=your-deezer-arl-token

# Fallback ARL token (optional)
DEEZER_ARL_FALLBACK=

# Preferred audio quality: FLAC, MP3_320, MP3_128 (optional)
# If not specified, the highest available quality for your account will be used
DEEZER_QUALITY=

# Minimum interval between requests in milliseconds (default: 200)
DEEZER_MIN_REQUEST_INTERVAL_MS=200

# ===== QOBUZ CONFIGURATION =====
# Qobuz user authentication token (required if using Qobuz)
# Get this from your browser after logging into play.qobuz.com
# See README.md for detailed instructions
QOBUZ_USER_AUTH_TOKEN=

# Qobuz user ID (required if using Qobuz)
# Get this from your browser after logging into play.qobuz.com
QOBUZ_USER_ID=
# Preferred audio quality: FLAC, FLAC_24_HIGH, FLAC_24_LOW, FLAC_16, MP3_320 (optional)
# If not specified, the highest available quality will be used
QOBUZ_QUALITY=

# Minimum interval between requests in milliseconds (default: 200)
QOBUZ_MIN_REQUEST_INTERVAL_MS=200

# ===== MUSICBRAINZ CONFIGURATION =====
# Enable MusicBrainz metadata lookups (optional, default: true)
MUSICBRAINZ_ENABLED=true

# Optional MusicBrainz account credentials for authenticated requests
MUSICBRAINZ_USERNAME=
MUSICBRAINZ_PASSWORD=

# ===== GENERAL SETTINGS =====
# External playlists support (optional, default: true)
# When enabled, allows searching and downloading playlists from Deezer/Qobuz
# Starring a playlist triggers automatic download of all tracks and creates an M3U file
ENABLE_EXTERNAL_PLAYLISTS=true

# Playlists directory name (optional, default: playlists)
# M3U playlist files will be created in {DOWNLOAD_PATH}/{PLAYLISTS_DIRECTORY}/
PLAYLISTS_DIRECTORY=playlists

# Explicit content filter (optional, default: All)
# - All: Show all tracks (no filtering)
# - ExplicitOnly: Exclude clean/edited versions, keep original explicit content
# - CleanOnly: Only show clean content (naturally clean or edited versions)
# Note: This only works with Deezer, Qobuz doesn't expose explicit content flags
EXPLICIT_FILTER=All

# Download mode (optional, default: Track)
# - Track: Download only the played track
# - Album: When playing a track, download the entire album in background
#          The played track is downloaded first, remaining tracks are queued
DOWNLOAD_MODE=Track

# Storage mode (optional, default: Cache)
# - Permanent: Files are saved to the library permanently and registered in the media server
# - Cache: Files are stored in /tmp and automatically cleaned up after CACHE_DURATION_HOURS
#          Not registered in media server, ideal for streaming without library bloat
#          Note: On Linux/Docker, you can customize cache location by setting TMPDIR environment variable
STORAGE_MODE=Cache
# Cache duration in hours (optional, default: 1)
# Files older than this duration will be automatically deleted when STORAGE_MODE=Cache
# Based on last access time (updated each time the file is streamed)
# Cache location: /tmp/allstarr-cache (or $TMPDIR/allstarr-cache if TMPDIR is set)
CACHE_DURATION_HOURS=1

# ===== SPOTIFY PLAYLIST INJECTION (JELLYFIN ONLY) =====
# REQUIRES: Jellyfin Spotify Import Plugin (https://github.com/Viperinius/jellyfin-plugin-spotify-import)
# This feature intercepts Spotify Import plugin playlists and fills them with tracks from external providers
# Uses JELLYFIN_URL and JELLYFIN_API_KEY configured above (no separate credentials needed)

# Enable Spotify playlist injection (optional, default: false)
SPOTIFY_IMPORT_ENABLED=false

# Matching interval: How often to run track matching (in hours)
# Spotify playlists like Discover Weekly update once per week, Release Radar updates weekly
# Set to 0 to only run once on startup (manual trigger via admin UI still works)
# Default: 24 hours
SPOTIFY_IMPORT_MATCHING_INTERVAL_HOURS=24

# Playlists configuration (JSON ARRAY FORMAT - managed by web UI)
# Format: [["PlaylistName","SpotifyPlaylistId","first|last"],...]
# - PlaylistName: Name as it appears in Jellyfin
# - SpotifyPlaylistId: Get from Spotify URL (e.g., 37i9dQZF1DXcBWIGoYBM5M)
#   Accepts: spotify:playlist:ID, full URL, or just the ID
# - first|last: Where to position local tracks (first=local tracks first, last=external tracks first)
#
# Example:
# SPOTIFY_IMPORT_PLAYLISTS=[["Discover Weekly","37i9dQZEVXcV6s7Dm7RXsU","first"],["Release Radar","37i9dQZEVXbng2vDHnfQlC","first"]]
#
# RECOMMENDED: Use the web UI (Link Playlists tab) to manage playlists instead of editing this manually
SPOTIFY_IMPORT_PLAYLISTS=[]

# ===== SPOTIFY DIRECT API (RECOMMENDED - ENABLES TRACK ORDERING & LYRICS) =====
# This is the preferred method for Spotify playlist integration.
# Provides: Correct track ordering, ISRC-based exact matching, synchronized lyrics
# Does NOT require the Jellyfin Spotify Import plugin (can work standalone)

# Enable direct Spotify API access (default: false)
SPOTIFY_API_ENABLED=true
# To get your sp_dc cookie:
# 1. Open https://open.spotify.com in your browser and log in
# 2. Open DevTools (F12) → Application → Cookies → https://open.spotify.com
# 3. Find the cookie named "sp_dc" and copy its value
# 4. Note: This cookie expires periodically (typically every few months)
SPOTIFY_API_SESSION_COOKIE=CENSORED

# Date when the session cookie was set (ISO 8601 format)
# Automatically set by the web UI when you update the cookie
# Used to track cookie age and warn when approaching expiration (~1 year)
SPOTIFY_API_SESSION_COOKIE_SET_DATE=2026-03-25T09:50:05.9489094Z

# Cache duration for playlist data in minutes (default: 60)
# Release Radar updates weekly, Discover Weekly updates Mondays
SPOTIFY_API_CACHE_DURATION_MINUTES=60

# Rate limit delay between API requests in milliseconds (default: 100)
SPOTIFY_API_RATE_LIMIT_DELAY_MS=100

# Prefer ISRC matching over fuzzy title/artist matching (default: true)
# ISRC provides exact track identification across different streaming services
SPOTIFY_API_PREFER_ISRC_MATCHING=true

# Spotify Lyrics API URL (default: http://spotify-lyrics:8080)
# Uses the spotify-lyrics-api sidecar service for fetching synchronized lyrics
# This service is automatically started in docker-compose
# Leave as default unless running a custom deployment
SPOTIFY_LYRICS_API_URL=http://spotify-lyrics:8080

# ===== SCROBBLING (LAST.FM, LISTENBRAINZ) =====
# Scrobble your listening history to Last.fm and/or ListenBrainz
# Tracks are scrobbled when you listen to at least half the track or 4 minutes (whichever comes first)
# Tracks shorter than 30 seconds are not scrobbled (per Last.fm rules)

# Enable scrobbling globally (default: false)
SCROBBLING_ENABLED=true

# Enable scrobbling for local library tracks (default: false)
# RECOMMENDED: Keep this disabled and use native Jellyfin plugins instead:
# - Last.fm: https://github.com/danielfariati/jellyfin-plugin-lastfm
# - ListenBrainz: https://github.com/lyarenei/jellyfin-plugin-listenbrainz
# This ensures Allstarr only scrobbles external tracks (Spotify, Deezer, Qobuz)
SCROBBLING_LOCAL_TRACKS_ENABLED=false

# Emit synthetic local "played" events from progress when local scrobbling is disabled (default: false)
# Only enable this if you explicitly need UserPlayedItems-based plugin triggering.
# Keep false to avoid duplicate local scrobbles with Jellyfin plugins.
SCROBBLING_SYNTHETIC_LOCAL_PLAYED_SIGNAL_ENABLED=false
ords in Docker Compose .env files!
# Docker Compose handles special characters correctly without quotes.
SCROBBLING_LASTFM_USERNAME=
SCROBBLING_LASTFM_PASSWORD=

# Last.fm session key (automatically obtained via authentication)
# This key never expires unless you revoke it on Last.fm
# Use the Admin UI (Scrobbling tab) to authenticate and get your session key
SCROBBLING_LASTFM_SESSION_KEY=

# ===== LISTENBRAINZ SCROBBLING =====
# Enable ListenBrainz scrobbling (default: false)
# Only scrobbles external tracks (Spotify, Deezer, Qobuz) - local library tracks are not scrobbled
SCROBBLING_LISTENBRAINZ_ENABLED=true

# ListenBrainz user token (get from https://listenbrainz.org/settings/)
# To get your token:
# 1. Sign up or log in at https://listenbrainz.org
# 2. Go to https://listenbrainz.org/settings/
# 3. Copy your User Token
SCROBBLING_LISTENBRAINZ_USER_TOKEN=CENSORED

# ===== DEBUG SETTINGS =====
# Enable detailed request logging (default: false)
# When enabled, logs every incoming HTTP request with full details:
# - Method, path, query string
# - Headers
# - Response status and timing
# Useful for debugging client issues and seeing what API calls are being made
DEBUG_LOG_ALL_REQUESTS=false

# Redact auth/query sensitive values in request logs (default: false).
# Set true if you want DEBUG_LOG_ALL_REQUESTS while still masking tokens.
DEBUG_REDACT_SENSITIVE_REQUEST_VALUES=true

# ===== CUSTOM / UNKNOWN VARIABLES =====
KEPT_PATH=/mnt/blackpearl/seedbox/music
CACHE_PATH=/srv/app/services/allstarr/data/cache

Metadata

Metadata

Assignees

Labels

bugSomething isn't working

Projects

No projects

Milestone

No milestone

Relationships

None yet

Development

No branches or pull requests

Issue actions