infinicode 2.8.7 → 2.8.9

package/packages/robopark/scheduler/main.py

@@ -107,6 +107,8 @@ class Device(BaseModel):
     motor_server_url: Optional[str] = None
     character_id: Optional[str] = None
     livekit_url: Optional[str] = None
+    video_device: Optional[str] = None
+    audio_device: Optional[str] = None
     status: str = "enrolled"  # enrolled, online, offline, disabled
     last_heartbeat: Optional[datetime] = None
     enrolled_at: Optional[datetime] = None
@@ -121,6 +123,8 @@ class DeviceCreate(BaseModel):
     motor_server_url: Optional[str] = None
     character_id: Optional[str] = None
     livekit_url: Optional[str] = None
+    video_device: Optional[str] = None
+    audio_device: Optional[str] = None
     notes: Optional[str] = None
     enrollment_token: Optional[str] = None  # if omitted, one is auto-generated
 
@@ -132,6 +136,8 @@ class DeviceEnrollRequest(BaseModel):
     motor_server_url: Optional[str] = None
     livekit_url: Optional[str] = None
     character_id: Optional[str] = None
+    video_device: Optional[str] = None
+    audio_device: Optional[str] = None
 
 class DeviceEnrollResponse(BaseModel):
     device_id: str
@@ -235,6 +241,8 @@ async def init_db():
                 motor_server_url TEXT,
                 character_id TEXT,
                 livekit_url TEXT,
+                video_device TEXT,
+                audio_device TEXT,
                 token_hash TEXT,
                 enrollment_token_hash TEXT,
                 status TEXT DEFAULT 'enrolled',
@@ -258,6 +266,19 @@ async def init_db():
                 expires_at TEXT NOT NULL,
                 created_at TEXT DEFAULT CURRENT_TIMESTAMP
             );
