infinicode 2.8.45 → 2.8.49

package/dist/robopark/preview-agent-launcher.d.ts

@@ -11,6 +11,7 @@ export interface PreviewAgentOptions {
     visionWebhookPort?: string;
     visionTriggerCooldown?: string;
     visionSessionSeconds?: string;
+    robovisionUrl?: string;
     saveConfig?: boolean;
     foreground?: boolean;
 }

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

@@ -47,6 +47,8 @@ export async function roboparkPreviewAgent(opts) {
         args.push('--vision-trigger-cooldown', opts.visionTriggerCooldown);
     if (opts.visionSessionSeconds)
         args.push('--vision-session-seconds', opts.visionSessionSeconds);
+    if (opts.robovisionUrl)
+        args.push('--robovision-url', opts.robovisionUrl);
     if (opts.saveConfig)
         args.push('--save-config');
     console.log(chalk.bold('\n  robopark preview-agent'));

package/dist/robopark/setup.js

@@ -225,6 +225,8 @@ 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;
+    if (visionEnabled)
+        previewAgentArgs.push('--robovision-url', 'http://127.0.0.1:5000');
     const visionAgentArgs = ['vision-agent'];
     console.log(chalk.dim('  robot command:'));
     console.log('  ' + chalk.cyan(`infinicode ${args.join(' ')}`));

package/package.json

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

package/packages/robopark/pi-client/client.py

@@ -20,13 +20,15 @@
 # Subsequent runs (token is in device.json):
 #   python client.py --scheduler-url http://100.64.1.5:8080
 
-import argparse
-import asyncio
-import json
-import logging
-import os
-import signal
-import sys
+import argparse
+import asyncio
+import glob
+import json
+import logging
+import os
+import signal
+import subprocess
+import sys
 import time
 from pathlib import Path
 from typing import Optional
@@ -39,7 +41,45 @@ logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
 )
-log = logging.getLogger("robopark-pi")
+log = logging.getLogger("robopark-pi")
+
+
+def get_device_inventory() -> dict:
+    """Report real Linux media devices so the remote dashboard can select them."""
+    inventory = {
+        "video": [{"id": "auto", "name": "Auto detect"}, {"id": "none", "name": "Disable camera"}],
+        "audio_input": [{"id": "default", "name": "System default input"}],
+        "audio_output": [{"id": "default", "name": "System default output"}],
+        "platform": sys.platform,
+    }
+    for path in sorted(glob.glob("/dev/video*")):
+        inventory["video"].append({"id": path, "name": path, "backend": "v4l2"})
+
+    try:
+        import pyaudio
+        pa = pyaudio.PyAudio()
+        for index in range(pa.get_device_count()):
+            info = pa.get_device_info_by_index(index)
+            name = str(info.get("name", f"Audio device {index}"))
+            item = {"id": str(index), "name": name, "host_api": str(info.get("hostApi", ""))}
+            if info.get("maxInputChannels", 0) > 0:
+                inventory["audio_input"].append(item.copy())
+            if info.get("maxOutputChannels", 0) > 0:
+                inventory["audio_output"].append(item.copy())
+        pa.terminate()
+    except Exception as exc:
+        # Keep the device visible even when PortAudio is not installed; ALSA
+        # names are still useful for an operator diagnosing a Pi remotely.
+        log.debug("PyAudio inventory unavailable: %s", exc)
+        for command, key, kind in (("arecord", "audio_input", "input"), ("aplay", "audio_output", "output")):
+            try:
+                output = subprocess.run([command, "-L"], capture_output=True, text=True, timeout=3, check=False).stdout
+                for name in (line.strip() for line in output.splitlines()):
+                    if name and not name.startswith("(") and name not in {x["id"] for x in inventory[key]}:
+                        inventory[key].append({"id": name, "name": name, "backend": "alsa", "kind": kind})
+            except Exception:
+                pass
+    return inventory
 
 
 class PiClient:
@@ -56,7 +96,10 @@ class PiClient:
         self.heartbeat_interval = args.heartbeat_interval
         self.config_poll_interval = args.config_poll_interval
         self.join_room = args.join_room
-        self.room_name = args.room_name
+        self.room_name = args.room_name
+        self.video_device = args.video_device
+        self.audio_device = args.audio_device
+        self.audio_output_device = args.audio_output_device
 
         self.device_id: Optional[str] = None
         self.device_token: Optional[str] = None
@@ -129,8 +172,12 @@ class PiClient:
         log.info(f"Enrolled as device_id={self.device_id}")
         self._save_state()
 
-    async def heartbeat(self):
-        body = {"status": "online", "ip": self.tailscale_ip or self.lan_ip}
+    async def heartbeat(self):
+        body = {
+            "status": "online",
+            "ip": self.tailscale_ip or self.lan_ip,
+            "device_inventory": get_device_inventory(),
+        }
         async with httpx.AsyncClient(timeout=10.0) as c:
             r = await c.post(
                 f"{self.scheduler_url}/api/devices/{self.device_id}/heartbeat",
@@ -186,7 +233,10 @@ class PiClient:
             production_mode_provider=lambda: self.production_mode,
             scheduler_url=self.scheduler_url,
             device_id=self.device_id,
-            device_token=self.device_token,
+            device_token=self.device_token,
+            video_device=self.video_device,
+            audio_device=self.audio_device,
+            audio_output_device=self.audio_output_device,
         )
 
     # ---- main loop ------------------------------------------------------
