infinicode 2.8.92 → 2.8.93

package/dist/kernel/federation/dashboard-html.js

@@ -6888,7 +6888,7 @@ button.act:disabled{opacity:0.5;cursor:default;}
       var overlay=$('pk-camera-ops-overlay');if(overlay)overlay.innerHTML='<div class="metric"><b>'+esc(readiness.replace(/_/g,' '))+'</b><span>readiness</span></div><div class="metric"><b>'+esc(active?'in session':'standing by')+'</b><span>conversation</span></div><div class="metric"><b>'+(row.avg_latency_ms!=null?Math.round(row.avg_latency_ms)+'ms':'--')+'</b><span>average latency</span></div><div class="metric"><b>'+(row.drop_rate!=null?Math.round(row.drop_rate*100)+'%':'--')+'</b><span>session drops</span></div>';
       var insights=$('pk-camera-ops-insights');if(insights)insights.innerHTML='<span>Camera relay</span><b class="'+(cameraLive?'ok':'bad')+'">'+(cameraLive?'LIVE':'CONNECTING')+'</b><span>Mesh node</span><b class="'+(n.connected?'ok':'bad')+'">'+(n.connected?'connected':'offline')+'</b><span>Production mode</span><b class="'+(device.production_mode?'ok':'')+'">'+(device.production_mode?'armed':'disabled')+'</b><span>Readiness</span><b>'+esc(readiness.replace(/_/g,' '))+'</b><span>Heartbeat</span><b>'+(row.heartbeat_age_seconds!=null?Math.round(row.heartbeat_age_seconds)+'s ago':'--')+'</b><span>Current room</span><b>'+esc(String(row.current_session_id||row.active_session_id||'none').slice(0,24))+'</b><span>Triggers</span><b>'+esc(row.trigger_count!=null?row.trigger_count:0)+'</b><span>Sessions</span><b>'+esc(row.sessions_total!=null?row.sessions_total:0)+'</b>';
       var stages=[['Robot online',!!n.connected],['Camera streaming',cameraLive],['Motion detector armed',!!device.production_mode],['Scheduler session',active],['Voice pipeline',readiness==='in_session'||active]],pipe=$('pk-camera-ops-pipeline');if(pipe)pipe.innerHTML=stages.map(function(s){return '<div><i class="'+(s[1]?'ok':'warn')+'"></i><span>'+esc(s[0])+'</span><b>'+(s[1]?'ready':'waiting')+'</b></div>';}).join('');
