infinicode 2.8.54 → 2.8.56

package/packages/robopark/scheduler/main.py

@@ -1881,10 +1881,13 @@ async def robot_stream(robot_id: str,
     if not await get_production_mode():
         return {"active": False, "reason": "production_mode_off"}
 
-    async with aiosqlite.connect(DB_PATH) as db:
-        db.row_factory = aiosqlite.Row
-        async with db.execute("SELECT * FROM robots WHERE id = ?", (robot_id,)) as c:
-            robot = await c.fetchone()
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        resolved_id = await _resolve_robot_reference(db, robot_id)
+        if not resolved_id:
+            raise HTTPException(404, "Robot not found")
+        async with db.execute("SELECT * FROM robots WHERE id = ?", (resolved_id,)) as c:
+            robot = await c.fetchone()
         if not robot:
             raise HTTPException(404, "Robot not found")
         if not robot["current_session_id"]:
@@ -1909,7 +1912,7 @@ async def robot_stream(robot_id: str,
     except ImportError:
         raise HTTPException(503, "livekit-api not installed on scheduler")
 
-    identity = f"viewer:{robot_id}:{int(datetime.utcnow().timestamp())}"
+    identity = f"viewer:{resolved_id}:{int(datetime.utcnow().timestamp())}"
     grants = VideoGrants(
         room=room_name,
         room_join=True,
@@ -1947,7 +1950,7 @@ async def robot_stream(robot_id: str,
 PREVIEW_TTL_SECONDS = 45  # preview auto-expires this long after the last keepalive
 DEFAULT_VISION_PORT = 5000  # RoboVisionAI_PI's default Flask port (/video_feed, /api/motion/*)
 
-async def _mirror_device_to_robot(db, device_id: str):
+async def _mirror_device_to_robot(db, device_id: str):
     """Ensure a `robots` row exists for an enrolled device, so id-keyed routes
     (/stream, /preview/*) work even before the device's first real voice
     session (device_request_session normally creates this mirror, but only on
@@ -1965,8 +1968,30 @@ async def _mirror_device_to_robot(db, device_id: str):
         (device_id, device["name"] or device_id, device["character_id"]),
     )
     await db.commit()
-    async with db.execute("SELECT * FROM robots WHERE id = ?", (device_id,)) as c:
-        return await c.fetchone()
+    async with db.execute("SELECT * FROM robots WHERE id = ?", (device_id,)) as c:
+        return await c.fetchone()
+
+async def _resolve_robot_reference(db, robot_ref: str) -> Optional[str]:
+    """Resolve a display name to its active enrolled device id when needed."""
+    async with db.execute("SELECT id FROM devices WHERE id = ?", (robot_ref,)) as c:
+        row = await c.fetchone()
+    if row:
+        return row["id"]
+    async with db.execute(
+        """SELECT id FROM devices WHERE lower(name) = lower(?)
+           ORDER BY CASE lower(status) WHEN 'online' THEN 0 WHEN 'running' THEN 1 ELSE 2 END,
+                    last_heartbeat DESC, enrolled_at DESC LIMIT 1""",
+        (robot_ref,),
+    ) as c:
+        row = await c.fetchone()
+    if row:
+        return row["id"]
+    async with db.execute(
+        "SELECT id FROM robots WHERE id = ? OR lower(name) = lower(?) LIMIT 1",
+        (robot_ref, robot_ref),
+    ) as c:
+        row = await c.fetchone()
+    return row["id"] if row else None
 
 async def _pick_preview_server(db, prefer_id: Optional[str] = None):
     """Return a LiveKit server row for a preview: a preferred one if still present,
@@ -2010,15 +2035,18 @@ def _mint_lk(server, room, identity, name, publish: bool, ttl_min: int):
     )
 
 @app.post("/api/robots/{robot_id}/preview/start")
-async def preview_start(robot_id: str):
+async def preview_start(robot_id: str):
     """Operator dashboard: begin an on-demand live camera preview for a robot.
     Returns a SUBSCRIBE-only viewer token + the preview room."""
-    if not await get_production_mode():
-        return {"active": False, "reason": "production_mode_off"}
-    async with aiosqlite.connect(DB_PATH) as db:
-        db.row_factory = aiosqlite.Row
-        if not await _mirror_device_to_robot(db, robot_id):
-            raise HTTPException(404, "Robot not found")
+    if not await get_production_mode():
+        return {"active": False, "reason": "production_mode_off"}
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        robot_id = await _resolve_robot_reference(db, robot_id)
+        if not robot_id:
+            raise HTTPException(404, "Robot not found")
+        if not await _mirror_device_to_robot(db, robot_id):
+            raise HTTPException(404, "Robot not found")
         async with db.execute("SELECT * FROM previews WHERE robot_id = ?", (robot_id,)) as c:
             existing = await c.fetchone()
         server = await _pick_preview_server(db, existing["server_id"] if existing else None)
@@ -2043,11 +2071,15 @@ async def preview_start(robot_id: str):
             "identity": identity, "expires_in": PREVIEW_TTL_SECONDS}
 
 @app.post("/api/robots/{robot_id}/preview/keepalive")
-async def preview_keepalive(robot_id: str):
-    """Dashboard pings while the operator is watching, to keep the preview alive."""
-    expires = (datetime.utcnow() + timedelta(seconds=PREVIEW_TTL_SECONDS)).isoformat()
-    async with aiosqlite.connect(DB_PATH) as db:
-        cur = await db.execute("UPDATE previews SET expires_at = ? WHERE robot_id = ?", (expires, robot_id))
+async def preview_keepalive(robot_id: str):
+    """Dashboard pings while the operator is watching, to keep the preview alive."""
+    expires = (datetime.utcnow() + timedelta(seconds=PREVIEW_TTL_SECONDS)).isoformat()
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        robot_id = await _resolve_robot_reference(db, robot_id)
+        if not robot_id:
+            return {"active": False}
+        cur = await db.execute("UPDATE previews SET expires_at = ? WHERE robot_id = ?", (expires, robot_id))
         await db.commit()
         if cur.rowcount == 0:
             return {"active": False}
@@ -2055,10 +2087,14 @@ async def preview_keepalive(robot_id: str):
     return {"active": True, "expires_in": PREVIEW_TTL_SECONDS}
 
 @app.post("/api/robots/{robot_id}/preview/stop")
-async def preview_stop(robot_id: str):
-    """Dashboard closed / operator stopped watching -> end the preview now."""
-    async with aiosqlite.connect(DB_PATH) as db:
-        await db.execute("DELETE FROM previews WHERE robot_id = ?", (robot_id,))
+async def preview_stop(robot_id: str):
+    """Dashboard closed / operator stopped watching -> end the preview now."""
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        robot_id = await _resolve_robot_reference(db, robot_id)
+        if not robot_id:
+            return {"stopped": False}
+        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}
@@ -2068,11 +2104,14 @@ async def preview_agent(robot_id: str, authorization: Optional[str] = Header(def
     """The ROBOT polls this. While an operator preview is active it returns a
     PUBLISH token + room so the Pi opens its cam and joins; otherwise
     {active:false} so the Pi stops publishing. Enrolled-device auth."""
-    if not await _authorize_fleet(authorization):
-        raise HTTPException(401, "Invalid or missing device token")
-    async with aiosqlite.connect(DB_PATH) as db:
-        db.row_factory = aiosqlite.Row
-        async with db.execute("SELECT * FROM previews WHERE robot_id = ?", (robot_id,)) as c:
+    if not await _authorize_fleet(authorization):
+        raise HTTPException(401, "Invalid or missing device token")
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        robot_id = await _resolve_robot_reference(db, robot_id)
+        if not robot_id:
+            return {"active": False}
+        async with db.execute("SELECT * FROM previews WHERE robot_id = ?", (robot_id,)) as c:
             row = await c.fetchone()
         if not _preview_active(row):
             return {"active": False}

package/packages/robopark/scheduler/preview_agent.py

@@ -302,19 +302,27 @@ def _get_lan_ip() -> Optional[str]:
         return None
 
 
-async def _send_heartbeat(scheduler_url: str, device_id: str, token: str) -> Optional[bool]:
-    try:
-        async with httpx.AsyncClient() as client:
-            response = await client.post(
-                f"{scheduler_url.rstrip('/')}/api/devices/{device_id}/heartbeat",
-                json={"status": "online", "ip": _get_lan_ip(), "device_inventory": _get_device_inventory()},
-                headers={"Authorization": f"Bearer {token}"},
-                timeout=10.0,
-            )
-            response.raise_for_status()
-            return bool(response.json().get("production_mode", False))
-    except Exception as e:
-        logger.debug(f"heartbeat failed: {e}")
+async def _send_heartbeat(scheduler_url: str, device_id: str, token: str) -> Optional[bool]:
+    try:
+        inventory = _get_device_inventory()
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{scheduler_url.rstrip('/')}/api/devices/{device_id}/heartbeat",
+                json={"status": "online", "ip": _get_lan_ip(), "device_inventory": inventory},
+                headers={"Authorization": f"Bearer {token}"},
+                timeout=10.0,
+            )
+            response.raise_for_status()
+            logger.info(
+                "heartbeat accepted: inventory source=%s camera=%d mic=%d speaker=%d",
+                inventory.get("source", "local"),
+                len(inventory.get("video", [])),
+                len(inventory.get("audio_input", [])),
+                len(inventory.get("audio_output", [])),
+            )
+            return bool(response.json().get("production_mode", False))
+    except Exception as e:
+        logger.warning(f"heartbeat failed: {e}")
     return None