+
+            CREATE TABLE IF NOT EXISTS history_log (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp TEXT DEFAULT CURRENT_TIMESTAMP,
+                category TEXT NOT NULL,
+                entity_type TEXT,
+                entity_id TEXT,
+                action TEXT,
+                actor TEXT,
+                details TEXT
+            );
+            CREATE INDEX IF NOT EXISTS idx_history_category ON history_log(category);
+            CREATE INDEX IF NOT EXISTS idx_history_entity ON history_log(entity_type, entity_id);
         """)
         await db.commit()
 
@@ -269,6 +290,8 @@ async def init_db():
         for _table, _column, _coldef in (
             ("robots", "trigger_count", "INTEGER DEFAULT 0"),
             ("sessions", "joined_at", "TEXT"),
+            ("devices", "video_device", "TEXT"),
+            ("devices", "audio_device", "TEXT"),
         ):
             try:
                 await db.execute(f"ALTER TABLE {_table} ADD COLUMN {_column} {_coldef}")
@@ -432,6 +455,7 @@ async def robot_heartbeat(robot_id: str, ip_address: Optional[str] = None):
         )
         await db.commit()
     await broadcast("robot_heartbeat", {"robot_id": robot_id})
+    await _log_history("robot", "robot", robot_id, "heartbeat", "robot", f"ip={ip_address}")
     return {"status": "ok"}
 
 @app.post("/api/robots/{robot_id}/request-session")
@@ -446,11 +470,22 @@ async def request_session(robot_id: str,
         raise HTTPException(401, "Invalid or missing device token")
     async with aiosqlite.connect(DB_PATH) as db:
         db.row_factory = aiosqlite.Row
-        
-        # Check robot exists and is idle
+
+        # Check robot exists and is idle; auto-create a robot row for an enrolled
+        # device that has not yet appeared in the robots table.
         async with db.execute("SELECT * FROM robots WHERE id = ?", (robot_id,)) as cursor:
             robot = await cursor.fetchone()
-            if not robot:
+        if not robot:
+            async with db.execute("SELECT name FROM devices WHERE id = ?", (robot_id,)) as dc:
+                device_row = await dc.fetchone()
+            if device_row:
+                await db.execute(
+                    "INSERT OR IGNORE INTO robots (id, name, status) VALUES (?, ?, 'idle')",
+                    (robot_id, device_row["name"]),
+                )
+                await db.commit()
+                robot = {"id": robot_id, "name": device_row["name"], "status": "idle"}
+            else:
                 raise HTTPException(404, "Robot not found")
             if robot["status"] != "idle":
                 raise HTTPException(400, f"Robot is {robot['status']}, not idle")
@@ -498,6 +533,8 @@ async def request_session(robot_id: str,
         "server_id": server["id"],
         "session_id": session_id
     })
+    await _log_history("session", "robot", robot_id, "requested", "robot", f"session_id={session_id}, server={server['id']}, room={room_name}")
+
 
     # Mint a short-lived LiveKit token so the robot can join the room without
     # ever receiving the raw api_key/api_secret.
@@ -569,6 +606,7 @@ async def end_session(robot_id: str, reason: str = "silence"):
         await db.commit()
     
     await broadcast("session_ended", {"robot_id": robot_id, "reason": reason})
+    await _log_history("session", "robot", robot_id, "session_ended", "robot", f"reason={reason}, session_id={robot.get('current_session_id')}")
     return {"status": "ok"}
 
 @app.post("/api/robots/{robot_id}/trigger")
@@ -597,6 +635,7 @@ async def robot_trigger(robot_id: str,
         async with db.execute("SELECT trigger_count FROM robots WHERE id = ?", (robot_id,)) as c:
             row = await c.fetchone()
     await broadcast("robot_triggered", {"robot_id": robot_id})
+    await _log_history("robot", "robot", robot_id, "trigger", "robot", f"trigger_count={row[0] if row else None}")
     return {"status": "ok", "trigger_count": row[0] if row else None}
 
 # =============================================================================
@@ -629,6 +668,7 @@ async def add_server(server: LiveKitServer):
               server.gpu_vram_mb, server.max_sessions, server.status))
         await db.commit()
     await broadcast("server_added", {"server_id": server.id})
+    await _log_history("server", "server", server.id, "added", "operator", f"name={server.name}, url={server.url}")
     return {"status": "ok"}
 
 @app.delete("/api/servers/{server_id}")
@@ -638,6 +678,7 @@ async def remove_server(server_id: str):
         await db.execute("DELETE FROM livekit_servers WHERE id = ?", (server_id,))
         await db.commit()
     await broadcast("server_removed", {"server_id": server_id})
+    await _log_history("server", "server", server_id, "removed", "operator")
     return {"status": "ok"}
 
 @app.get("/api/servers/{server_id}/metrics")
@@ -805,6 +846,7 @@ async def end_web_session(session_id: str, reason: str = "disconnect"):
             await db.commit()
     
     await broadcast("session_ended", {"session_id": session_id, "reason": reason})
+    await _log_history("session", "session", session_id, "ended", "operator/web", f"reason={reason}, duration={duration}")
     return {"status": "ok"}
 
 def _session_latency_ms(started_at: Optional[str], joined_at: Optional[str]) -> Optional[int]:
@@ -846,6 +888,7 @@ async def session_joined(session_id: str,
         await db.commit()
     latency_ms = _session_latency_ms(session["started_at"], now)
     await broadcast("session_joined", {"session_id": session_id, "latency_ms": latency_ms})
+    await _log_history("session", "session", session_id, "joined", "robot", f"latency_ms={latency_ms}")
     return {"status": "ok", "joined_at": now, "latency_ms": latency_ms}
 
 # ── Back-compat: legacy web-client session token (ported from the deployed OLD
@@ -1089,6 +1132,7 @@ async def update_settings(payload: SettingsPayload):
     """Update scheduler settings (production mode, etc.)."""
     await set_setting("production_mode", "true" if payload.production_mode else "false")
     await broadcast("settings_changed", {"production_mode": payload.production_mode})
+    await _log_history("settings", "settings", "production_mode", "updated", "operator", f"value={payload.production_mode}")
     return {"status": "ok", "production_mode": payload.production_mode}
 
 @app.post("/api/settings/enrollment-token/rotate")
@@ -1097,8 +1141,28 @@ async def rotate_enrollment_token():
     token = secrets.token_urlsafe(24)
     await set_setting("default_enrollment_token", _hash(token))
     logger.info("Default enrollment token rotated")
+    await _log_history("settings", "settings", "default_enrollment_token", "rotated", "operator")
     return {"enrollment_token": token}
 
+@app.get("/api/history")
+async def get_history(category: Optional[str] = None, limit: int = 200):
+    """Audit / history log for devices, robots, sessions, previews and settings."""
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        if category:
+            async with db.execute(
+                "SELECT * FROM history_log WHERE category = ? ORDER BY timestamp DESC LIMIT ?",
+                (category, limit),
+            ) as c:
+                rows = await c.fetchall()
+        else:
+            async with db.execute(
+                "SELECT * FROM history_log ORDER BY timestamp DESC LIMIT ?",
+                (limit,),
+            ) as c:
+                rows = await c.fetchall()
+        return [dict(r) for r in rows]
+
 # =============================================================================
 # LIVEKIT CONFIG + TOKEN ISSUANCE
 # =============================================================================
@@ -1164,6 +1228,7 @@ async def update_livekit_config(payload: LiveKitConfig):
     # Note: there's no separate endpoint to set the secret via JSON to avoid
     # accidental overwrites; use POST /api/livekit/config/secret for that.
     await broadcast("livekit_config_changed", {})
+    await _log_history("livekit", "settings", "livekit_config", "updated", "operator", f"url_set={payload.url is not None}, key_set={payload.api_key is not None}")
     return {"status": "ok"}
 
 @app.post("/api/livekit/config/secret")
@@ -1173,6 +1238,7 @@ async def set_livekit_secret(payload: dict):
         raise HTTPException(400, "api_secret must be a string of length >= 8")
     await set_setting("livekit_api_secret", secret)
     await broadcast("livekit_config_changed", {})
+    await _log_history("livekit", "settings", "livekit_secret", "updated", "operator")
     return {"status": "ok"}
 
 @app.post("/api/livekit/token", response_model=LiveKitTokenResponse)
@@ -1376,6 +1442,7 @@ async def preview_start(robot_id: str):
         token = _mint_lk(server, room_name, identity, "operator-preview", publish=False, ttl_min=5)
     except ImportError:
         raise HTTPException(503, "livekit-api not installed on scheduler")
+    await _log_history("preview", "robot", robot_id, "start", "operator", f"room={room_name}, server={server['id']}")
     return {"active": True, "url": server["url"], "token": token, "room": room_name,
             "identity": identity, "expires_in": PREVIEW_TTL_SECONDS}
 
@@ -1388,6 +1455,7 @@ async def preview_keepalive(robot_id: str):
         await db.commit()
         if cur.rowcount == 0:
             return {"active": False}
+    await _log_history("preview", "robot", robot_id, "keepalive", "operator")
     return {"active": True, "expires_in": PREVIEW_TTL_SECONDS}
 
 @app.post("/api/robots/{robot_id}/preview/stop")
@@ -1396,6 +1464,7 @@ async def preview_stop(robot_id: str):
     async with aiosqlite.connect(DB_PATH) as db:
         await db.execute("DELETE FROM previews WHERE robot_id = ?", (robot_id,))
         await db.commit()
+    await _log_history("preview", "robot", robot_id, "stop", "operator")
     return {"stopped": True}
 
 @app.get("/api/robots/{robot_id}/preview/agent")
@@ -1425,6 +1494,7 @@ async def preview_agent(robot_id: str, authorization: Optional[str] = Header(def
         token = _mint_lk(server, row["room_name"], robot_id, robot_id, publish=True, ttl_min=2)
     except ImportError:
         raise HTTPException(503, "livekit-api not installed on scheduler")
+    await _log_history("preview", "robot", robot_id, "agent_token", "pi", f"room={row['room_name']}")
     return {"active": True, "url": server["url"], "token": token, "room": row["room_name"]}
 
 # =============================================================================
@@ -1475,6 +1545,8 @@ class DeviceUpdate(BaseModel):
     character_id: Optional[str] = None
     motor_server_url: Optional[str] = None
     livekit_url: Optional[str] = None
+    video_device: Optional[str] = None
+    audio_device: Optional[str] = None
     tailscale_ip: Optional[str] = None
     lan_ip: Optional[str] = None
     notes: Optional[str] = None
@@ -1494,6 +1566,7 @@ async def update_device(device_id: str, payload: DeviceUpdate):
         if cur.rowcount == 0:
             raise HTTPException(404, "Device not found")
     await broadcast("device_updated", {"device_id": device_id, "fields": list(fields.keys())})
+    await _log_history("device", "device", device_id, "updated", "operator", f"fields={','.join(fields.keys())}")
     return await get_device(device_id)
 
 @app.post("/api/devices", response_model=Device)
@@ -1518,11 +1591,13 @@ async def create_device(payload: DeviceCreate):
         await db.execute(
             """INSERT INTO devices
                (id, name, tailscale_ip, lan_ip, motor_server_url, character_id,
-                livekit_url, enrollment_token_hash, status, enrolled_at, notes, created_at)
-               VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'enrolled', ?, ?, ?)""",
+                livekit_url, video_device, audio_device, enrollment_token_hash,
+                status, enrolled_at, notes, created_at)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'enrolled', ?, ?, ?)""",
             (
                 device_id, payload.name.strip(), payload.tailscale_ip, payload.lan_ip,
                 payload.motor_server_url, payload.character_id, payload.livekit_url,
+                payload.video_device, payload.audio_device,
                 enrollment_hash, now, payload.notes, now,
             ),
         )
