infinicode 2.8.91 → 2.8.93

package/packages/robopark/scheduler/preview_agent.py

@@ -70,6 +70,31 @@ _DEVICE_INVENTORY_CACHE: Optional[dict] = None
 _DEVICE_INVENTORY_CACHE_AT = 0.0
 DEVICE_INVENTORY_CACHE_SECONDS = 5.0
 ROBOVISION_MEDIA_URL = os.getenv("ROBOVISION_MEDIA_URL", "http://127.0.0.1:5000/api/media/inventory")
+
+
+def _stable_audio_label(value: object) -> str:
+    """Compare USB product names without volatile ALSA card coordinates."""
+    import re
+    return " ".join(re.sub(r"\s*\(hw:\d+,\d+\)\s*$", "", str(value), flags=re.I).lower().split())
+
+
+def _resolve_inventory_audio(items: list, selected: object, preferred: str) -> str:
+    if preferred:
+        wanted = _stable_audio_label(preferred)
+        match = next((item for item in items if _stable_audio_label(item.get("name")) == wanted), None)
+        if match and match.get("name"):
+            return str(match["name"])
+    selected_text = str(selected)
+    selected_label = _stable_audio_label(selected_text)
+    match = next(
+        (
+            item for item in items
+            if str(item.get("id")) == selected_text
+            or _stable_audio_label(item.get("name")) == selected_label
+        ),
+        None,
+    )
+    return str(match.get("name")) if match and match.get("name") else selected_text
 
 
 def _normalize_livekit_url(url: Optional[str]) -> Optional[str]:
@@ -103,17 +128,23 @@ def _play_audio_effect(selected_output: str | None, effect: str) -> None:
     if sys.platform.startswith("linux") and "hw:" in selected:
         import re
         import subprocess
+        from media_lock import media_lock
 
         match = re.search(r"\b(hw:\d+,\d+)\b", selected)
         if not match:
             return
