feat: terminal spotify client (ncmpcpp-style)

2026-09-06 08:08:56 +00:00
commit 352ed02871
12 changed files with 1673 additions and 0 deletions
@@ -0,0 +1,168 @@
+import hashlib
+import base64
+import secrets
+import webbrowser
+import time
+import json
+from urllib.parse import urlencode
+import requests
+
+from .config import load_config, save_token, load_token, clear_token
+
+SPOTIFY_AUTH_URL = "https://accounts.spotify.com/authorize"
+SPOTIFY_TOKEN_URL = "https://accounts.spotify.com/api/token"
+SCOPES = [
+    "user-read-playback-state",
+    "user-modify-playback-state",
+    "user-read-currently-playing",
+    "playlist-read-private",
+    "playlist-read-collaborative",
+    "user-library-read",
+    "user-read-recently-played",
+    "user-top-read",
+    "streaming",
+]
+
+def _generate_pkce():
+    code_verifier = secrets.token_urlsafe(64)[:128]
+    digest = hashlib.sha256(code_verifier.encode()).digest()
+    code_challenge = base64.urlsafe_b64encode(digest).rstrip(b"=").decode()
+    return code_verifier, code_challenge
+
+class SpotifyAuth:
+    def __init__(self):
+        self.cfg = load_config()
+        self.client_id = self.cfg.get("client_id", "")
+        self.token_data = load_token()
+
+    def _is_token_valid(self):
+        if not self.token_data:
+            return False
+        return time.time() < self.token_data.get("expires_at", 0) - 60
+
+    def get_token(self):
+        if self._is_token_valid():
+            return self.token_data["access_token"]
+
+        if self.token_data and self.token_data.get("refresh_token"):
+            refreshed = self._refresh(self.token_data["refresh_token"])
+            if refreshed:
+                return self.token_data["access_token"]
+
+        return self._full_auth()
+
+    def _refresh(self, refresh_token):
+        resp = requests.post(SPOTIFY_TOKEN_URL, data={
+            "grant_type": "refresh_token",
+            "refresh_token": refresh_token,
+            "client_id": self.client_id,
+        })
+        if resp.status_code == 200:
+            data = resp.json()
+            self.token_data = {
+                "access_token": data["access_token"],
+                "refresh_token": data.get("refresh_token", refresh_token),
+                "expires_at": time.time() + data["expires_in"],
+            }
+            save_token(self.token_data)
+            return True
+        clear_token()
+        self.token_data = None
+        return False
+
+    def _full_auth(self):
+        if not self.client_id:
+            self.client_id = input("Spotify Client ID: ").strip()
+            self.cfg["client_id"] = self.client_id
+            from .config import save_config
+            save_config(self.cfg)
+
+        code_verifier, code_challenge = _generate_pkce()
+        state = secrets.token_urlsafe(16)
+
+        params = {
+            "client_id": self.client_id,
+            "response_type": "code",
+            "redirect_uri": "http://localhost:8888/callback",
+            "code_challenge_method": "S256",
+            "code_challenge": code_challenge,
+            "state": state,
+            "scope": " ".join(SCOPES),
+        }
+
+        auth_url = f"{SPOTIFY_AUTH_URL}?{urlencode(params)}"
+        print(f"\nOeffne Browser fuer Spotify Login...")
+        print(f"Falls der Browser nicht öffnet, nutze diese URL:\n{auth_url}\n")
+        webbrowser.open(auth_url)
+
+        code = self._wait_for_callback()
+        if not code:
+            print("Authentifizierung fehlgeschlagen.")
+            return None
+
+        return self._exchange_code(code, code_verifier)
+
+    def _wait_for_callback(self, timeout=300):
+        from http.server import HTTPServer, BaseHTTPRequestHandler
+        import threading
+
+        received_code = {"code": None, "state": None}
+
+        class Handler(BaseHTTPRequestHandler):
+            def do_GET(self):
+                if "/callback" in self.path:
+                    from urllib.parse import urlparse, parse_qs
+                    query = urlparse(self.path).query
+                    params = parse_qs(query)
+                    received_code["code"] = params.get("code", [None])[0]
+                    received_code["state"] = params.get("state", [None])[0]
+                    self.send_response(200)
+                    self.send_header("Content-Type", "text/html")
+                    self.end_headers()
+                    self.wfile.write(b"<h1>Authentifizierung erfolgreich! Du kannst das Fenster schliessen.</h1>")
+                else:
+                    self.send_response(404)
+                    self.end_headers()
+
+            def log_message(self, format, *args):
+                pass
+
+        server = HTTPServer(("localhost", 8888), Handler)
+        server.timeout = timeout
+
+        start = time.time()
+        while time.time() - start < timeout:
+            server.handle_request()
+            if received_code["code"]:
+                break
+
+        server.server_close()
+        return received_code["code"]
+
+    def _exchange_code(self, code, code_verifier):
+        resp = requests.post(SPOTIFY_TOKEN_URL, data={
+            "grant_type": "authorization_code",
+            "code": code,
+            "redirect_uri": "http://localhost:8888/callback",
+            "client_id": self.client_id,
+            "code_verifier": code_verifier,
+        })
+
+        if resp.status_code == 200:
+            data = resp.json()
+            self.token_data = {
+                "access_token": data["access_token"],
+                "refresh_token": data["refresh_token"],
+                "expires_at": time.time() + data["expires_in"],
+            }
+            save_token(self.token_data)
+            return data["access_token"]
+
+        print(f"Token-Austausch fehlgeschlagen: {resp.status_code}")
+        print(resp.text)
+        return None
+
+    def logout(self):
+        clear_token()
+        self.token_data = None
+        print("Ausgelogged.")