-      var inv=device.device_inventory||{},hardware=$('pk-camera-ops-hardware');if(hardware)hardware.innerHTML='<span>CPU</span><b>'+(hw.cpu&&hw.cpu.percent!=null?Math.round(hw.cpu.percent)+'%':'--')+'</b><span>Memory</span><b>'+(hw.memory&&hw.memory.percent!=null?Math.round(hw.memory.percent)+'%':'--')+'</b><span>Temperature</span><b>'+(hw.temperatureC!=null?Math.round(hw.temperatureC)+'C':'--')+'</b><span>Camera inputs</span><b>'+((inv.video||[]).length||0)+'</b><span>Microphones</span><b>'+((inv.audio_input||[]).length||0)+'</b><span>Speaker outputs</span><b>'+((inv.audio_output||[]).length||0)+'</b><span>Selected camera</span><b>'+esc(device.video_device||'auto')+'</b><span>Selected microphone</span><b>'+esc(device.audio_device||'default')+'</b>';
+      var inv=device.device_inventory||{},mh=inv.media_health||{},hardware=$('pk-camera-ops-hardware');if(hardware)hardware.innerHTML='<span>CPU</span><b>'+(hw.cpu&&hw.cpu.percent!=null?Math.round(hw.cpu.percent)+'%':'--')+'</b><span>Memory</span><b>'+(hw.memory&&hw.memory.percent!=null?Math.round(hw.memory.percent)+'%':'--')+'</b><span>Temperature</span><b>'+(hw.temperatureC!=null?Math.round(hw.temperatureC)+'C':'--')+'</b><span>Camera inputs</span><b>'+((inv.video||[]).length||0)+'</b><span>Microphones</span><b>'+((inv.audio_input||[]).length||0)+'</b><span>Speaker outputs</span><b>'+((inv.audio_output||[]).length||0)+'</b><span>Camera permission</span><b class="'+(mh.camera_access===false?'bad':'ok')+'">'+(mh.camera_access===false?'DENIED':mh.camera_access===true?'granted':'--')+'</b><span>Audio permission</span><b class="'+(mh.audio_access===false?'bad':'ok')+'">'+(mh.audio_access===false?'DENIED':mh.audio_access===true?'granted':'--')+'</b><span>Camera worker</span><b class="'+(mh.camera_stalled?'bad':'ok')+'">'+(mh.camera_stalled?'STALLED':mh.camera_worker?'streaming':'--')+'</b><span>Frame age</span><b>'+(mh.camera_frame_age_seconds!=null?Number(mh.camera_frame_age_seconds).toFixed(1)+'s':'--')+'</b><span>Selected camera</span><b>'+esc(device.video_device||'auto')+'</b><span>Selected microphone</span><b>'+esc(device.audio_device||'default')+'</b>';
       var prod=$('pk-camera-ops-production');if(prod){prod.textContent=device.production_mode?'Disable production':'Enable production';prod.classList.toggle('primary',!!device.production_mode);}
     }
     function reloadCameraOperations(){

package/dist/robopark/auto-start.js

@@ -65,19 +65,56 @@ async function registerSystemd(service) {
     const envLines = Object.entries(service.env ?? {})
         .map(([k, v]) => `Environment="${k}=${v.replace(/"/g, '\\"')}"`)
         .join('\n');
-    const unit = `[Unit]
-Description=RoboPark ${service.role} for ${service.name}
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-ExecStart=${service.command} ${service.args.map(shellQuote).join(' ')}
+    const mediaService = service.role === 'robot-runtime' || service.role === 'robot-preview-agent' || service.role === 'robot-vision-agent';
+    const mediaGroups = mediaService
+        ? ['audio', 'video', 'render', 'input', 'plugdev'].filter(group => spawnSync('getent', ['group', group], { stdio: 'ignore' }).status === 0)
+        : [];
+    const mediaPolicy = mediaService ? [
+        mediaGroups.length ? `SupplementaryGroups=${mediaGroups.join(' ')}` : '',
+        'UMask=0007',
+        'LimitNOFILE=65536',
+        'TasksMax=512',
+        'OOMScoreAdjust=-500',
+    ].filter(Boolean).join('\n') : '';
+    let mediaRulesInstalled = false;
+    if (mediaService) {
+        const rulesPath = '/etc/udev/rules.d/70-robopark-media.rules';
+        const rules = [
+            '# Managed by RoboPark. Shared hardware profile for production robots.',
+            'SUBSYSTEM=="video4linux", GROUP="video", MODE="0660"',
+            'SUBSYSTEM=="video4linux", ENV{ID_BUS}=="usb", ATTR{index}=="0", SYMLINK+="robopark-camera"',
+            'SUBSYSTEM=="sound", GROUP="audio", MODE="0660"',
+            '',
+        ].join('\n');
+        try {
+            writeFileSync(rulesPath, rules, 'utf8');
+            spawnSync('udevadm', ['control', '--reload-rules'], { stdio: 'ignore' });
+            spawnSync('udevadm', ['trigger', '--subsystem-match=video4linux'], { stdio: 'ignore' });
+            spawnSync('udevadm', ['trigger', '--subsystem-match=sound'], { stdio: 'ignore' });
+            mediaRulesInstalled = true;
+        }
+        catch {
+            // The explicit systemd groups below still cover standard distro rules.
+        }
+    }
+    const unit = `[Unit]
+Description=RoboPark ${service.role} for ${service.name}
+After=network-online.target sound.target
+Wants=network-online.target sound.target
+StartLimitIntervalSec=120
+StartLimitBurst=20
+
+[Service]
+Type=simple
+ExecStart=${service.command} ${service.args.map(shellQuote).join(' ')}
 WorkingDirectory=${service.workingDir ?? homedir()}
 Restart=always
-RestartSec=5
+RestartSec=3
 KillMode=control-group
-TimeoutStopSec=10
+TimeoutStopSec=20
+SendSIGKILL=yes
+FinalKillSignal=SIGKILL
+${mediaPolicy}
 ${envLines}
 
 [Install]
@@ -93,7 +130,10 @@ WantedBy=multi-user.target
         if (enabled.status !== 0) {
             return { ok: false, message: `wrote ${unitPath}, but systemctl enable --now failed: ${enabled.stderr || enabled.stdout}` };
         }
-        return { ok: true, message: `enabled and started systemd unit ${unitName}` };
+        return {
+            ok: true,
+            message: `enabled and started systemd unit ${unitName}${mediaRulesInstalled ? ' with persistent media permissions' : ''}`,
+        };
     }
     catch (e) {
         return { ok: false, message: `could not write ${unitPath}: ${e instanceof Error ? e.message : String(e)}` };

package/dist/robopark/robot-runtime.js

@@ -15,7 +15,9 @@ import { fileURLToPath } from 'node:url';
 import chalk from 'chalk';
 import { resolveInfinicodeBin } from './serve.js';
 const VISION_URL = 'http://127.0.0.1:5000/api/media/inventory';
+const VISION_STATUS_URL = 'http://127.0.0.1:5000/api/camera/status';
 const RESTART_DELAY_MS = 5_000;
+const MEDIA_WATCHDOG_INTERVAL_MS = 10_000;
 function resetStaleEnrollment() {
     const configDir = join(homedir(), '.robopark');
     const tokenPath = join(configDir, 'device_token');
@@ -97,6 +99,9 @@ export async function roboparkRobotRuntime(opts) {
             command: process.execPath,
             args: [cli, 'vision-agent', '--foreground', '--port', '5000',
                 '--motion-webhook-url', 'http://127.0.0.1:5057/'],
+            env: {
+                ROBOPARK_CAMERA_DEVICE: opts.videoDevice ?? '/dev/robopark-camera',
+            },
         });
     }
     const previewArgs = [cli, 'preview-agent', '--foreground',
@@ -122,6 +127,10 @@ export async function roboparkRobotRuntime(opts) {
                 ? 'http://127.0.0.1:5000/api/media/inventory'
                 : '',
             ROBOVISION_CAMERA: opts.vision !== false ? '1' : '0',
+            // Fleet hardware profile: resolve volatile ALSA hw:X,Y coordinates
+            // from these USB product labels on every inventory refresh.
+            ROBOPARK_AUDIO_INPUT_MATCH: 'Usb Audio Device: USB Audio',
+            ROBOPARK_AUDIO_OUTPUT_MATCH: 'USB Audio Device: -',
             // Inventory changes should reach the Control Center promptly.
             HEARTBEAT_INTERVAL: '5',
         },
@@ -182,6 +191,43 @@ export async function roboparkRobotRuntime(opts) {
             signalChild(entry, 'SIGTERM');
         });
     };
