Spaces:

jrubiosainz
/

spotify_manager

Running

App Files Files Community

jrubiosainz commited on 2 days ago

Commit

9e29ba2

verified ·

1 Parent(s): 9d7cbf2

Upload folder using huggingface_hub

Browse files

Files changed (17) hide show

.gitattributes +2 -0
.gitignore +5 -0
README.md +76 -4
caelum_spotify_manager.mp4 +3 -0
index.html +114 -17
pyproject.toml +31 -0
reachy_spotify.png +3 -0
spotify_manager/__init__.py +3 -0
spotify_manager/demo.py +203 -0
spotify_manager/gesture_controller.py +121 -0
spotify_manager/main.py +203 -0
spotify_manager/robot_feedback.py +109 -0
spotify_manager/setup_server.py +244 -0
spotify_manager/setup_wizard.py +166 -0
spotify_manager/spotify_control.py +98 -0
spotify_manager/voice_controller.py +86 -0
style.css +201 -18

.gitattributes CHANGED Viewed

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text

 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+caelum_spotify_manager.mp4 filter=lfs diff=lfs merge=lfs -text
+reachy_spotify.png filter=lfs diff=lfs merge=lfs -text

.gitignore ADDED Viewed

	@@ -0,0 +1,5 @@

+__pycache__/
+*.egg-info/
+dist/
+build/
+.venv/

README.md CHANGED Viewed

@@ -1,10 +1,82 @@
 ---
 title: Spotify Manager
-emoji: 📚
-colorFrom: yellow
-colorTo: pink
 sdk: static
 pinned: false
 ---
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

 ---
 title: Spotify Manager
+emoji: 🎵
+colorFrom: green
+colorTo: gray
 sdk: static
 pinned: false
+tags:
+  - reachy_mini
 ---
+# Spotify Manager
+🎵 Your robot DJ — control Spotify with hand gestures, voice commands, and full robot personality feedback.
+## Features
+- **🖐️ Gesture Control** — Wave to skip, thumbs up to like, open palm to play/pause, point to navigate, fist for volume down
+- **🎤 Voice Commands** — "Pon Arctic Monkeys", "siguiente", "pause", "sube volumen" (Spanish + English)
+- **🤖 Robot Feedback** — Head flicks, antenna spreads, nods, and tilts react to every action
+- **🔄 Now Playing Detection** — Robot notices track changes with a curious tilt
+## Gestures
+| Gesture | Action |
+|---------|--------|
+| 🖐️ Open Palm | Play / Pause toggle |
+| 👆 Point Right | Next track |
+| 👈 Point Left | Previous track |
+| 👍 Thumbs Up | Like current track |
+| ✊ Fist | Volume down |
+| 👋 Wave | Skip track |
+## Requirements
+- [spogo](https://github.com/nicholasgasior/spogo) CLI installed and authenticated
+- Camera for gesture detection
+- Microphone for voice commands (optional)
+## Install
+```bash
+cd spotify_manager
+pip install -e .
+```
+## Test locally
+```bash
+# Check spogo works
+spogo status --json
+# Run the app in simulator
+python -m spotify_manager.demo
+```
+## Voice Commands (ES/EN)
+- "siguiente" / "next" / "skip"
+- "anterior" / "prev"
+- "pausa" / "pause"
+- "play" / "reproduce" / "dale"
+- "sube volumen" / "baja volumen"
+- "me gusta" / "like"
+- "pon [artista/canción]" / "play [query]"
+- "qué suena" / "what's playing"
+## Architecture
+```
+spotify_manager/
+├── main.py              # ReachyMiniApp entry point
+├── spotify_control.py   # spogo CLI wrapper
+├── gesture_controller.py # MediaPipe hand gesture → command
+├── voice_controller.py  # Whisper STT → intent parser
+├── robot_feedback.py    # Physical robot reactions
+└── demo.py              # MuJoCo simulator demo + video recording
+```
+## HuggingFace Space
+Will be deployed to `jrubiosainz/spotify_manager` once spogo integration is validated.

caelum_spotify_manager.mp4 ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:08efa1cf73ddfbfb8368fbaf677a9a368d486882e36f9c7b3380cb786d50d219
+size 689202

index.html CHANGED Viewed

@@ -1,19 +1,116 @@
 <!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
 </html>

 <!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+  <title>Spotify Manager</title>
+  <link rel="stylesheet" href="style.css"/>
+</head>
+<body>
+  <nav>
+    <a href="#" class="nav-brand"><span class="dot"></span> jrubiosainz</a>
+    <div class="nav-links">
+      <a href="#features">Features</a>
+      <a href="#gestures">Gestures</a>
+      <a href="#install">Install</a>
+      <a href="https://huggingface.co/reachy-mini#/apps">App Store</a>
+    </div>
+  </nav>
+  <section class="hero">
+    <div class="badge">Reachy Mini App</div>
+    <h1>🎵 Spotify Manager</h1>
+    <p class="tagline">Your robot DJ — control Spotify with gestures, voice, and personality.</p>
+  </section>
+  <div class="video-showcase">
+    <div class="video-frame">
+      <video autoplay loop muted playsinline>
+        <source src="demo.mp4" type="video/mp4">
+      </video>
+    </div>
+    <p class="video-label">MuJoCo simulator — gesture control, voice commands, robot feedback</p>
+  </div>
+  <section class="features" id="features">
+    <h2>Features</h2>
+    <p class="subtitle">Three ways to control your music</p>
+    <div class="feature-grid">
+        <div class="feature-card">
+          <div class="icon">🖐️</div>
+          <h3>Gesture Control</h3>
+          <p>6 hand gestures via MediaPipe — wave to skip, thumbs up to like, open palm to play/pause.</p>
+        </div>
+        <div class="feature-card">
+          <div class="icon">🎤</div>
+          <h3>Voice Commands</h3>
+          <p>Say "pon Arctic Monkeys" or "next" — Whisper STT understands Spanish and English naturally.</p>
+        </div>
+        <div class="feature-card">
+          <div class="icon">🤖</div>
+          <h3>Robot Personality</h3>
+          <p>Every action triggers unique physical feedback — head flicks, antenna spreads, curious tilts, and beat pulses.</p>
+        </div>
+    </div>
+  </section>
+  <section class="gestures" id="gestures">
+    <h2>Gesture Map</h2>
+    <p class="subtitle">Your hands are the remote</p>
+    <div class="feature-grid">
+        <div class="feature-card">
+          <div class="icon">🖐️</div>
+          <h3>Open Palm</h3>
+          <p>Play / Pause toggle</p>
+        </div>
+        <div class="feature-card">
+          <div class="icon">👆</div>
+          <h3>Point Right</h3>
+          <p>Next track</p>
+        </div>
+        <div class="feature-card">
+          <div class="icon">👈</div>
+          <h3>Point Left</h3>
+          <p>Previous track</p>
+        </div>
+        <div class="feature-card">
+          <div class="icon">👍</div>
+          <h3>Thumbs Up</h3>
+          <p>Like current track</p>
+        </div>
+        <div class="feature-card">
+          <div class="icon">✊</div>
+          <h3>Fist</h3>
+          <p>Volume down</p>
+        </div>
+        <div class="feature-card">
+          <div class="icon">👋</div>
+          <h3>Wave</h3>
+          <p>Skip track</p>
+        </div>
+    </div>
+  </section>
+  <section class="install" id="install">
+    <h2>Get Started</h2>
+    <div class="steps">
+      <div class="step">
+        <div class="step-num">1</div>
+        <div><h4>Install spogo</h4><p>The CLI handles Spotify auth via browser cookies — no OAuth dance needed.</p></div>
+      </div>
+      <div class="step">
+        <div class="step-num">2</div>
+        <div><h4>Install App</h4><p>From the Reachy Mini dashboard, search "Spotify Manager" and install.</p></div>
+      </div>
+      <div class="step">
+        <div class="step-num">3</div>
+        <div><h4>Play Music</h4><p>Wave your hand or say "play" — your robot takes over as DJ.</p></div>
+      </div>
+    </div>
+  </section>
+  <footer>
+    🎵 Spotify Manager · Built by <a href="https://huggingface.co/jrubiosainz">jrubiosainz</a> · <a href="https://huggingface.co/reachy-mini#/apps">Browse More Apps</a>
+  </footer>
+</body>
 </html>

pyproject.toml ADDED Viewed

	@@ -0,0 +1,31 @@

+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+[project]
+name = "spotify_manager"
+version = "0.1.0"
+description = "Your robot DJ — control Spotify with gestures, voice, and personality"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "reachy-mini",
+    "mediapipe",
+    "opencv-python",
+    "numpy",
+    "openai-whisper",
+]
+keywords = ["reachy-mini-app"]
+[project.entry-points."reachy_mini_apps"]
+spotify_manager = "spotify_manager.main:SpotifyManager"
+[tool.setuptools]
+package-dir = { "" = "." }
+include-package-data = true
+[tool.setuptools.packages.find]
+where = ["."]
+[tool.setuptools.package-data]
+spotify_manager = ["**/*"]