@@ -1530,6 +1605,7 @@ async def create_device(payload: DeviceCreate):
 
     logger.info(f"Device {device_id} ({payload.name}) created")
     await broadcast("device_added", {"device_id": device_id, "name": payload.name})
+    await _log_history("device", "device", device_id, "created", "operator", f"name={payload.name.strip()}")
 
     device = await get_device(device_id)
     return {
@@ -1540,13 +1616,16 @@ async def create_device(payload: DeviceCreate):
 @app.delete("/api/devices/{device_id}")
 async def delete_device(device_id: str):
     async with aiosqlite.connect(DB_PATH) as db:
-        async with db.execute("SELECT id FROM devices WHERE id = ?", (device_id,)) as c:
+        db.row_factory = aiosqlite.Row
+        async with db.execute("SELECT name FROM devices WHERE id = ?", (device_id,)) as c:
             row = await c.fetchone()
         if not row:
             raise HTTPException(404, "Device not found")
+        name = row["name"]
         await db.execute("DELETE FROM devices WHERE id = ?", (device_id,))
         await db.commit()
     await broadcast("device_removed", {"device_id": device_id})
+    await _log_history("device", "device", device_id, "deleted", "operator", f"name={name}")
     return {"status": "deleted", "device_id": device_id}
 
 @app.post("/api/devices/{device_id}/token/rotate")
@@ -1560,6 +1639,7 @@ async def rotate_device_token(device_id: str):
         if cur.rowcount == 0:
             raise HTTPException(404, "Device not found")
     await broadcast("device_token_rotated", {"device_id": device_id})
+    await _log_history("device", "device", device_id, "token_rotated", "operator")
     return {"device_id": device_id, "device_token": new_token}
 
 async def _authorize_device(device_id: str, authorization: Optional[str]) -> bool:
@@ -1574,6 +1654,20 @@ async def _authorize_device(device_id: str, authorization: Optional[str]) -> boo
         return False
     return hmac.compare_digest(row[0], _hash(token))
 
+async def _log_history(category: str, entity_type: Optional[str] = None, entity_id: Optional[str] = None,
+                       action: Optional[str] = None, actor: Optional[str] = None, details: Optional[str] = None):
+    """Append an immutable audit/history record."""
+    try:
+        async with aiosqlite.connect(DB_PATH) as db:
+            await db.execute(
+                """INSERT INTO history_log (timestamp, category, entity_type, entity_id, action, actor, details)
+                   VALUES (?, ?, ?, ?, ?, ?, ?)""",
+                (datetime.utcnow().isoformat(), category, entity_type, entity_id, action, actor, details),
+            )
+            await db.commit()
+    except Exception as e:
+        logger.warning(f"history log failed: {e}")
+
 async def _authorize_fleet(authorization: Optional[str]) -> bool:
     """Verify a Bearer token matches ANY enrolled device token (fleet auth).
 
@@ -1632,14 +1726,21 @@ async def enroll_device(payload: DeviceEnrollRequest):
                        motor_server_url = COALESCE(?, motor_server_url),
                        livekit_url = COALESCE(?, livekit_url),
                        character_id = COALESCE(?, character_id),
+                       video_device = COALESCE(?, video_device),
+                       audio_device = COALESCE(?, audio_device),
                        name = COALESCE(?, name)
                    WHERE id = ?""",
                 (
                     new_hash, now, payload.tailscale_ip, payload.lan_ip,
                     payload.motor_server_url, payload.livekit_url, payload.character_id,
+                    payload.video_device, payload.audio_device,
                     payload.name, device_id,
                 ),
             )