@@ -234,8 +284,14 @@ class PiClient:
                     if int(time.time()) % int(self.config_poll_interval) < int(self.heartbeat_interval):
                         cfg = await self.fetch_config()
                         self.production_mode = bool(cfg.get("production_mode", False))
-                        if cfg.get("character_id"):
-                            self.character_id = cfg["character_id"]
+                        if cfg.get("character_id"):
+                            self.character_id = cfg["character_id"]
+                        if cfg.get("video_device") is not None:
+                            self.video_device = cfg["video_device"]
+                        if cfg.get("audio_device") is not None:
+                            self.audio_device = cfg["audio_device"]
+                        if cfg.get("audio_output_device") is not None:
+                            self.audio_output_device = cfg["audio_output_device"]
                 except Exception as e:
                     log.debug(f"Config poll error: {e}")
 
@@ -267,8 +323,11 @@ def parse_args() -> argparse.Namespace:
                    help="Base URL of the local RoboVisionAI_PI motor server")
     p.add_argument("--livekit-url", default=None, help="e.g. ws://100.64.1.5:7880")
     p.add_argument("--character-id", default=None, help="Override character assignment")
-    p.add_argument("--room-name", default="robopark-pi-standby",
-                   help="LiveKit room to join")
+    p.add_argument("--room-name", default="robopark-pi-standby",
+                   help="LiveKit room to join")
+    p.add_argument("--video-device", default="auto", help="Camera path/index, picamera, or auto")
+    p.add_argument("--audio-device", default="default", help="Microphone name/index or default")
+    p.add_argument("--audio-output-device", default="default", help="Speaker name/index or default")
     p.add_argument("--heartbeat-interval", type=float, default=10.0)
     p.add_argument("--config-poll-interval", type=float, default=30.0)
     p.add_argument("--join-room", action="store_true",
@@ -302,4 +361,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

package/packages/robopark/pi-client/livekit_bridge.py

@@ -75,9 +75,12 @@ async def run_livekit(
     on_motor_command: Callable[[str | bytes], Awaitable[str]],
     stop_event: asyncio.Event,
     production_mode_provider: Callable[[], bool],
-    scheduler_url: str = "",
-    device_id: str = "",
-    device_token: str = "",
+    scheduler_url: str = "",
+    device_id: str = "",
+    device_token: str = "",
+    video_device: str = "auto",
+    audio_device: str = "default",
+    audio_output_device: str = "default",
 ):
     """Join a LiveKit room, publish mic + cam, subscribe to data channel.
 
@@ -140,7 +143,8 @@ async def run_livekit(
                     try:
                         stream = rtc.AudioStream(track=track)
                         # Open output stream at 48kHz mono (Pi speaker)
-                        out = sd.OutputStream(samplerate=OUT_RATE, channels=1, dtype="int16", blocksize=0)
+                        output = None if str(audio_output_device).lower() in ("", "default", "auto") else audio_output_device
+                        out = sd.OutputStream(samplerate=OUT_RATE, channels=1, dtype="int16", blocksize=0, device=output)
                         out.start()
                         _active_streams[sid] = out
 
@@ -203,13 +207,16 @@ async def run_livekit(
             except Exception as e:
                 log.warning(f"sounddevice unavailable, skipping mic: {e}")
                 return
-            # The USB mic is ALSA device index 1 (1 in, 0 out). Default is output-only.
-            MIC_DEVICE = 1
-            try:
-                log.info(f"mic: opening device {MIC_DEVICE} ({sd.query_devices()[MIC_DEVICE]['name']})")
-            except Exception:
-                log.warning(f"mic: device {MIC_DEVICE} not found, trying default")
-                MIC_DEVICE = None
+            selected_mic = str(audio_device or "default")
+            MIC_DEVICE = None if selected_mic.lower() in ("", "default", "auto") else selected_mic
+            try:
+                if MIC_DEVICE is None:
+                    log.info("mic: opening system default input")
+                else:
+                    log.info(f"mic: opening device {MIC_DEVICE}")
+            except Exception:
+                log.warning(f"mic: device {MIC_DEVICE} not found, trying default")
+                MIC_DEVICE = None
             try:
                 source = rtc.AudioSource(sample_rate=16000, num_channels=1)
                 track = rtc.LocalAudioTrack.create_audio_track("mic", source)
@@ -241,9 +248,11 @@ async def run_livekit(
             except Exception as e:
                 log.warning(f"opencv unavailable, skipping camera: {e}")
                 return
-            cap = cv2.VideoCapture(0, cv2.CAP_V4L2)
-            if not cap.isOpened():
-                log.warning("camera /dev/video0 not available")
+            selected_camera = str(video_device or "auto")
+            camera_index = 0 if selected_camera.lower() in ("", "auto", "default", "first") else selected_camera
+            cap = cv2.VideoCapture(camera_index, cv2.CAP_V4L2)
+            if not cap.isOpened():
+                log.warning(f"camera {selected_camera} not available")
                 return
             cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
             cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
@@ -286,4 +295,4 @@ async def run_livekit(
                 except Exception: pass
             try: await room.disconnect()
             except Exception: pass
-            log.info("left room, will loop to reconnect")
+            log.info("left room, will loop to reconnect")

package/packages/robopark/scheduler/main.py

@@ -4230,23 +4230,37 @@ async def dashboard():
                     const buildDeviceInventory = () => {
                         const map = {};
                         for (const robot of robots.value) {
-                            const device = devices.value.find(d => d.name === robot.name || d.id === robot.id);
+                            const robotName = String(robot.name || '').toLowerCase();
+                            const device = devices.value.find(d => String(d.name || '').toLowerCase() === robotName || d.id === robot.id);
                             const savedVideo = device?.video_device || 'auto';
                             const savedAudio = device?.audio_device || 'default';
                             const hardware = device?.device_inventory || {};
-                            const videoOptions = (hardware.video || []).map(x => typeof x === 'string' ? x : x.id).filter(Boolean);
-                            const audioOptions = (hardware.audio_input || []).map(x => typeof x === 'string' ? x : x.id).filter(Boolean);
-                            const audioOutputOptions = (hardware.audio_output || []).map(x => typeof x === 'string' ? x : x.id).filter(Boolean);
+                            const inventoryReported = !!device?.device_inventory;
+                            const videoOptions = (hardware.video || []).filter(Boolean);
+                            const audioOptions = (hardware.audio_input || []).filter(Boolean);
+                            const audioOutputOptions = (hardware.audio_output || []).filter(Boolean);
+                            const optionId = x => typeof x === 'string' ? x : x.id;
+                            const optionName = x => typeof x === 'string' ? x : (x.name || x.id);
+                            const uniqueOptions = (items, defaults) => {
+                                const seen = new Set();
+                                return defaults.concat(items).filter(x => {
+                                    const id = optionId(x);
+                                    if (!id || seen.has(id)) return false;
+                                    seen.add(id); return true;
+                                });
+                            };
                             map[robot.id] = {
                                 deviceId: device?.id || null,
                                 robotName: robot.name,
+                                inventoryReported,
                                 selectedVideo: savedVideo,
                                 selectedAudio: savedAudio,
                                 selectedAudioOutput: device?.audio_output_device || 'default',
                                 greetingText: (device?.greeting_phrases || []).join('\\n'),
-                                videoOptions: [...new Set(['auto', 'none', savedVideo, ...videoOptions])],
-                                audioOptions: [...new Set(['default', 'none', savedAudio, ...audioOptions])],
-                                audioOutputOptions: [...new Set(['default', 'none', device?.audio_output_device || 'default', ...audioOutputOptions])],
+                                videoOptions: uniqueOptions(videoOptions, ['auto', 'none', savedVideo]),
+                                audioOptions: uniqueOptions(audioOptions, ['default', 'none', savedAudio]),
+                                audioOutputOptions: uniqueOptions(audioOutputOptions, ['default', 'none', device?.audio_output_device || 'default']),
+                                optionId, optionName,
                             };
                         }
                         deviceInventory.value = map;
@@ -4366,7 +4380,7 @@ async def dashboard():
                         const inv = deviceInventory.value[robotId];
                         if (!inv || !inv.deviceId) return;
                         try {
-                            await fetch(`/api/devices/${inv.deviceId}`, {
+                            const response = await fetch(`/api/devices/${inv.deviceId}`, {
                                 method: 'PATCH',
                                 headers: {'Content-Type': 'application/json'},
                                 body: JSON.stringify({
@@ -4416,6 +4430,31 @@ async def dashboard():
                             } catch (e) { console.warn('preview stop failed', e); }
                         }
                     };
+
+                    const testSpeaker = async (robot) => {
+                        const inv = deviceInventory.value[robot.id];
+                        const deviceId = inv?.deviceId || robot.id;
+                        try {
+                            const response = await fetch(`/api/robots/${deviceId}/shell/speaker-test`, {
+                                method: 'POST', headers: {'Content-Type': 'application/json'},
+                                body: JSON.stringify({
+                                    output: inv?.selectedAudioOutput || 'default',
+                                    input: inv?.selectedAudio || 'default',
+                                    duration: 0.6,
+                                }),
+                            });
+                            const queued = await response.json();
+                            if (!response.ok) throw new Error(queued.detail || `HTTP ${response.status}`);
+                            const result = await fetch(`/api/robots/${deviceId}/shell/wait/${queued.request_id}?timeout=12`).then(r => r.json());
+                            if (!result.completed) throw new Error('Robot did not answer. Check its heartbeat and supervisor.');
+                            const detail = result.result || {};
+                            alert(detail.ok
+                                ? `Audio test passed\\nOutput: ${detail.output_device || 'default'}\\nInput: ${detail.input_device || 'default'}\\nPeak: ${detail.peak_db ?? 'n/a'} dB`
+                                : `Audio test failed: ${detail.error || 'no microphone signal'}`);
+                        } catch (e) {
+                            alert('Audio test failed: ' + e.message);
+                        }
+                    };
 
                     const simulateTrigger = async (robot) => {
                         if (!settings.value.production_mode || simulation.value.busy) return;
@@ -4766,14 +4805,14 @@ async def dashboard():
                     return {
                         robots, servers, sessions, stats, connected, serverMetrics,
                         devices, settings, livekit, showAddDevice, showDevices, showCommands, commandNetwork, commandHubLan, commandHubTailscale, commandRobotId, selectedCommandRobot, commandRows, copyCommand, newDevice, rotatedToken, enrollmentNetwork, enrollmentCommand, simulation,
-                        showLiveKitConfig, livekitForm, preview, deviceInventory,
+                        showLiveKitConfig, livekitForm, preview, deviceInventory,
                         voiceStacks, characterPresets, showVoiceStackForm, showCharacterForm,
                         editingVoiceStack, editingCharacter, voiceStackForm, characterForm,
                         loadModel, unloadModel, statusColor, formatDuration, formatTime,
                         toggleProductionMode, rotateEnrollmentToken, provisionAgentToken,
                         submitNewDevice, deleteDevice, rotateDeviceToken, dismissRotatedToken,
                         joinConversation, saveLiveKitConfig, openLiveKitConfig,
-                        startPreview, stopPreview, simulateTrigger, stopConversation, recoverRobot, toggleDeviceProduction, setDeviceProduction, saveDeviceGreetings, updateDeviceMedia,
+                        startPreview, stopPreview, simulateTrigger, stopConversation, recoverRobot, toggleDeviceProduction, setDeviceProduction, saveDeviceGreetings, updateDeviceMedia, testSpeaker,
                         openVoiceStackForm, saveVoiceStack, deleteVoiceStack,
                         openCharacterForm, saveCharacter, deleteCharacter,
                         assignRobotCharacter, stackName, characterName,
@@ -5096,6 +5135,21 @@ async def dashboard():
                                             <span>Robot production: <strong :class="devices.find(d => d.id === deviceInventory[robot.id].deviceId)?.production_mode ? 'text-green-400' : 'text-gray-400'">{{ devices.find(d => d.id === deviceInventory[robot.id].deviceId)?.production_mode ? 'ON' : 'OFF' }}</strong></span>
                                             <button @click="toggleDeviceProduction(robot.id)" class="px-2 py-1 rounded bg-gray-600 hover:bg-gray-500">Toggle</button>
                                         </div>
+                                        <div v-if="deviceInventory[robot.id]" class="mb-3 rounded bg-gray-800/70 p-2">
+                                            <div class="flex items-center justify-between mb-2 text-xs font-semibold text-gray-300">
+                                                <span>Robot Hardware</span>
+                                                <span :class="deviceInventory[robot.id].inventoryReported ? 'text-green-300' : 'text-amber-300'">{{ deviceInventory[robot.id].inventoryReported ? 'inventory reported' : 'waiting for heartbeat' }}</span>
+                                            </div>
+                                            <div class="grid grid-cols-3 gap-2 text-sm">
+                                                <div><label class="text-xs text-gray-500">Camera</label><select v-model="deviceInventory[robot.id].selectedVideo" @change="updateDeviceMedia(robot.id)" class="w-full bg-gray-700 rounded px-2 py-1 text-xs"><option v-for="opt in deviceInventory[robot.id].videoOptions" :key="deviceInventory[robot.id].optionId(opt)" :value="deviceInventory[robot.id].optionId(opt)">{{ deviceInventory[robot.id].optionName(opt) }}</option></select></div>
+                                                <div><label class="text-xs text-gray-500">Microphone</label><select v-model="deviceInventory[robot.id].selectedAudio" @change="updateDeviceMedia(robot.id)" class="w-full bg-gray-700 rounded px-2 py-1 text-xs"><option v-for="opt in deviceInventory[robot.id].audioOptions" :key="deviceInventory[robot.id].optionId(opt)" :value="deviceInventory[robot.id].optionId(opt)">{{ deviceInventory[robot.id].optionName(opt) }}</option></select></div>
+                                                <div><label class="text-xs text-gray-500">Speaker</label><select v-model="deviceInventory[robot.id].selectedAudioOutput" @change="updateDeviceMedia(robot.id)" class="w-full bg-gray-700 rounded px-2 py-1 text-xs"><option v-for="opt in deviceInventory[robot.id].audioOutputOptions" :key="deviceInventory[robot.id].optionId(opt)" :value="deviceInventory[robot.id].optionId(opt)">{{ deviceInventory[robot.id].optionName(opt) }}</option></select></div>
+                                            </div>
+                                            <div class="grid grid-cols-2 gap-2 mt-2">
+                                                <button @click="startPreview(robot)" :disabled="!settings.production_mode || !livekit.url || !livekit.has_secret || preview.active" class="px-2 py-1 rounded text-xs bg-cyan-600 hover:bg-cyan-500 disabled:bg-gray-700 disabled:cursor-not-allowed">Camera Feed</button>
+                                                <button @click="testSpeaker(robot)" class="px-2 py-1 rounded text-xs bg-emerald-700 hover:bg-emerald-600">Audio Test</button>
+                                            </div>
+                                        </div>
                                         <div class="grid grid-cols-2 gap-2 mb-2 text-sm">
                                             <div>
                                                 <label class="text-xs text-gray-500">Character</label>
@@ -5111,44 +5165,15 @@ async def dashboard():
                                                 <div class="text-xs text-gray-400 px-2 py-1 bg-gray-800 rounded truncate">{{ stackName(robot.voice_stack_id) }}</div>
                                             </div>
                                         </div>
-                                        <div v-if="deviceInventory[robot.id]" class="space-y-2 text-sm">
-                                            <div class="grid grid-cols-3 gap-2">
-                                                <div>
-                                                    <label class="text-xs text-gray-500">Camera</label>
-                                                    <select v-model="deviceInventory[robot.id].selectedVideo"
-                                                            @change="updateDeviceMedia(robot.id)"
-                                                            class="w-full bg-gray-800 rounded px-2 py-1 text-xs">
-                                                        <option v-for="opt in deviceInventory[robot.id].videoOptions" :key="opt" :value="opt">{{ opt }}</option>
-                                                    </select>
-                                                </div>
-                                                <div>
-                                                    <label class="text-xs text-gray-500">Microphone</label>
-                                                    <select v-model="deviceInventory[robot.id].selectedAudio"
-                                                            @change="updateDeviceMedia(robot.id)"
-                                                            class="w-full bg-gray-800 rounded px-2 py-1 text-xs">
-                                                        <option v-for="opt in deviceInventory[robot.id].audioOptions" :key="opt" :value="opt">{{ opt }}</option>
-                                                    </select>
-                                                </div>
-                                                <div>
-                                                    <label class="text-xs text-gray-500">Speaker</label>
-                                                    <select v-model="deviceInventory[robot.id].selectedAudioOutput"
-                                                            @change="updateDeviceMedia(robot.id)"
-                                                            class="w-full bg-gray-800 rounded px-2 py-1 text-xs">
-                                                        <option v-for="opt in deviceInventory[robot.id].audioOutputOptions" :key="opt" :value="opt">{{ opt }}</option>
-                                                    </select>
-                                                </div>
+                                        <div v-if="deviceInventory[robot.id]" class="space-y-2 text-sm">
+                                            <div v-if="!deviceInventory[robot.id].inventoryReported" class="rounded bg-amber-900/40 border border-amber-700 px-2 py-1 text-xs text-amber-200">
+                                                Hardware inventory not reported yet. Keep the Pi client or preview agent running for one heartbeat, then refresh.
                                             </div>
                                             <div>
                                                 <label class="text-xs text-gray-500">Cached greeting phrases (one per line)</label>
                                                 <textarea v-model="deviceInventory[robot.id].greetingText" rows="2" class="w-full bg-gray-800 rounded px-2 py-1 text-xs" placeholder="Hello! Want to go for a ride?"></textarea>
                                                 <button @click="saveDeviceGreetings(robot.id)" class="mt-1 px-2 py-1 rounded bg-gray-600 hover:bg-gray-500 text-xs">Save Greetings</button>
                                             </div>
-                                            <button @click="startPreview(robot)"
-                                                    :disabled="!settings.production_mode || !livekit.url || !livekit.has_secret || preview.active"
-                                                    :class="(settings.production_mode && livekit.url && livekit.has_secret && !preview.active) ? 'bg-cyan-600 hover:bg-cyan-700' : 'bg-gray-700 cursor-not-allowed'"
-                                                    class="w-full px-2 py-1 rounded text-xs">
-                                                {{ preview.active && preview.robot?.id === robot.id ? 'Preview Active' : 'Start Preview' }}
-                                            </button>
                                             <div class="grid grid-cols-2 gap-2">
                                                 <button @click="simulateTrigger(robot)"
                                                         :disabled="!settings.production_mode || simulation.busy || robot.status === 'connecting' || robot.status === 'running'"

package/packages/robopark/scheduler/preview_agent.py

@@ -66,7 +66,10 @@ import httpx
 
 logger = logging.getLogger("robopark.preview_agent")
 
-_DEVICE_INVENTORY_CACHE: Optional[dict] = None
+_DEVICE_INVENTORY_CACHE: Optional[dict] = None
+_DEVICE_INVENTORY_CACHE_AT = 0.0
+DEVICE_INVENTORY_CACHE_SECONDS = 30.0
+ROBOVISION_MEDIA_URL = os.getenv("ROBOVISION_MEDIA_URL", "http://127.0.0.1:5000/api/media/inventory")
 
 
 def _normalize_livekit_url(url: Optional[str]) -> Optional[str]:
@@ -131,58 +134,78 @@ def _play_audio_effect(selected_output: str | None, effect: str) -> None:
         pa.terminate()
 
 
-def _get_device_inventory() -> dict:
-    """Return discoverable camera and audio devices for dashboard selection."""
-    global _DEVICE_INVENTORY_CACHE
-    if _DEVICE_INVENTORY_CACHE is not None:
-        return _DEVICE_INVENTORY_CACHE
-
-    inventory = {"video": [], "audio_input": [], "audio_output": [], "platform": sys.platform}
-    inventory["video"].append({"id": "auto", "name": "Auto detect"})
-    inventory["video"].append({"id": "none", "name": "Disable camera"})
-
-    try:
-        import cv2
-        candidates = sorted(glob.glob("/dev/video*")) if os.name != "nt" else [str(i) for i in range(10)]
-        for candidate in candidates:
-            value = int(candidate) if os.name == "nt" else candidate
-            backend = cv2.CAP_DSHOW if os.name == "nt" else cv2.CAP_ANY
-            cap = cv2.VideoCapture(value, backend)
-            if cap.isOpened():
-                device_id = str(value)
-                inventory["video"].append({"id": device_id, "name": f"Camera {candidate}", "backend": "dshow" if os.name == "nt" else "v4l2"})
-            cap.release()
-    except Exception as e:
-        logger.debug(f"camera inventory unavailable: {e}")
-
-    try:
-        import pyaudio
-        pa = pyaudio.PyAudio()
-        default_in = None
-        default_out = None
-        try:
-            wasapi = pa.get_host_api_info_by_type(pyaudio.paWASAPI)
-            default_in = wasapi.get("defaultInputDevice")
-            default_out = wasapi.get("defaultOutputDevice")
-        except Exception:
-            pass
-        inventory["audio_input"].append({"id": "default", "name": "System default input"})
-        inventory["audio_output"].append({"id": "default", "name": "System default output"})
-        for i in range(pa.get_device_count()):
-            info = pa.get_device_info_by_index(i)
-            name = str(info.get("name", f"Audio device {i}"))
-            item = {"id": str(i), "name": name, "host_api": str(info.get("hostApi", ""))}
-            if info.get("maxInputChannels", 0) > 0:
-                item["default"] = i == default_in
-                inventory["audio_input"].append(item.copy())
-            if info.get("maxOutputChannels", 0) > 0:
-                item["default"] = i == default_out
-                inventory["audio_output"].append(item.copy())
-        pa.terminate()
-    except Exception as e:
-        logger.debug(f"audio inventory unavailable: {e}")
-
-    _DEVICE_INVENTORY_CACHE = inventory
+def _get_device_inventory() -> dict:
+    """Return discoverable camera and audio devices for dashboard selection."""
+    global _DEVICE_INVENTORY_CACHE, _DEVICE_INVENTORY_CACHE_AT
+    now = time.monotonic()
+    if (_DEVICE_INVENTORY_CACHE is not None
+            and now - _DEVICE_INVENTORY_CACHE_AT < DEVICE_INVENTORY_CACHE_SECONDS):
+        return _DEVICE_INVENTORY_CACHE
+
+    inventory = {"video": [], "audio_input": [], "audio_output": [], "platform": sys.platform}
+    inventory["video"].append({"id": "auto", "name": "Auto detect"})
+    inventory["video"].append({"id": "none", "name": "Disable camera"})
+
+    # RoboVisionAI_PI owns the production camera. Prefer its native inventory
+    # so this process never probes an already-open V4L2 device just to fill a
+    # dashboard dropdown.
+    robovision_inventory = None
+    try:
+        response = httpx.get(ROBOVISION_MEDIA_URL, timeout=0.8)
+        if response.is_success:
+            robovision_inventory = response.json()
+            for key in ("video", "audio_input", "audio_output"):
+                if isinstance(robovision_inventory.get(key), list):
+                    inventory[key] = robovision_inventory[key]
+            inventory["source"] = robovision_inventory.get("source", "robovision_pi")
+    except Exception:
+        pass
+
+    if not robovision_inventory:
+        try:
+            import cv2
+            candidates = sorted(glob.glob("/dev/video*")) if os.name != "nt" else [str(i) for i in range(10)]
+            for candidate in candidates:
+                value = int(candidate) if os.name == "nt" else candidate
+                backend = cv2.CAP_DSHOW if os.name == "nt" else cv2.CAP_ANY
+                cap = cv2.VideoCapture(value, backend)
+                if cap.isOpened():
+                    device_id = str(value)
+                    inventory["video"].append({"id": device_id, "name": f"Camera {candidate}", "backend": "dshow" if os.name == "nt" else "v4l2"})
+                cap.release()
+        except Exception as e:
+            logger.debug(f"camera inventory unavailable: {e}")
+
+    if not robovision_inventory:
+        try:
+            import pyaudio
+            pa = pyaudio.PyAudio()
+            default_in = None
+            default_out = None
+            try:
+                wasapi = pa.get_host_api_info_by_type(pyaudio.paWASAPI)
+                default_in = wasapi.get("defaultInputDevice")
+                default_out = wasapi.get("defaultOutputDevice")
+            except Exception:
+                pass
+            inventory["audio_input"].append({"id": "default", "name": "System default input"})
+            inventory["audio_output"].append({"id": "default", "name": "System default output"})
+            for i in range(pa.get_device_count()):
+                info = pa.get_device_info_by_index(i)
+                name = str(info.get("name", f"Audio device {i}"))
+                item = {"id": str(i), "name": name, "host_api": str(info.get("hostApi", ""))}
+                if info.get("maxInputChannels", 0) > 0:
+                    item["default"] = i == default_in
+                    inventory["audio_input"].append(item.copy())
+                if info.get("maxOutputChannels", 0) > 0:
+                    item["default"] = i == default_out
+                    inventory["audio_output"].append(item.copy())
+            pa.terminate()
+        except Exception as e:
+            logger.debug(f"audio inventory unavailable: {e}")
+
+    _DEVICE_INVENTORY_CACHE = inventory
+    _DEVICE_INVENTORY_CACHE_AT = now
     logger.info(
         f"device inventory: {len(inventory['video']) - 2} cameras, "
         f"{len(inventory['audio_input']) - 1} inputs, "
@@ -313,8 +336,10 @@ class PreviewAgent:
         self.device_id: Optional[str] = cfg.get("device_id")
         self.enrollment_token: Optional[str] = cfg.get("enrollment_token")
         self.video_device = cfg.get("video_device", os.getenv("VIDEO_DEVICE", "auto"))
-        self.audio_device = cfg.get("audio_device", os.getenv("AUDIO_DEVICE", "default"))
-        self.audio_output_device = cfg.get("audio_output_device", os.getenv("AUDIO_OUTPUT_DEVICE", "default"))
+        self.audio_device = cfg.get("audio_device", os.getenv("AUDIO_DEVICE", "default"))
+        self.audio_output_device = cfg.get("audio_output_device", os.getenv("AUDIO_OUTPUT_DEVICE", "default"))
+        self.robovision_url = cfg.get("robovision_url", os.getenv("ROBOVISION_URL", "http://127.0.0.1:5000"))
+        self.use_robovision_camera = bool(cfg.get("use_robovision_camera", False))
         self.width = int(cfg.get("video_width", os.getenv("VIDEO_WIDTH", DEFAULT_VIDEO_WIDTH)))
         self.height = int(cfg.get("video_height", os.getenv("VIDEO_HEIGHT", DEFAULT_VIDEO_HEIGHT)))
         self.fps = int(cfg.get("video_fps", os.getenv("VIDEO_FPS", DEFAULT_FPS)))
@@ -519,7 +544,7 @@ class PreviewAgent:
         if data.get("trigger"):
             await self._on_vision_motion({"source": data.get("source", "dashboard")})
 
-    async def _poll_device_config(self) -> None:
+    async def _poll_device_config(self) -> None:
         """Apply dashboard-selected camera and microphone IDs before preview."""
         if not self._session or not self.device_id or not self.device_token:
             return
@@ -533,16 +558,41 @@ class PreviewAgent:
                 headers={"Authorization": f"Bearer {self.device_token}"},
                 timeout=10.0,
             )
-            r.raise_for_status()
-            data = r.json()
-            if data.get("video_device") is not None:
-                self.video_device = data["video_device"]
-            if data.get("audio_device") is not None:
-                self.audio_device = data["audio_device"]
-            if data.get("audio_output_device") is not None:
-                self.audio_output_device = data["audio_output_device"]
-        except Exception as e:
-            logger.debug(f"device config poll failed: {e}")
+            r.raise_for_status()
+            data = r.json()
+            changed = False
+            if data.get("video_device") is not None:
+                changed = changed or self.video_device != data["video_device"]
+                self.video_device = data["video_device"]
+            if data.get("audio_device") is not None:
+                changed = changed or self.audio_device != data["audio_device"]
+                self.audio_device = data["audio_device"]
+            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"]
+            if changed:
+                await self._sync_robovision_media_config()
+        except Exception as e:
+            logger.debug(f"device config poll failed: {e}")
+
+    async def _sync_robovision_media_config(self) -> None:
+        """Apply scheduler media choices to the local RoboVisionAI_PI owner."""
+        try:
+            response = await self._session.post(
+                f"{self.robovision_url.rstrip('/')}/api/media/config",
+                json={
+                    "video_device": self.video_device,
+                    "audio_device": self.audio_device,
+                    "audio_output_device": self.audio_output_device,
+                },
+                timeout=1.0,
+            )
+            if response.is_success:
+                global _DEVICE_INVENTORY_CACHE
+                _DEVICE_INVENTORY_CACHE = None
+        except Exception:
+            # RoboVision is optional on laptops and simulation nodes.
+            pass
 
     async def _check_vision_session(self) -> None:
         """Decide whether the active motion-triggered session should keep
@@ -903,7 +953,8 @@ class LiveKitPublisher:
         if video_enabled:
             try:
                 self._capture = await asyncio.to_thread(
-                    create_video_capture, self.agent.video_device, self.agent.width, self.agent.height, self.agent.fps
+                            create_video_capture, self.agent.video_device, self.agent.width, self.agent.height, self.agent.fps,
+                            self.agent.robovision_url if self.agent.use_robovision_camera else None,
                 )
             except Exception as e:
                 # Camera availability must not block the microphone/session.
@@ -1384,15 +1435,26 @@ class Picamera2Capture(VideoCapture):
             pass
 
 
-def create_video_capture(device: str, width: int, height: int, fps: int) -> Optional[VideoCapture]:
+def create_video_capture(device: str, width: int, height: int, fps: int,
+                         robovision_url: Optional[str] = None) -> Optional[VideoCapture]:
     if device.lower() in ("none", "", "false", "null"):
         return None
-    try:
+    try:
         from livekit import rtc
         _ = rtc.VideoSource
     except Exception as e:
         logger.error(f"livekit python sdk not installed: {e}")
-        return None
+        return None
+
+    if robovision_url:
+        stream_url = f"{robovision_url.rstrip('/')}/video_feed"
+        try:
+            cap = OpencvVideoCapture(stream_url, width, height, fps)
+            logger.info(f"using RoboVisionAI_PI camera stream {stream_url}")
+            return cap
+        except Exception as e:
+            logger.error(f"RoboVision camera stream unavailable: {e}")
+            return None
 
     # Auto-detect: prefer first V4L2 device, fall back to picamera2 if available.
     if device.lower() in ("auto", "default", "first"):
@@ -1533,7 +1595,9 @@ def main() -> None:
     parser.add_argument("--device-token", default=os.getenv("DEVICE_TOKEN"))
     parser.add_argument("--enrollment-token", default=os.getenv("ENROLLMENT_TOKEN"))
     parser.add_argument("--video-device", default=os.getenv("VIDEO_DEVICE", "auto"))
-    parser.add_argument("--audio-device", default=os.getenv("AUDIO_DEVICE", "default"))
+    parser.add_argument("--audio-device", default=os.getenv("AUDIO_DEVICE", "default"))
+    parser.add_argument("--robovision-url", default=None,
+                        help="use RoboVisionAI_PI's /video_feed as the LiveKit camera source")
     parser.add_argument("--width", type=int, default=int(os.getenv("VIDEO_WIDTH", DEFAULT_VIDEO_WIDTH)))
     parser.add_argument("--height", type=int, default=int(os.getenv("VIDEO_HEIGHT", DEFAULT_VIDEO_HEIGHT)))
     parser.add_argument("--fps", type=int, default=int(os.getenv("VIDEO_FPS", DEFAULT_FPS)))
@@ -1556,7 +1620,9 @@ def main() -> None:
         "scheduler_url": args.scheduler_url,
         "robot_id": args.robot_id,
         "video_device": args.video_device,
-        "audio_device": args.audio_device,
+        "audio_device": args.audio_device,
+        "robovision_url": args.robovision_url or os.getenv("ROBOVISION_URL", "http://127.0.0.1:5000"),
+        "use_robovision_camera": bool(args.robovision_url),
         "video_width": args.width,
         "video_height": args.height,
         "video_fps": args.fps,

package/packages/robopark/vision/app_pi_clean.py

@@ -1,7 +1,8 @@
 from flask import Flask, Response, jsonify, request
 from flask_cors import CORS
-import argparse
-import cv2
+import argparse
+import glob
+import cv2
 import os
 import sys
 import time
@@ -14,8 +15,10 @@ app = Flask(__name__)
 CORS(app)
 
 # Camera management
-current_camera_index = 0
-camera = None
+current_camera_index = 0
+camera = None
+audio_input_device = "default"
+audio_output_device = "default"
 
 def _open_camera(index):
     # On Windows, cv2.VideoCapture(index) with no explicit backend can
@@ -312,21 +315,24 @@ def caption_mode():
     caption_mode_enabled = bool(data.get('enabled', False))
     return jsonify({"enabled": caption_mode_enabled})
 
-@app.route('/api/cameras', methods=['GET'])
-def list_cameras():
-    available = []
-    for i in range(4):
-        cap = _open_camera(i)
-        if cap.isOpened():
-            available.append({"index": i, "name": f"Camera {i}"})
-            cap.release()
-    return jsonify({"cameras": available, "current": current_camera_index})
+@app.route('/api/cameras', methods=['GET'])
+def list_cameras():
+    available = []
+    candidates = sorted(glob.glob('/dev/video*')) if sys.platform != 'win32' else list(range(4))
+    for candidate in candidates:
+        cap = _open_camera(candidate)
+        if cap.isOpened():
+            available.append({"index": candidate, "id": str(candidate), "name": f"Camera {candidate}", "backend": "v4l2" if sys.platform != 'win32' else "dshow"})
+            cap.release()
+    return jsonify({"cameras": available, "current": current_camera_index})
 
 @app.route('/api/camera/switch', methods=['POST'])
-def switch_camera():
+def switch_camera():
     global camera, current_camera_index
     data = request.json or {}
-    new_index = int(data.get('index', 0))
+    new_index = data.get('device', data.get('index', 0))
+    if isinstance(new_index, str) and new_index.isdigit():
+        new_index = int(new_index)
 
     if camera:
         camera.release()
@@ -334,7 +340,64 @@ def switch_camera():
     current_camera_index = new_index
     camera = None
 
-    return jsonify({"status": "ok", "camera_index": current_camera_index})
+    return jsonify({"status": "ok", "camera_index": current_camera_index})
+
+
+def _audio_inventory():
+    inputs = [{"id": "default", "name": "System default input"}]
+    outputs = [{"id": "default", "name": "System default output"}]
+    try:
+        import pyaudio
+        pa = pyaudio.PyAudio()
+        for index in range(pa.get_device_count()):
+            info = pa.get_device_info_by_index(index)
+            item = {"id": str(index), "name": str(info.get("name", f"Audio device {index}")), "host_api": str(info.get("hostApi", ""))}
+            if info.get("maxInputChannels", 0) > 0:
+                inputs.append(item.copy())
+            if info.get("maxOutputChannels", 0) > 0:
+                outputs.append(item.copy())
+        pa.terminate()
+    except Exception:
+        pass
+    return inputs, outputs
+
+
+@app.route('/api/media/inventory', methods=['GET'])
+def media_inventory():
+    cameras = list_cameras().get_json().get("cameras", [])
+    if not cameras and sys.platform != 'win32':
+        # The active V4L2 handle may reject a second probe. The node path is
+        # still a valid selectable camera and is safer than hiding it.
+        cameras = [{"id": path, "index": path, "name": f"Camera {path}", "backend": "v4l2"}
+                   for path in sorted(glob.glob('/dev/video*'))]
+    inputs, outputs = _audio_inventory()
+    return jsonify({
+        "video": [{"id": "auto", "name": "Auto detect"}, {"id": "none", "name": "Disable camera"}] + cameras,
+        "audio_input": inputs,
+        "audio_output": outputs,
+        "selected": {"video_device": str(current_camera_index), "audio_device": audio_input_device, "audio_output_device": audio_output_device},
+        "source": "robovision_pi",
+    })
+
+
+@app.route('/api/media/config', methods=['GET', 'POST'])
+def media_config():
+    global audio_input_device, audio_output_device, camera, current_camera_index
+    if request.method == 'POST':
+        data = request.json or {}
+        if "video_device" in data:
+            value = str(data["video_device"])
+            if value not in ("", "auto", "none"):
+                switch_camera_value = value
+                if camera:
+                    camera.release()
+                current_camera_index = int(switch_camera_value) if switch_camera_value.isdigit() else switch_camera_value
+                camera = None
+        if "audio_device" in data:
+            audio_input_device = str(data["audio_device"])
+        if "audio_output_device" in data:
+            audio_output_device = str(data["audio_output_device"])
+    return jsonify({"video_device": str(current_camera_index), "audio_device": audio_input_device, "audio_output_device": audio_output_device, "source": "robovision_pi"})
 
 @app.route('/api/motion/status', methods=['GET'])
 def motion_status():