reachy_spotify.png ADDED Viewed

Git LFS Details

SHA256: a425960fcc1ffc49ab685b8ebfa768018bf496d181121036f8cbdbe7dd967a76
Pointer size: 131 Bytes
Size of remote file: 565 kB

spotify_manager/__init__.py ADDED Viewed

	@@ -0,0 +1,3 @@


1	+ """Spotify Manager — Your robot DJ that controls Spotify with gestures, voice, and personality."""
2	+
3	+ __version__ = "0.1.0"

spotify_manager/demo.py ADDED Viewed

	@@ -0,0 +1,203 @@

+"""Spotify Manager — MuJoCo simulator demo with video recording.
+Usage:
+    GST_PLUGIN_SCANNER="" python3.13 -m spotify_manager.demo
+"""
+from __future__ import annotations
+import math
+import subprocess
+import time
+from pathlib import Path
+import mujoco
+import numpy as np
+SCENE_XML = Path(__file__).parents[1] / ".." / "reachy_mini" / "src" / "reachy_mini" / "descriptions" / "reachy_mini" / "mjcf" / "scenes" / "minimal.xml"
+OUTPUT_MP4 = Path(__file__).parents[1] / "caelum_spotify_manager.mp4"
+WIDTH, HEIGHT = 800, 600
+FPS = 30
+# Joint indices (from reachy_mini MJCF) — adjust if needed
+PITCH = 0  # head pitch
+ROLL = 1   # head roll
+YAW = 2    # head yaw
+L_ANTENNA = 3
+R_ANTENNA = 4
+def _smooth(data, target: dict, duration_s: float, frames: list, model, renderer, cam, stp):
+    """Smoothly interpolate controls to target over duration."""
+    n_frames = max(1, int(duration_s * FPS))
+    start_ctrl = data.ctrl.copy()
+    target_ctrl = start_ctrl.copy()
+    for k, v in target.items():
+        target_ctrl[k] = v
+    for f in range(n_frames):
+        t = (f + 1) / n_frames
+        # Smooth step
+        t = t * t * (3 - 2 * t)
+        data.ctrl[:] = start_ctrl + (target_ctrl - start_ctrl) * t
+        for _ in range(stp):
+            mujoco.mj_step(model, data)
+        renderer.update_scene(data, cam)
+        frames.append(renderer.render().copy())
+def _hold(data, duration_s: float, frames: list, model, renderer, cam, stp):
+    """Hold current pose."""
+    n = max(1, int(duration_s * FPS))
+    for _ in range(n):
+        for _ in range(stp):
+            mujoco.mj_step(model, data)
+        renderer.update_scene(data, cam)
+        frames.append(renderer.render().copy())
+def run_demo():
+    """Generate a demo video showcasing Spotify Manager robot reactions."""
+    scene_path = SCENE_XML.resolve()
+    if not scene_path.exists():
+        # Try alternate path
+        scene_path = Path(__file__).resolve().parents[2] / "reachy_mini" / "src" / "reachy_mini" / "descriptions" / "reachy_mini" / "mjcf" / "scenes" / "minimal.xml"
+    print(f"Loading scene: {scene_path}")
+    model = mujoco.MjModel.from_xml_path(str(scene_path))
+    model.vis.global_.offwidth = WIDTH
+    model.vis.global_.offheight = HEIGHT
+    data = mujoco.MjData(model)
+    renderer = mujoco.Renderer(model, HEIGHT, WIDTH)
+    cam = mujoco.MjvCamera()
+    cam.type = mujoco.mjtCamera.mjCAMERA_FREE
+    cam.distance = 0.48
+    cam.azimuth = 175
+    cam.elevation = -8
+    cam.lookat[:] = [0, 0, 0.14]
+    stp = max(1, int(1.0 / (model.opt.timestep * FPS)))
+    frames = []
+    # Helpers
+    deg = math.radians
+    def smooth(target, dur=0.3):
+        _smooth(data, target, dur, frames, model, renderer, cam, stp)
+    def hold(dur=0.5):
+        _hold(data, dur, frames, model, renderer, cam, stp)
+    def reset(dur=0.4):
+        smooth({PITCH: 0, ROLL: 0, YAW: 0, L_ANTENNA: 0, R_ANTENNA: 0}, dur)
+    print(f"Recording Spotify Manager demo at {WIDTH}x{HEIGHT} @ {FPS}fps")
+    mujoco.mj_resetData(model, data)
+    # --- Start ---
+    hold(0.8)
+    # 1. PLAY — antenna spread + head up (energized)
+    print("▶️  Play")
+    smooth({L_ANTENNA: deg(-30), R_ANTENNA: deg(30), PITCH: deg(-10)}, 0.3)
+    hold(0.5)
+    reset()
+    hold(0.4)
+    # 2. NEXT TRACK — head flick right
+    print("⏭️  Next track")
+    smooth({YAW: deg(-25)}, 0.2)
+    hold(0.15)
+    smooth({YAW: 0}, 0.3)
+    hold(0.4)
+    # 3. PREVIOUS TRACK — head flick left
+    print("⏮️  Previous track")
+    smooth({YAW: deg(25)}, 0.2)
+    hold(0.15)
+    smooth({YAW: 0}, 0.3)
+    hold(0.4)
+    # 4. LIKE — happy double nod
+    print("❤️  Like")
+    smooth({L_ANTENNA: deg(-20), R_ANTENNA: deg(20)}, 0.2)
+    for _ in range(2):
+        smooth({PITCH: deg(-8)}, 0.15)
+        smooth({PITCH: deg(5)}, 0.15)
+    smooth({PITCH: 0, L_ANTENNA: 0, R_ANTENNA: 0}, 0.3)
+    hold(0.4)
+    # 5. VOLUME UP — tilt right
+    print("🔊 Volume up")
+    smooth({ROLL: deg(-15)}, 0.2)
+    hold(0.2)
+    smooth({ROLL: 0}, 0.3)
+    hold(0.3)
+    # 6. VOLUME DOWN — tilt left
+    print("🔉 Volume down")
+    smooth({ROLL: deg(15)}, 0.2)
+    hold(0.2)
+    smooth({ROLL: 0}, 0.3)
+    hold(0.3)
+    # 7. NEW SONG — curious tilt
+    print("🎵 New song detected")
+    smooth({PITCH: deg(-5), ROLL: deg(12), L_ANTENNA: deg(-15), R_ANTENNA: deg(15)}, 0.4)
+    hold(0.6)
+    reset()
+    hold(0.4)
+    # 8. SEARCH — look around
+    print("🔍 Searching...")
+    smooth({YAW: deg(-15), PITCH: deg(-5)}, 0.3)
+    hold(0.2)
+    smooth({YAW: deg(15), PITCH: deg(-5)}, 0.4)
+    hold(0.2)
+    smooth({YAW: 0, PITCH: 0}, 0.3)
+    hold(0.4)
+    # 9. PAUSE — head down + antenna droop
+    print("⏸️  Pause")
+    smooth({PITCH: deg(15), L_ANTENNA: deg(10), R_ANTENNA: deg(-10)}, 0.4)
+    hold(0.8)
+    reset()
+    hold(0.4)
+    # 10. IDLE BEAT PULSE — subtle bouncing
+    print("💫 Idle beat pulse")
+    for i in range(4):
+        amp = deg(2 + i)
+        smooth({PITCH: -amp}, 0.12)
+        smooth({PITCH: 0}, 0.12)
+    hold(0.5)
+    # Final hold
+    hold(1.0)
+    # --- Encode ---
+    total_s = len(frames) / FPS
+    print(f"\nEncoding {len(frames)} frames ({total_s:.1f}s)...")
+    out = str(OUTPUT_MP4.resolve())
+    proc = subprocess.Popen([
+        'ffmpeg', '-y', '-f', 'rawvideo', '-vcodec', 'rawvideo',
+        '-s', f'{WIDTH}x{HEIGHT}', '-pix_fmt', 'rgb24', '-r', str(FPS),
+        '-i', '-', '-c:v', 'libx264', '-pix_fmt', 'yuv420p',
+        '-preset', 'fast', '-crf', '18', out
+    ], stdin=subprocess.PIPE, stderr=subprocess.PIPE)
+    for frame in frames:
+        proc.stdin.write(frame.tobytes())
+    proc.stdin.close()
+    proc.wait()
+    stderr = proc.stderr.read()
+    if proc.returncode == 0:
+        size_mb = Path(out).stat().st_size / 1024 / 1024
+        print(f"✅ Video saved: {out} ({size_mb:.1f} MB)")
+    else:
+        print(f"❌ ffmpeg error:\n{stderr.decode()[-500:]}")
+if __name__ == "__main__":
+    run_demo()

