Suchen, stöbern, laden: Titel, Alben, Artists, Playlists und Podcasts finden, Alben/Playlists als Trackliste sehen, einzelne Lieder oder ganze Sammlungen per Sammelkorb laden — alles über eine dunkle/helle Weboberfläche mit Cover-Grid und Preview-Player.

Features

Suche über Titel, Alben, Artists, Playlists und Podcasts (mit Cover + Preview-Player)
Artist-Seiten: Alben/EPs/Singles (sortierbar), Featuring-Näherung, ähnliche Artists
Album-/Playlist-Seiten: Trackliste mit Einzeldownloads
Podcast-Seiten: Show-Infos + Episodenliste (nur Übersicht — streamrip kann keine Podcasts laden)
Entdecken: Neuheiten, Charts und Playlists nach Genre, Genre-Sender mit aufklappbarer Trackliste
Download-Dialog mit Server-Defaults (Qualität/Codec/Ordner), URL-Import für Deezer-Links
Sammelkorb: Treffer seitenübergreifend sammeln, als Batch laden
Queue mit Live-Status, Logs und Stopp-Button; Verlauf mit Re-Download
Einstellungen in 5 Gruppen (Deezer-Konto/ARL, Downloads, Verhalten, Netzwerk, config.toml-Editor) — mit Validierung, Backup und maskierter ARL
Dateien: Download-Ordner browsen und Dateien per URL herunterladen
Hell-/Dunkelmodus, Backend-Status im Header

Start (lokal)

Backend braucht streamrip 2.2.0 aus dem System (nicht auf PyPI — venv mit Systempaketen anlegen):

cd backend && python3 -m venv --system-site-packages .venv \
  && .venv/bin/pip install -r requirements.txt \
  && .venv/bin/python -m uvicorn app.main:app --port 8000
cd ../frontend && npm install && npm run dev

UI: http://localhost:3000 · API: http://localhost:8000 (/api/* wird per Rewrite geproxyt).

Start (Docker)

docker compose up --build

UI: http://localhost:3002 · API: http://localhost:8000
Beide Images laufen als Non-Root-User und haben Healthchecks
Backend baut streamrip exakt auf v2.2.0 (Git-Tag, kein PyPI-Release)

Volumes anpassen

Die Pfade sind per .env frei wählbar (ohne .env gelten die Defaults):

cp .env.example .env   # dann Pfade in .env anpassen

.env-Beispiel:

CONFIG_DIR=~/.config/streamrip   # config.toml + streamrip-DBs -> /config
DOWNLOAD_DIR=~/StreamripDownloads # Downloads -> /downloads
UID=1000                          # Besitzer der Dateien im Container
GID=1000
BACKEND_HOST_PORT=8000            # API auf deinem Rechner (linke Seite)
BACKEND_PORT=8000                 # API im Container (rechte Seite)
FRONTEND_HOST_PORT=3002           # UI auf deinem Rechner
FRONTEND_PORT=3000                # UI im Container

Beispiel: BACKEND_HOST_PORT=8333 → API unter http://localhost:8333 (innen unverändert). BACKEND_PORT=8334 stellt zusätzlich den Container-Port um — BACKEND_URL und Healthchecks folgen automatisch, nur diese eine Variable ist nötig.

Variante mit fertigen Images (ohne Bauen)

docker-compose.image.yml nutzt die per Action gebauten Images aus der Gitea-Registry (Version per APP_IMAGE_TAG pinnbar, Default latest):

docker compose -f docker-compose.image.yml pull
docker compose -f docker-compose.image.yml up -d

Frischer Server in drei Schritten: Volumes mounten (werden ggf. angelegt), starten — fehlende config.toml erzeugt das Backend automatisch —, dann ARL auf der Einstellungen-Seite eintragen. Fertig.

Compose-Auszug (docker-compose.image.yml — fertige Images, kein Bauen):

services:
  backend:
    image: gitea.lokcal.de/loki/streamrip-ui-backend:${APP_IMAGE_TAG:-latest}
    ports:
      - "${BACKEND_HOST_PORT:-8000}:${BACKEND_PORT:-8000}"
    environment:
      - STREAMRIP_CONFIG=/config/config.toml
      - STREAMRIP_DOWNLOAD_DIR=/downloads
      - BACKEND_PORT=${BACKEND_PORT:-8000}
    volumes:
      - ${CONFIG_DIR:-~/.config/streamrip}:/config
      - ${DOWNLOAD_DIR:-~/StreamripDownloads}:/downloads
  frontend:
    image: gitea.lokcal.de/loki/streamrip-ui-frontend:${APP_IMAGE_TAG:-latest}
    ports:
      - "${FRONTEND_HOST_PORT:-3002}:${FRONTEND_PORT:-3000}"
    environment:
      - BACKEND_URL=http://backend:${BACKEND_PORT:-8000}
      - HOSTNAME=0.0.0.0
      - PORT=${FRONTEND_PORT:-3000}
    depends_on:
      - backend

(Entwicklungs-Variante mit build: steht in docker-compose.yml.)

CI (.gitea/workflows/ci.yml): Backend-Tests + Docker-Builds beider Images bei jedem Push auf main.

Versionierung (automatisch, CalVer)

scripts/version.sh erzeugt DATUM.Commitanzahl (z. B. 2026.10.04.7, sonst dev). Lokal vor dem Bauen exportieren, die Action macht das selbst:

export APP_VERSION=$(./scripts/version.sh)
docker compose up --build -d

Die Version steckt im Backend-Image (GET /api/version), steht im Header der UI und taggt die Registry-Images (:latest + :2026.10.04.7).

API-Überblick (Backend)

GET /api/search?type=track|album|artist|playlist|podcast&q=..
GET /api/artist/{id}, GET /api/artist/{id}/related
GET /api/album/{id}, GET /api/playlist/{id}, GET /api/podcast/{id}
GET /api/discover?kind=tracks|albums|artists|playlists|new&genre_id=.., GET /api/discover/genres, GET /api/discover/radios?genre_id=.., GET /api/discover/radios/{id}/tracks
POST /api/downloads (media_type+id oder url), POST /api/downloads/batch, DELETE /api/downloads/{id}, SSE unter GET /api/downloads/{id}/events
GET /api/history, GET/PUT /api/config (ARL maskiert), GET/PUT /api/config/arl, GET/PUT /api/config/ui
GET /api/files?path=.., GET /api/files/download?path=..

Hinweise

Lokal gehostet gedacht (kein Login) — nicht ins Internet stellen.
Echte %-Fortschritte pro Track gibt es nicht (Job-Status + Logs); Abbrüche landen als cancelled.
Podcasts: Übersicht + Episodenliste, kein Download (streamrip kann das technisch nicht).
Manche Deezer-Chart-Endpoints sind leer — Entdecken nutzt dann Fallbacks (z. B. Top-Playlist-Tracks).