robopark 3.3.27 → 3.3.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "robopark",
-  "version": "3.3.27",
+  "version": "3.3.29",
   "description": "RoboPark fleet control CLI — scheduler, control UI, and character voice calls. Standalone: no infinicode runtime.",
   "type": "module",
   "bin": {

package/scheduler/main.py

@@ -18,11 +18,11 @@ import uuid
 from datetime import datetime, timedelta
 from html import escape as html_escape
 from pathlib import Path
-from typing import Any, Optional, List
+from typing import Any, Dict, Optional, List
 from urllib.parse import quote, urlparse
 from contextlib import asynccontextmanager
 
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Query, Header, Request
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Query, Header, Request, Body
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import HTMLResponse, FileResponse, RedirectResponse
@@ -1963,12 +1963,41 @@ async def _claim_character_device(
         """INSERT INTO robots (id, name, character_id, status, last_heartbeat)
            VALUES (?, ?, ?, 'online', ?)
            ON CONFLICT(id) DO UPDATE SET
+               name = excluded.name,
                character_id = excluded.character_id,
                status = 'online',
                last_heartbeat = excluded.last_heartbeat""",
         (device_id, label, character_id, stamp),
     )
+    # Retire every OTHER auto-claim for this character.
+    #
+    # The claim key is the join link, so each regenerated share link mints a
+    # fresh claim device for the same character and nothing ever retired the
+    # old ones. Three live claim_* rows for one character meant three
+    # robopark-<device> rooms: the publisher joined the newest while the camera
+    # grid was still watching an older twin, which is why a feed visible on the
+    # call page showed as "waiting for camera track" everywhere else. Only
+    # auto-claimed rows are touched -- enrolled hardware is never retired.
+    async with db.execute(
+        "SELECT id FROM devices WHERE lower(character_id) = lower(?) AND id != ? "
+        "AND notes LIKE 'auto-claimed via join link%'",
+        (character_id or "", device_id),
+    ) as cursor:
+        twins = [str(row[0]) for row in await cursor.fetchall()]
+    for twin in twins:
+        await db.execute(
+            "UPDATE sessions SET ended_at = ?, end_reason = ? WHERE robot_id = ? AND ended_at IS NULL",
+            (stamp, "claim_superseded", twin),
+        )
+        await db.execute("UPDATE devices SET status = 'offline' WHERE id = ?", (twin,))
+        await db.execute(
+            "UPDATE robots SET status = 'idle', current_session_id = NULL, "
+            "connected_server_id = NULL WHERE id = ?",
+            (twin,),
+        )
     await db.commit()
+    for twin in twins:
+        await broadcast("device_status_changed", {"device_id": twin, "status": "offline"})
     # No MJPEG ref: a claimed device publishes its own browser camera rather than
     # exposing a robot-side vision server, so the page falls back to local video.
     return device_id, None
@@ -2356,6 +2385,70 @@ async def session_joined(session_id: str,
     await _log_history("session", "session", session_id, "joined", "robot", f"latency_ms={latency_ms}")
     return {"status": "ok", "joined_at": now, "latency_ms": latency_ms}
 
+@app.post("/api/sessions/{session_id}/heartbeat")
+async def session_heartbeat(session_id: str,
+                            payload: Optional[Dict[str, Any]] = Body(default=None),
+                            authorization: Optional[str] = Header(default=None),
+                            session_token: Optional[str] = Header(default=None, alias="X-RoboPark-Session-Token")):
+    """Liveness beat from the browser join page, every 30s for the whole call.
+
+    This route is the one the public join page has always called. It did not
+    exist, so every beat 404'd and nothing refreshed liveness for a browser
+    call. Three minutes in, _reap_robot_session_if_stale saw last_activity_at
+    still equal to started_at, ended the session as 'stale_activity' and set
+    robots.status='idle'/current_session_id=NULL; the device then fell out of
+    health_checker's live-session exclusion and flipped offline 90s later.
+    The call itself stayed up the whole time — only every operator view lost
+    it, which is why robots vanished from the park map and the camera grid
+    dropped feeds partway through a working call.
+
+    Bumps all three clocks the operator views read: the session's activity,
+    the device heartbeat and the robot heartbeat.
+    """
+    if not await _session_event_authorized(session_id, session_token, authorization, None):
+        raise HTTPException(401, "Invalid or missing session token")
+    now = datetime.utcnow().isoformat()
+    source = str((payload or {}).get("source") or "")[:40]
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute(
+            "SELECT robot_id, ended_at FROM sessions WHERE id = ?", (session_id,)
+        ) as cursor:
+            session = await cursor.fetchone()
+        if not session:
+            raise HTTPException(404, "Session not found")
+        if session["ended_at"]:
+            # Do not resurrect a closed session; tell the page so it can stop.
+            return {"status": "ended", "ended_at": session["ended_at"]}
+        await db.execute(
+            "UPDATE sessions SET last_activity_at = ? WHERE id = ? AND ended_at IS NULL",
+            (now, session_id),
+        )
+        robot_id = session["robot_id"]
+        was_offline = False
+        if robot_id:
+            async with db.execute(
+                "SELECT status FROM devices WHERE id = ?", (robot_id,)
+            ) as cursor:
+                device = await cursor.fetchone()
+            was_offline = bool(device) and device["status"] != "online"
+            await db.execute(
+                "UPDATE devices SET status = 'online', last_heartbeat = ? WHERE id = ?",
+                (now, robot_id),
+            )
+            # Re-point the robot at this session as well. A beat that arrives
+            # after the reaper already released the pointer has to restore it,
+            # otherwise the session stays live but invisible until it ends.
+            await db.execute(
+                "UPDATE robots SET status = 'running', current_session_id = ?, last_heartbeat = ? "
+                "WHERE id = ?",
+                (session_id, now, robot_id),
+            )
+        await db.commit()
+    if robot_id and was_offline:
+        await broadcast("device_status_changed", {"device_id": robot_id, "status": "online"})
+    return {"status": "ok", "last_activity_at": now, "source": source}
+
 @app.post("/api/sessions/{session_id}/keepalive")
 async def session_keepalive(session_id: str,
                             authorization: Optional[str] = Header(default=None),
@@ -3528,11 +3621,17 @@ def _lk_public_url(url: str, request: Optional[Request] = None) -> str:
             return url  # the caller IS local; localhost is correct for them
 
         proto = (request.headers.get("x-forwarded-proto") or request.url.scheme or "").lower()
-        # ws:// from an https:// page is mixed content and is blocked outright,
-        # so a TLS-fronted request must be told wss.
-        scheme = "wss" if proto == "https" else "ws"
+        if proto == "https":
+            # ws:// from an https:// page is mixed content and is blocked, so a
+            # TLS-fronted caller must get wss. But LiveKit's own port serves
+            # plain ws — pointing wss at it just fails the TLS handshake, which
+            # is what this fallback did on its first outing. TLS comes from a
+            # separate front door (`tailscale serve --https=3443`), and the
+            # control center already assumes 3443, so use that port.
+            tls_port = (os.getenv("ROBOPARK_LIVEKIT_TLS_PORT", "").strip() or "3443")
+            return f"wss://{caller}:{tls_port}"
         port = f":{parsed.port}" if parsed.port else ""
-        return f"{scheme}://{caller}{port}"
+        return f"ws://{caller}{port}"
     except Exception:
         return url