spotify_manager/gesture_controller.py ADDED Viewed

	@@ -0,0 +1,121 @@

+"""Gesture detection → Spotify command mapping via MediaPipe Hands."""
+import enum
+import time
+from typing import Optional, Callable
+try:
+    import mediapipe as mp
+    import cv2
+    import numpy as np
+except ImportError:
+    mp = None
+class SpotifyGesture(str, enum.Enum):
+    NONE = "none"
+    WAVE = "wave"              # Skip track (next)
+    THUMBS_UP = "thumbs_up"   # Like current track
+    POINT_RIGHT = "point_right"  # Next track
+    POINT_LEFT = "point_left"    # Previous track
+    OPEN_PALM = "open_palm"      # Play/pause toggle
+    FIST = "fist"                # Volume down
+# Landmark indices
+WRIST = 0
+THUMB_TIP, THUMB_MCP = 4, 2
+INDEX_MCP, INDEX_PIP, INDEX_TIP = 5, 6, 8
+MIDDLE_MCP, MIDDLE_PIP, MIDDLE_TIP = 9, 10, 12
+RING_MCP, RING_PIP, RING_TIP = 13, 14, 16
+PINKY_MCP, PINKY_PIP, PINKY_TIP = 17, 18, 20
+class GestureDetector:
+    """Detects hand gestures and maps them to Spotify commands."""
+    COOLDOWN_S = 1.5  # Prevent rapid-fire commands
+    def __init__(self):
+        if mp is None:
+            raise RuntimeError("mediapipe not installed")
+        self._hands = mp.solutions.hands.Hands(
+            static_image_mode=False,
+            max_num_hands=1,
+            min_detection_confidence=0.7,
+            min_tracking_confidence=0.6,
+        )
+        self._last_gesture = SpotifyGesture.NONE
+        self._last_trigger_time: float = 0
+        self._stability_count = 0
+        self._stability_threshold = 3  # Frames before triggering
+    def _is_extended(self, lms, tip, pip) -> bool:
+        return lms[tip].y < lms[pip].y
+    def _thumb_extended(self, lms) -> bool:
+        return abs(lms[THUMB_TIP].x - lms[INDEX_MCP].x) > abs(lms[THUMB_MCP].x - lms[INDEX_MCP].x) * 1.2
+    def _classify(self, lms) -> SpotifyGesture:
+        if len(lms) < 21:
+            return SpotifyGesture.NONE
+        thumb = self._thumb_extended(lms)
+        index = self._is_extended(lms, INDEX_TIP, INDEX_PIP)
+        middle = self._is_extended(lms, MIDDLE_TIP, MIDDLE_PIP)
+        ring = self._is_extended(lms, RING_TIP, RING_PIP)
+        pinky = self._is_extended(lms, PINKY_TIP, PINKY_PIP)
+        ext = sum([thumb, index, middle, ring, pinky])
+        if ext == 0:
+            return SpotifyGesture.FIST
+        elif thumb and not index and not middle and not ring and not pinky:
+            return SpotifyGesture.THUMBS_UP
+        elif index and not middle and not ring and not pinky:
+            # Determine point direction
+            if lms[INDEX_TIP].x > lms[WRIST].x + 0.1:
+                return SpotifyGesture.POINT_RIGHT
+            elif lms[INDEX_TIP].x < lms[WRIST].x - 0.1:
+                return SpotifyGesture.POINT_LEFT
+            return SpotifyGesture.POINT_RIGHT
+        elif ext >= 4:
+            # Check for wave (hand moving) vs open palm (stationary)
+            return SpotifyGesture.OPEN_PALM
+        return SpotifyGesture.NONE
+    def process_frame(self, frame: np.ndarray) -> Optional[SpotifyGesture]:
+        """Process a BGR frame. Returns gesture if newly triggered, None otherwise."""
+        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        results = self._hands.process(rgb)
+        if not results.multi_hand_landmarks:
+            self._stability_count = 0
+            self._last_gesture = SpotifyGesture.NONE
+            return None
+        lms = results.multi_hand_landmarks[0].landmark
+        gesture = self._classify(lms)
+        if gesture == SpotifyGesture.NONE:
+            self._stability_count = 0
+            self._last_gesture = SpotifyGesture.NONE
+            return None
+        if gesture == self._last_gesture:
+            self._stability_count += 1
+        else:
+            self._stability_count = 1
+            self._last_gesture = gesture
+        now = time.time()
+        if self._stability_count >= self._stability_threshold and (now - self._last_trigger_time) > self.COOLDOWN_S:
+            self._last_trigger_time = now
+            self._stability_count = 0
+            return gesture
+        return None
+    def close(self):
+        self._hands.close()

spotify_manager/main.py ADDED Viewed

	@@ -0,0 +1,203 @@