+            await db.execute(
+                "INSERT OR IGNORE INTO robots (id, name, character_id, status) VALUES (?, ?, ?, 'idle')",
+                (device_id, existing["name"] or payload.name or device_id, existing["character_id"]),
+            )
         else:
             # First-boot enroll via the global default token -> create a new device.
             device_id = f"dev_{secrets.token_hex(4)}"
@@ -1649,21 +1750,28 @@ async def enroll_device(payload: DeviceEnrollRequest):
             await db.execute(
                 """INSERT INTO devices
                    (id, name, tailscale_ip, lan_ip, motor_server_url, character_id,
-                    livekit_url, token_hash, enrollment_token_hash, status, enrolled_at, created_at)
-                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'enrolled', ?, ?)""",
+                    livekit_url, video_device, audio_device, token_hash,
+                    enrollment_token_hash, status, enrolled_at, created_at)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'enrolled', ?, ?)""",
                 (
                     device_id,
                     (payload.name or f"Pi-{device_id[-4:]}").strip(),
                     payload.tailscale_ip, payload.lan_ip,
                     payload.motor_server_url, payload.character_id,
-                    payload.livekit_url, new_hash, token_hash, now, now,
+                    payload.livekit_url, payload.video_device, payload.audio_device,
+                    new_hash, token_hash, now, now,
                 ),
             )
+            await db.execute(
+                "INSERT OR IGNORE INTO robots (id, name, character_id, status) VALUES (?, ?, ?, 'idle')",
+                (device_id, (payload.name or f"Pi-{device_id[-4:]}").strip(), payload.character_id),
+            )
 
         await db.commit()
 
     await broadcast("device_enrolled", {"device_id": device_id})
     logger.info(f"Device {device_id} enrolled")
+    await _log_history("device", "device", device_id, "enrolled", "pi", f"name={(payload.name or device_id).strip()}")
 
     # Discover our own scheduler URL (best effort)
     scheduler_url = os.getenv("SCHEDULER_PUBLIC_URL", f"http://localhost:{os.getenv('SCHEDULER_PORT', '8080')}")
@@ -1690,6 +1798,7 @@ async def device_heartbeat(device_id: str, payload: DeviceHeartbeat,
             if cur.rowcount == 0:
                 raise HTTPException(404, "Device not found")
     await broadcast("device_heartbeat", {"device_id": device_id, "status": payload.status})
+    await _log_history("device", "device", device_id, "heartbeat", "pi", f"status={payload.status or 'online'}, ip={payload.ip}")
     # Tell the Pi whether production mode is on (so it can decide to join LiveKit or stand by)
     return {
         "status": "ok",
@@ -2058,6 +2167,7 @@ async def dashboard():
         <meta name="viewport" content="width=device-width, initial-scale=1">
         <script src="https://cdn.tailwindcss.com"></script>
         <script src="https://unpkg.com/vue@3/dist/vue.global.js"></script>
+        <script src="https://cdn.jsdelivr.net/npm/livekit-client@1/dist/livekit-client.umd.min.js"></script>
     </head>
     <body class="bg-gray-900 text-white">
         <div id="app"></div>
@@ -2077,8 +2187,10 @@ async def dashboard():
                     const livekit = ref({ url: null, api_key: null, has_secret: false });
                     const showAddDevice = ref(false);
                     const showDevices = ref(true);
-                    const newDevice = ref({ name: '', tailscale_ip: '', lan_ip: '', motor_server_url: '', character_id: '', livekit_url: '', notes: '' });
+                    const newDevice = ref({ name: '', tailscale_ip: '', lan_ip: '', motor_server_url: '', character_id: '', livekit_url: '', video_device: 'auto', audio_device: 'default', notes: '' });
                     const rotatedToken = ref(null);
+                    const preview = ref({ robot: null, active: false, url: null, token: null, room: null, keepalive: null });
+                    const deviceInventory = ref({});
                     const showLiveKitConfig = ref(false);
                     const livekitForm = ref({ url: '', api_key: '', api_secret: '' });
                     let ws = null;
@@ -2108,11 +2220,30 @@ async def dashboard():
                                     serverMetrics.value[server.id] = metrics;
                                 } catch (e) {}
                             }
+                            buildDeviceInventory();
                         } catch (e) {
                             console.error('Failed to fetch data:', e);
                         }
                     };
 
+                    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 savedVideo = device?.video_device || 'auto';
+                            const savedAudio = device?.audio_device || 'default';
+                            map[robot.id] = {
+                                deviceId: device?.id || null,
+                                robotName: robot.name,
+                                selectedVideo: savedVideo,
+                                selectedAudio: savedAudio,
+                                videoOptions: ['auto', 'none', 'picamera', '/dev/video0', '/dev/video1', '/dev/video2'],
+                                audioOptions: ['default', 'none'],
+                            };
+                        }
+                        deviceInventory.value = map;
+                    };
+
                     const connectWebSocket = () => {
                         const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
                         ws = new WebSocket(`${protocol}//${window.location.host}/ws`);
@@ -2198,13 +2329,75 @@ async def dashboard():
                                 rotatedToken.value = { device_id: r.id, name: r.name, token: r.enrollment_token };
                             }
                             showAddDevice.value = false;
-                            newDevice.value = { name: '', tailscale_ip: '', lan_ip: '', motor_server_url: '', character_id: '', livekit_url: '', notes: '' };
+                            newDevice.value = { name: '', tailscale_ip: '', lan_ip: '', motor_server_url: '', character_id: '', livekit_url: '', video_device: 'auto', audio_device: 'default', notes: '' };
                             fetchData();
                         } catch (e) {
                             alert('Failed to add device: ' + e.message);
                         }
                     };
 
+                    const updateDeviceMedia = async (robotId) => {
+                        const inv = deviceInventory.value[robotId];
+                        if (!inv || !inv.deviceId) return;
+                        try {
+                            await fetch(`/api/devices/${inv.deviceId}`, {
+                                method: 'PATCH',
+                                headers: {'Content-Type': 'application/json'},
+                                body: JSON.stringify({
+                                    video_device: inv.selectedVideo,
+                                    audio_device: inv.selectedAudio,
+                                }),
+                            });
+                            fetchData();
+                        } catch (e) {
+                            alert('Failed to update device media: ' + e.message);
+                        }
+                    };
+
+                    const startPreview = async (robot) => {
+                        stopPreview();
+                        try {
+                            const r = await fetch(`/api/robots/${robot.id}/preview/start`, { method: 'POST' }).then(r => r.json());
+                            if (!r.active) {
+                                alert('Preview not active: ' + (r.reason || 'unknown'));
+                                return;
+                            }
+                            preview.value = { robot, active: true, url: r.url, token: r.token, room: r.room, keepalive: null };
+                            await connectLiveKitPreview(r.url, r.token);
+                            preview.value.keepalive = setInterval(async () => {
+                                if (!preview.value.active) return;
+                                try {
+                                    await fetch(`/api/robots/${robot.id}/preview/keepalive`, { method: 'POST' });
+                                } catch (e) { console.warn('keepalive failed', e); }
+                            }, 15000);
+                        } catch (e) {
+                            alert('Failed to start preview: ' + e.message);
+                        }
+                    };
+
+                    const stopPreview = () => {
+                        if (preview.value.keepalive) clearInterval(preview.value.keepalive);
+                        if (preview.value.room) {
+                            try { window.__lkPreviewRoom?.disconnect(); } catch (e) {}
+                        }
+                        preview.value = { robot: null, active: false, url: null, token: null, room: null, keepalive: null };
+                    };
+
+                    const connectLiveKitPreview = async (url, token) => {
+                        const { Room } = LiveKitClient;
+                        const room = new Room({ adaptiveStream: true });
+                        window.__lkPreviewRoom = room;
+                        room.on('trackSubscribed', (track, publication, participant) => {
+                            if (track.kind === 'video') {
+                                track.attach(document.getElementById('preview-video'));
+                            }
+                            if (track.kind === 'audio') {
+                                track.attach(document.createElement('audio'));
+                            }
+                        });
+                        await room.connect(url, token);
+                    };
+
                     const deleteDevice = async (id, name) => {
                         if (!confirm(`Delete device "${name}"?`)) return;
                         try {
@@ -2335,11 +2528,12 @@ async def dashboard():
                     return {
                         robots, servers, sessions, stats, connected, serverMetrics,
                         devices, settings, livekit, showAddDevice, showDevices, newDevice, rotatedToken,
-                        showLiveKitConfig, livekitForm,
+                        showLiveKitConfig, livekitForm, preview, deviceInventory,
                         loadModel, unloadModel, statusColor, formatDuration, formatTime,
                         toggleProductionMode, rotateEnrollmentToken,
                         submitNewDevice, deleteDevice, rotateDeviceToken, dismissRotatedToken,
                         joinConversation, saveLiveKitConfig, openLiveKitConfig,
+                        startPreview, stopPreview, updateDeviceMedia,
                     };
                 },
                 template: `
@@ -2492,6 +2686,25 @@ async def dashboard():
                                         <label class="block text-gray-400 mb-1">LiveKit URL (for this device)</label>
                                         <input v-model="newDevice.livekit_url" class="w-full bg-gray-700 rounded px-3 py-2" placeholder="ws://100.64.1.5:7880" />
                                     </div>
+                                    <div class="grid grid-cols-2 gap-3">
+                                        <div>
+                                            <label class="block text-gray-400 mb-1">Default Camera</label>
+                                            <select v-model="newDevice.video_device" class="w-full bg-gray-700 rounded px-3 py-2">
+                                                <option value="auto">auto</option>
+                                                <option value="none">none</option>
+                                                <option value="picamera">picamera</option>
+                                                <option value="/dev/video0">/dev/video0</option>
+                                                <option value="/dev/video1">/dev/video1</option>
+                                            </select>
+                                        </div>
+                                        <div>
+                                            <label class="block text-gray-400 mb-1">Default Mic</label>
+                                            <select v-model="newDevice.audio_device" class="w-full bg-gray-700 rounded px-3 py-2">
+                                                <option value="default">default</option>
+                                                <option value="none">none</option>
+                                            </select>
+                                        </div>
+                                    </div>
                                     <div>
                                         <label class="block text-gray-400 mb-1">Character ID</label>
                                         <input v-model="newDevice.character_id" class="w-full bg-gray-700 rounded px-3 py-2" placeholder="panda-character" />
@@ -2550,28 +2763,66 @@ async def dashboard():
                         <!-- Main Grid -->
                         <div class="grid grid-cols-12 gap-6">
 
-                            <!-- Robots Panel -->
+                                     <!-- Robots Panel -->
                             <div class="col-span-4 bg-gray-800 rounded-lg p-4">
                                 <h2 class="text-xl font-semibold mb-4">🤖 Robot Fleet</h2>
                                 <div class="space-y-3">
                                     <div v-for="robot in robots" :key="robot.id"
-                                         class="bg-gray-700 rounded-lg p-3 flex items-center gap-3">
-                                        <div class="w-3 h-3 rounded-full" :class="statusColor(robot.status)"></div>
-                                        <div class="flex-1">
-                                            <div class="font-medium">{{ robot.name }}</div>
-                                            <div class="text-sm text-gray-400">
-                                                {{ robot.status }}
-                                                <span v-if="robot.connected_server_id" class="ml-1">
-                                                    → {{ robot.connected_server_id }}
-                                                </span>
+                                         class="bg-gray-700 rounded-lg p-3">
+                                        <div class="flex items-center gap-3 mb-2">
+                                            <div class="w-3 h-3 rounded-full" :class="statusColor(robot.status)"></div>
+                                            <div class="flex-1">
+                                                <div class="font-medium">{{ robot.name }}</div>
+                                                <div class="text-sm text-gray-400">
+                                                    {{ robot.status }}
+                                                    <span v-if="robot.connected_server_id" class="ml-1">
+                                                        → {{ robot.connected_server_id }}
+                                                    </span>
+                                                </div>
+                                            </div>
+                                            <div class="text-right text-sm text-gray-400">
+                                                {{ robot.total_sessions }} sessions
                                             </div>
                                         </div>
-                                        <div class="text-right text-sm text-gray-400">
-                                            {{ robot.total_sessions }} sessions
+                                        <div v-if="deviceInventory[robot.id]" class="space-y-2 text-sm">
+                                            <div class="grid grid-cols-2 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>
+                                            <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>
+                                            <button v-if="preview.active && preview.robot?.id === robot.id"
+                                                    @click="stopPreview"
+                                                    class="w-full px-2 py-1 bg-red-600 hover:bg-red-700 rounded text-xs">
+                                                Stop Preview
+                                            </button>
                                         </div>
                                     </div>
                                 </div>
-                            </div>
+                                <!-- Live preview panel -->
+                                <div v-if="preview.active" class="mt-4 bg-black rounded-lg overflow-hidden">
+                                    <video id="preview-video" class="w-full" autoplay playsinline muted></video>
+                                    <div class="text-xs text-gray-400 px-2 py-1">{{ preview.room }}</div>
+                                </div>
+                            </div>
                             
                             <!-- Servers Panel -->
                             <div class="col-span-5 space-y-4">