Update

.dockerignore

@@ -1,3 +1,5 @@
+**/static-frontend/
+
 **/node_modules/
 **/.npm
 **/npm-debug.log*

Dockerfile

@@ -1,13 +1,6 @@
 # Stage 1: Build frontend with Bun (client library + demo)
 FROM oven/bun:1-alpine AS frontend-builder
 
-# Build argument for transport server URL
-ARG PUBLIC_TRANSPORT_SERVER_URL=https://blanchon-robothub-transportserver.hf.space/api
-ENV PUBLIC_TRANSPORT_SERVER_URL=${PUBLIC_TRANSPORT_SERVER_URL}
-
-ARG PORT=8000
-ENV PORT=${PORT}
-
 WORKDIR /app
 
 # Install git for dependencies that might need it
@@ -113,6 +106,13 @@ WORKDIR /app
 # Add virtual environment to PATH
 ENV PATH="/app/server/.venv/bin:$PATH"
 
+# Build argument for transport server URL
+ARG PUBLIC_TRANSPORT_SERVER_URL=https://blanchon-robothub-transportserver.hf.space/api
+ENV PUBLIC_TRANSPORT_SERVER_URL=${PUBLIC_TRANSPORT_SERVER_URL}
+
+ARG PORT=8000
+ENV PORT=${PORT}
+
 # Expose the configured port (default 8000)
 EXPOSE ${PORT}
 

client/python/examples/video_producer_example.py

@@ -3,7 +3,7 @@
 Video Producer Example - Updated for Workspace API
 
 Demonstrates how to use the RobotHub TransportServer Python video client for streaming.