+"""Spotify Manager — Main app entry point for Reachy Mini."""
+import logging
+import threading
+import time
+from typing import Optional
+from reachy_mini import ReachyMini, ReachyMiniApp
+from .spotify_control import SpogoController, TrackInfo
+from .gesture_controller import GestureDetector, SpotifyGesture
+from .voice_controller import VoiceController, VoiceCommand
+from .robot_feedback import RobotFeedback
+from .setup_wizard import is_spogo_installed, is_authenticated
+from .setup_server import SetupServer
+logger = logging.getLogger(__name__)
+class SpotifyManager(ReachyMiniApp):
+    """Your robot DJ — control Spotify with gestures, voice, and personality."""
+    name = "spotify_manager"
+    description = "Control Spotify with gestures, voice commands, and robot personality"
+    def __init__(self):
+        super().__init__()
+        self._spotify: Optional[SpogoController] = None
+        self._gesture: Optional[GestureDetector] = None
+        self._voice: Optional[VoiceController] = None
+        self._feedback: Optional[RobotFeedback] = None
+        self._setup_server: Optional[SetupServer] = None
+        self._running = False
+        self._current_track: Optional[TrackInfo] = None
+        self._poll_thread: Optional[threading.Thread] = None
+    def setup(self, robot: ReachyMini):
+        """Initialize all controllers."""
+        logger.info("🎵 Spotify Manager starting up...")
+        # Start setup wizard server (always available for re-auth)
+        self._setup_server = SetupServer(port=8888)
+        self._setup_server.start()
+        # Check if spogo is installed and authenticated
+        if not is_spogo_installed() or not is_authenticated():
+            logger.warning(
+                "🔧 Setup required! Open http://ROBOT_IP:8888/setup to connect Spotify"
+            )
+            # Still start the app — it will work once auth is done
+            self._feedback = RobotFeedback(robot)
+            self._feedback.on_search()  # Curious look while waiting
+            self._running = True
+            self._poll_thread = threading.Thread(target=self._wait_for_auth, daemon=True)
+            self._poll_thread.start()
+            return
+        self._init_controllers(robot)
+    def _init_controllers(self, robot: ReachyMini):
+        """Initialize all controllers after auth is confirmed."""
+        self._spotify = SpogoController()
+        self._gesture = GestureDetector()
+        self._feedback = RobotFeedback(robot)
+        try:
+            self._voice = VoiceController(model_size="base")
+            logger.info("🎤 Voice control enabled")
+        except Exception as e:
+            logger.warning(f"Voice control unavailable: {e}")
+            self._voice = None
+        self._running = True
+        self._poll_thread = threading.Thread(target=self._poll_now_playing, daemon=True)
+        self._poll_thread.start()
+        # Initial greeting
+        self._feedback.on_play()
+        logger.info("🎵 Spotify Manager ready!")
+    def _wait_for_auth(self):
+        """Poll until spogo is installed and authenticated, then init."""
+        while self._running:
+            if is_spogo_installed() and is_authenticated():
+                logger.info("✅ Auth detected! Initializing controllers...")
+                self._init_controllers(self._feedback._robot)
+                return
+            time.sleep(5)
+    def on_frame(self, frame):
+        """Process camera frame for gesture detection."""
+        if not self._running or self._gesture is None:
+            return
+        gesture = self._gesture.process_frame(frame)
+        if gesture:
+            self._handle_gesture(gesture)
+        # Check for voice commands
+        if self._voice:
+            cmd = self._voice.get_pending_command()
+            if cmd:
+                self._handle_voice_command(cmd)
+    def _handle_gesture(self, gesture: SpotifyGesture):
+        """Map gesture to Spotify action + robot feedback."""
+        logger.info(f"🖐️ Gesture: {gesture.value}")
+        try:
+            if gesture == SpotifyGesture.WAVE or gesture == SpotifyGesture.POINT_RIGHT:
+                self._spotify.next_track()
+                self._feedback.on_next_track()
+            elif gesture == SpotifyGesture.POINT_LEFT:
+                self._spotify.prev_track()
+                self._feedback.on_prev_track()
+            elif gesture == SpotifyGesture.THUMBS_UP:
+                self._spotify.like()
+                self._feedback.on_like()
+            elif gesture == SpotifyGesture.OPEN_PALM:
+                status = self._spotify.status()
+                if status.is_playing:
+                    self._spotify.pause()
+                    self._feedback.on_pause()
+                else:
+                    self._spotify.resume()
+                    self._feedback.on_play()
+            elif gesture == SpotifyGesture.FIST:
+                self._spotify.volume(max(0, self._get_current_volume() - 10))
+                self._feedback.on_volume_change(-1)
+        except Exception as e:
+            logger.error(f"Gesture action failed: {e}")
+    def _handle_voice_command(self, cmd: VoiceCommand):
+        """Execute voice command."""
+        logger.info(f"🎤 Voice: {cmd.intent} (query={cmd.query})")
+        try:
+            if cmd.intent == "next":
+                self._spotify.next_track()
+                self._feedback.on_next_track()
+            elif cmd.intent == "prev":
+                self._spotify.prev_track()
+                self._feedback.on_prev_track()
+            elif cmd.intent == "pause":
+                self._spotify.pause()
+                self._feedback.on_pause()
+            elif cmd.intent == "play":
+                self._spotify.resume()
+                self._feedback.on_play()
+            elif cmd.intent == "like":
+                self._spotify.like()
+                self._feedback.on_like()
+            elif cmd.intent == "volume_up":
+                self._spotify.volume(min(100, self._get_current_volume() + 15))
+                self._feedback.on_volume_change(1)
+            elif cmd.intent == "volume_down":
+                self._spotify.volume(max(0, self._get_current_volume() - 15))
+                self._feedback.on_volume_change(-1)
+            elif cmd.intent == "search" and cmd.query:
+                self._feedback.on_search()
+                results = self._spotify.search(cmd.query)
+                if results:
+                    self._spotify.play(uri=results[0].get("uri"))
+                    self._feedback.on_play()
+            elif cmd.intent == "status":
+                self._feedback.on_new_song()  # Acknowledge
+        except Exception as e:
+            logger.error(f"Voice command failed: {e}")
+    def _poll_now_playing(self):
+        """Background thread to detect track changes."""
+        while self._running:
+            try:
+                status = self._spotify.status()
+                if self._current_track and status.uri != self._current_track.uri and status.uri:
+                    logger.info(f"🎵 Now playing: {status.name} — {status.artist}")
+                    self._feedback.on_new_song()
+                self._current_track = status
+            except Exception:
+                pass
+            time.sleep(3)
+    def _get_current_volume(self) -> int:
+        """Get approximate current volume (defaults to 50 if unknown)."""
+        return 50  # spogo doesn't expose volume level in status easily
+    def on_audio(self, audio_data):
+        """Handle incoming audio for voice commands."""
+        if self._voice:
+            self._voice.submit_audio(audio_data)
+    def teardown(self):
+        """Clean shutdown."""
+        self._running = False
+        if self._setup_server:
+            self._setup_server.stop()
+        if self._gesture:
+            self._gesture.close()
+        if self._voice:
+            self._voice.close()
+        if self._feedback:
+            self._feedback.reset()
+        logger.info("🎵 Spotify Manager stopped")

spotify_manager/robot_feedback.py ADDED Viewed

	@@ -0,0 +1,109 @@

