infinicode 2.8.84 → 2.8.85

package/package.json

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

package/packages/robopark/scheduler/main.py

@@ -839,10 +839,70 @@ async def broadcast(event_type: str, data: dict):
             ws_clients.remove(client)
 
 # =============================================================================
-# ROBOT ENDPOINTS
-# =============================================================================
-
-@app.get("/api/robots", response_model=List[Robot])
+# ROBOT ENDPOINTS
+# =============================================================================
+
+CONNECTING_SESSION_LEASE_SECONDS = max(
+    15, int(os.getenv("ROBOPARK_CONNECTING_SESSION_LEASE_SECONDS", "45"))
+)
+ACTIVE_SESSION_LEASE_SECONDS = max(
+    CONNECTING_SESSION_LEASE_SECONDS,
+    int(os.getenv("ROBOPARK_ACTIVE_SESSION_LEASE_SECONDS", "180")),
+)
+
+
+async def _reap_robot_session_if_stale(db, robot_id: str, current_session_id: Optional[str],
+                                       robot_status: Optional[str] = None) -> Optional[str]:
+    """Release an invalid or expired session pointer without operator action."""
+    if not current_session_id:
+        return None
+
+    async with db.execute(
+        "SELECT id, started_at, last_activity_at, ended_at FROM sessions WHERE id = ?",
+        (current_session_id,),
+    ) as cursor:
+        session = await cursor.fetchone()
+
+    reason = None
+    if not session:
+        reason = "missing_session"
+    elif session["ended_at"]:
+        reason = "ended_session"
+    else:
+        timestamp = session["last_activity_at"] or session["started_at"]
+        try:
+            activity_age = (datetime.utcnow() - datetime.fromisoformat(timestamp)).total_seconds()
+        except (TypeError, ValueError):
+            activity_age = ACTIVE_SESSION_LEASE_SECONDS + 1
+        lease = (
+            CONNECTING_SESSION_LEASE_SECONDS
+            if robot_status == "connecting"
+            else ACTIVE_SESSION_LEASE_SECONDS
+        )
+        if activity_age >= lease:
+            reason = "stale_connecting" if robot_status == "connecting" else "stale_activity"
+
+    if not reason:
+        return None
+
+    now = datetime.utcnow().isoformat()
+    if session and not session["ended_at"]:
+        await db.execute(
+            "UPDATE sessions SET ended_at = ?, end_reason = ? WHERE id = ? AND ended_at IS NULL",
+            (now, reason, current_session_id),
+        )
+    await db.execute(
+        "UPDATE robots SET status = 'idle', current_session_id = NULL, connected_server_id = NULL "
+        "WHERE id = ? AND current_session_id = ?",
+        (robot_id, current_session_id),
+    )
+    logger.warning(
+        "Automatically released %s session %s for robot %s",
+        reason, current_session_id, robot_id,
+    )
+    return reason
+
+@app.get("/api/robots", response_model=List[Robot])
 async def list_robots():
     """List all robots"""
     async with aiosqlite.connect(DB_PATH) as db:
@@ -909,11 +969,23 @@ async def request_session(robot_id: str,
                     (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")
+                robot = {
+                    "id": robot_id,
+                    "name": device_row["name"],
+                    "status": "idle",
+                    "current_session_id": None,
+                }
+            else:
+                raise HTTPException(404, "Robot not found")
+        stale_reason = await _reap_robot_session_if_stale(
+            db, robot_id, robot["current_session_id"], robot["status"]
+        )
+        if stale_reason:
+            await db.commit()
+            async with db.execute("SELECT * FROM robots WHERE id = ?", (robot_id,)) as cursor:
+                robot = await cursor.fetchone()
+        if robot["current_session_id"] or robot["status"] != "idle":
+            raise HTTPException(409, f"Robot is {robot['status']}, not idle")
         
         # Find least-loaded online server
         async with db.execute("""
@@ -1046,7 +1118,7 @@ async def simulate_trigger(robot_id: str):
     async with aiosqlite.connect(DB_PATH) as db:
         db.row_factory = aiosqlite.Row
         async with db.execute(
-            "SELECT id, current_session_id FROM robots WHERE id = ?", (robot_id,)
+            "SELECT id, current_session_id, status FROM robots WHERE id = ?", (robot_id,)
         ) as c:
             robot = await c.fetchone()
         if not robot:
@@ -1059,11 +1131,14 @@ async def simulate_trigger(robot_id: str):
                 (device["id"], device["name"], device["character_id"]),
             )
             await db.commit()
-            robot = {"id": device["id"], "current_session_id": None}
+            robot = {"id": device["id"], "current_session_id": None, "status": "idle"}
         if not await _effective_device_production_mode(db, robot_id):
             return {"queued": False, "reason": "device_production_mode_off"}
-        if robot["current_session_id"]:
-            return {"queued": False, "reason": "session_active"}
+        stale_reason = await _reap_robot_session_if_stale(
+            db, robot_id, robot["current_session_id"], robot["status"]
+        )
+        if robot["current_session_id"] and not stale_reason:
+            return {"queued": False, "reason": "session_active"}
         await db.execute(
             "INSERT INTO trigger_commands (robot_id, source, requested_at) VALUES (?, ?, ?) "
             "ON CONFLICT(robot_id) DO UPDATE SET source = excluded.source, requested_at = excluded.requested_at",
@@ -1072,7 +1147,12 @@ async def simulate_trigger(robot_id: str):
         await db.commit()
     await broadcast("robot_triggered", {"robot_id": robot_id, "source": "dashboard"})
     await _log_history("robot", "robot", robot_id, "simulate_trigger", "operator")
-    return {"queued": True, "source": "dashboard"}
+    return {
+        "queued": True,
+        "source": "dashboard",
+        "recovered_stale_session": bool(stale_reason),
+        "recovery_reason": stale_reason,
+    }
 
 @app.post("/api/robots/{robot_id}/simulate-stop")
 async def simulate_stop(robot_id: str):
@@ -1487,14 +1567,31 @@ async def session_joined(session_id: str,
             session = await c.fetchone()
         if not session:
             raise HTTPException(404, "Session not found")
-        if session["joined_at"]:
-            return {
-                "status": "already_joined",
-                "joined_at": session["joined_at"],
-                "latency_ms": _session_latency_ms(session["started_at"], session["joined_at"]),
-            }
-        await db.execute("UPDATE sessions SET joined_at = ? WHERE id = ?", (now, session_id))
-        await db.commit()
+        if session["joined_at"]:
+            if not session["ended_at"]:
+                await db.execute(
+                    "UPDATE sessions SET last_activity_at = ? WHERE id = ?",
+                    (now, session_id),
+                )
+                await db.execute(
+                    "UPDATE robots SET status = 'running' WHERE id = ? AND current_session_id = ?",
+                    (session["robot_id"], session_id),
+                )
+                await db.commit()
+            return {
+                "status": "already_joined",
+                "joined_at": session["joined_at"],
+                "latency_ms": _session_latency_ms(session["started_at"], session["joined_at"]),
+            }
+        await db.execute(
+            "UPDATE sessions SET joined_at = ?, last_activity_at = ? WHERE id = ?",
+            (now, now, session_id),
+        )
+        await db.execute(
+            "UPDATE robots SET status = 'running' WHERE id = ? AND current_session_id = ?",
+            (session["robot_id"], session_id),
+        )
+        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}")
@@ -1955,19 +2052,38 @@ async def health_checker():
                     await db.execute("UPDATE devices SET status = 'offline' WHERE id = ?", (did,))
                     await broadcast("device_status_changed", {"device_id": did, "status": "offline"})
 
-                # Reap sessions leaked by a crashed worker or broken LiveKit
-                # disconnect. Normal sessions are closed by the worker, but
-                # this prevents stale rooms consuming server capacity forever.
-                session_cutoff = (datetime.utcnow() - timedelta(seconds=120)).isoformat()
-                async with db.execute(
-                    "SELECT id, robot_id FROM sessions "
-                    "WHERE ended_at IS NULL AND COALESCE(last_activity_at, started_at) < ?",
-                    (session_cutoff,),
-                ) as c:
+                # Release stale robot session pointers with the same lease rules
+                # used by the trigger path. Failed joins cannot require manual
+                # operator recovery or block an unattended robot indefinitely.
+                async with db.execute(
+                    "SELECT id, status, current_session_id FROM robots WHERE current_session_id IS NOT NULL"
+                ) as c:
+                    session_owners = await c.fetchall()
+                for owner in session_owners:
+                    reason = await _reap_robot_session_if_stale(
+                        db, owner["id"], owner["current_session_id"], owner["status"]
+                    )
+                    if reason:
+                        await broadcast("session_expired", {
+                            "session_id": owner["current_session_id"],
+                            "robot_id": owner["id"],
+                            "reason": reason,
+                        })
+
+                # Reap old orphan rows that are no longer owned by a robot.
+                session_cutoff = (
+                    datetime.utcnow() - timedelta(seconds=ACTIVE_SESSION_LEASE_SECONDS)
+                ).isoformat()
+                async with db.execute(
+                    "SELECT id, robot_id FROM sessions "
+                    "WHERE ended_at IS NULL AND COALESCE(last_activity_at, started_at) < ? "
+                    "AND NOT EXISTS (SELECT 1 FROM robots r WHERE r.current_session_id = sessions.id)",
+                    (session_cutoff,),
+                ) as c:
                     stale_sessions = await c.fetchall()
                 for session in stale_sessions:
                     await db.execute(
-                        "UPDATE sessions SET ended_at = ?, end_reason = 'silence' "
+                        "UPDATE sessions SET ended_at = ?, end_reason = 'stale_orphan' "
                         "WHERE id = ? AND ended_at IS NULL",
                         (datetime.utcnow().isoformat(), session["id"]),
                     )
@@ -1979,7 +2095,7 @@ async def health_checker():
                     await broadcast("session_expired", {
                         "session_id": session["id"],
                         "robot_id": session["robot_id"],
-                        "reason": "silence",
+                            "reason": "stale_orphan",
                     })
 
                 await db.commit()
@@ -4748,10 +4864,10 @@ async def _robot_telemetry(db, robot_id: str) -> Optional[dict]:
         readiness_code, readiness_message = "server_unavailable", f"LiveKit server {robot['connected_server_id']} is {server_status or 'missing'}"
     elif not robot["current_session_id"]:
         readiness_code, readiness_message = "ready", "ready for motion trigger"
-    elif robot["status"] == "connecting" and session_age is not None and session_age > 30:
-        readiness_code, readiness_message = "stuck_session", f"joining LiveKit for {session_age}s; recover robot"
-    elif activity_age is not None and activity_age > 180:
-        readiness_code, readiness_message = "stale_session", f"no session activity for {activity_age}s; recover robot"
+    elif robot["status"] == "connecting" and session_age is not None and session_age > CONNECTING_SESSION_LEASE_SECONDS:
+        readiness_code, readiness_message = "stuck_session", f"joining LiveKit for {session_age}s; automatic recovery pending"
+    elif activity_age is not None and activity_age > ACTIVE_SESSION_LEASE_SECONDS:
+        readiness_code, readiness_message = "stale_session", f"no session activity for {activity_age}s; automatic recovery pending"
     else:
         readiness_code, readiness_message = "in_session", "conversation session is active"