-This example creates animated video content and streams it to the arena server.
+This example creates animated video content and streams it to the robot hub tranport server.
 """
 
 import asyncio

server/launch_with_ui.py

@@ -14,7 +14,7 @@ from src.api import app as api_app
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[logging.StreamHandler(), logging.FileHandler("server.log")],
+    handlers=[logging.StreamHandler()],
 )
 
 logger = logging.getLogger(__name__)

server/launch_without_ui.py

@@ -8,7 +8,7 @@ import uvicorn
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[logging.StreamHandler(), logging.FileHandler("server.log")],
+    handlers=[logging.StreamHandler()],
 )
 
 logger = logging.getLogger(__name__)

server/src/api.py

@@ -8,7 +8,7 @@ from fastapi.middleware.cors import CORSMiddleware
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[logging.StreamHandler(), logging.FileHandler("server.log")],
+    handlers=[logging.StreamHandler()],
 )
 
 logger = logging.getLogger(__name__)

server/src/robotics/api.py

@@ -111,6 +111,7 @@ async def send_command(workspace_id: str, room_id: str, command: JointCommand):
 async def get_status():
     """Get system status"""
     stats = robotics_core.get_connection_stats()
+    cleanup_info = robotics_core.get_cleanup_status()
     return {
         "service": "robotics",
         "status": "active",
@@ -120,6 +121,11 @@ async def get_status():
         "version": "2.0.0",
         "supported_roles": [role.value for role in ParticipantRole],
         "supported_robot_types": ["so-arm100", "generic"],
+        "cleanup": {
+            "enabled": cleanup_info["cleanup_enabled"],
+            "inactivity_timeout_hours": cleanup_info["inactivity_timeout_minutes"] / 60,
+            "cleanup_interval_minutes": cleanup_info["cleanup_interval_minutes"],
+        },
     }
 
 
@@ -129,6 +135,20 @@ async def health_check():
     return {"status": "healthy", "service": "robotics"}
 
 
+@robotics_router.get("/cleanup/status")
+async def get_cleanup_status():
+    """Get cleanup system status and room information"""
+    status = robotics_core.get_cleanup_status()
+    return {"success": True, "cleanup_status": status}
+
+
+@robotics_router.post("/cleanup/manual")
+async def trigger_manual_cleanup():
+    """Manually trigger room cleanup"""
+    result = await robotics_core.manual_cleanup()
+    return {"success": True, "cleanup_result": result}
+
+
 # ============= WEBSOCKET ENDPOINT =============
 
 

server/src/robotics/core.py

@@ -1,7 +1,7 @@
 import json
 import logging
 import uuid
-from datetime import UTC, datetime
+from datetime import UTC, datetime, timedelta
 
 from fastapi import WebSocket, WebSocketDisconnect
 from typing_extensions import TypedDict
@@ -40,6 +40,10 @@ class RoboticsRoom:
         # State
         self.joints: dict[str, float] = {}
 
+        # Activity tracking
+        self.created_at = datetime.now(tz=UTC)
+        self.last_activity = datetime.now(tz=UTC)
+
 
 class RoboticsCore:
     """Core robotics system - simplified and merged with workspace support"""
@@ -52,6 +56,83 @@ class RoboticsCore:
             str, ConnectionMetadata
         ] = {}  # participant_id -> metadata
 
+        # Cleanup configuration
+        self.inactivity_timeout = timedelta(hours=1)  # 1 hour of inactivity
+        self.cleanup_interval = timedelta(minutes=15)  # Check every 15 minutes
+
+        # Start cleanup task
+        self._cleanup_task = None
+        self._start_cleanup_task()
+
+    def _start_cleanup_task(self):
+        """Start the background cleanup task"""
+        import asyncio
+
+        async def cleanup_loop():
+            while True:
+                try:
+                    await asyncio.sleep(self.cleanup_interval.total_seconds())
+                    await self._cleanup_inactive_rooms()
+                except Exception:
+                    logger.exception("Error in cleanup task")
+
+        try:
+            loop = asyncio.get_event_loop()
+            self._cleanup_task = loop.create_task(cleanup_loop())
+            logger.info("Started robotics room cleanup task")
+        except RuntimeError:
+            # No event loop running yet, cleanup will start when first room is created
+            logger.info("No event loop running, cleanup task will start later")
+
+    async def _cleanup_inactive_rooms(self):
+        """Remove rooms that have been inactive for more than the timeout period"""
+        current_time = datetime.now(tz=UTC)
+        rooms_to_remove = []
+
+        for workspace_id, rooms in self.workspaces.items():
+            for room_id, room in rooms.items():
+                # Check if room has any active connections
+                has_active_connections = False
+                room_last_activity = room.last_activity
+
+                # Check all connections for this room to find most recent activity
+                for metadata in self.connection_metadata.values():
+                    if (
+                        metadata["workspace_id"] == workspace_id
+                        and metadata["room_id"] == room_id
+                    ):
+                        has_active_connections = True
+                        room_last_activity = max(
+                            room_last_activity, metadata["last_activity"]
+                        )
+
+                # If no active connections, use room's last activity
+                if not has_active_connections:
+                    time_since_activity = current_time - room_last_activity
+
+                    if time_since_activity > self.inactivity_timeout:
+                        rooms_to_remove.append((workspace_id, room_id))
+                        logger.info(
+                            f"Marking room {room_id} in workspace {workspace_id} for cleanup "
+                            f"(inactive for {time_since_activity})"
+                        )
+
+        # Remove inactive rooms
+        for workspace_id, room_id in rooms_to_remove:
+            if self.delete_room(workspace_id, room_id):
+                logger.info(
+                    f"Auto-removed inactive room {room_id} from workspace {workspace_id}"
+                )
+
+        if rooms_to_remove:
+            logger.info(f"Cleaned up {len(rooms_to_remove)} inactive robotics rooms")
+
+    def _update_room_activity(self, workspace_id: str, room_id: str):
+        """Update the last activity timestamp for a room"""
+        room = self._get_room(workspace_id, room_id)
+        if room:
+            room.last_activity = datetime.now(tz=UTC)
+
     # ============= ROOM MANAGEMENT =============
 
     def create_room(
@@ -68,6 +149,10 @@ class RoboticsCore:
         room = RoboticsRoom(room_id, workspace_id)
         self.workspaces[workspace_id][room_id] = room
 
+        # Start cleanup task if not already running
+        if self._cleanup_task is None:
+            self._start_cleanup_task()
+
         logger.info(f"Created room {room_id} in workspace {workspace_id}")
         return workspace_id, room_id
 
@@ -170,6 +255,7 @@ class RoboticsCore:
         if role == ParticipantRole.PRODUCER:
             if room.producer is None:
                 room.producer = participant_id
+                self._update_room_activity(workspace_id, room_id)
                 logger.info(
                     f"Producer {participant_id} joined room {room_id} in workspace {workspace_id}"
                 )
@@ -183,6 +269,7 @@ class RoboticsCore:
         if role == ParticipantRole.CONSUMER:
             if participant_id not in room.consumers:
                 room.consumers.append(participant_id)
+                self._update_room_activity(workspace_id, room_id)
                 logger.info(
                     f"Consumer {participant_id} joined room {room_id} in workspace {workspace_id}"
                 )
@@ -228,6 +315,10 @@ class RoboticsCore:
                 room.joints[name] = value
                 changed_joints.append(joint)
 
+        # Update room activity if there were changes
+        if changed_joints:
+            self._update_room_activity(workspace_id, room_id)
+
         return changed_joints
 
     # ============= WEBSOCKET HANDLING =============
@@ -341,6 +432,9 @@ class RoboticsCore:
             )
             self.connection_metadata[participant_id]["message_count"] += 1
 
+        # Update room activity
+        self._update_room_activity(workspace_id, room_id)
+
         try:
             msg_type = MessageType(message.get("type"))
         except ValueError:
@@ -612,3 +706,65 @@ class RoboticsCore:
             )
 
         return len(changed_joints)
+
+    # ============= CLEANUP MANAGEMENT =============
+
+    async def manual_cleanup(self) -> dict:
+        """Manually trigger room cleanup and return results"""
+        logger.info("Manual robotics room cleanup triggered")
+        rooms_before = sum(len(rooms) for rooms in self.workspaces.values())
+        await self._cleanup_inactive_rooms()
+        rooms_after = sum(len(rooms) for rooms in self.workspaces.values())
+
+        return {
+            "cleanup_triggered": True,
+            "rooms_before": rooms_before,
+            "rooms_after": rooms_after,
+            "rooms_removed": rooms_before - rooms_after,
+            "timestamp": datetime.now(tz=UTC).isoformat(),
+        }
+
+    def get_cleanup_status(self) -> dict:
+        """Get cleanup system status and configuration"""
+        current_time = datetime.now(tz=UTC)
+
+        # Calculate room ages and activity
+        room_info = []
+        for workspace_id, rooms in self.workspaces.items():
+            for room_id, room in rooms.items():
+                # Find latest activity for this room
+                latest_activity = room.last_activity
+                for metadata in self.connection_metadata.values():
+                    if (
+                        metadata["workspace_id"] == workspace_id
+                        and metadata["room_id"] == room_id
+                    ):
+                        latest_activity = max(
+                            latest_activity, metadata["last_activity"]
+                        )
+
+                age = current_time - room.created_at
+                inactivity = current_time - latest_activity
+
+                room_info.append({
+                    "workspace_id": workspace_id,
+                    "room_id": room_id,
+                    "age_minutes": age.total_seconds() / 60,
+                    "inactivity_minutes": inactivity.total_seconds() / 60,
+                    "has_connections": any(
+                        metadata["workspace_id"] == workspace_id
+                        and metadata["room_id"] == room_id
+                        for metadata in self.connection_metadata.values()
+                    ),
+                    "will_be_cleaned": inactivity > self.inactivity_timeout,
+                })
+
+        return {
+            "service": "robotics",
+            "cleanup_enabled": self._cleanup_task is not None,
+            "inactivity_timeout_minutes": self.inactivity_timeout.total_seconds() / 60,
+            "cleanup_interval_minutes": self.cleanup_interval.total_seconds() / 60,
+            "total_rooms": len(room_info),
+            "rooms": room_info,
+            "timestamp": current_time.isoformat(),
+        }

server/src/video/api.py

@@ -145,6 +145,7 @@ async def get_status():
     """Get video service status"""
     total_workspaces = len(video_core.workspaces)
     total_rooms = sum(len(rooms) for rooms in video_core.workspaces.values())
+    cleanup_info = video_core.get_cleanup_status()
 
     return {
         "service": "video",
@@ -157,6 +158,11 @@ async def get_status():
         "supported_roles": [role.value for role in ParticipantRole],
         "supported_encodings": [encoding.value for encoding in VideoEncoding],
         "recovery_policies": [policy.value for policy in RecoveryPolicy],
+        "cleanup": {
+            "enabled": cleanup_info["cleanup_enabled"],
+            "inactivity_timeout_hours": cleanup_info["inactivity_timeout_minutes"] / 60,
+            "cleanup_interval_minutes": cleanup_info["cleanup_interval_minutes"],
+        },
     }
 
 
@@ -166,6 +172,20 @@ async def health_check():
     return {"status": "healthy", "service": "video"}
 
 
+@video_router.get("/cleanup/status")
+async def get_cleanup_status():
+    """Get cleanup system status and room information"""
+    status = video_core.get_cleanup_status()
+    return {"success": True, "cleanup_status": status}
+
+
+@video_router.post("/cleanup/manual")
+async def trigger_manual_cleanup():
+    """Manually trigger room cleanup"""
+    result = await video_core.manual_cleanup()
+    return {"success": True, "cleanup_result": result}
+
+
 @video_router.get("/")
 async def video_status():
     """Video service main endpoint"""
@@ -181,5 +201,7 @@ async def video_status():
             "/video/workspaces/{workspace_id}/rooms/{room_id}/webrtc/signal - WebRTC signaling",
             "/video/workspaces/{workspace_id}/rooms/{room_id}/ws - WebSocket connection",
             "/video/status - Service status",
+            "/video/cleanup/status - Cleanup system status",
+            "/video/cleanup/manual - Manual cleanup trigger",
         ],
     }

server/src/video/core.py

@@ -4,7 +4,7 @@ import logging
 import time
 import uuid
 from collections.abc import Callable, Coroutine
-from datetime import UTC, datetime
+from datetime import UTC, datetime, timedelta
 from fractions import Fraction
 from functools import lru_cache
 
@@ -600,6 +600,10 @@ class VideoRoom:
         self.start_time = datetime.now(tz=UTC)
         self.last_frame_time: datetime | None = None
 
+        # Activity tracking
+        self.created_at = datetime.now(tz=UTC)
+        self.last_activity = datetime.now(tz=UTC)
+
 
 # ============= VIDEO CORE (main class) =============
 
@@ -616,6 +620,84 @@ class VideoCore:
         # Track background tasks to prevent garbage collection
         self.background_tasks: set = set()
 
+        # Cleanup configuration
+        self.inactivity_timeout = timedelta(hours=1)  # 1 hour of inactivity
+        self.cleanup_interval = timedelta(minutes=15)  # Check every 15 minutes
+
+        # Start cleanup task
+        self._cleanup_task = None
+        self._start_cleanup_task()
+
+    def _start_cleanup_task(self):
+        """Start the background cleanup task"""
+
+        async def cleanup_loop():
+            while True:
+                try:
+                    await asyncio.sleep(self.cleanup_interval.total_seconds())
+                    await self._cleanup_inactive_rooms()
+                except Exception:
+                    logger.exception("Error in video cleanup task")
+
+        try:
+            loop = asyncio.get_event_loop()
+            self._cleanup_task = loop.create_task(cleanup_loop())
+            logger.info("Started video room cleanup task")
+        except RuntimeError:
+            # No event loop running yet, cleanup will start when first room is created
+            logger.info("No event loop running, video cleanup task will start later")
+
+    async def _cleanup_inactive_rooms(self):
+        """Remove rooms that have been inactive for more than the timeout period"""
+        current_time = datetime.now(tz=UTC)
+        rooms_to_remove = []
+
+        for workspace_id, rooms in self.workspaces.items():
+            for room_id, room in rooms.items():
+                # Check if room has any active connections
+                has_active_connections = False
+                room_last_activity = room.last_activity
+
+                # Check all connections for this room to find most recent activity
+                for metadata in self.connection_metadata.values():
+                    if (
+                        metadata.get("workspace_id") == workspace_id
+                        and metadata.get("room_id") == room_id
+                    ):
+                        has_active_connections = True
+                        if (
+                            metadata.get("last_activity")
+                            and metadata["last_activity"] > room_last_activity
+                        ):
+                            room_last_activity = metadata["last_activity"]
+
+                # If no active connections, use room's last activity
+                if not has_active_connections:
+                    time_since_activity = current_time - room_last_activity
+
+                    if time_since_activity > self.inactivity_timeout:
+                        rooms_to_remove.append((workspace_id, room_id))
+                        logger.info(
+                            f"Marking video room {room_id} in workspace {workspace_id} for cleanup "
+                            f"(inactive for {time_since_activity})"
+                        )
+
+        # Remove inactive rooms
+        for workspace_id, room_id in rooms_to_remove:
+            if self.delete_room(workspace_id, room_id):
+                logger.info(
+                    f"Auto-removed inactive video room {room_id} from workspace {workspace_id}"
+                )
+
+        if rooms_to_remove:
+            logger.info(f"Cleaned up {len(rooms_to_remove)} inactive video rooms")
+
+    def _update_room_activity(self, workspace_id: str, room_id: str):
+        """Update the last activity timestamp for a room"""
+        room = self._get_room(workspace_id, room_id)
+        if room:
+            room.last_activity = datetime.now(tz=UTC)
+
     # ============= ROOM MANAGEMENT (same pattern as robotics) =============
 
     def create_room(
@@ -635,6 +717,11 @@ class VideoCore:
 
         room = VideoRoom(room_id, workspace_id, config, recovery_config)
         self.workspaces[workspace_id][room_id] = room
+
+        # Start cleanup task if not already running
+        if self._cleanup_task is None:
+            self._start_cleanup_task()
+
         logger.info(f"Created video room {room_id} in workspace {workspace_id}")
         return workspace_id, room_id
 
@@ -769,6 +856,7 @@ class VideoCore:
         if role == ParticipantRole.PRODUCER:
             if room.producer is None:
                 room.producer = participant_id
+                self._update_room_activity(workspace_id, room_id)
                 logger.info(
                     f"Producer {participant_id} joined video room {room_id} in workspace {workspace_id}"
                 )
@@ -788,6 +876,7 @@ class VideoCore:
         if role == ParticipantRole.CONSUMER:
             if participant_id not in room.consumers:
                 room.consumers.append(participant_id)
+                self._update_room_activity(workspace_id, room_id)
                 logger.info(
                     f"Consumer {participant_id} joined video room {room_id} in workspace {workspace_id}"
                 )
@@ -953,6 +1042,8 @@ class VideoCore:
                     logger.exception(f"Error sending frame to {consumer_id}")
 
         if consumer_count > 0:
+            # Update room activity when frames are being broadcast
+            self._update_room_activity(workspace_id, room_id)
             logger.debug(f"Broadcasted frame to {consumer_count} consumers")
 
         return consumer_count
@@ -1053,6 +1144,9 @@ class VideoCore:
             )
             self.connection_metadata[participant_id]["message_count"] += 1
 
+        # Update room activity
+        self._update_room_activity(workspace_id, room_id)
+
         # Handle heartbeat
         if message["type"] == MessageType.HEARTBEAT:
             heartbeat_ack: HeartbeatAckMessageDict = {
@@ -1319,3 +1413,67 @@ class VideoCore:
         self.background_tasks.add(task)
         task.add_done_callback(self.background_tasks.discard)
         return task
+
+    # ============= CLEANUP MANAGEMENT =============
+
+    async def manual_cleanup(self) -> dict:
+        """Manually trigger room cleanup and return results"""
+        logger.info("Manual video room cleanup triggered")
+        rooms_before = sum(len(rooms) for rooms in self.workspaces.values())
+        await self._cleanup_inactive_rooms()
+        rooms_after = sum(len(rooms) for rooms in self.workspaces.values())
+
+        return {
+            "cleanup_triggered": True,
+            "rooms_before": rooms_before,
+            "rooms_after": rooms_after,
+            "rooms_removed": rooms_before - rooms_after,
+            "timestamp": datetime.now(tz=UTC).isoformat(),
+        }
+
+    def get_cleanup_status(self) -> dict:
+        """Get cleanup system status and configuration"""
+        current_time = datetime.now(tz=UTC)
+
+        # Calculate room ages and activity
+        room_info = []
+        for workspace_id, rooms in self.workspaces.items():
+            for room_id, room in rooms.items():
+                # Find latest activity for this room
+                latest_activity = room.last_activity
+                for metadata in self.connection_metadata.values():
+                    if (
+                        metadata.get("workspace_id") == workspace_id
+                        and metadata.get("room_id") == room_id
+                    ):
+                        if (
+                            metadata.get("last_activity")
+                            and metadata["last_activity"] > latest_activity
+                        ):
+                            latest_activity = metadata["last_activity"]
+
+                age = current_time - room.created_at
+                inactivity = current_time - latest_activity
+
+                room_info.append({
+                    "workspace_id": workspace_id,
+                    "room_id": room_id,
+                    "age_minutes": age.total_seconds() / 60,
+                    "inactivity_minutes": inactivity.total_seconds() / 60,
+                    "has_connections": any(
+                        metadata.get("workspace_id") == workspace_id
+                        and metadata.get("room_id") == room_id
+                        for metadata in self.connection_metadata.values()
+                    ),
+                    "will_be_cleaned": inactivity > self.inactivity_timeout,
+                })
+
+        return {
+            "service": "video",
+            "cleanup_enabled": self._cleanup_task is not None,
+            "inactivity_timeout_minutes": self.inactivity_timeout.total_seconds() / 60,
+            "cleanup_interval_minutes": self.cleanup_interval.total_seconds() / 60,
+            "total_rooms": len(room_info),
+            "rooms": room_info,
+            "timestamp": current_time.isoformat(),
+        }