+"""Robot physical feedback for Spotify actions — head moves, antenna, expressions."""
+import math
+import time
+from typing import Optional
+from reachy_mini import ReachyMini
+from reachy_mini.utils import create_head_pose
+class RobotFeedback:
+    """Maps Spotify events to robot physical reactions."""
+    def __init__(self, robot: ReachyMini):
+        self._robot = robot
+        self._base_pitch = 0.0
+        self._base_yaw = 0.0
+        self._base_roll = 0.0
+    def _pose(self, pitch: float = 0, yaw: float = 0, roll: float = 0, duration: float = 0.3):
+        """Set head pose with smooth transition."""
+        pose = create_head_pose(
+            pitch=math.radians(pitch),
+            yaw=math.radians(yaw),
+            roll=math.radians(roll),
+        )
+        self._robot.send_head_pose(pose, duration=duration)
+    def _antenna(self, left: float, right: float, duration: float = 0.3):
+        """Set antenna angles (degrees)."""
+        self._robot.send_antenna_pose(
+            left=math.radians(left),
+            right=math.radians(right),
+            duration=duration,
+        )
+    # --- Action reactions ---
+    def on_next_track(self):
+        """Head flick right — skip gesture."""
+        self._pose(yaw=-25, duration=0.2)
+        time.sleep(0.25)
+        self._pose(yaw=0, duration=0.3)
+    def on_prev_track(self):
+        """Head flick left — going back."""
+        self._pose(yaw=25, duration=0.2)
+        time.sleep(0.25)
+        self._pose(yaw=0, duration=0.3)
+    def on_play(self):
+        """Antenna spread + head up — energized."""
+        self._antenna(left=-30, right=30, duration=0.3)
+        self._pose(pitch=-10, duration=0.3)
+        time.sleep(0.5)
+        self._antenna(left=0, right=0, duration=0.4)
+        self._pose(pitch=0, duration=0.4)
+    def on_pause(self):
+        """Head down + antenna droop — resting."""
+        self._pose(pitch=15, duration=0.4)
+        self._antenna(left=10, right=-10, duration=0.4)
+        time.sleep(0.3)
+    def on_like(self):
+        """Happy nod — liked the track."""
+        self._antenna(left=-20, right=20, duration=0.2)
+        for _ in range(2):
+            self._pose(pitch=-8, duration=0.15)
+            time.sleep(0.15)
+            self._pose(pitch=5, duration=0.15)
+            time.sleep(0.15)
+        self._pose(pitch=0, duration=0.3)
+        self._antenna(left=0, right=0, duration=0.3)
+    def on_volume_change(self, direction: int):
+        """Tilt in volume direction."""
+        roll = -15 * direction  # +1 up, -1 down
+        self._pose(roll=roll, duration=0.2)
+        time.sleep(0.3)
+        self._pose(roll=0, duration=0.3)
+    def on_new_song(self):
+        """Curious tilt — new song detected."""
+        self._pose(pitch=-5, roll=12, duration=0.4)
+        self._antenna(left=-15, right=15, duration=0.3)
+        time.sleep(0.6)
+        self._pose(pitch=0, roll=0, duration=0.4)
+        self._antenna(left=0, right=0, duration=0.4)
+    def on_search(self):
+        """Look around — searching."""
+        self._pose(yaw=-15, pitch=-5, duration=0.3)
+        time.sleep(0.3)
+        self._pose(yaw=15, pitch=-5, duration=0.4)
+        time.sleep(0.3)
+        self._pose(yaw=0, pitch=0, duration=0.3)
+    def idle_beat_pulse(self, intensity: float = 0.5):
+        """Subtle pulse to beat — lightweight idle animation."""
+        amp = 3 * intensity
+        self._pose(pitch=-amp, duration=0.15)
+        time.sleep(0.15)
+        self._pose(pitch=0, duration=0.15)
+    def reset(self):
+        """Return to neutral."""
+        self._pose(0, 0, 0, duration=0.5)
+        self._antenna(0, 0, duration=0.5)

spotify_manager/setup_server.py ADDED Viewed

	@@ -0,0 +1,244 @@

