infinicode 2.8.22 → 2.8.25

package/packages/robopark/scheduler/main.py

@@ -298,6 +298,13 @@ async def init_db():
             ("sessions", "joined_at", "TEXT"),
             ("devices", "video_device", "TEXT"),
             ("devices", "audio_device", "TEXT"),
+            # Silence-based session end (see POST /api/sessions/{id}/keepalive
+            # and GET /api/sessions/{id}/status): tracks the last time some
+            # caller signaled this session was still active. Defaults to
+            # started_at at INSERT time; existing rows on an upgraded DB will
+            # have NULL here until touched, so readers should fall back to
+            # started_at (see the /status endpoint below).
+            ("sessions", "last_activity_at", "TEXT"),
         ):
             try:
                 await db.execute(f"ALTER TABLE {_table} ADD COLUMN {_column} {_coldef}")
@@ -485,6 +492,12 @@ async def request_session(robot_id: str,
             async with db.execute("SELECT name FROM devices WHERE id = ?", (robot_id,)) as dc:
                 device_row = await dc.fetchone()
             if device_row:
+                # OR IGNORE means this name is only ever written on first
+                # creation of the robots row. PATCH /api/devices/{device_id}
+                # now keeps robots.name in sync on every rename going forward,
+                # so a stale robots.name here is only possible if a session
+                # request race wins before that PATCH sync runs — not an
+                # ongoing drift concern.
                 await db.execute(
                     "INSERT OR IGNORE INTO robots (id, name, status) VALUES (?, ?, 'idle')",
                     (robot_id, device_row["name"]),
@@ -517,11 +530,12 @@ async def request_session(robot_id: str,
         session_id = f"session_{robot_id}_{int(datetime.utcnow().timestamp())}"
         room_name = f"robopark-{robot_id}-{int(datetime.utcnow().timestamp())}"
         
+        _now_iso = datetime.utcnow().isoformat()
         await db.execute("""
-            INSERT INTO sessions (id, robot_id, server_id, room_name, started_at)
-            VALUES (?, ?, ?, ?, ?)
-        """, (session_id, robot_id, server["id"], room_name, datetime.utcnow().isoformat()))
-        
+            INSERT INTO sessions (id, robot_id, server_id, room_name, started_at, last_activity_at)
+            VALUES (?, ?, ?, ?, ?, ?)
+        """, (session_id, robot_id, server["id"], room_name, _now_iso, _now_iso))
+
         # Update robot status + count this as a camera trigger. request-session
         # is the natural trigger point ("robot requests a session after scene
         # detection"), so the trigger_count populates here with no client change.
@@ -808,10 +822,11 @@ async def create_web_client_session(req: Optional[WebClientSessionRequest] = Non
         session_id = f"web_{int(datetime.utcnow().timestamp())}"
         room_name = f"robopark_web_{int(datetime.utcnow().timestamp())}"
         
+        _now_iso = datetime.utcnow().isoformat()
         await db.execute("""
-            INSERT INTO sessions (id, robot_id, server_id, room_name, started_at)
-            VALUES (?, ?, ?, ?, ?)
-        """, (session_id, "web-client", server["id"], room_name, datetime.utcnow().isoformat()))
+            INSERT INTO sessions (id, robot_id, server_id, room_name, started_at, last_activity_at)
+            VALUES (?, ?, ?, ?, ?, ?)
+        """, (session_id, "web-client", server["id"], room_name, _now_iso, _now_iso))
         
         await db.commit()
     
@@ -899,6 +914,61 @@ 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}/keepalive")
+async def session_keepalive(session_id: str,
+                            authorization: Optional[str] = Header(default=None)):
+    """Silence-based session extension signal.
+
+    INTEGRATION POINT (out of scope here — lives in a different repo): the
+    VOICE AGENT is the one process that actually knows, via VAD, whether the
+    user/agent are still talking. While a motion-triggered session's
+    conversation is active, the voice agent should call this endpoint
+    periodically (e.g. every few seconds) to bump last_activity_at. The robot
+    side (preview_agent.py) has no independent way to know if a conversation
+    is ongoing — it only knows this via what it reads back from here through
+    GET /api/sessions/{session_id}/status. If nothing ever calls this
+    endpoint, last_activity_at simply stays at started_at and the session
+    will be torn down by preview_agent.py's silence timeout shortly after it
+    starts — that's an intentionally conservative default, not a bug.
+
+    preview_agent.py additionally enforces vision_session_seconds as a hard
+    ceiling regardless of activity, so a misbehaving/stuck caller can never
+    hold the publisher forever even if it calls this endpoint continuously.
+    """
+    if not await _authorize_fleet(authorization):
+        raise HTTPException(401, "Invalid or missing device token")
+    now = datetime.utcnow().isoformat()
+    async with aiosqlite.connect(DB_PATH) as db:
+        cur = await db.execute(
+            "UPDATE sessions SET last_activity_at = ? WHERE id = ? AND ended_at IS NULL",
+            (now, session_id),
+        )
+        await db.commit()
+        if cur.rowcount == 0:
+            raise HTTPException(404, "Session not found or already ended")
+    return {"status": "ok", "last_activity_at": now}
+
+@app.get("/api/sessions/{session_id}/status")
+async def get_session_status(session_id: str):
+    """Lightweight session status for polling — used by preview_agent.py to
+    decide whether a motion-triggered session is still "active" (recent
+    last_activity_at) or has gone silent and should be torn down. See
+    POST /api/sessions/{session_id}/keepalive for who updates last_activity_at."""
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute("SELECT * FROM sessions WHERE id = ?", (session_id,)) as c:
+            session = await c.fetchone()
+        if not session:
+            raise HTTPException(404, "Session not found")
+    return {
+        "session_id": session["id"],
+        "started_at": session["started_at"],
+        "ended_at": session["ended_at"],
+        # Existing rows created before this column existed (or that predate
+        # any keepalive call) have NULL here — fall back to started_at.
+        "last_activity_at": session["last_activity_at"] or session["started_at"],
+    }
+
 # ── Back-compat: legacy web-client session token (ported from the deployed OLD
 #    scheduler so voice_client.html / the old frontend keep working after the
 #    fork reconcile). Raw-PyJWT HS256, publish-capable "Web User" token. ──
@@ -1591,6 +1661,20 @@ async def update_device(device_id: str, payload: DeviceUpdate):
         await db.commit()
         if cur.rowcount == 0:
             raise HTTPException(404, "Device not found")
+        # Keep the legacy `robots` table's own `name` column in sync when this
+        # PATCH actually changes the device name. Without this, robots.name
+        # only ever gets set once (at first-creation, via INSERT OR IGNORE)
+        # and silently goes stale on every subsequent rename — the dashboard
+        # reads from /api/robots, not /api/devices, so it would keep showing
+        # the old name forever. Only touch robots.name when a name was part
+        # of this update (don't unconditionally overwrite it on unrelated
+        # field updates), and only if a robots row for this id exists.
+        if "name" in fields:
+            await db.execute(
+                "UPDATE robots SET name = ? WHERE id = ?",
+                (fields["name"], device_id),
+            )
+            await db.commit()
     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)
