Refactor mujoco_server.py and protocol_types.py for external client support

- Replaced trainer-specific WebSocket handling with a more generic external client model, allowing for better integration of various client types.
- Updated message types and payload structures to reflect the new client identity and notification system, ensuring backward compatibility with legacy trainer messages.
- Enhanced the broadcast mechanisms to notify all connected clients about their connection status, improving the overall communication flow.
- Removed deprecated trainer-related code and tests, streamlining the server's functionality and focusing on external client interactions.
- Updated README.md to reflect changes in client messaging and connection handling, providing clearer guidance for developers.

README.md

@@ -14,9 +14,9 @@ A unified MuJoCo-based robot simulation platform with web interface for multiple
 6. [Docker Deployment](#docker-deployment)
 7. [Controls](#controls)
 8. [Architecture](#architecture)
-9. [Spot Controller Options](#spot-controller-options)
-10. [API](#api)
-11. [Wandelbots Nova API Integration](#wandelbots-nova-api-integration)
+9. [API](#api)
+10. [Wandelbots Nova API Integration](#wandelbots-nova-api-integration)
+11. [Testing](#testing)
 12. [License](#license)
 
 ## Overview
@@ -28,7 +28,7 @@ Nova Sim combines MuJoCo physics, a Flask/WebSocket server, and a browser UI so
 - Real-time MuJoCo physics simulation
 - Web-based video streaming interface with TypeScript frontend
 - WebSocket-based state/command communication
-- **One-command setup**: `make dev` starts both backend and frontend with hot reload
+- Simple venv-based setup with Python and npm
 - Gym-style WebSocket API for RL/IL clients
 - Interactive camera controls (rotate, zoom, pan)
 - Robot switching without restart
@@ -113,39 +113,7 @@ nova_sim/
 
 ## Quick Start
 
-### Using Makefile (Recommended)
-
-The easiest way to get started is using the included Makefile:
-
-```bash
-# First time setup: install all dependencies
-make install
-
-# Start development servers (backend + frontend with hot reload)
-make dev
-# Backend: http://localhost:5000
-# Frontend dev server: http://localhost:3004
-# Access the application at: http://localhost:3004/nova-sim
-
-# Press Ctrl+C to stop all servers
-```
-
-**Production build:**
-```bash
-make build  # Build frontend assets
-make prod   # Run production server
-```
-
-**Other commands:**
-```bash
-make help   # Show all available commands
-make clean  # Clean build artifacts
-make kill   # Stop all running servers
-```
-
-### Manual Setup (Alternative)
-
-If you prefer not to use the Makefile:
+### Setup
 
 ```bash
 # Create and activate a virtualenv
@@ -153,7 +121,7 @@ python3 -m venv .venv
 source .venv/bin/activate
 
 # Install Python dependencies
-pip install mujoco gymnasium flask flask-sock opencv-python torch numpy
+pip install -r requirements.txt
 
 # Install frontend dependencies
 cd frontend && npm install && cd ..
@@ -171,32 +139,35 @@ python mujoco_server.py
 
 ## Docker Deployment
 
-### Quick Start with Makefile
+### Quick Start
 
 ```bash
-# Build and run in Docker (CPU mode)
-make docker
+# Build and run (CPU/software rendering)
+docker-compose up --build
 
 # Or with GPU acceleration (requires NVIDIA GPU)
-make docker-gpu
-
-# View logs
-make docker-logs
+docker-compose -f docker-compose.gpu.yml up --build
 
-# Stop containers
-make docker-down
+# Access at: http://localhost:3004/nova-sim
 ```
 
-### Manual Docker Commands
+### Docker Commands
 
 ```bash
-# Build and run (CPU/software rendering)
+# Build and run (CPU mode)
 docker-compose up --build
 
-# Or with docker run
-docker run -p 3004:5000 nova-sim
+# Run with GPU support
+docker-compose -f docker-compose.gpu.yml up --build
 
-# Access at: http://localhost:3004/nova-sim
+# View logs
+docker-compose logs -f
+
+# Stop containers
+docker-compose down
+
+# Or with docker run directly
+docker run -p 3004:5000 nova-sim
 ```
 
 ### Configuration & Tuning
@@ -415,23 +386,6 @@ docker run --gpus all -p 3004:5000 \
 
 All controllers output joint position targets; MuJoCo's built-in PD control tracks these targets.
 
-## Spot Controller Options
-
-The Spot robot supports multiple controller types via the `controller_type` parameter:
-
-```python
-from spot_env import SpotEnv
-
-# MPC Gait - Feedback-based balance control (default, no extra deps)
-env = SpotEnv(controller_type='mpc_gait')
-
-# PyMPC Gait - Uses standalone gait generator (no external dependencies needed)
-env = SpotEnv(controller_type='pympc')
-
-# Trot Gait - Simple open-loop trot pattern
-env = SpotEnv(controller_type='trot')
-```
-
 ## API
 
 All endpoints are prefixed with `/nova-sim/api/v1`.
@@ -527,6 +481,11 @@ For robot arms (UR5):
 {"type": "home"}
 ```
 
+**`stop_home`** - Stop homing sequence (UR5 only):
+```json
+{"type": "stop_home"}
+```
+
 **`teleop_action`** - Send teleoperation action (primarily for UR5 keyboard control):
 ```json
 {"type": "teleop_action", "data": {"vx": 0.01, "vy": 0.0, "vz": 0.0}}
@@ -594,6 +553,37 @@ For robot arms (UR5):
 ```
 - `action`: `"open"` or `"close"`
 
+**`set_nova_mode`** (Configure Nova API integration):
+```json
+{"type": "set_nova_mode", "data": {"state_streaming": true, "ik": false}}
+```
+- `enabled`: (Optional, legacy) Enable/disable all Nova features
+- `state_streaming`: (Optional) Enable/disable Nova state streaming
+- `ik`: (Optional) Enable/disable Nova IK computation
+
+#### Client Identity & Notification Messages
+
+**`client_identity`** (Client handshake):
+```json
+{"type": "client_identity", "data": {"client_id": "my_client_v1"}}
+```
+- `client_id`: Unique identifier for the external client
+- **Note:** Old `trainer_identity` type is still supported for backward compatibility
+
+**`client_notification`** (Send client notification to all connected clients):
+```json
+{"type": "client_notification", "data": {"message": "Starting epoch 5", "level": "info"}}
+```
+- `message`: Notification text
+- `level`: `"info"`, `"warning"`, or `"error"`
+- **Note:** Old `notification` type is still supported for backward compatibility
+
+**`episode_control`** (Control episode state):
+```json
+{"type": "episode_control", "data": {"action": "terminate"}}
+```
+- `action`: `"terminate"` (episode ended successfully) or `"truncate"` (episode cut short)
+
 #### Server → Client Messages
 
 **`state`** (broadcast at ~10 Hz):
@@ -647,15 +637,15 @@ For robot arm (UR5):
 *Common fields (all robots):*
 - `observation`: Contains robot-specific sensor data and state information
 - `steps`: Number of simulation steps since last reset
-- `reward`: The integrated task reward from the simulator that remote trainers can consume
-- `teleop_action`: The canonical action/velocity stream that drives locomotion or arm movement; the UI and every trainer should read this field as the unified action record. Always present with zero values when idle
+- `reward`: The integrated task reward from the simulator that external clients can consume
+- `teleop_action`: The canonical action/velocity stream that drives locomotion or arm movement; the UI and every external client should read this field as the unified action record. Always present with zero values when idle
   - Cartesian velocities: `vx` (forward/back or X-axis), `vy` (strafe or Y-axis), `vz` (vertical for UR5), `vyaw` (rotation for locomotion)
   - Cartesian rotation velocities (UR5 only): `vrx`, `vry`, `vrz` (rad/s)
   - Joint velocities (UR5 only): `j1`, `j2`, `j3`, `j4`, `j5`, `j6` (rad/s)
   - Gripper: `gripper` (0-255 for UR5, 0 for others)
   - Locomotion robots: Use `vx`, `vy`, `vyaw` (other fields are 0)
   - UR5: Use `vx`/`vy`/`vz` for Cartesian translation, `vrx`/`vry`/`vrz` for rotation, `j1`-`j6` for joint velocities, and `gripper` for gripper control
-- `trainer_connected`: Whether a trainer handshake is active on `/ws` (useful for status LEDs)
+- `connected_clients`: List of connected external client IDs (e.g., `["trainer_v1", "monitor"]`)
 
 *Locomotion observation fields (inside `observation`):*
 - `position`: Robot base position in world coordinates (x, y, z) in meters
@@ -679,15 +669,39 @@ For robot arm (UR5):
 
 **Note:** Static environment information (robot name, scene name, has_gripper, action/observation spaces, camera feeds) has been moved to the `GET /env` endpoint and is no longer included in the state stream.
 
-### State broadcasts and trainer notifications
+**`connected_clients`** (broadcast to all clients):
+```json
+{
+  "type": "connected_clients",
+  "data": {
+    "clients": ["trainer_v1", "monitor"]
+  }
+}
+```
+- `clients`: Array of connected external client IDs
+
+**`client_notification`** (broadcast to all clients):
+```json
+{
+  "type": "client_notification",
+  "data": {
+    "message": "Starting epoch 5",
+    "level": "info"
+  }
+}
+```
+- `message`: Notification text from external client
+- `level`: `"info"`, `"warning"`, or `"error"`
+
+### State broadcasts and client notifications
 
 Every `/ws` client receives a `state` message roughly every 100 ms. The examples above show the locomotion (`spot`) and arm (`ur5`) payloads; the payload also now includes:
 
-- `teleop_action`: The latest action/teleoperation stream (includes `vx`, `vy`, `vz`, `vyaw`, `vrx`, `vry`, `vrz`, `j1`-`j6`, `gripper`) so trainers and the UI read a single canonical action payload. Always present with zero values when idle.
-- `reward`: The integrated task reward that trainers can consume without sending a separate `step`.
-- `trainer_connected`: Whether a trainer handshake is active on `/ws` (used to update the UI indicator).
+- `teleop_action`: The latest action/teleoperation stream (includes `vx`, `vy`, `vz`, `vyaw`, `vrx`, `vry`, `vrz`, `j1`-`j6`, `gripper`) so external clients and the UI read a single canonical action payload. Always present with zero values when idle.
+- `reward`: The integrated task reward that external clients can consume without sending a separate `step`.
+- `connected_clients`: Array of connected external client IDs (used to display which clients are connected).
 
-Trainers announce themselves by sending a `trainer_identity` payload when the socket opens. The server mirrors that information into the `trainer_status` broadcasts (`trainer_status` messages flow to every UI client) and lets trainers emit `notification` payloads that the UI receives as `trainer_notification` events.
+External clients (trainers, monitors, etc.) announce themselves by sending a `client_identity` payload when the socket opens. The server mirrors that information into the `connected_clients` broadcasts (`connected_clients` messages flow to all clients) and lets external clients emit `client_notification` payloads that all clients receive.
 
 ### HTTP Endpoints
 
@@ -946,68 +960,6 @@ The Nova API integration is implemented in:
 
 The tests assume the server is accessible via `http://localhost:3004/nova-sim/api/v1` and will skip automatically if the API is unreachable.
 
-## Frontend Development
-
-The Nova Sim web UI is built with TypeScript, Vite, and vanilla JavaScript (no framework dependencies).
-
-### Development Setup
-
-1. **Install Node.js dependencies:**
-   ```bash
-   cd frontend
-   npm install
-   ```
-
-2. **Start development server with hot reload:**
-   ```bash
-   # Terminal 1: Start Flask backend
-   python mujoco_server.py
-
-   # Terminal 2: Start Vite dev server
-   cd frontend
-   npm run dev
-   ```
-
-3. **Access the development UI:**
-   - Open [http://localhost:3004/nova-sim](http://localhost:3004/nova-sim)
-   - All API/WebSocket calls are automatically proxied to Flask at `:5000`
-   - Changes to TypeScript/CSS auto-reload in the browser
-
-### Production Build
-
-```bash
-cd frontend
-npm run build
-```
-
-This compiles TypeScript and bundles all assets to `frontend/dist/`. The Flask server automatically serves these built files from the `/static` route.
-
-### Frontend Structure
-
-- **`src/main.ts`**: Main application entry point with WebSocket handling and UI logic
-- **`src/api/client.ts`**: Type-safe WebSocket client for server communication
-- **`src/types/protocol.ts`**: TypeScript definitions mirroring Python protocol types
-- **`src/styles.css`**: All CSS styles (Wandelbots design system)
-- **`src/index.html`**: HTML template with viewport structure
-
-### Type Safety
-
-The frontend uses TypeScript for compile-time type checking:
-
-```bash
-# Run type checker
-cd frontend
-npm run type-check
-```
-
-All WebSocket messages are strongly typed to match the Python protocol definitions in `protocol_types.py`.
-
-### Modifying the UI
-
-- **Styles**: Edit `frontend/src/styles.css`
-- **Behavior**: Edit `frontend/src/main.ts`
-- **Protocol**: Update both `protocol_types.py` (Python) and `frontend/src/types/protocol.ts` (TypeScript)
-
 ## License
 
 This project uses models from:

examples/ur5_nova_api_example.py

@@ -1,155 +0,0 @@
-#!/usr/bin/env python3
-"""Example script demonstrating Nova API integration with UR5 environment.
-
-This script shows how to use the Wandelbots Nova API for robot state streaming
-and inverse kinematics with the UR5 simulation environment.
-
-Requirements:
-    - Nova instance credentials in .env file
-    - websockets: pip install websockets
-    - python-dotenv: pip install python-dotenv
-
-Usage:
-    python examples/ur5_nova_api_example.py [--mode MODE]
-
-Modes:
-    state_only: Enable state streaming only
-    ik_only: Enable Nova IK only
-    both: Enable both state streaming and Nova IK (default)
-    none: Disable Nova API (local simulation only)
-"""
-
-import argparse
-import sys
-from pathlib import Path
-
-# Add parent directory to path
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-try:
-    from dotenv import load_dotenv
-except ImportError:
-    print("Warning: python-dotenv not installed. Install with: pip install python-dotenv")
-    print("Continuing without .env file support...")
-    load_dotenv = None
-
-from nova_sim.robots.ur5.ur5_env import UR5Env
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="UR5 Nova API Integration Example",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=__doc__
-    )
-    parser.add_argument(
-        "--mode",
-        choices=["state_only", "ik_only", "both", "none"],
-        default="both",
-        help="Nova API integration mode"
-    )
-    parser.add_argument(
-        "--steps",
-        type=int,
-        default=1000,
-        help="Number of simulation steps to run"
-    )
-    parser.add_argument(
-        "--no-render",
-        action="store_true",
-        help="Disable rendering"
-    )
-    args = parser.parse_args()
-
-    # Load environment variables
-    if load_dotenv is not None:
-        env_path = Path(__file__).parent.parent / ".env"
-        if env_path.exists():
-            load_dotenv(env_path)
-            print(f"Loaded environment variables from {env_path}")
-        else:
-            print(f"Warning: .env file not found at {env_path}")
-            print("Copy .env.example to .env and fill in your Nova credentials")
-
-    # Configure Nova API based on mode
-    nova_config = None
-    if args.mode != "none":
-        use_state = args.mode in ("state_only", "both")
-        use_ik = args.mode in ("ik_only", "both")
-
-        nova_config = {
-            "use_state_stream": use_state,
-            "use_ik": use_ik
-        }
-
-        print(f"\nNova API Integration Mode: {args.mode}")
-        print(f"  State Streaming: {'enabled' if use_state else 'disabled'}")
-        print(f"  Nova IK: {'enabled' if use_ik else 'disabled'}")
-    else:
-        print("\nNova API Integration: disabled (local simulation only)")
-
-    # Create environment
-    print("\nCreating UR5 environment...")
-    try:
-        env = UR5Env(
-            render_mode="human" if not args.no_render else None,
-            scene_name="scene",
-            nova_api_config=nova_config
-        )
-    except Exception as e:
-        print(f"Error creating environment: {e}")
-        print("\nMake sure your .env file is configured correctly with Nova credentials.")
-        return 1
-
-    print("Environment created successfully!")
-
-    # Reset environment
-    print("\nResetting environment...")
-    obs, info = env.reset()
-    print(f"Initial observation shape: {obs.shape}")
-
-    # Get initial state
-    joint_pos = env.get_joint_positions()
-    ee_pos = env.get_end_effector_pos()
-    print(f"Initial joint positions: {joint_pos}")
-    print(f"Initial end-effector position: {ee_pos}")
-
-    # Set a target position
-    print("\nSetting target position...")
-    target_pos = [0.4, 0.2, 0.6]
-    env.set_target(*target_pos)
-    print(f"Target position: {target_pos}")
-
-    # Run simulation
-    print(f"\nRunning simulation for {args.steps} steps...")
-    print("Press Ctrl+C to stop early")
-
-    try:
-        for step in range(args.steps):
-            # Step with controller (uses IK to reach target)
-            obs = env.step_with_controller(dt=0.002)
-
-            # Render
-            if not args.no_render:
-                env.render()
-
-            # Print progress every 100 steps
-            if (step + 1) % 100 == 0:
-                ee_pos = env.get_end_effector_pos()
-                distance = ((ee_pos - target_pos) ** 2).sum() ** 0.5
-                print(f"Step {step + 1}/{args.steps} - Distance to target: {distance:.4f}m")
-
-    except KeyboardInterrupt:
-        print("\nSimulation interrupted by user")
-
-    finally:
-        # Clean up
-        print("\nClosing environment...")
-        env.close()
-        print("Done!")
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

mujoco_server.py

@@ -139,10 +139,10 @@ homing_lock = threading.Lock()
 # WebSocket clients
 ws_clients = set()
 ws_clients_lock = threading.Lock()
-trainer_ws_clients = set()
-trainer_ws_clients_lock = threading.Lock()
-trainer_client_metadata: dict = {}
-trainer_client_metadata_lock = threading.Lock()
+external_ws_clients = set()  # External clients (not UI) that can send notifications
+external_ws_clients_lock = threading.Lock()
+client_metadata: dict = {}  # Metadata for all external clients
+client_metadata_lock = threading.Lock()
 # Camera state for orbit controls
 cam = mujoco.MjvCamera()
 cam.azimuth = 135
@@ -580,8 +580,8 @@ def broadcast_state():
         if hasattr(env, "get_task_reward"):
             reward_value = env.get_task_reward()
 
-        with trainer_ws_clients_lock:
-            trainer_connected = len(trainer_ws_clients) > 0
+        with external_ws_clients_lock:
+            connected_clients = [info.get("identity", "client") for ws, info in list(client_metadata.items()) if ws in external_ws_clients]
 
         # UR5 has different state structure
         if current_robot in ("ur5", "ur5_t_push"):
@@ -636,7 +636,7 @@ def broadcast_state():
                         'available': nova_available,
                         'enabled': nova_enabled_pref
                     },
-                    'trainer_connected': trainer_connected
+                    'connected_clients': connected_clients
                 }
             })
         else:
@@ -656,7 +656,7 @@ def broadcast_state():
                     'steps': int(steps),
                     'reward': reward_value,
                     'teleop_action': teleop_snapshot,
-                    'trainer_connected': trainer_connected
+                    'connected_clients': connected_clients
                 }
             })
 
@@ -681,64 +681,58 @@ def broadcast_state():
         ws_clients.difference_update(dead_clients)
 
 
-def _handle_trainer_message(ws, data):
-    """Process message payloads originating from trainers."""
+def _handle_external_client_message(ws, data):
+    """Process message payloads originating from external clients."""
     msg_type = data.get("type")
-    if msg_type == "trainer_identity":
+    if msg_type in ("client_identity", "trainer_identity"):  # Support old name for backward compat
         payload = data.get("data", {}) or {}
-        identity = payload.get("trainer_id") or payload.get("trainer_name") or payload.get("name") or "trainer"
-        with trainer_ws_clients_lock:
-            trainer_ws_clients.add(ws)
-        _register_trainer_client(ws)
-        _set_trainer_identity(ws, identity)
+        identity = payload.get("client_id") or payload.get("trainer_id") or payload.get("name") or "client"
+        with external_ws_clients_lock:
+            external_ws_clients.add(ws)
+        _register_external_client(ws)
+        _set_client_identity(ws, identity)
         broadcast_state()
-        broadcast_trainer_connection_status()
+        broadcast_connected_clients_status()
         return
-    if msg_type == "notification":
+    if msg_type in ("client_notification", "notification"):  # Support old name for backward compat
         payload = data.get("data", {})
         payload.setdefault("timestamp", time.time())
-        broadcast_notification_to_ui(payload)
+        broadcast_notification_to_all(payload)
 
 
-def _build_trainer_status_payload():
-    """Build a summary payload describing connected trainer clients."""
-    with trainer_ws_clients_lock:
-        connection_count = len(trainer_ws_clients)
-        connected = connection_count > 0
-    with trainer_client_metadata_lock:
-        identities = [info.get("identity") for info in trainer_client_metadata.values() if info.get("identity")]
+def _build_connected_clients_payload():
+    """Build a summary payload describing connected external clients."""
+    with client_metadata_lock:
+        identities = [info.get("identity", "client") for ws, info in client_metadata.items() if ws in external_ws_clients and info.get("identity")]
     payload = {
-        "connected": connected,
-        "trainer_count": connection_count,
+        "clients": identities,
     }
-    if identities:
-        payload["identities"] = identities
     return payload
 
 
-def _register_trainer_client(ws):
-    with trainer_client_metadata_lock:
-        trainer_client_metadata[ws] = {"identity": None, "connected_at": time.time()}
+def _register_external_client(ws):
+    with client_metadata_lock:
+        client_metadata[ws] = {"identity": None, "connected_at": time.time()}
 
 
-def _unregister_trainer_client(ws):
-    with trainer_client_metadata_lock:
-        trainer_client_metadata.pop(ws, None)
+def _unregister_external_client(ws):
+    with client_metadata_lock:
+        client_metadata.pop(ws, None)
 
 
-def _set_trainer_identity(ws, identity: str):
-    with trainer_client_metadata_lock:
-        info = trainer_client_metadata.get(ws)
+def _set_client_identity(ws, identity: str):
+    with client_metadata_lock:
+        info = client_metadata.get(ws)
         if not info:
             return
         info["identity"] = identity
         info["last_seen"] = time.time()
 
 
-def broadcast_trainer_connection_status():
-    """Notify UI clients about trainer connection state."""
-    payload = _build_trainer_status_payload()
-    message = json.dumps({"type": "trainer_status", "data": payload})
+def broadcast_connected_clients_status():
+    """Notify all clients about connected external clients."""
+    payload = _build_connected_clients_payload()
+    message = json.dumps({"type": "connected_clients", "data": payload})
     with ws_clients_lock:
         dead_clients = set()
         for client in ws_clients:
@@ -748,22 +742,22 @@ def broadcast_trainer_connection_status():
                 dead_clients.add(client)
         ws_clients.difference_update(dead_clients)
 
-def broadcast_to_trainer(event_type: str, payload: dict):
-    """Broadcast a structured event to connected trainer WebSocket clients."""
+def broadcast_to_external_clients(event_type: str, payload: dict):
+    """Broadcast a structured event to connected external WebSocket clients."""
     message = json.dumps({"type": event_type, "data": payload})
-    with trainer_ws_clients_lock:
+    with external_ws_clients_lock:
         dead_clients = set()
-        for ws in trainer_ws_clients:
+        for ws in external_ws_clients:
             try:
                 ws.send(message)
             except Exception:
                 dead_clients.add(ws)
-        trainer_ws_clients.difference_update(dead_clients)
+        external_ws_clients.difference_update(dead_clients)
 
 
-def broadcast_notification_to_ui(payload: dict):
-    """Send a notification message (from trainer) to every UI client."""
-    notification = json.dumps({"type": "trainer_notification", "data": payload})
+def broadcast_notification_to_all(payload: dict):
+    """Send a notification message (from external client) to all clients."""
+    notification = json.dumps({"type": "client_notification", "data": payload})
     with ws_clients_lock:
         dead_clients = set()
         for ws in ws_clients:
@@ -798,7 +792,7 @@ def _signal_episode_control(action: str):
         "source": "ui",
         "timestamp": time.time(),
     }
-    broadcast_to_trainer("episode_event", payload)
+    broadcast_to_external_clients("episode_event", payload)
     # Reset UI environment so the user can continue without manual reset
     with mujoco_lock:
         if env is not None:
@@ -968,8 +962,8 @@ def handle_ws_message(ws, data):
     msg_type = data.get('type')
     print(f"[WS] Received message type: {msg_type}")
 
-    if msg_type in ("trainer_identity", "notification"):
-        _handle_trainer_message(ws, data)
+    if msg_type in ("client_identity", "trainer_identity", "client_notification", "notification"):
+        _handle_external_client_message(ws, data)
         return
 
     # Backward compatibility: map old message types to new ones
@@ -1314,7 +1308,7 @@ def handle_ws_message(ws, data):
             last_teleop_action["vry"] = 0.0
             last_teleop_action["vrz"] = 0.0
 
-        broadcast_to_trainer(
+        broadcast_to_external_clients(
             "action_update",
             {
                 "robot": current_robot,
@@ -1501,13 +1495,13 @@ def websocket_handler(ws):
         # Unregister client
         with ws_clients_lock:
             ws_clients.discard(ws)
-        with trainer_ws_clients_lock:
-            was_trainer = ws in trainer_ws_clients
-            trainer_ws_clients.discard(ws)
-        if was_trainer:
-            _unregister_trainer_client(ws)
+        with external_ws_clients_lock:
+            was_external = ws in external_ws_clients
+            external_ws_clients.discard(ws)
+        if was_external:
+            _unregister_external_client(ws)
             broadcast_state()
-            broadcast_trainer_connection_status()
+            broadcast_connected_clients_status()
         print('WebSocket client disconnected')
 
 
@@ -2000,11 +1994,11 @@ def index():
                         </div>
                     </div>
                 </div>
-            <div id="trainer_status_card" class="status-card disconnected">
-                <strong>Trainer Connection</strong>
-                <div class="trainer-status disconnected" id="trainer_status_indicator">
-                    <span class="trainer-status-dot" id="trainer_status_dot" aria-hidden="true"></span>
-                    <span class="status-card-text" id="trainer_status_text">Trainer: Disconnected</span>
+            <div id="clients_status_card" class="status-card">
+                <strong>Connected Clients</strong>
+                <div class="clients-status" id="clients_status_indicator">
+                    <span class="status-card-text" id="clients_status_text">No clients connected</span>
+                    <ul id="clients_list" style="margin: 0.5em 0 0 0; padding-left: 1.5em; font-size: 0.9em;"></ul>
                 </div>
             </div>
         </div>
@@ -2259,9 +2253,10 @@ def index():
             const robotSelect = document.getElementById('robot_select');
             const sceneLabel = document.getElementById('scene_label');
             const overlayTiles = document.getElementById('overlay_tiles');
-            const trainerStatusCard = document.getElementById('trainer_status_card');
-            const trainerStatusIndicator = document.getElementById('trainer_status_indicator');
-            const trainerStatusText = document.getElementById('trainer_status_text');
+            const clientsStatusCard = document.getElementById('clients_status_card');
+            const clientsStatusIndicator = document.getElementById('clients_status_indicator');
+            const clientsStatusText = document.getElementById('clients_status_text');
+            const clientsList = document.getElementById('clients_list');
             const viewportImage = document.querySelector('.video-container img');
             const robotTitle = document.getElementById('robot_title');
             const robotInfo = document.getElementById('robot_info');
@@ -2339,22 +2334,29 @@ def index():
             const NOVA_JOINT_VELOCITY = 0.5;
             let novaVelocitiesConfigured = false;
 
-            function updateTrainerStatus(connected) {
-                if (!trainerStatusCard || !trainerStatusText) {
+            function updateConnectedClients(clients) {
+                if (!clientsStatusCard || !clientsStatusText || !clientsList) {
                     return;
                 }
-                trainerStatusText.innerText = connected ? 'Trainer: Connected' : 'Trainer: Disconnected';
-                trainerStatusCard.classList.toggle('connected', connected);
-                trainerStatusCard.classList.toggle('disconnected', !connected);
-                if (trainerStatusIndicator) {
-                    trainerStatusIndicator.classList.toggle('connected', connected);
-                    trainerStatusIndicator.classList.toggle('disconnected', !connected);
-                }
-                if (connected) {
-                    configureNovaVelocities();
+
+                // Update text and list
+                if (!clients || clients.length === 0) {
+                    clientsStatusText.innerText = "No clients connected";
+                    clientsList.innerHTML = "";
+                    clientsList.style.display = "none";
+                } else {
+                    clientsStatusText.innerText = `${clients.length} client${clients.length > 1 ? 's' : ''} connected`;
+                    clientsList.innerHTML = clients.map(id => `<li>${id}</li>`).join('');
+                    clientsList.style.display = "block";
                 }
             }
 
+            // Legacy function for backward compatibility with old state messages
+            function updateTrainerStatus(connected) {
+                // Deprecated: convert to new format
+                updateConnectedClients(connected ? ["legacy-client"] : []);
+            }
+
             function configureNovaVelocities() {
                 if (novaVelocitiesConfigured) {
                     return;
@@ -2682,7 +2684,11 @@ def index():
                             currentScene = data.scene;
                         }
 
-                        if (typeof data.trainer_connected === 'boolean') {
+                        // Handle both new and legacy client status formats
+                        if (data.connected_clients && Array.isArray(data.connected_clients)) {
+                            updateConnectedClients(data.connected_clients);
+                        } else if (typeof data.trainer_connected === 'boolean') {
+                            // Legacy format
                             updateTrainerStatus(data.trainer_connected);
                         }
 
@@ -2927,13 +2933,19 @@ def index():
 
                                 stepVal.innerText = data.steps;
                             }
+                        } else if (msg.type === 'connected_clients') {
+                            const payload = msg.data || {};
+                            if (payload.clients && Array.isArray(payload.clients)) {
+                                updateConnectedClients(payload.clients);
+                            }
                         } else if (msg.type === 'trainer_status') {
+                            // Legacy support
                             const payload = msg.data || {};
                             if (typeof payload.connected === 'boolean') {
                                 updateTrainerStatus(payload.connected);
                             }
-                        } else if (msg.type === 'trainer_notification') {
-                            showTrainerNotification(msg.data);
+                        } else if (msg.type === 'client_notification' || msg.type === 'trainer_notification') {
+                            showClientNotification(msg.data);
                         }
                     } catch (e) {
                         console.error('Error parsing message:', e);
@@ -2965,7 +2977,7 @@ def index():
                 }
             }
 
-            function showTrainerNotification(payload) {
+            function showClientNotification(payload) {
                 if (!notificationList || !payload) {
                     return;
                 }

protocol_types.py

@@ -262,30 +262,30 @@ class SetNovaModeMessage(TypedDict):
 
 
 # ============================================================================
-# Trainer Messages (Client -> Server)
+# Client Identity & Notification Messages (Client -> Server)
 # ============================================================================
 
-class TrainerIdentityData(TypedDict):
-    """Trainer identity data."""
-    trainer_id: str
+class ClientIdentityData(TypedDict):
+    """Client identity data."""
+    client_id: str
 
 
-class TrainerIdentityMessage(TypedDict):
-    """Trainer identity handshake message."""
-    type: Literal["trainer_identity"]
-    data: TrainerIdentityData
+class ClientIdentityMessage(TypedDict):
+    """Client identity handshake message."""
+    type: Literal["client_identity"]
+    data: ClientIdentityData
 
 
-class TrainerNotificationData(TypedDict, total=False):
-    """Trainer notification data."""
+class ClientNotificationData(TypedDict, total=False):
+    """Client notification data."""
     message: str
     level: Literal["info", "warning", "error"]
 
 
-class TrainerNotificationMessage(TypedDict):
-    """Trainer notification message."""
-    type: Literal["notification"]
-    data: TrainerNotificationData
+class ClientNotificationMessage(TypedDict):
+    """Client notification message."""
+    type: Literal["client_notification"]
+    data: ClientNotificationData
 
 
 class EpisodeControlData(TypedDict):
@@ -358,7 +358,7 @@ class StateData(TypedDict, total=False):
     steps: int
     reward: float
     teleop_action: ActionData  # Current action/velocity commands
-    trainer_connected: bool
+    connected_clients: List[str]  # List of connected client IDs
 
     # UR5-specific fields
     control_mode: ControlMode
@@ -371,22 +371,21 @@ class StateMessage(TypedDict):
     data: StateData
 
 
-class TrainerStatusData(TypedDict):
-    """Trainer connection status data."""
-    connected: bool
-    trainer_id: Optional[str]
+class ConnectedClientsData(TypedDict):
+    """Connected clients status data."""
+    clients: List[str]  # List of connected client IDs
 
 
-class TrainerStatusMessage(TypedDict):
-    """Trainer status broadcast message (to UI clients)."""
-    type: Literal["trainer_status"]
-    data: TrainerStatusData
+class ConnectedClientsMessage(TypedDict):
+    """Connected clients broadcast message (to all clients)."""
+    type: Literal["connected_clients"]
+    data: ConnectedClientsData
 
 
-class TrainerNotificationBroadcast(TypedDict):
-    """Trainer notification broadcast (to UI clients)."""
-    type: Literal["trainer_notification"]
-    data: TrainerNotificationData
+class ClientNotificationBroadcast(TypedDict):
+    """Client notification broadcast (to all clients)."""
+    type: Literal["client_notification"]
+    data: ClientNotificationData
 
 
 # ============================================================================
@@ -444,13 +443,13 @@ ClientMessage = Union[
     ControlModeMessage,
     GripperMessage,
     SetNovaModeMessage,
-    TrainerIdentityMessage,
-    TrainerNotificationMessage,
+    ClientIdentityMessage,
+    ClientNotificationMessage,
     EpisodeControlMessage,
 ]
 
 ServerMessage = Union[
     StateMessage,
-    TrainerStatusMessage,
-    TrainerNotificationBroadcast,
+    ConnectedClientsMessage,
+    ClientNotificationBroadcast,
 ]

templates/index.html

@@ -1,41 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Nova Sim - Wandelbots Robot Simulator</title>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <script type="module" crossorigin src="/nova-sim/assets/index-CwMJ-B8R.js"></script>
-    <link rel="stylesheet" crossorigin href="/nova-sim/assets/index-DoqnwcEU.css">
-</head>
-<body>
-    <!-- Video viewport -->
-    <div class="video-container" id="viewport">
-        <img src="/nova-sim/api/v1/video_feed" draggable="false" alt="Robot simulation video feed">
-    </div>
-
-    <!-- Main control overlay -->
-    <div class="overlay" id="main_overlay">
-        <!-- Content will be generated by JavaScript -->
-    </div>
-
-    <!-- State panel -->
-    <div class="state-panel" id="state_panel">
-        <!-- Content will be generated by JavaScript -->
-    </div>
-
-    <!-- Camera panel -->
-    <div class="camera-panel" id="camera_panel">
-        <!-- Content will be generated by JavaScript -->
-    </div>
-
-    <!-- Overlay tiles for auxiliary camera feeds -->
-    <div class="overlay-tiles" id="overlay_tiles">
-        <!-- Generated dynamically -->
-    </div>
-
-    <!-- Notification area -->
-    <div class="rl-notifications" id="rl_notifications">
-        <!-- Toast notifications appear here -->
-    </div>
-</body>
-</html>

test_home.py

@@ -1,97 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test the home function by sending continuous home commands.
-Simulates the UI button press behavior.
-"""
-
-import time
-import json
-from websocket import create_connection
-import threading
-
-WS_URL = "ws://localhost:3004/nova-sim/api/v1/ws"
-
-print("=" * 80)
-print("HOME FUNCTION TEST")
-print("=" * 80)
-
-# Connect to WebSocket
-print("\n1. Connecting to WebSocket...")
-ws = create_connection(WS_URL)
-print("   ✓ Connected")
-
-# Switch to UR5
-print("\n2. Switching to UR5...")
-ws.send(json.dumps({"type": "switch_robot", "data": {"robot": "ur5", "scene": None}}))
-time.sleep(2)
-print("   ✓ Switched to UR5")
-
-# Jog some joints away from home position
-print("\n3. Moving joints away from home...")
-for joint, direction, duration in [(1, "+", 2), (3, "-", 2), (6, "+", 3)]:
-    ws.send(json.dumps({
-        "type": "start_jog",
-        "data": {"jog_type": "joint", "params": {"joint": joint, "direction": direction, "velocity": 0.4}}
-    }))
-    time.sleep(duration)
-    ws.send(json.dumps({"type": "stop_jog"}))
-    time.sleep(0.5)
-print("   ✓ Joints moved away from home")
-
-# Send continuous home messages (simulating button press)
-print("\n4. Starting HOME sequence (sending messages every 100ms)...")
-print("   Press Ctrl+C to stop or wait 60 seconds")
-print("=" * 80)
-print("\n📺 WATCH SERVER CONSOLE FOR:")
-print("   🏠 Starting homing sequence for X joints")
-print("   → Homing joint X...")
-print("   J1: err=..., dir=..., vel=...")
-print("   ✓ Joint X reached target")
-print("   ✓ Homing sequence complete!")
-print("")
-
-stop_homing = False
-message_count = 0
-
-def send_home_messages():
-    """Send home messages every 100ms while running"""
-    global message_count
-    while not stop_homing:
-        ws.send(json.dumps({"type": "home"}))
-        message_count += 1
-        time.sleep(0.1)
-
-# Start sending home messages in background
-home_thread = threading.Thread(target=send_home_messages, daemon=True)
-home_thread.start()
-
-try:
-    # Wait for homing to complete (up to 60 seconds)
-    for i in range(12):
-        time.sleep(5)
-        print(f"   {(i+1)*5}s - sent {message_count} home messages")
-
-    print("\n   Timeout reached (60 seconds)")
-
-except KeyboardInterrupt:
-    print("\n\n   Interrupted by user")
-
-# Stop homing
-print("\n5. Stopping homing...")
-stop_homing = True
-time.sleep(0.2)
-ws.send(json.dumps({"type": "stop_home"}))
-print(f"   ✓ Sent stop_home message (total: {message_count} home messages)")
-
-# Close connection
-ws.close()
-
-print("\n" + "=" * 80)
-print("TEST COMPLETE")
-print("=" * 80)
-print("\nCheck the server console to verify:")
-print("  ✓ Sequential homing (one joint after another)")
-print("  ✓ Joints stopped when error <= 0.01 rad")
-print("  ✓ Overshoot detection and velocity halving (if applicable)")
-print("  ✓ 'Homing sequence complete!' was printed")
-print("=" * 80)

tests/test_api.py

@@ -80,10 +80,10 @@ class TestWebSocketMessages:
     def test_websocket_connection(self, check_server):
         """Test basic WebSocket connection."""
         with connect(WS_URL, timeout=10) as ws:
-            # Send trainer identity
+            # Send client identity (old trainer_identity still works for backward compat)
             ws.send(json.dumps({
-                "type": "trainer_identity",
-                "data": {"trainer_id": "test-trainer"}
+                "type": "client_identity",
+                "data": {"client_id": "test-client"}
             }))
 
             # Should receive state messages
@@ -359,7 +359,7 @@ class TestStateStructure:
             assert "steps" in state_data
             assert "reward" in state_data
             assert "teleop_action" in state_data
-            assert "trainer_connected" in state_data
+            assert "connected_clients" in state_data
             # Verify old fields are not in state root
             assert "target" not in state_data
             assert "target_orientation" not in state_data
@@ -389,7 +389,7 @@ class TestStateStructure:
             assert "steps" in state_data
             assert "reward" in state_data
             assert "teleop_action" in state_data
-            assert "trainer_connected" in state_data
+            assert "connected_clients" in state_data
             # Verify old fields are removed
             assert "base_height" not in state_data
             assert "upright" not in state_data