+    let visionFailureCount = 0;
+    let visionRecoveryInFlight = false;
+    const monitorVision = async () => {
+        if (stopping || recycling || visionRecoveryInFlight || opts.vision === false)
+            return;
+        const vision = children.find(entry => entry.label === 'vision');
+        if (!vision?.child)
+            return;
+        let healthy = false;
+        try {
+            const response = await fetch(VISION_STATUS_URL, { signal: AbortSignal.timeout(2_000) });
+            if (response.ok) {
+                const status = await response.json();
+                const frameTooOld = status.worker_started === true
+                    && typeof status.last_frame_age_seconds === 'number'
+                    && status.last_frame_age_seconds > 15;
+                healthy = !status.read_stalled && !frameTooOld;
+            }
+        }
+        catch {
+            healthy = false;
+        }
+        visionFailureCount = healthy ? 0 : visionFailureCount + 1;
+        if (visionFailureCount < 3)
+            return;
+        visionRecoveryInFlight = true;
+        console.error(chalk.yellow('  media watchdog: RoboVision unhealthy for 30s; recycling camera/audio pair'));
+        try {
+            await stopChild(vision);
+            if (!stopping)
+                start(vision);
+            visionFailureCount = 0;
+        }
+        finally {
+            visionRecoveryInFlight = false;
+        }
+    };
     const recycleAfterMeshUpdate = async () => {
         if (stopping || recycling)
             return;
@@ -231,8 +277,10 @@ export async function roboparkRobotRuntime(opts) {
                     : chalk.yellow('  RoboVision is degraded; preview heartbeat remains online and will retry'));
         });
     }
+    const mediaWatchdog = setInterval(() => { void monitorVision(); }, MEDIA_WATCHDOG_INTERVAL_MS);
     const shutdown = () => {
         stopping = true;
+        clearInterval(mediaWatchdog);
         for (const entry of [...children, preview])
             signalChild(entry, 'SIGTERM');
     };

package/dist/robopark/setup.js