-        result = subprocess.run(
-            [
-                "aplay", "-q", "-D", f"plug{match.group(1)}", "-t", "raw",
-                "-f", "S16_LE", "-r", str(sample_rate), "-c", str(channels),
-            ],
-            input=bytes(frames), capture_output=True, timeout=3.0,
-        )
+        try:
+            with media_lock("speaker", timeout=3.0):
+                result = subprocess.run(
+                    [
+                        "aplay", "-q", "-D", f"plug{match.group(1)}", "-t", "raw",
+                        "-f", "S16_LE", "-r", str(sample_rate), "-c", str(channels),
+                    ],
+                    input=bytes(frames), capture_output=True, timeout=3.0,
+                )
+        except TimeoutError as exc:
+            logger.warning("audio effect skipped: %s", exc)
+            return
         if result.returncode:
             logger.warning(
                 "audio effect failed on %s: %s",
@@ -225,7 +256,38 @@ def _get_device_inventory() -> dict:
             pa.terminate()
         except Exception as e:
             logger.debug(f"audio inventory unavailable: {e}")
-
+
+    media_health = {
+        "service_uid": os.geteuid() if hasattr(os, "geteuid") else None,
+        "camera_access": None,
+        "audio_access": None,
+        "camera_worker": None,
+        "camera_stalled": None,
+        "camera_frame_age_seconds": None,
+    }
+    if sys.platform.startswith("linux"):
+        camera_nodes = [
+            str(item.get("id")) for item in inventory.get("video", [])
+            if str(item.get("id", "")).startswith("/dev/video")
+        ]
+        sound_nodes = glob.glob("/dev/snd/pcm*")
+        media_health["camera_access"] = bool(camera_nodes) and all(
+            os.access(path, os.R_OK | os.W_OK) for path in camera_nodes[:1]
+        )
+        media_health["audio_access"] = bool(sound_nodes) and all(
+            os.access(path, os.R_OK | os.W_OK) for path in sound_nodes
+        )
+        try:
+            camera_response = httpx.get("http://127.0.0.1:5000/api/camera/status", timeout=0.6)
+            if camera_response.is_success:
+                camera_status = camera_response.json()
+                media_health["camera_worker"] = bool(camera_status.get("worker_started"))
+                media_health["camera_stalled"] = bool(camera_status.get("read_stalled"))
+                media_health["camera_frame_age_seconds"] = camera_status.get("last_frame_age_seconds")
+        except Exception:
+            pass
+    inventory["media_health"] = media_health
+
     _DEVICE_INVENTORY_CACHE = inventory
     _DEVICE_INVENTORY_CACHE_AT = now
     logger.info(
@@ -707,26 +769,18 @@ class PreviewAgent:
                 self.audio_device = data["audio_device"]
                 inventory = data.get("device_inventory") or {}
                 selected = str(self.audio_device)
-                self.audio_capture_device = next(
-                    (
-                        str(item.get("name"))
-                        for item in inventory.get("audio_input", [])
-                        if str(item.get("id")) == selected and item.get("name")
-                    ),
-                    self.audio_device,
+                self.audio_capture_device = _resolve_inventory_audio(
+                    inventory.get("audio_input", []), selected,
+                    os.getenv("ROBOPARK_AUDIO_INPUT_MATCH", ""),
                 )
             if data.get("audio_output_device") is not None:
                 changed = changed or self.audio_output_device != data["audio_output_device"]
                 self.audio_output_device = data["audio_output_device"]
                 inventory = data.get("device_inventory") or {}
                 selected = str(self.audio_output_device)
-                self.audio_playback_device = next(
-                    (
-                        str(item.get("name"))
-                        for item in inventory.get("audio_output", [])
-                        if str(item.get("id")) == selected and item.get("name")
-                    ),
-                    self.audio_output_device,
+                self.audio_playback_device = _resolve_inventory_audio(
+                    inventory.get("audio_output", []), selected,
+                    os.getenv("ROBOPARK_AUDIO_OUTPUT_MATCH", ""),
                 )
             if changed:
                 await self._sync_robovision_media_config()
@@ -1257,17 +1311,14 @@ class LiveKitPublisher:
         # — until it finished, so a short "Hello friend!" greeting could be
         # over and gone before we ever got a chance to subscribe to it.
         if audio_enabled:
-            self._tasks.append(asyncio.create_task(self._audio_loop()))
+            self._tasks.append(asyncio.create_task(self._audio_retry_loop()))
             try:
                 await asyncio.wait_for(self._mic_streaming.wait(), timeout=5.0)
-                await self.agent._report_pipeline(
-                    "microphone_published", "ok", "Microphone track published with live PCM frames"
-                )
             except asyncio.TimeoutError:
                 await self.agent._report_pipeline(
                     "microphone_published", "blocked", "Microphone track published but PCM capture did not start"
                 )
-                raise RuntimeError(f"microphone capture did not start for {self.agent.audio_capture_device}")
+                logger.warning("microphone PCM is not ready; keeping the session alive while capture retries")
 
         if self._capture and self.video_source:
             self._tasks.append(asyncio.create_task(self._video_loop()))
@@ -1278,6 +1329,7 @@ class LiveKitPublisher:
         selected_output = str(self.agent.audio_playback_device or "default")
         pa = None
         output_device_index = None
+        speaker_guard = None
 
         # RoboVision inventories Linux devices through sounddevice/PortAudio,
         # but the numeric indices are not stable across PyAudio builds. More
@@ -1287,23 +1339,33 @@ class LiveKitPublisher:
         if sys.platform.startswith("linux") and "hw:" in selected_output:
             import re
             import subprocess
+            from media_lock import media_lock
 
             match = re.search(r"\b(hw:\d+,\d+)\b", selected_output)
             if not match:
                 logger.warning(f"audio out: no ALSA hardware address in {selected_output!r}")
                 return
             alsa_device = f"plug{match.group(1)}"
-            process = subprocess.Popen(
-                [
-                    "aplay", "-q", "-D", alsa_device, "-t", "raw",
-                    "-f", "S16_LE", "-r", str(OUT_RATE), "-c", str(OUT_CHANNELS),
-                ],
-                stdin=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-            )
+            try:
+                speaker_guard = media_lock("speaker", timeout=8.0).acquire()
+                process = subprocess.Popen(
+                    [
+                        "aplay", "-q", "-D", alsa_device, "-t", "raw",
+                        "-f", "S16_LE", "-r", str(OUT_RATE), "-c", str(OUT_CHANNELS),
+                    ],
+                    stdin=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                )
+            except Exception as exc:
+                if speaker_guard is not None:
+                    speaker_guard.release()
+                logger.warning(f"audio out: could not acquire {alsa_device}: {exc}")
+                return
             if process.stdin is None:
                 logger.warning(f"audio out: aplay did not expose stdin for {alsa_device}")
                 process.kill()
+                process.wait(timeout=1)
+                speaker_guard.release()
                 return
 
             class _AplayOutput:
@@ -1525,6 +1587,8 @@ class LiveKitPublisher:
             out.close()
             if pa is not None:
                 pa.terminate()
+            if speaker_guard is not None:
+                speaker_guard.release()
 
     async def stop(self) -> None:
         self._stop_event.set()
@@ -1596,7 +1660,29 @@ class LiveKitPublisher:
         except Exception as e:
             logger.debug(f"preview motion sampling failed: {e}")
 
-    async def _audio_loop(self) -> None:
+    async def _audio_retry_loop(self) -> None:
+        """Keep microphone capture alive across transient ALSA ownership errors."""
+        while not self._stop_event.is_set():
+            try:
+                await self._audio_loop()
+            except asyncio.CancelledError:
+                raise
+            except Exception as e:
+                logger.warning(
+                    f"audio_loop: capture failed on {self.agent.audio_capture_device}: {e}; retrying"
+                )
+            finally:
+                mic = self._mic_capture
+                self._mic_capture = None
+                if mic is not None:
+                    await asyncio.to_thread(mic.stop)
+            if not self._stop_event.is_set():
+                try:
+                    await asyncio.wait_for(self._stop_event.wait(), timeout=1.0)
+                except asyncio.TimeoutError:
+                    pass
+
+    async def _audio_loop(self) -> None:
         assert self.audio_source is not None
         mic = create_audio_capture(self.agent.audio_capture_device)
         if mic is None:
@@ -1642,7 +1728,12 @@ class LiveKitPublisher:
                         data=chunk, sample_rate=48000, num_channels=1, samples_per_channel=samples_per_frame,
                     )
                     await self.audio_source.capture_frame(frame)
-                    self._mic_streaming.set()
+                    if not self._mic_streaming.is_set():
+                        self._mic_streaming.set()
+                        await self.agent._report_pipeline(
+                            "microphone_published", "ok",
+                            "Microphone track published with live PCM frames",
+                        )
                     p = audioop.max(chunk, 2)
                     _diag_peak = max(_diag_peak, p)
                     _diag_count += 1
@@ -1840,21 +1931,30 @@ class AlsaAudioCapture(AudioCapture):
     def __init__(self, device: str):
         import re
         import subprocess
+        from media_lock import media_lock
 
         match = re.search(r"\b(hw:\d+,\d+)\b", device)
         if not match:
             raise ValueError(f"no ALSA hardware address in {device!r}")
         alsa_device = f"plug{match.group(1)}"
         self.buffer = bytearray()
-        self.process = subprocess.Popen(
-            [
-                "arecord", "-q", "-D", alsa_device, "-t", "raw",
-                "-f", "S16_LE", "-r", "48000", "-c", "1",
-            ],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.DEVNULL,
-        )
+        self.media_guard = media_lock("microphone", timeout=5.0).acquire()
+        try:
+            self.process = subprocess.Popen(
+                [
+                    "arecord", "-q", "-D", alsa_device, "-t", "raw",
+                    "-f", "S16_LE", "-r", "48000", "-c", "1",
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+        except Exception:
+            self.media_guard.release()
+            raise
         if self.process.stdout is None:
+            self.process.kill()
+            self.process.wait(timeout=1)
+            self.media_guard.release()
             raise RuntimeError("arecord did not provide a PCM stream")
         self.alsa_device = alsa_device
 
@@ -1865,7 +1965,10 @@ class AlsaAudioCapture(AudioCapture):
         while len(self.buffer) < bytes_needed:
             chunk = self.process.stdout.read(bytes_needed - len(self.buffer))
             if not chunk:
-                raise OSError(f"ALSA capture stopped on {self.alsa_device}")
+                detail = ""
+                if self.process.stderr is not None:
+                    detail = self.process.stderr.read().decode("utf-8", errors="replace").strip()
+                raise OSError(f"ALSA capture stopped on {self.alsa_device}: {detail or 'no PCM data'}")
             self.buffer.extend(chunk)
         data = bytes(self.buffer[:bytes_needed])
         del self.buffer[:bytes_needed]
@@ -1877,12 +1980,16 @@ class AlsaAudioCapture(AudioCapture):
         )
 
     def stop(self):
-        if self.process.poll() is None:
-            self.process.terminate()
-            try:
-                self.process.wait(timeout=2)
-            except Exception:
-                self.process.kill()
+        try:
+            if self.process.poll() is None:
+                self.process.terminate()
+                try:
+                    self.process.wait(timeout=2)
+                except Exception:
+                    self.process.kill()
+                    self.process.wait(timeout=1)
+        finally:
+            self.media_guard.release()
 
 
 class PyAudioCapture(AudioCapture):
@@ -1972,6 +2079,7 @@ def create_audio_capture(device: str) -> Optional[AudioCapture]:
             return AlsaAudioCapture(device)
         except Exception as e:
             logger.warning(f"ALSA capture unavailable for {device}: {e}")
+            raise
     try:
         import pyaudio  # noqa: F401
         return PyAudioCapture(device if device != "default" else None)

package/packages/robopark/scheduler/robot_supervisor.py

@@ -600,24 +600,29 @@ def _linux_aplay_pcm16(raw: bytes, selected_output: str, sample_rate: int,
     # ALSA can retain an exclusive USB handle briefly after the LiveKit
     # playback stream closes. Retry for a bounded period instead of declaring
     # a valid device unsupported on the first EBUSY response.
-    for attempt in range(5):
-        if attempt:
-            time.sleep(0.5)
-        try:
-            completed = subprocess.run(
-                command,
-                input=raw,
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.PIPE,
-                timeout=max(5.0, len(raw) / max(1, sample_rate * channels * 2) + 3.0),
-                check=False,
-            )
-        except Exception as exc:
-            last_error = f"{type(exc).__name__}: {exc}"
-            continue
-        if completed.returncode == 0:
-            return True, alsa_device
-        last_error = completed.stderr.decode("utf-8", errors="replace").strip() or f"aplay exited {completed.returncode}"
+    try:
+        from media_lock import media_lock
+        with media_lock("speaker", timeout=8.0):
+            for attempt in range(5):
+                if attempt:
+                    time.sleep(0.5)
+                try:
+                    completed = subprocess.run(
+                        command,
+                        input=raw,
+                        stdout=subprocess.DEVNULL,
+                        stderr=subprocess.PIPE,
+                        timeout=max(5.0, len(raw) / max(1, sample_rate * channels * 2) + 3.0),
+                        check=False,
+                    )
+                except Exception as exc:
+                    last_error = f"{type(exc).__name__}: {exc}"
+                    continue
+                if completed.returncode == 0:
+                    return True, alsa_device
+                last_error = completed.stderr.decode("utf-8", errors="replace").strip() or f"aplay exited {completed.returncode}"
+    except TimeoutError as exc:
+        return False, str(exc)
     return False, f"{alsa_device}: {last_error}"
 
 

package/packages/robopark/vision/app_pi_clean.py

@@ -15,8 +15,10 @@ import struct
 app = Flask(__name__)
 CORS(app)
 
-# Camera management
-current_camera_index = 0
+# Camera management. Production installs create /dev/robopark-camera from
+# the primary USB capture interface, avoiding /dev/videoN renumbering.
+_configured_camera = os.getenv("ROBOPARK_CAMERA_DEVICE", "")
+current_camera_index = _configured_camera or ("/dev/robopark-camera" if os.path.exists("/dev/robopark-camera") else 0)
 camera = None
 camera_lock = threading.Lock()
 frame_condition = threading.Condition()
@@ -625,8 +627,11 @@ if __name__ == '__main__':
     print("RoboVision - Raspberry Pi Vision Server (Minimal)")
     print("=" * 60)
     print(f"Starting Flask server on http://0.0.0.0:{args.port}")
-    if webhook_url:
-        print(f"Motion webhook: {webhook_url}")
-    print(f"Motion detection: {'ARMED' if motion_detection_active else 'off (POST /api/motion/toggle to arm)'}")
-    print("=" * 60)
-    app.run(host='0.0.0.0', port=args.port, debug=False, threaded=True)
+    if webhook_url:
+        print(f"Motion webhook: {webhook_url}")
+    print(f"Motion detection: {'ARMED' if motion_detection_active else 'off (POST /api/motion/toggle to arm)'}")
+    print("=" * 60)
+    # Start the single camera owner at boot. Production motion and MJPEG
+    # readiness must not depend on an operator opening the dashboard first.
+    _ensure_camera_worker()
+    app.run(host='0.0.0.0', port=args.port, debug=False, threaded=True)

package/packages/robopark/vision/audio_server_pi.py

@@ -17,12 +17,29 @@ import os
 from datetime import datetime
 import logging
 import subprocess
-import base64
-from groq import Groq
+import base64
+import functools
+import sys
+from pathlib import Path
+from groq import Groq
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scheduler"))
+from media_lock import media_lock
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(message)s')
-logger = logging.getLogger(__name__)
+logger = logging.getLogger(__name__)
+
+
+def exclusive_media(kind: str):
+    """Prevent diagnostics from stealing ALSA devices from production."""
+    def decorate(func):
+        @functools.wraps(func)
+        def wrapped(*args, **kwargs):
+            with media_lock(kind, timeout=3.0):
+                return func(*args, **kwargs)
+        return wrapped
+    return decorate
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
@@ -173,7 +190,8 @@ def find_bluetooth_devices():
 # Find Bluetooth devices on startup
 find_bluetooth_devices()
 
-def play_audio_file(file_path: str):
+@exclusive_media("speaker")
+def play_audio_file(file_path: str):
     """Play audio file using sounddevice (supports Bluetooth)"""
     try:
         logger.info(f"🔊 Playing audio: {file_path}")
@@ -231,7 +249,8 @@ def get_available_input_devices():
             input_devices.append(i)
     return input_devices
 
-def record_audio_with_vad():
+@exclusive_media("microphone")
+def record_audio_with_vad():
     """
     Record audio from Bluetooth microphone with Voice Activity Detection
     Rotates through available devices if no audio detected