+"""Setup web server — dashboard UI for spogo install + auth."""
+import json
+import logging
+import threading
+from pathlib import Path
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from typing import Optional
+from . import setup_wizard
+logger = logging.getLogger(__name__)
+SETUP_HTML = """<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Spotify Manager — Setup</title>
+<style>
+* { box-sizing: border-box; margin: 0; padding: 0; }
+body { font-family: 'Inter', -apple-system, sans-serif; background: #0d0d0d; color: #e0e0e0; min-height: 100vh; display: flex; align-items: center; justify-content: center; }
+.container { max-width: 900px; width: 100%; padding: 2rem; }
+.main-layout { display: grid; grid-template-columns: 1fr 1fr; gap: 1.5rem; align-items: start; }
+.steps-col { display: flex; flex-direction: column; gap: 1rem; }
+@media (max-width: 700px) { .main-layout { grid-template-columns: 1fr; } }
+h1 { font-size: 1.8rem; margin-bottom: 0.5rem; color: #1DB954; }
+.subtitle { color: #888; margin-bottom: 2rem; }
+.step { background: #1a1a1a; border-radius: 12px; padding: 1.5rem; margin-bottom: 1rem; border: 1px solid #333; }
+.step.done { border-color: #1DB954; }
+.step.active { border-color: #7c5cfc; }
+.step-header { display: flex; align-items: center; gap: 0.75rem; margin-bottom: 0.5rem; }
+.step-num { width: 28px; height: 28px; border-radius: 50%; display: flex; align-items: center; justify-content: center; font-size: 0.85rem; font-weight: 600; background: #333; }
+.done .step-num { background: #1DB954; color: #000; }
+.active .step-num { background: #7c5cfc; color: #fff; }
+.step-title { font-weight: 600; }
+.step-body { margin-left: 2.5rem; color: #aaa; font-size: 0.9rem; }
+button { background: #1DB954; color: #000; border: none; padding: 0.7rem 1.5rem; border-radius: 8px; font-weight: 600; cursor: pointer; font-size: 0.9rem; margin-top: 0.75rem; }
+button:hover { background: #1ed760; }
+button:disabled { background: #333; color: #666; cursor: not-allowed; }
+button.secondary { background: #333; color: #e0e0e0; }
+button.secondary:hover { background: #444; }
+.status { margin-top: 0.5rem; font-size: 0.85rem; padding: 0.5rem; border-radius: 6px; }
+.status.ok { background: #1DB95422; color: #1DB954; }
+.status.err { background: #ff444422; color: #ff6666; }
+.input-row { display: flex; gap: 0.5rem; margin-top: 0.75rem; }
+.input-row input { flex: 1; background: #222; border: 1px solid #444; border-radius: 6px; padding: 0.5rem 0.75rem; color: #e0e0e0; font-size: 0.85rem; }
+.ready-banner { background: #1DB95422; border: 1px solid #1DB954; border-radius: 12px; padding: 2rem; text-align: center; display: flex; flex-direction: column; align-items: center; justify-content: center; min-height: 200px; }
+.ready-banner h2 { color: #1DB954; margin-bottom: 0.5rem; }
+</style>
+</head>
+<body>
+<div class="container">
+<h1>🎵 Spotify Manager</h1>
+<p class="subtitle">Setup your Reachy Mini as a Spotify controller</p>
+<div class="main-layout">
+<div class="steps-col">
+<div class="step" id="step1">
+  <div class="step-header"><div class="step-num">1</div><span class="step-title">Install spogo engine</span></div>
+  <div class="step-body">
+    <p>Downloads the spogo binary for your platform (~8MB)</p>
+    <button id="btn-install" onclick="installSpogo()">Install spogo</button>
+    <div class="status" id="status-install" style="display:none"></div>
+  </div>
+</div>
+<div class="step" id="step2">
+  <div class="step-header"><div class="step-num">2</div><span class="step-title">Connect your Spotify</span></div>
+  <div class="step-body">
+    <p style="margin-bottom:0.75rem; line-height:1.5">Spotify Manager connects to your account using your browser's session cookie (<code style="background:#222;padding:2px 5px;border-radius:3px;font-size:0.8rem">sp_dc</code>). This is the same cookie Spotify's web player uses — no API keys, no developer app, no OAuth. Your credentials stay local on this device and are never sent anywhere else.</p>
+    <p>Option A: Auto-import from browser (close browser first)</p>
+    <button id="btn-import" onclick="importCookies()">Import from Chrome</button>
+    <button class="secondary" onclick="importCookies('firefox')">Firefox</button>
+    <button class="secondary" onclick="importCookies('safari')">Safari</button>
+    <p style="margin-top:1rem">Option B: Paste sp_dc cookie manually</p>
+    <div class="input-row">
+      <input type="text" id="cookie-input" placeholder="Paste sp_dc value here...">
+      <button onclick="pasteCookie()">Save</button>
+    </div>
+    <div class="status" id="status-auth" style="display:none"></div>
+  </div>
+</div>
+</div>
+<div class="ready-banner" id="ready-banner" style="display:none">
+  <h2 style="font-size:1.6rem">🎵 Connected to Spotify!</h2>
+  <p style="font-size:1.1rem; margin-bottom:0.5rem">Your Reachy Mini is now a Spotify controller.</p>
+  <p style="color:#aaa">Use gestures, voice, or both to control your music.</p>
+  <img src="/reachy_spotify.png" alt="Reachy Mini Spotify" style="width:180px; margin-top:1rem; border-radius:8px;">
+</div>
+</div>
+</div>
+<script>
+async function api(endpoint, body) {
+  const r = await fetch('/api/' + endpoint, { method: 'POST', headers: {'Content-Type':'application/json'}, body: JSON.stringify(body || {}) });
+  return r.json();
+}
+function showStatus(id, ok, msg) {
+  const el = document.getElementById(id);
+  el.style.display = 'block';
+  el.className = 'status ' + (ok ? 'ok' : 'err');
+  el.textContent = msg;
+}
+async function checkStatus() {
+  const data = await api('status');
+  if (data.spogo_installed) {
+    markStep1Done();
+  }
+  if (data.authenticated) {
+    document.getElementById('step2').className = 'step done';
+    document.getElementById('ready-banner').style.display = 'block';
+  } else if (data.spogo_installed) {
+    document.getElementById('step2').className = 'step active';
+  }
+}
+async function installSpogo() {
+  document.getElementById('btn-install').disabled = true;
+  document.getElementById('btn-install').textContent = 'Installing...';
+  const r = await api('install');
+  if (r.success) {
+    showStatus('status-install', true, 'spogo installed at ' + r.path);
+    markStep1Done();
+  } else {
+    showStatus('status-install', false, r.error);
+    document.getElementById('btn-install').disabled = false;
+    document.getElementById('btn-install').textContent = 'Retry';
+  }
+}
+function markStep1Done() {
+  document.getElementById('step1').className = 'step done';
+  document.getElementById('btn-install').textContent = '✓ Installed';
+  document.getElementById('btn-install').disabled = true;
+  document.getElementById('step2').className = 'step active';
+}
+async function importCookies(browser) {
+  const r = await api('import', { browser: browser || 'chrome' });
+  if (r.success) {
+    const msg = r.message || '';
+    const cookieMatch = msg.match(/(\\d+) cookies/);
+    const count = cookieMatch ? cookieMatch[1] : '';
+    const detail = count ? `Found ${count} session cookies from ${(browser || 'chrome').charAt(0).toUpperCase() + (browser || 'chrome').slice(1)}` : msg;
+    showStatus('status-auth', true, detail);
+    document.getElementById('step2').className = 'step done';
+    document.getElementById('ready-banner').style.display = 'block';
+  } else {
+    showStatus('status-auth', false, r.error || 'No cookies found. Make sure you are logged in and the browser is closed.');
+  }
+}
+async function pasteCookie() {
+  const val = document.getElementById('cookie-input').value.trim();
+  if (!val) return;
+  const r = await api('paste', { cookie: val });
+  if (r.success) {
+    showStatus('status-auth', true, '✅ Connected to Spotify!');
+    checkStatus();
+  } else {
+    showStatus('status-auth', false, r.error);
+  }
+}
+checkStatus();
+</script>
+</body>
+</html>"""
+class SetupHandler(BaseHTTPRequestHandler):
+    def do_GET(self):
+        if self.path == "/" or self.path == "/setup":
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html")
+            self.end_headers()
+            self.wfile.write(SETUP_HTML.encode())
+        elif self.path == "/reachy_spotify.png":
+            img_path = Path(__file__).parent.parent / "reachy_spotify.png"
+            if img_path.exists():
+                self.send_response(200)
+                self.send_header("Content-Type", "image/png")
+                self.end_headers()
+                self.wfile.write(img_path.read_bytes())
+            else:
+                self.send_response(404)
+                self.end_headers()
+        else:
+            self.send_response(404)
+            self.end_headers()
+    def do_POST(self):
+        content_len = int(self.headers.get("Content-Length", 0))
+        body = json.loads(self.rfile.read(content_len)) if content_len else {}
+        if self.path == "/api/status":
+            result = setup_wizard.get_setup_status()
+        elif self.path == "/api/install":
+            result = setup_wizard.install_spogo()
+        elif self.path == "/api/import":
+            browser = body.get("browser", "chrome")
+            profile = body.get("profile")
+            result = setup_wizard.import_browser_cookies(browser, profile)
+        elif self.path == "/api/paste":
+            cookie = body.get("cookie", "")
+            result = setup_wizard.paste_cookie(cookie)
+        else:
+            self.send_response(404)
+            self.end_headers()
+            return
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.end_headers()
+        self.wfile.write(json.dumps(result).encode())
+    def log_message(self, format, *args):
+        logger.debug(f"Setup server: {args[0]}")
+class SetupServer:
+    """Runs the setup wizard web UI on a local port."""
+    def __init__(self, port: int = 8888):
+        self.port = port
+        self._server: Optional[HTTPServer] = None
+        self._thread: Optional[threading.Thread] = None
+    def start(self):
+        self._server = HTTPServer(("0.0.0.0", self.port), SetupHandler)
+        self._thread = threading.Thread(target=self._server.serve_forever, daemon=True)
+        self._thread.start()
+        logger.info(f"Setup wizard running at http://localhost:{self.port}/setup")
+    def stop(self):
+        if self._server:
+            self._server.shutdown()

spotify_manager/setup_wizard.py ADDED Viewed

	@@ -0,0 +1,166 @@