@@ -196,6 +196,9 @@ async function setupRobot(config, opts, ctx, internal) {
     // production trigger — on by default. --no-vision opts out (e.g. no camera
     // on this box, or RoboVisionAI_PI isn't installed).
     const visionEnabled = opts.vision !== false;
+    const defaultVideoDevice = process.platform === 'linux' && opts.autoStart
+        ? '/dev/robopark-camera'
+        : '/dev/video0';
     const runtimeArgs = [
         'robot', 'up',
         '--name', internal.name,
@@ -204,7 +207,7 @@ async function setupRobot(config, opts, ctx, internal) {
         '--token', internal.token,
         '--port', String(internal.port),
         networkFlag,
-        '--video-device', opts.videoDevice ?? '/dev/video0',
+        '--video-device', opts.videoDevice ?? defaultVideoDevice,
         '--audio-device', opts.audioDevice ?? 'Usb Audio Device: USB Audio (hw:3,0)',
     ];
     if (opts.enrollmentToken)

package/dist/robopark/vision-agent-launcher.js

@@ -49,13 +49,34 @@ export async function roboparkVisionAgent(opts) {
         console.log(`  audio:   ${chalk.green('RoboVision audio server :8000')}`);
     console.log();
     if (opts.foreground) {
-        if (audioScript) {
-            const audio = spawn(python, [audioScript], { stdio: 'inherit', env: { ...process.env, ROBOPARK_AUDIO_SERVER: '1' } });
-            audio.unref();
-        }
-        const proc = spawn(python, args, { stdio: 'inherit' });
+        const audio = audioScript
+            ? spawn(python, [audioScript], { stdio: 'inherit', env: { ...process.env, ROBOPARK_AUDIO_SERVER: '1' } })
+            : null;
+        const camera = spawn(python, args, { stdio: 'inherit' });
+        let stopping = false;
+        const stopChildren = () => {
+            if (stopping)
+                return;
+            stopping = true;
+            camera.kill('SIGTERM');
+            audio?.kill('SIGTERM');
+        };
+        process.once('SIGINT', stopChildren);
+        process.once('SIGTERM', stopChildren);
+        // If either required media service exits, tear down its sibling. The
+        // robot runtime then restarts one coherent pair instead of accumulating
+        // orphan audio servers and duplicate owners of ports/devices.
         await new Promise((resolve) => {
-            proc.on('close', () => resolve());
+            let resolved = false;
+            const finish = () => {
+                if (resolved)
+                    return;
+                resolved = true;
+                stopChildren();
+                resolve();
+            };
+            camera.once('close', finish);
+            audio?.once('close', finish);
         });
         return;
     }

package/docs/ROBOPARK_PRODUCTION_MEMORY.md

@@ -127,3 +127,18 @@ $s.events | Where-Object session_id -eq $id | Select-Object timestamp,stage,stat
 ```
 
 Required result: `playback_started  ok`.
+
+## Fleet Media Reliability Contract (2.8.93+)
+
+- Linux setup installs persistent udev permissions for `video4linux` and
+  `sound`, plus `/dev/robopark-camera` for the primary USB capture interface.
+- The systemd runtime receives available media groups and uses control-group
+  shutdown so descendants cannot survive an update or restart.
+- `/run/lock/robopark-speaker.lock` and
+  `/run/lock/robopark-microphone.lock` serialize production media and tests.
+- The vision launcher owns both camera and audio children. If either exits,
+  the runtime restarts one coherent pair instead of leaving an orphan owner.
+- RoboVision opens its shared camera worker at boot. The runtime polls camera
+  status and recycles media after three consecutive unhealthy checks.
+- Park media operations display camera/audio permission, camera worker state,
+  and latest frame age from `device_inventory.media_health`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.92",
+  "version": "2.8.93",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",

package/packages/robopark/scheduler/media_lock.py

@@ -0,0 +1,57 @@
+"""Cross-process media ownership for Linux robot appliances."""
+from __future__ import annotations
+
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+
+class MediaLock:
+    def __init__(self, kind: str, timeout: float = 5.0):
+        self.kind = kind
+        self.timeout = timeout
+        self.fd: Optional[int] = None
+
+    def acquire(self) -> "MediaLock":
+        if not sys.platform.startswith("linux"):
+            return self
+        import fcntl
+
+        lock_dir = Path("/run/lock") if os.access("/run/lock", os.W_OK) else Path("/tmp")
+        path = lock_dir / f"robopark-{self.kind}.lock"
+        self.fd = os.open(path, os.O_CREAT | os.O_RDWR, 0o660)
+        deadline = time.monotonic() + self.timeout
+        while True:
+            try:
+                fcntl.flock(self.fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                os.ftruncate(self.fd, 0)
+                os.write(self.fd, f"{os.getpid()}\n".encode("ascii"))
+                return self
+            except BlockingIOError:
+                if time.monotonic() >= deadline:
+                    self.release()
+                    raise TimeoutError(f"{self.kind} is owned by another RoboPark media process")
+                time.sleep(0.05)
+
+    def release(self) -> None:
+        if self.fd is None:
+            return
+        try:
+            if sys.platform.startswith("linux"):
+                import fcntl
+                fcntl.flock(self.fd, fcntl.LOCK_UN)
+        finally:
+            os.close(self.fd)
+            self.fd = None
+
+    def __enter__(self) -> "MediaLock":
+        return self.acquire()
+
+    def __exit__(self, exc_type, exc, traceback) -> None:
+        self.release()
+
+
+def media_lock(kind: str, timeout: float = 5.0) -> MediaLock:
+    return MediaLock(kind, timeout)

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()
@@ -1275,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
@@ -1284,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:
@@ -1522,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()
@@ -1864,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.PIPE,
-        )
+        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
 
@@ -1904,13 +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()
-                self.process.wait(timeout=1)
+        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):
@@ -2000,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}"