@@ -1769,6 +1853,10 @@ async def enroll_device(payload: DeviceEnrollRequest):
                     payload.name, device_id,
                 ),
             )
+            # OR IGNORE: only fires the first time this robots row is created.
+            # PATCH /api/devices/{device_id} now propagates renames into
+            # robots.name afterwards, so this is purely a first-creation
+            # concern, not an ongoing sync path.
             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"]),
@@ -1805,6 +1893,10 @@ async def enroll_device(payload: DeviceEnrollRequest):
                     new_hash, None, now, now,
                 ),
             )
+            # OR IGNORE: only fires the first time this robots row is created.
+            # PATCH /api/devices/{device_id} now propagates renames into
+            # robots.name afterwards, so this is purely a first-creation
+            # concern, not an ongoing sync path.
             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),
@@ -1910,6 +2002,10 @@ async def device_request_session(device_id: str,
 
         # Mirror device -> robot identity (id == device_id). Additive + idempotent:
         # if the robot row already exists it is left untouched.
+        # OR IGNORE: only fires the first time this robots row is created.
+        # PATCH /api/devices/{device_id} now propagates renames into
+        # robots.name afterwards, so this is purely a first-creation
+        # concern, not an ongoing sync path.
         await db.execute(
             "INSERT OR IGNORE INTO robots (id, name, character_id) VALUES (?, ?, ?)",
             (device_id, device["name"] or device_id, device["character_id"]),
@@ -1938,10 +2034,11 @@ async def device_request_session(device_id: str,
         # timeout instead of the 30s default).
         room_name = f"robopark-{device_id}-{ts}"
 
+        _now_iso = datetime.utcnow().isoformat()
         await db.execute("""
-            INSERT INTO sessions (id, robot_id, server_id, room_name, started_at)
-            VALUES (?, ?, ?, ?, ?)
-        """, (session_id, device_id, server["id"], room_name, datetime.utcnow().isoformat()))
+            INSERT INTO sessions (id, robot_id, server_id, room_name, started_at, last_activity_at)
+            VALUES (?, ?, ?, ?, ?, ?)
+        """, (session_id, device_id, server["id"], room_name, _now_iso, _now_iso))
 
         # Mark the mirrored robot connecting + count the camera trigger, exactly
         # as the robot path does (request-session is the natural trigger point).