+"""Setup wizard — auto-installs spogo and guides browser cookie auth."""
+import json
+import logging
+import os
+import platform
+import shutil
+import stat
+import subprocess
+import tempfile
+import urllib.request
+from pathlib import Path
+from typing import Optional
+logger = logging.getLogger(__name__)
+SPOGO_VERSION = "latest"
+SPOGO_DATA_DIR = Path.home() / ".config" / "spotify_manager"
+SPOGO_BIN_DIR = SPOGO_DATA_DIR / "bin"
+SPOGO_AUTH_STATUS_FILE = SPOGO_DATA_DIR / "auth_status.json"
+# Download URLs by platform/arch
+SPOGO_DOWNLOAD_URLS = {
+    ("linux", "aarch64"): "https://github.com/steipete/spogo/releases/latest/download/spogo_linux_arm64.tar.gz",
+    ("linux", "x86_64"): "https://github.com/steipete/spogo/releases/latest/download/spogo_linux_amd64.tar.gz",
+    ("darwin", "arm64"): "https://github.com/steipete/spogo/releases/latest/download/spogo_darwin_arm64.tar.gz",
+    ("darwin", "x86_64"): "https://github.com/steipete/spogo/releases/latest/download/spogo_darwin_amd64.tar.gz",
+}
+def get_spogo_path() -> Optional[str]:
+    """Find spogo binary — bundled or system."""
+    # Check bundled location first
+    bundled = SPOGO_BIN_DIR / "spogo"
+    if bundled.exists() and os.access(bundled, os.X_OK):
+        return str(bundled)
+    # Fall back to system PATH
+    return shutil.which("spogo")
+def is_spogo_installed() -> bool:
+    return get_spogo_path() is not None
+def is_authenticated() -> bool:
+    """Check if spogo has valid cookies."""
+    spogo = get_spogo_path()
+    if not spogo:
+        return False
+    try:
+        result = subprocess.run(
+            [spogo, "auth", "status", "--json"],
+            capture_output=True, text=True, timeout=5
+        )
+        if result.returncode == 0:
+            data = json.loads(result.stdout) if result.stdout.strip() else {}
+            return data.get("authenticated", False) or "valid" in result.stdout.lower()
+        # If no --json support, check stderr/stdout for positive signals
+        return "authenticated" in (result.stdout + result.stderr).lower()
+    except Exception:
+        return False
+def install_spogo() -> dict:
+    """Download and install spogo binary to bundled location."""
+    system = platform.system().lower()
+    machine = platform.machine()
+    key = (system, machine)
+    url = SPOGO_DOWNLOAD_URLS.get(key)
+    if not url:
+        return {
+            "success": False,
+            "error": f"Unsupported platform: {system}/{machine}. "
+                     f"Supported: {list(SPOGO_DOWNLOAD_URLS.keys())}"
+        }
+    SPOGO_BIN_DIR.mkdir(parents=True, exist_ok=True)
+    target = SPOGO_BIN_DIR / "spogo"
+    try:
+        logger.info(f"Downloading spogo for {system}/{machine}...")
+        with tempfile.NamedTemporaryFile(suffix=".tar.gz", delete=False) as tmp:
+            urllib.request.urlretrieve(url, tmp.name)
+            tmp_path = tmp.name
+        # Extract
+        import tarfile
+        with tarfile.open(tmp_path, "r:gz") as tar:
+            # Find the spogo binary in the archive
+            for member in tar.getmembers():
+                if member.name.endswith("spogo") or member.name == "spogo":
+                    member.name = "spogo"
+                    tar.extract(member, path=str(SPOGO_BIN_DIR))
+                    break
+        os.unlink(tmp_path)
+        # Make executable
+        target.chmod(target.stat().st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+        if target.exists():
+            logger.info(f"spogo installed at {target}")
+            return {"success": True, "path": str(target)}
+        else:
+            return {"success": False, "error": "Binary not found in archive"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+def import_browser_cookies(browser: str = "chrome", profile: Optional[str] = None) -> dict:
+    """Import Spotify cookies from a browser."""
+    spogo = get_spogo_path()
+    if not spogo:
+        return {"success": False, "error": "spogo not installed"}
+    cmd = [spogo, "auth", "import", "--browser", browser]
+    if profile:
+        cmd.extend(["--browser-profile", profile])
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=15)
+        if result.returncode == 0:
+            return {"success": True, "message": result.stdout.strip()}
+        else:
+            return {"success": False, "error": result.stderr.strip() or result.stdout.strip()}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+def paste_cookie(sp_dc: str) -> dict:
+    """Authenticate with a manually provided sp_dc cookie value."""
+    spogo = get_spogo_path()
+    if not spogo:
+        return {"success": False, "error": "spogo not installed"}
+    try:
+        result = subprocess.run(
+            [spogo, "auth", "paste"],
+            input=sp_dc,
+            capture_output=True, text=True, timeout=10
+        )
+        if result.returncode == 0:
+            return {"success": True, "message": "Cookie saved"}
+        else:
+            return {"success": False, "error": result.stderr.strip()}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+def get_setup_status() -> dict:
+    """Full status for the setup wizard UI."""
+    spogo_installed = is_spogo_installed()
+    authenticated = is_authenticated() if spogo_installed else False
+    spogo_path = get_spogo_path()
+    return {
+        "spogo_installed": spogo_installed,
+        "spogo_path": spogo_path,
+        "authenticated": authenticated,
+        "platform": f"{platform.system()}/{platform.machine()}",
+        "ready": spogo_installed and authenticated,
+    }

spotify_manager/spotify_control.py ADDED Viewed

	@@ -0,0 +1,98 @@

+"""Spotify control via spogo CLI — zero OAuth, uses browser cookies."""
+import json
+import subprocess
+import shutil
+from .setup_wizard import get_spogo_path
+from dataclasses import dataclass
+from typing import Optional
+@dataclass
+class TrackInfo:
+    name: str = ""
+    artist: str = ""
+    album: str = ""
+    uri: str = ""
+    is_playing: bool = False
+    progress_ms: int = 0
+    duration_ms: int = 0
+class SpogoController:
+    """Wraps spogo CLI commands for Spotify control."""
+    def __init__(self):
+        self._spogo = get_spogo_path()
+        if not self._spogo:
+            raise RuntimeError(
+                "spogo not found. Run the setup wizard at http://localhost:8888/setup "
+                "or install manually: brew install steipete/tap/spogo"
+            )
+    def _run(self, args: list[str], json_output: bool = True) -> dict | str:
+        cmd = [self._spogo] + args
+        if json_output:
+            cmd.append("--json")
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
+        if result.returncode != 0:
+            raise RuntimeError(f"spogo error: {result.stderr.strip()}")
+        if json_output:
+            return json.loads(result.stdout) if result.stdout.strip() else {}
+        return result.stdout.strip()
+    def status(self) -> TrackInfo:
+        data = self._run(["status"])
+        if not data:
+            return TrackInfo()
+        item = data.get("item", {})
+        artists_raw = item.get("artists", [])
+        # artists can be list of strings or list of dicts
+        if artists_raw and isinstance(artists_raw[0], dict):
+            artist_str = ", ".join(a.get("name", "") for a in artists_raw)
+        else:
+            artist_str = ", ".join(str(a) for a in artists_raw)
+        album_raw = item.get("album", "")
+        album_str = album_raw.get("name", "") if isinstance(album_raw, dict) else str(album_raw)
+        return TrackInfo(
+            name=item.get("name", ""),
+            artist=artist_str,
+            album=album_str,
+            uri=item.get("uri", ""),
+            is_playing=data.get("is_playing", False),
+            progress_ms=data.get("progress_ms", 0),
+            duration_ms=item.get("duration_ms", 0),
+        )
+    def play(self, query: Optional[str] = None, uri: Optional[str] = None):
+        if uri:
+            self._run(["play", uri], json_output=False)
+        elif query:
+            self._run(["play", query], json_output=False)
+        else:
+            self._run(["resume"], json_output=False)
+    def pause(self):
+        self._run(["pause"], json_output=False)
+    def resume(self):
+        self._run(["resume"], json_output=False)
+    def next_track(self):
+        self._run(["next"], json_output=False)
+    def prev_track(self):
+        self._run(["prev"], json_output=False)
+    def volume(self, level: int):
+        self._run(["volume", str(max(0, min(100, level)))], json_output=False)
+    def like(self):
+        self._run(["like"], json_output=False)
+    def search(self, query: str, search_type: str = "track", limit: int = 5) -> list[dict]:
+        data = self._run(["search", search_type, query, "--limit", str(limit)])
+        return data.get("items", []) if isinstance(data, dict) else []
+    def queue_add(self, uri: str):
+        self._run(["queue", "add", "--uri", uri], json_output=False)

spotify_manager/voice_controller.py ADDED Viewed

	@@ -0,0 +1,86 @@

+"""Voice control — Whisper STT → intent parsing → Spotify commands."""
+import re
+import threading
+import queue
+import tempfile
+from typing import Optional
+from dataclasses import dataclass
+try:
+    import whisper
+    import numpy as np
+except ImportError:
+    whisper = None
+@dataclass
+class VoiceCommand:
+    intent: str  # play, pause, next, prev, volume_up, volume_down, like, search, status
+    query: Optional[str] = None
+    value: Optional[int] = None
+# Intent patterns (Spanish + English)
+INTENT_PATTERNS = [
+    (r"(?:siguiente|next|skip)", "next"),
+    (r"(?:anterior|prev|previous|atrás)", "prev"),
+    (r"(?:pausa|pause|para|stop)", "pause"),
+    (r"(?:play|reproduce|continua|resume|dale)", "play"),
+    (r"(?:sube|subir|más)\s*(?:volumen|volume|vol)", "volume_up"),
+    (r"(?:baja|bajar|menos)\s*(?:volumen|volume|vol)", "volume_down"),
+    (r"(?:me gusta|like|favorit)", "like"),
+    (r"(?:qué suena|what.s playing|qué es esto|now playing)", "status"),
+    (r"(?:pon|play|busca|search|reproduce)\s+(.+)", "search"),
+]
+def parse_intent(text: str) -> Optional[VoiceCommand]:
+    """Parse transcribed text into a voice command."""
+    text = text.lower().strip()
+    if not text:
+        return None
+    for pattern, intent in INTENT_PATTERNS:
+        m = re.search(pattern, text)
+        if m:
+            query = m.group(1) if m.lastindex and m.lastindex >= 1 else None
+            return VoiceCommand(intent=intent, query=query)
+    return None
+class VoiceController:
+    """Listens for voice commands using Whisper for transcription."""
+    def __init__(self, model_size: str = "base"):
+        if whisper is None:
+            raise RuntimeError("openai-whisper not installed")
+        self._model = whisper.load_model(model_size)
+        self._command_queue: queue.Queue[VoiceCommand] = queue.Queue()
+        self._running = False
+        self._thread: Optional[threading.Thread] = None
+    def transcribe_audio(self, audio_data: np.ndarray) -> Optional[VoiceCommand]:
+        """Transcribe audio numpy array and parse intent."""
+        result = self._model.transcribe(audio_data, language=None, fp16=False)
+        text = result.get("text", "")
+        return parse_intent(text)
+    def get_pending_command(self) -> Optional[VoiceCommand]:
+        """Get next pending command (non-blocking)."""
+        try:
+            return self._command_queue.get_nowait()
+        except queue.Empty:
+            return None
+    def submit_audio(self, audio_data: np.ndarray):
+        """Submit audio for background transcription."""
+        def _process():
+            cmd = self.transcribe_audio(audio_data)
+            if cmd:
+                self._command_queue.put(cmd)
+        threading.Thread(target=_process, daemon=True).start()
+    def close(self):
+        self._running = False

style.css CHANGED Viewed

@@ -1,28 +1,211 @@
 body {
-	padding: 2rem;
-	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
 }
-h1 {
-	font-size: 16px;
-	margin-top: 0;
 }
-p {
-	color: rgb(107, 114, 128);
-	font-size: 15px;
-	margin-bottom: 10px;
-	margin-top: 5px;
 }
-.card {
-	max-width: 620px;
-	margin: 0 auto;
-	padding: 16px;
-	border: 1px solid lightgray;
-	border-radius: 16px;
 }
-.card p:last-child {
-	margin-bottom: 0;
 }

+/* jrubiosainz Reachy Mini Apps — Shared Brand */
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&display=swap');
+* { margin: 0; padding: 0; box-sizing: border-box; }
+:root {
+  --bg: #0c0c14;
+  --surface: #15152a;
+  --surface-2: #1e1e3a;
+  --accent: #7c5cfc;
+  --accent-glow: #9d7fff;
+  --accent-soft: rgba(124, 92, 252, 0.12);
+  --green: #3ddc84;
+  --text: #e8e8f0;
+  --text-dim: #8888aa;
+  --border: rgba(255,255,255,0.06);
+  --radius: 16px;
+}
 body {
+  font-family: 'Inter', -apple-system, sans-serif;
+  background: var(--bg);
+  color: var(--text);
+  min-height: 100vh;
+  -webkit-font-smoothing: antialiased;
 }
+nav {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 1rem 2rem;
+  border-bottom: 1px solid var(--border);
+  backdrop-filter: blur(20px);
+  position: sticky;
+  top: 0;
+  z-index: 100;
+  background: rgba(12,12,20,0.85);
 }
+.nav-brand {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  font-weight: 700;
+  font-size: 1rem;
+  color: var(--text);
+  text-decoration: none;
+}
+.nav-brand .dot {
+  width: 8px; height: 8px;
+  background: var(--green);
+  border-radius: 50%;
+  display: inline-block;
+}
+.nav-links { display: flex; gap: 1.5rem; }
+.nav-links a {
+  color: var(--text-dim);
+  text-decoration: none;
+  font-size: 0.85rem;
+  font-weight: 500;
+  transition: color 0.2s;
+}
+.nav-links a:hover { color: var(--text); }
+.hero {
+  text-align: center;
+  padding: 5rem 2rem 3rem;
+  position: relative;
+}
+.hero::before {
+  content: '';
+  position: absolute;
+  top: 0; left: 50%;
+  transform: translateX(-50%);
+  width: 600px; height: 600px;
+  background: radial-gradient(circle, var(--accent-soft) 0%, transparent 70%);
+  pointer-events: none;
+}
+.badge {
+  display: inline-block;
+  background: var(--accent-soft);
+  color: var(--accent-glow);
+  padding: 0.35rem 1rem;
+  border-radius: 20px;
+  font-size: 0.75rem;
+  font-weight: 600;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  margin-bottom: 1.5rem;
+}
+.hero h1 {
+  font-size: 3.5rem;
+  font-weight: 800;
+  margin-bottom: 1rem;
+  position: relative;
+}
+.tagline {
+  font-size: 1.2rem;
+  color: var(--text-dim);
+  max-width: 500px;
+  margin: 0 auto;
+  line-height: 1.6;
 }
+.video-showcase {
+  max-width: 800px;
+  margin: 0 auto 4rem;
+  padding: 0 2rem;
+}
+.video-frame {
+  border-radius: var(--radius);
+  overflow: hidden;
+  border: 1px solid var(--border);
+  background: var(--surface);
+}
+.video-frame video {
+  width: 100%;
+  display: block;
+}
+.video-label {
+  text-align: center;
+  font-size: 0.8rem;
+  color: var(--text-dim);
+  margin-top: 0.75rem;
 }
+.features, .gestures, .install {
+  max-width: 900px;
+  margin: 0 auto;
+  padding: 4rem 2rem;
+}
+.features h2, .gestures h2, .install h2 {
+  text-align: center;
+  font-size: 2rem;
+  font-weight: 700;
+  margin-bottom: 0.5rem;
+}
+.subtitle {
+  text-align: center;
+  color: var(--text-dim);
+  margin-bottom: 2.5rem;
+}
+.feature-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
+  gap: 1.5rem;
+}
+.feature-card {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 2rem;
+  transition: border-color 0.2s, transform 0.2s;
+}
+.feature-card:hover {
+  border-color: var(--accent);
+  transform: translateY(-2px);
+}
+.feature-card .icon {
+  font-size: 2rem;
+  margin-bottom: 1rem;
+}
+.feature-card h3 {
+  font-size: 1.1rem;
+  font-weight: 600;
+  margin-bottom: 0.5rem;
+}
+.feature-card p {
+  color: var(--text-dim);
+  font-size: 0.9rem;
+  line-height: 1.5;
+}
+.steps {
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+  max-width: 600px;
+  margin: 0 auto;
+}
+.step {
+  display: flex;
+  gap: 1.5rem;
+  align-items: flex-start;
+}
+.step-num {
+  width: 36px; height: 36px;
+  background: var(--accent-soft);
+  color: var(--accent-glow);
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-weight: 700;
+  flex-shrink: 0;
+}
+.step h4 { margin-bottom: 0.25rem; }
+.step p { color: var(--text-dim); font-size: 0.9rem; }
+footer {
+  text-align: center;
+  padding: 3rem 2rem;
+  border-top: 1px solid var(--border);
+  color: var(--text-dim);
+  font-size: 0.85rem;
+}
+footer a {
+  color: var(--accent-glow);
+  text-decoration: none;
 }
+footer a:hover { text-decoration: underline; }