Update

Dockerfile

@@ -41,7 +41,8 @@ ENV PYTHONUNBUFFERED=1 \
     PYTHONDONTWRITEBYTECODE=1 \
     UV_SYSTEM_PYTHON=1 \
     UV_COMPILE_BYTECODE=1 \
-    UV_CACHE_DIR=/tmp/uv-cache
+    UV_CACHE_DIR=/tmp/uv-cache \
+    PORT=8000
 
 # Install system dependencies needed for video processing
 RUN apt-get update && apt-get install -y \
@@ -106,12 +107,12 @@ WORKDIR /app
 # Add virtual environment to PATH
 ENV PATH="/app/server/.venv/bin:$PATH"
 
-# Expose port 7860 (HuggingFace Spaces default)
-EXPOSE 7860
+# Expose the configured port (default 8000)
+EXPOSE ${PORT}
 
 # Health check
 HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
-    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:7860/health')" || exit 1
+    CMD python -c "import urllib.request; urllib.request.urlopen(f'http://localhost:${PORT}/health')" || exit 1
 
 # Start the FastAPI server (serves both frontend and backend)
-CMD ["sh", "-c", "cd server && SERVE_FRONTEND=true uv run python launch_with_ui.py --host 0.0.0.0 --port 7860"] 
+CMD ["sh", "-c", "cd server && SERVE_FRONTEND=true uv run python launch_with_ui.py --host localhost --port ${PORT}"] 

README.md

@@ -4,7 +4,7 @@ emoji: 🤖
 colorFrom: blue
 colorTo: purple
 sdk: docker
-app_port: 7860
+app_port: 8000
 suggested_hardware: cpu-upgrade
 suggested_storage: small
 short_description: Real-time robotics control and video streaming platform

client/COMPARE.md

@@ -0,0 +1,127 @@
+# Client Library API Comparison
+
+This table shows the correspondence between the Python and JavaScript/TypeScript client libraries for RobotHub TransportServer.
+
+## 📦 Installation
+
+| Python | JavaScript/TypeScript |
+|--------|----------------------|
+| `uv add transport-server-client` | `bun add @robothub/transport-server-client` |
+
+## 🔧 Imports
+
+| Python | JavaScript/TypeScript |
+|--------|----------------------|
+| `from transport_server_client import RoboticsProducer` | `import { robotics } from '@robothub/transport-server-client'` |
+| `from transport_server_client import RoboticsConsumer` | `const producer = new robotics.RoboticsProducer()` |
+| `from transport_server_client.video import VideoProducer` | `import { video } from '@robothub/transport-server-client'` |
+| `from transport_server_client.video import VideoConsumer` | `const producer = new video.VideoProducer()` |
+
+## 🤖 Robotics Producer
+
+| Operation | Python | JavaScript/TypeScript |
+|-----------|--------|----------------------|
+| **Create instance** | `producer = RoboticsProducer('http://localhost:8000')` | `const producer = new robotics.RoboticsProducer('http://localhost:8000')` |
+| **Connect to room** | `await producer.connect(workspace_id, room_id)` | `await producer.connect(workspaceId, roomId)` |
+| **Create room** | `room_info = await producer.create_room()` | `const { workspaceId, roomId } = await producer.createRoom()` |
+| **Send joint update** | `await producer.send_joint_update(joints)` | `await producer.sendJointUpdate(joints)` |
+| **Send state sync** | `await producer.send_state_sync(state)` | `await producer.sendStateSync(state)` |
+| **Emergency stop** | `await producer.send_emergency_stop(reason)` | `await producer.sendEmergencyStop(reason)` |
+| **List rooms** | `rooms = await producer.list_rooms(workspace_id)` | `const rooms = await producer.listRooms(workspaceId)` |
+| **Delete room** | `await producer.delete_room(workspace_id, room_id)` | `await producer.deleteRoom(workspaceId, roomId)` |
+| **Disconnect** | `await producer.disconnect()` | `await producer.disconnect()` |
+
+## 🤖 Robotics Consumer
+
+| Operation | Python | JavaScript/TypeScript |
+|-----------|--------|----------------------|
+| **Create instance** | `consumer = RoboticsConsumer('http://localhost:8000')` | `const consumer = new robotics.RoboticsConsumer('http://localhost:8000')` |
+| **Connect to room** | `await consumer.connect(workspace_id, room_id)` | `await consumer.connect(workspaceId, roomId)` |
+| **Get current state** | `state = await consumer.get_state_sync()` | `const state = await consumer.getStateSyncAsync()` |
+| **Joint update callback** | `consumer.on_joint_update(callback)` | `consumer.onJointUpdate(callback)` |
+| **State sync callback** | `consumer.on_state_sync(callback)` | `consumer.onStateSync(callback)` |
+| **Error callback** | `consumer.on_error(callback)` | `consumer.onError(callback)` |
+| **Connected callback** | `consumer.on_connected(callback)` | `consumer.onConnected(callback)` |
+| **Disconnected callback** | `consumer.on_disconnected(callback)` | `consumer.onDisconnected(callback)` |
+| **Disconnect** | `await consumer.disconnect()` | `await consumer.disconnect()` |
+
+## 📹 Video Producer
+
+| Operation | Python | JavaScript/TypeScript |
+|-----------|--------|----------------------|
+| **Create instance** | `producer = VideoProducer('http://localhost:8000')` | `const producer = new video.VideoProducer('http://localhost:8000')` |
+| **Connect to room** | `await producer.connect(workspace_id, room_id)` | `await producer.connect(workspaceId, roomId)` |
+| **Start camera** | `await producer.start_camera(config)` | `await producer.startCamera(constraints)` |
+| **Start screen share** | `await producer.start_screen_share()` | `await producer.startScreenShare()` |
+| **Stop streaming** | `await producer.stop_streaming()` | `await producer.stopStreaming()` |
+| **Update config** | `await producer.update_video_config(config)` | `await producer.updateVideoConfig(config)` |
+| **Disconnect** | `await producer.disconnect()` | `await producer.disconnect()` |
+
+## 📹 Video Consumer
+
+| Operation | Python | JavaScript/TypeScript |
+|-----------|--------|----------------------|
+| **Create instance** | `consumer = VideoConsumer('http://localhost:8000')` | `const consumer = new video.VideoConsumer('http://localhost:8000')` |
+| **Connect to room** | `await consumer.connect(workspace_id, room_id)` | `await consumer.connect(workspaceId, roomId)` |
+| **Start receiving** | `await consumer.start_receiving()` | `await consumer.startReceiving()` |
+| **Stop receiving** | `await consumer.stop_receiving()` | `await consumer.stopReceiving()` |
+| **Attach to video element** | N/A (Python) | `consumer.attachToVideoElement(videoElement)` |
+| **Frame callback** | `consumer.on_frame_update(callback)` | `consumer.onFrameUpdate(callback)` |
+| **Stream started callback** | `consumer.on_stream_started(callback)` | `consumer.onStreamStarted(callback)` |
+| **Stream stopped callback** | `consumer.on_stream_stopped(callback)` | `consumer.onStreamStopped(callback)` |
+| **Disconnect** | `await consumer.disconnect()` | `await consumer.disconnect()` |
+
+## ⚡ Factory Functions
+
+| Operation | Python | JavaScript/TypeScript |
+|-----------|--------|----------------------|
+| **Quick producer** | `producer = await create_producer_client(url)` | `const producer = await robotics.createProducerClient(url)` |
+| **Quick consumer** | `consumer = await create_consumer_client(room_id, url)` | `const consumer = await robotics.createConsumerClient(workspaceId, roomId, url)` |
+
+## 🔧 Context Managers / Lifecycle
+
+| Operation | Python | JavaScript/TypeScript |
+|-----------|--------|----------------------|
+| **Auto cleanup** | `async with RoboticsProducer(url) as producer:` | No built-in equivalent |
+| **Check connection** | `producer.is_connected()` | `producer.isConnected()` |
+| **Connection info** | `info = producer.get_connection_info()` | `const info = producer.getConnectionInfo()` |
+
+## 📝 Data Formats
+
+### Joint Data
+
+| Python | JavaScript/TypeScript |
+|--------|----------------------|
+| `{'name': 'shoulder', 'value': 45.0}` | `{ name: 'shoulder', value: 45.0 }` |
+| `[{'name': 'shoulder', 'value': 45.0}]` | `[{ name: 'shoulder', value: 45.0 }]` |
+
+### State Data
+
+| Python | JavaScript/TypeScript |
+|--------|----------------------|
+| `{'shoulder': 45.0, 'elbow': -30.0}` | `{ shoulder: 45.0, elbow: -30.0 }` |
+
+### Room Info Response
+
+| Python | JavaScript/TypeScript |
+|--------|----------------------|
+| `{'workspace_id': 'uuid', 'room_id': 'uuid'}` | `{ workspaceId: 'uuid', roomId: 'uuid' }` |
+
+## 🔄 Naming Conventions
+
+| Python (snake_case) | JavaScript/TypeScript (camelCase) |
+|---------------------|-----------------------------------|
+| `send_joint_update` | `sendJointUpdate` |
+| `send_state_sync` | `sendStateSync` |
+| `get_state_sync` | `getStateSyncAsync` |
+| `on_joint_update` | `onJointUpdate` |
+| `create_room` | `createRoom` |
+| `list_rooms` | `listRooms` |
+| `workspace_id` | `workspaceId` |
+| `room_id` | `roomId` |
+| `start_camera` | `startCamera` |
+| `stop_streaming` | `stopStreaming` |
+
+---
+
+**Both libraries provide the same functionality with language-appropriate conventions!** 🤖✨ 

client/js/tests/README.md

@@ -0,0 +1,228 @@
+# RobotHub TransportServer JavaScript Client Tests
+
+## Overview
+
+This directory contains comprehensive tests for the RobotHub TransportServer JavaScript/TypeScript client library, mirroring the Python test structure. The tests are built using [Bun's test framework](https://bun.sh/docs/test/writing) and provide full coverage of both robotics and video functionality.
+
+## Test Structure
+
+The test suite is organized to match the Python client tests:
+
+```
+tests/
+├── setup.ts              # Test utilities and helpers (equivalent to conftest.py)
+├── producer.test.ts       # RoboticsProducer tests
+├── consumer.test.ts       # RoboticsConsumer tests  
+├── factory.test.ts        # Factory function tests
+├── integration.test.ts    # Integration tests
+├── rest-api.test.ts       # REST API tests
+├── video-client.test.ts   # Video client tests
+└── README.md             # This file
+```
+
+## Running Tests
+
+### Prerequisites
+
+1. **Server Running**: Ensure the RobotHub TransportServer is running on `http://localhost:8000`
+2. **Dependencies**: Install dependencies with `bun install`
+
+### Run All Tests
+
+```bash
+# From the js client directory
+bun test
+
+# Or using npm script
+bun run test
+```
+
+### Run Specific Test Files
+
+```bash
+# Run only producer tests
+bun test tests/producer.test.ts
+
+# Run only integration tests  
+bun test tests/integration.test.ts
+
+# Run with verbose output
+bun test --verbose
+```
+
+## Test Categories
+
+### 1. Robotics Producer Tests (`producer.test.ts`)
+- ✅ Basic connection and disconnection
+- ✅ Connection info validation
+- ✅ Joint updates and state synchronization
+- ✅ Emergency stop functionality
+- ✅ Event callbacks (connected, disconnected, error)
+- ✅ Error handling for disconnected operations
+- ✅ Multiple room connections
+- ✅ Custom participant IDs
+- ✅ Large data handling
+- ✅ High-frequency updates
+
+### 2. Robotics Consumer Tests (`consumer.test.ts`)
+- ✅ Basic connection and disconnection
+- ✅ Connection info validation
+- ✅ State synchronization retrieval
+- ✅ Event callbacks setup
+- ✅ Multiple consumers in same room
+- ✅ Receiving state sync and joint updates
+- ✅ Emergency stop reception
+- ✅ Custom participant IDs
+- ✅ Reconnection scenarios
+- ✅ State persistence after producer updates
+
+### 3. Factory Function Tests (`factory.test.ts`)
+- ✅ Client creation by role
+- ✅ Invalid role handling
+- ✅ Auto room creation for producers
+- ✅ Specific room connection
+- ✅ Producer-consumer pair creation
+- ✅ Default URL handling
+- ✅ Multiple producer management
+- ✅ Nonexistent room error handling
+
+### 4. Integration Tests (`integration.test.ts`)
+- ✅ Full producer-consumer workflow
+- ✅ Multiple consumers receiving same data
+- ✅ Emergency stop propagation
+- ✅ Producer reconnection scenarios
+- ✅ Late-joining consumers
+- ✅ Room state persistence
+- ✅ High-frequency update handling
+
+### 5. REST API Tests (`rest-api.test.ts`)
+- ✅ Room listing (empty and populated)
+- ✅ Room creation (auto and custom IDs)
+- ✅ Room information retrieval
+- ✅ Room state retrieval
+- ✅ Room deletion
+- ✅ Error handling for nonexistent rooms
+
+### 6. Video Client Tests (`video-client.test.ts`)
+- ✅ Type definitions validation
+- ✅ Producer and consumer creation
+- ✅ Room creation and listing (when server available)
+- ✅ Connection validation
+- ✅ Factory function existence
+- ✅ Mock frame source functionality
+- ✅ Configuration type validation
+
+## Test Results Summary
+
+```
+✅ 69 tests passed
+❌ 0 tests failed
+🔍 187 expect() calls
+⏱️ Runtime: ~4 seconds
+```
+
+## API Correspondence
+
+The JavaScript tests mirror the Python test structure, ensuring API parity:
+
+| Python Test | JavaScript Test | Coverage |
+|-------------|-----------------|----------|
+| `test_producer.py` | `producer.test.ts` | ✅ Complete |
+| `test_consumer.py` | `consumer.test.ts` | ✅ Complete |
+| `test_factory_functions.py` | `factory.test.ts` | ✅ Complete |
+| `test_integration.py` | `integration.test.ts` | ✅ Complete |
+| `test_rest_api.py` | `rest-api.test.ts` | ✅ Complete |
+| `test_video_client.py` | `video-client.test.ts` | ✅ Complete |
+| `conftest.py` | `setup.ts` | ✅ Complete |
+
+## Test Features
+
+### Async/Await Support
+All tests use modern async/await patterns with proper cleanup:
+
+```typescript
+test("producer connection", async () => {
+    const { workspaceId, roomId } = await producer.createRoom();
+    await producer.connect(workspaceId, roomId);
+    expect(producer.isConnected()).toBe(true);
+    await producer.disconnect();
+});
+```
+
+### Message Collection
+Tests use a `MessageCollector` utility for testing callbacks:
+
+```typescript
+const updateCollector = new MessageCollector(1);
+consumer.onJointUpdate(updateCollector.collect);
+await producer.sendJointUpdate(joints);
+const updates = await updateCollector.waitForMessages(2000);
+expect(updates.length).toBeGreaterThanOrEqual(1);
+```
+
+### Resource Management
+Automatic cleanup prevents test interference:
+
+```typescript
+afterEach(async () => {
+    if (producer.isConnected()) {
+        await producer.disconnect();
+    }
+    await roomManager.cleanup(producer);
+});
+```
+
+### Error Testing
+Comprehensive error scenario coverage:
+
+```typescript
+test("send without connection", async () => {
+    await expect(producer.sendJointUpdate([]))
+        .rejects.toThrow("Must be connected");
+});
+```
+
+## Debugging Tests
+
+### Enable Debug Logging
+```bash
+# Run with debug output
+DEBUG=* bun test
+
+# Or specific modules
+DEBUG=robotics:* bun test
+```
+
+### Test Individual Scenarios
+```bash
+# Test specific functionality
+bun test --grep "emergency stop"
+bun test --grep "multiple consumers"
+```
+
+### Server Connectivity Issues
+If tests fail due to server connectivity:
+
+1. Ensure server is running: `curl http://localhost:8000/health`
+2. Check server logs for errors
+3. Verify WebSocket connections are allowed
+4. Try running tests with longer timeouts
+
+## Contributing
+
+When adding new tests:
+
+1. Follow the existing naming conventions
+2. Add proper cleanup in `afterEach` blocks
+3. Use `MessageCollector` for callback testing
+4. Test both success and error scenarios
+5. Update this README with new test descriptions
+
+## Performance Notes
+
+- Tests run in parallel by default
+- Average test suite runtime: ~4 seconds
+- Individual test timeouts: 10 seconds
+- Message collection timeouts: 2-5 seconds
+
+The JavaScript test suite provides comprehensive validation that the TypeScript/JavaScript client maintains full API compatibility with the Python client while leveraging modern JavaScript testing practices. 

client/js/tests/consumer.test.ts

@@ -0,0 +1,316 @@
+/**
+ * Tests for RoboticsConsumer - equivalent to Python's test_consumer.py
+ */
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { robotics } from "../src/index";
+import { TEST_SERVER_URL, TestRoomManager, MessageCollector, sleep, assertIsConnected, assertIsDisconnected } from "./setup";
+
+const { RoboticsProducer, RoboticsConsumer } = robotics;
+
+describe("RoboticsConsumer", () => {
+    let consumer: robotics.RoboticsConsumer;
+    let producer: robotics.RoboticsProducer;
+    let roomManager: TestRoomManager;
+
+    beforeEach(() => {
+        consumer = new RoboticsConsumer(TEST_SERVER_URL);
+        producer = new RoboticsProducer(TEST_SERVER_URL);
+        roomManager = new TestRoomManager();
+    });
+
+    afterEach(async () => {
+        if (consumer.isConnected()) {
+            await consumer.disconnect();
+        }
+        if (producer.isConnected()) {
+            await producer.disconnect();
+        }
+        await roomManager.cleanup(producer);
+    });
+
+    test("consumer connection", async () => {
+        // Create room first
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        expect(consumer.isConnected()).toBe(false);
+
+        const success = await consumer.connect(workspaceId, roomId);
+        expect(success).toBe(true);
+        assertIsConnected(consumer, workspaceId, roomId);
+
+        const info = consumer.getConnectionInfo();
+        expect(info.role).toBe("consumer");
+
+        await consumer.disconnect();
+        assertIsDisconnected(consumer);
+    });
+
+    test("consumer connection info", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+        await consumer.connect(workspaceId, roomId);
+
+        const info = consumer.getConnectionInfo();
+        expect(info.connected).toBe(true);
+        expect(info.room_id).toBe(roomId);
+        expect(info.workspace_id).toBe(workspaceId);
+        expect(info.role).toBe("consumer");
+        expect(info.participant_id).toBeTruthy();
+        expect(info.base_url).toBe(TEST_SERVER_URL);
+    });
+
+    test("get state sync", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+        await consumer.connect(workspaceId, roomId);
+
+        const state = await consumer.getStateSyncAsync();
+        expect(typeof state).toBe("object");
+        // Initial state should be empty
+        expect(Object.keys(state)).toHaveLength(0);
+    });
+
+    test("consumer callbacks setup", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        let stateSyncCalled = false;
+        let jointUpdateCalled = false;
+        let errorCalled = false;
+        let connectedCalled = false;
+        let disconnectedCalled = false;
+
+        consumer.onStateSync((state) => {
+            stateSyncCalled = true;
+        });
+
+        consumer.onJointUpdate((joints) => {
+            jointUpdateCalled = true;
+        });
+
+        consumer.onError((error) => {
+            errorCalled = true;
+        });
+
+        consumer.onConnected(() => {
+            connectedCalled = true;
+        });
+
+        consumer.onDisconnected(() => {
+            disconnectedCalled = true;
+        });
+
+        // Connect and test connection callbacks
+        await consumer.connect(workspaceId, roomId);
+        await sleep(100);
+        expect(connectedCalled).toBe(true);
+
+        await consumer.disconnect();
+        await sleep(100);
+        expect(disconnectedCalled).toBe(true);
+    });
+
+    test("multiple consumers", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        const consumer1 = new RoboticsConsumer(TEST_SERVER_URL);
+        const consumer2 = new RoboticsConsumer(TEST_SERVER_URL);
+
+        try {
+            // Both consumers should be able to connect
+            const success1 = await consumer1.connect(workspaceId, roomId);
+            const success2 = await consumer2.connect(workspaceId, roomId);
+
+            expect(success1).toBe(true);
+            expect(success2).toBe(true);
+            expect(consumer1.isConnected()).toBe(true);
+            expect(consumer2.isConnected()).toBe(true);
+        } finally {
+            if (consumer1.isConnected()) {
+                await consumer1.disconnect();
+            }
+            if (consumer2.isConnected()) {
+                await consumer2.disconnect();
+            }
+        }
+    });
+
+    test("consumer receive state sync", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        const updateCollector = new MessageCollector(1);
+        consumer.onJointUpdate(updateCollector.collect);
+
+        await producer.connect(workspaceId, roomId);
+        await consumer.connect(workspaceId, roomId);
+
+        // Give some time for connection to stabilize
+        await sleep(100);
+
+        // Producer sends state sync (which gets converted to joint updates)
+        await producer.sendStateSync({ shoulder: 45.0, elbow: -20.0 });
+
+        // Wait for message to be received
+        const receivedUpdates = await updateCollector.waitForMessages(2000);
+
+        // Consumer should have received the joint updates from the state sync
+        expect(receivedUpdates.length).toBeGreaterThanOrEqual(1);
+    });
+
+    test("consumer receive joint updates", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        const updateCollector = new MessageCollector(1);
+        consumer.onJointUpdate(updateCollector.collect);
+
+        await producer.connect(workspaceId, roomId);
+        await consumer.connect(workspaceId, roomId);
+
+        // Give some time for connection to stabilize
+        await sleep(100);
+
+        // Producer sends joint updates
+        const testJoints = [
+            { name: "shoulder", value: 45.0 },
+            { name: "elbow", value: -20.0 }
+        ];
+        await producer.sendJointUpdate(testJoints);
+
+        // Wait for message to be received
+        const receivedUpdates = await updateCollector.waitForMessages(2000);
+
+        // Consumer should have received the joint update
+        expect(receivedUpdates.length).toBeGreaterThanOrEqual(1);
+        if (receivedUpdates.length > 0) {
+            const receivedJoints = receivedUpdates[receivedUpdates.length - 1];
+            expect(Array.isArray(receivedJoints)).toBe(true);
+            expect(receivedJoints).toHaveLength(2);
+        }
+    });
+
+    test("consumer multiple updates", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        const updateCollector = new MessageCollector(3);
+        consumer.onJointUpdate(updateCollector.collect);
+
+        await producer.connect(workspaceId, roomId);
+        await consumer.connect(workspaceId, roomId);
+
+        // Give some time for connection to stabilize
+        await sleep(100);
+
+        // Send multiple updates
+        for (let i = 0; i < 5; i++) {
+            await producer.sendStateSync({
+                joint1: i * 10,
+                joint2: i * -5
+            });
+            await sleep(50);
+        }
+
+        // Wait for all messages to be received
+        const receivedUpdates = await updateCollector.waitForMessages(3000);
+
+        // Should have received multiple updates
+        expect(receivedUpdates.length).toBeGreaterThanOrEqual(3);
+    });
+
+    test("consumer emergency stop", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        const errorCollector = new MessageCollector<string>(1);
+        consumer.onError(errorCollector.collect);
+
+        await producer.connect(workspaceId, roomId);
+        await consumer.connect(workspaceId, roomId);
+
+        // Give some time for connection to stabilize
+        await sleep(100);
+
+        // Producer sends emergency stop
+        await producer.sendEmergencyStop("Test emergency stop");
+
+        // Wait for message to be received
+        const receivedErrors = await errorCollector.waitForMessages(2000);
+
+        // Consumer should have received emergency stop as error
+        expect(receivedErrors.length).toBeGreaterThanOrEqual(1);
+        if (receivedErrors.length > 0) {
+            expect(receivedErrors[receivedErrors.length - 1].toLowerCase()).toContain("emergency stop");
+        }
+    });
+
+    test("custom participant id", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+        const customId = "custom-consumer-456";
+
+        await consumer.connect(workspaceId, roomId, customId);
+
+        const info = consumer.getConnectionInfo();
+        expect(info.participant_id).toBe(customId);
+    });
+
+    test("get state without connection", async () => {
+        expect(consumer.isConnected()).toBe(false);
+
+        await expect(consumer.getStateSyncAsync())
+            .rejects.toThrow("Must be connected");
+    });
+
+    test("consumer reconnection", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        // First connection
+        await consumer.connect(workspaceId, roomId);
+        expect(consumer.isConnected()).toBe(true);
+
+        await consumer.disconnect();
+        expect(consumer.isConnected()).toBe(false);
+
+        // Reconnect to same room
+        await consumer.connect(workspaceId, roomId);
+        expect(consumer.isConnected()).toBe(true);
+        expect(consumer.getConnectionInfo().room_id).toBe(roomId);
+        expect(consumer.getConnectionInfo().workspace_id).toBe(workspaceId);
+    });
+
+    test("consumer state after producer updates", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        await producer.connect(workspaceId, roomId);
+        await consumer.connect(workspaceId, roomId);
+
+        // Give some time for connection to stabilize
+        await sleep(100);
+
+        // Producer sends some state updates
+        await producer.sendStateSync({
+            shoulder: 45.0,
+            elbow: -20.0,
+            wrist: 10.0
+        });
+
+        // Wait for state to propagate
+        await sleep(200);
+
+        // Consumer should be able to get updated state
+        const state = await consumer.getStateSyncAsync();
+        expect(typeof state).toBe("object");
+
+        // State should contain the joints we sent
+        const expectedJoints = new Set(["shoulder", "elbow", "wrist"]);
+        if (Object.keys(state).length > 0) { // Only check if state is not empty
+            expect(new Set(Object.keys(state))).toEqual(expectedJoints);
+        }
+    });
+}); 

client/js/tests/factory.test.ts

@@ -0,0 +1,218 @@
+/**
+ * Tests for Factory Functions - equivalent to Python's test_factory_functions.py
+ */
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { robotics } from "../src/index";
+import { TEST_SERVER_URL, TestRoomManager, MessageCollector, sleep } from "./setup";
+
+const { RoboticsProducer, RoboticsConsumer, createClient, createProducerClient, createConsumerClient } = robotics;
+
+describe("Factory Functions", () => {
+    let roomManager: TestRoomManager;
+
+    beforeEach(() => {
+        roomManager = new TestRoomManager();
+    });
+
+    afterEach(async () => {
+        // Cleanup will be handled by individual tests
+    });
+
+    test("create client producer", () => {
+        const client = createClient("producer");
+        expect(client).toBeInstanceOf(RoboticsProducer);
+        expect(client.isConnected()).toBe(false);
+        expect(client.getConnectionInfo().base_url).toBe("http://localhost:8000");
+    });
+
+    test("create client consumer", () => {
+        const client = createClient("consumer");
+        expect(client).toBeInstanceOf(RoboticsConsumer);
+        expect(client.isConnected()).toBe(false);
+        expect(client.getConnectionInfo().base_url).toBe("http://localhost:8000");
+    });
+
+    test("create client invalid role", () => {
+        expect(() => createClient("invalid_role" as any)).toThrow("Invalid role");
+    });
+
+    test("create client default url", () => {
+        const client = createClient("producer");
+        expect(client.getConnectionInfo().base_url).toBe("http://localhost:8000");
+    });
+
+    test("create producer client auto room", async () => {
+        const producer = await createProducerClient(TEST_SERVER_URL);
+        
+        try {
+            expect(producer).toBeInstanceOf(RoboticsProducer);
+            expect(producer.isConnected()).toBe(true);
+            const info = producer.getConnectionInfo();
+            expect(info.room_id).toBeTruthy();
+            expect(info.workspace_id).toBeTruthy();
+            expect(info.role).toBe("producer");
+
+            // Should be able to send commands immediately
+            await producer.sendStateSync({ test: 123.0 });
+
+            // Track for cleanup
+            roomManager.addRoom(info.workspace_id!, info.room_id!);
+        } finally {
+            await producer.disconnect();
+            await roomManager.cleanup(producer);
+        }
+    });
+
+    test("create producer client specific room", async () => {
+        // First create a room
+        const tempProducer = new RoboticsProducer(TEST_SERVER_URL);
+        const { workspaceId, roomId } = await tempProducer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        try {
+            const producer = await createProducerClient(TEST_SERVER_URL, workspaceId, roomId);
+
+            expect(producer).toBeInstanceOf(RoboticsProducer);
+            expect(producer.isConnected()).toBe(true);
+            const info = producer.getConnectionInfo();
+            expect(info.room_id).toBe(roomId);
+            expect(info.workspace_id).toBe(workspaceId);
+            expect(info.role).toBe("producer");
+
+            await producer.disconnect();
+        } finally {
+            await roomManager.cleanup(tempProducer);
+        }
+    });
+
+    test("create consumer client", async () => {
+        // First create a room
+        const tempProducer = new RoboticsProducer(TEST_SERVER_URL);
+        const { workspaceId, roomId } = await tempProducer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        try {
+            const consumer = await createConsumerClient(workspaceId, roomId, TEST_SERVER_URL);
+
+            expect(consumer).toBeInstanceOf(RoboticsConsumer);
+            expect(consumer.isConnected()).toBe(true);
+            const info = consumer.getConnectionInfo();
+            expect(info.room_id).toBe(roomId);
+            expect(info.workspace_id).toBe(workspaceId);
+            expect(info.role).toBe("consumer");
+
+            // Should be able to get state immediately
+            const state = await consumer.getStateSyncAsync();
+            expect(typeof state).toBe("object");
+
+            await consumer.disconnect();
+        } finally {
+            await roomManager.cleanup(tempProducer);
+        }
+    });
+
+    test("create producer consumer pair", async () => {
+        const producer = await createProducerClient(TEST_SERVER_URL);
+        const producerInfo = producer.getConnectionInfo();
+        const workspaceId = producerInfo.workspace_id!;
+        const roomId = producerInfo.room_id!;
+        roomManager.addRoom(workspaceId, roomId);
+
+        try {
+            const consumer = await createConsumerClient(workspaceId, roomId, TEST_SERVER_URL);
+
+            // Both should be connected to same room
+            const consumerInfo = consumer.getConnectionInfo();
+            expect(producerInfo.room_id).toBe(consumerInfo.room_id);
+            expect(producerInfo.workspace_id).toBe(consumerInfo.workspace_id);
+            expect(producer.isConnected()).toBe(true);
+            expect(consumer.isConnected()).toBe(true);
+
+            // Test communication
+            const updateCollector = new MessageCollector(1);
+            consumer.onJointUpdate(updateCollector.collect);
+
+            // Give some time for connection to stabilize
+            await sleep(100);
+
+            // Send update from producer
+            await producer.sendStateSync({ test_joint: 42.0 });
+
+            // Wait for message
+            const receivedUpdates = await updateCollector.waitForMessages(2000);
+
+            // Consumer should have received update
+            expect(receivedUpdates.length).toBeGreaterThanOrEqual(1);
+
+            await consumer.disconnect();
+        } finally {
+            await producer.disconnect();
+            await roomManager.cleanup(producer);
+        }
+    });
+
+    test("convenience functions with default url", async () => {
+        const producer = await createProducerClient();
+        const producerInfo = producer.getConnectionInfo();
+        const workspaceId = producerInfo.workspace_id!;
+        const roomId = producerInfo.room_id!;
+        roomManager.addRoom(workspaceId, roomId);
+
+        try {
+            expect(producerInfo.base_url).toBe("http://localhost:8000");
+            expect(producer.isConnected()).toBe(true);
+
+            const consumer = await createConsumerClient(workspaceId, roomId);
+
+            try {
+                const consumerInfo = consumer.getConnectionInfo();
+                expect(consumerInfo.base_url).toBe("http://localhost:8000");
+                expect(consumer.isConnected()).toBe(true);
+            } finally {
+                await consumer.disconnect();
+            }
+        } finally {
+            await producer.disconnect();
+            await roomManager.cleanup(producer);
+        }
+    });
+
+    test("multiple convenience producers", async () => {
+        const producer1 = await createProducerClient(TEST_SERVER_URL);
+        const producer2 = await createProducerClient(TEST_SERVER_URL);
+
+        try {
+            const info1 = producer1.getConnectionInfo();
+            const info2 = producer2.getConnectionInfo();
+
+            // Both should be connected to different rooms
+            expect(info1.room_id).not.toBe(info2.room_id);
+            expect(producer1.isConnected()).toBe(true);
+            expect(producer2.isConnected()).toBe(true);
+
+            // Track for cleanup
+            roomManager.addRoom(info1.workspace_id!, info1.room_id!);
+            roomManager.addRoom(info2.workspace_id!, info2.room_id!);
+
+            // Both should work independently
+            await producer1.sendStateSync({ joint1: 10.0 });
+            await producer2.sendStateSync({ joint2: 20.0 });
+        } finally {
+            await producer1.disconnect();
+            await producer2.disconnect();
+            await roomManager.cleanup(producer1);
+        }
+    });
+
+    test("create consumer nonexistent room", async () => {
+        const fakeWorkspaceId = "00000000-0000-0000-0000-000000000000";
+        const fakeRoomId = "00000000-0000-0000-0000-000000000000";
+
+        const consumer = new RoboticsConsumer(TEST_SERVER_URL);
+        const success = await consumer.connect(fakeWorkspaceId, fakeRoomId);
+
+        // Should fail to connect to non-existent room
+        expect(success).toBe(false);
+        expect(consumer.isConnected()).toBe(false);
+    });
+}); 

client/js/tests/integration.test.ts

@@ -0,0 +1,353 @@
+/**
+ * Integration tests for producer-consumer interactions - equivalent to Python's test_integration.py
+ */
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { robotics } from "../src/index";
+import { TEST_SERVER_URL, TestRoomManager, MessageCollector, sleep } from "./setup";
+
+const { RoboticsProducer, createConsumerClient, createProducerClient } = robotics;
+
+describe("Integration", () => {
+    let roomManager: TestRoomManager;
+
+    beforeEach(() => {
+        roomManager = new TestRoomManager();
+    });
+
+    afterEach(async () => {
+        // Cleanup handled by individual tests
+    });
+
+    test("full producer consumer workflow", async () => {
+        // Create producer and room
+        const producer = await createProducerClient(TEST_SERVER_URL);
+        const producerInfo = producer.getConnectionInfo();
+        const workspaceId = producerInfo.workspace_id!;
+        const roomId = producerInfo.room_id!;
+        roomManager.addRoom(workspaceId, roomId);
+
+        try {
+            // Create consumer and connect to same room
+            const consumer = await createConsumerClient(workspaceId, roomId, TEST_SERVER_URL);
+
+            try {
+                // Set up consumer to collect messages
+                const stateCollector = new MessageCollector<Record<string, number>>(1);
+                const updateCollector = new MessageCollector(4);
+                const errorCollector = new MessageCollector<string>(1);
+
+                consumer.onStateSync(stateCollector.collect);
+                consumer.onJointUpdate(updateCollector.collect);
+                consumer.onError(errorCollector.collect);
+
+                // Wait for connections to stabilize
+                await sleep(200);
+
+                // Producer sends initial state
+                const initialState = { shoulder: 0.0, elbow: 0.0, wrist: 0.0 };
+                await producer.sendStateSync(initialState);
+                await sleep(100);
+
+                // Producer sends series of joint updates
+                const jointSequences = [
+                    [{ name: "shoulder", value: 45.0 }],
+                    [{ name: "elbow", value: -30.0 }],
+                    [{ name: "wrist", value: 15.0 }],
+                    [
+                        { name: "shoulder", value: 90.0 },
+                        { name: "elbow", value: -60.0 }
+                    ]
+                ];
+
+                for (const joints of jointSequences) {
+                    await producer.sendJointUpdate(joints);
+                    await sleep(100);
+                }
+
+                // Wait for all messages to be received
+                const receivedUpdates = await updateCollector.waitForMessages(3000);
+
+                // Verify consumer received messages
+                expect(receivedUpdates.length).toBeGreaterThanOrEqual(4);
+
+                // Verify final state
+                const finalState = await consumer.getStateSyncAsync();
+                const expectedFinalState = { shoulder: 90.0, elbow: -60.0, wrist: 15.0 };
+                expect(finalState).toEqual(expectedFinalState);
+
+            } finally {
+                await consumer.disconnect();
+            }
+        } finally {
+            await producer.disconnect();
+            await roomManager.cleanup(producer);
+        }
+    });
+
+    test("multiple consumers same room", async () => {
+        const producer = await createProducerClient(TEST_SERVER_URL);
+        const producerInfo = producer.getConnectionInfo();
+        const workspaceId = producerInfo.workspace_id!;
+        const roomId = producerInfo.room_id!;
+        roomManager.addRoom(workspaceId, roomId);
+
+        try {
+            // Create multiple consumers
+            const consumer1 = await createConsumerClient(workspaceId, roomId, TEST_SERVER_URL);
+            const consumer2 = await createConsumerClient(workspaceId, roomId, TEST_SERVER_URL);
+
+            try {
+                // Set up message collection for both consumers
+                const consumer1Collector = new MessageCollector(1);
+                const consumer2Collector = new MessageCollector(1);
+
+                consumer1.onJointUpdate(consumer1Collector.collect);
+                consumer2.onJointUpdate(consumer2Collector.collect);
+
+                // Wait for connections
+                await sleep(200);
+
+                // Producer sends updates
+                const testJoints = [
+                    { name: "joint1", value: 10.0 },
+                    { name: "joint2", value: 20.0 }
+                ];
+                await producer.sendJointUpdate(testJoints);
+
+                // Wait for message propagation
+                const consumer1Updates = await consumer1Collector.waitForMessages(2000);
+                const consumer2Updates = await consumer2Collector.waitForMessages(2000);
+
+                // Both consumers should receive the same update
+                expect(consumer1Updates.length).toBeGreaterThanOrEqual(1);
+                expect(consumer2Updates.length).toBeGreaterThanOrEqual(1);
+
+                // Verify both received same data
+                if (consumer1Updates.length > 0 && consumer2Updates.length > 0) {
+                    expect(consumer1Updates[consumer1Updates.length - 1]).toEqual(
+                        consumer2Updates[consumer2Updates.length - 1]
+                    );
+                }
+
+            } finally {
+                await consumer1.disconnect();
+                await consumer2.disconnect();
+            }
+        } finally {
+            await producer.disconnect();
+            await roomManager.cleanup(producer);
+        }
+    });
+
+    test("emergency stop propagation", async () => {
+        const producer = await createProducerClient(TEST_SERVER_URL);
+        const producerInfo = producer.getConnectionInfo();
+        const workspaceId = producerInfo.workspace_id!;
+        const roomId = producerInfo.room_id!;
+        roomManager.addRoom(workspaceId, roomId);
+
+        try {
+            // Create consumers
+            const consumer1 = await createConsumerClient(workspaceId, roomId, TEST_SERVER_URL);
+            const consumer2 = await createConsumerClient(workspaceId, roomId, TEST_SERVER_URL);
+
+            try {
+                // Set up error collection
+                const consumer1ErrorCollector = new MessageCollector<string>(1);
+                const consumer2ErrorCollector = new MessageCollector<string>(1);
+
+                consumer1.onError(consumer1ErrorCollector.collect);
+                consumer2.onError(consumer2ErrorCollector.collect);
+
+                // Wait for connections
+                await sleep(200);
+
+                // Producer sends emergency stop
+                await producer.sendEmergencyStop("Integration test emergency stop");
+
+                // Wait for message propagation
+                const consumer1Errors = await consumer1ErrorCollector.waitForMessages(2000);
+                const consumer2Errors = await consumer2ErrorCollector.waitForMessages(2000);
+
+                // Both consumers should receive emergency stop
+                expect(consumer1Errors.length).toBeGreaterThanOrEqual(1);
+                expect(consumer2Errors.length).toBeGreaterThanOrEqual(1);
+
+                // Verify error messages contain emergency stop info
+                if (consumer1Errors.length > 0) {
+                    expect(consumer1Errors[consumer1Errors.length - 1].toLowerCase()).toContain("emergency stop");
+                }
+                if (consumer2Errors.length > 0) {
+                    expect(consumer2Errors[consumer2Errors.length - 1].toLowerCase()).toContain("emergency stop");
+                }
+
+            } finally {
+                await consumer1.disconnect();
+                await consumer2.disconnect();
+            }
+        } finally {
+            await producer.disconnect();
+            await roomManager.cleanup(producer);
+        }
+    });
+
+    test("producer reconnection workflow", async () => {
+        // Create room first
+        const tempProducer = new RoboticsProducer(TEST_SERVER_URL);
+        const { workspaceId, roomId } = await tempProducer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        try {
+            // Create consumer first
+            const consumer = await createConsumerClient(workspaceId, roomId, TEST_SERVER_URL);
+
+            try {
+                const updateCollector = new MessageCollector(2);
+                consumer.onJointUpdate(updateCollector.collect);
+
+                // Create producer and connect
+                const producer = new RoboticsProducer(TEST_SERVER_URL);
+                await producer.connect(workspaceId, roomId);
+
+                // Send initial update
+                await producer.sendStateSync({ joint1: 10.0 });
+                await sleep(100);
+
+                // Disconnect producer
+                await producer.disconnect();
+
+                // Reconnect producer
+                await producer.connect(workspaceId, roomId);
+
+                // Send another update
+                await producer.sendStateSync({ joint1: 20.0 });
+                await sleep(200);
+
+                // Consumer should have received both updates
+                const receivedUpdates = await updateCollector.waitForMessages(3000);
+                expect(receivedUpdates.length).toBeGreaterThanOrEqual(2);
+
+                await producer.disconnect();
+
+            } finally {
+                await consumer.disconnect();
+            }
+        } finally {
+            await roomManager.cleanup(tempProducer);
+        }
+    });
+
+    test("consumer late join", async () => {
+        const producer = await createProducerClient(TEST_SERVER_URL);
+        const producerInfo = producer.getConnectionInfo();
+        const workspaceId = producerInfo.workspace_id!;
+        const roomId = producerInfo.room_id!;
+        roomManager.addRoom(workspaceId, roomId);
+
+        try {
+            // Producer sends some updates before consumer joins
+            await producer.sendStateSync({ joint1: 10.0, joint2: 20.0 });
+            await sleep(100);
+
+            await producer.sendJointUpdate([{ name: "joint3", value: 30.0 }]);
+            await sleep(100);
+
+            // Now consumer joins
+            const consumer = await createConsumerClient(workspaceId, roomId, TEST_SERVER_URL);
+
+            try {
+                // Consumer should be able to get current state
+                const currentState = await consumer.getStateSyncAsync();
+
+                // Should contain all previously sent updates
+                const expectedState = { joint1: 10.0, joint2: 20.0, joint3: 30.0 };
+                expect(currentState).toEqual(expectedState);
+
+            } finally {
+                await consumer.disconnect();
+            }
+        } finally {
+            await producer.disconnect();
+            await roomManager.cleanup(producer);
+        }
+    });
+
+    test("room cleanup on producer disconnect", async () => {
+        const producer = await createProducerClient(TEST_SERVER_URL);
+        const producerInfo = producer.getConnectionInfo();
+        const workspaceId = producerInfo.workspace_id!;
+        const roomId = producerInfo.room_id!;
+        roomManager.addRoom(workspaceId, roomId);
+
+        try {
+            const consumer = await createConsumerClient(workspaceId, roomId, TEST_SERVER_URL);
+
+            try {
+                // Send some state
+                await producer.sendStateSync({ joint1: 42.0 });
+                await sleep(100);
+
+                // Verify state exists
+                const stateBefore = await consumer.getStateSyncAsync();
+                expect(stateBefore).toEqual({ joint1: 42.0 });
+
+                // Producer disconnects
+                await producer.disconnect();
+                await sleep(100);
+
+                // State should still be accessible to consumer
+                const stateAfter = await consumer.getStateSyncAsync();
+                expect(stateAfter).toEqual({ joint1: 42.0 });
+
+            } finally {
+                await consumer.disconnect();
+            }
+        } finally {
+            // Room cleanup handled by roomManager since producer disconnected
+        }
+    });
+
+    test("high frequency updates", async () => {
+        const producer = await createProducerClient(TEST_SERVER_URL);
+        const producerInfo = producer.getConnectionInfo();
+        const workspaceId = producerInfo.workspace_id!;
+        const roomId = producerInfo.room_id!;
+        roomManager.addRoom(workspaceId, roomId);
+
+        try {
+            const consumer = await createConsumerClient(workspaceId, roomId, TEST_SERVER_URL);
+
+            try {
+                const updateCollector = new MessageCollector(5);
+                consumer.onJointUpdate(updateCollector.collect);
+
+                // Wait for connection
+                await sleep(100);
+
+                // Send rapid updates
+                for (let i = 0; i < 20; i++) {
+                    await producer.sendStateSync({ joint1: i, timestamp: i });
+                    await sleep(10); // 10ms intervals
+                }
+
+                // Wait for all messages
+                const receivedUpdates = await updateCollector.waitForMessages(5000);
+
+                // Should have received multiple updates
+                // (exact number may vary due to change detection)
+                expect(receivedUpdates.length).toBeGreaterThanOrEqual(5);
+
+                // Final state should reflect last update
+                const finalState = await consumer.getStateSyncAsync();
+                expect(finalState.joint1).toBe(19);
+                expect(finalState.timestamp).toBe(19);
+
+            } finally {
+                await consumer.disconnect();
+            }
+        } finally {
+            await producer.disconnect();
+            await roomManager.cleanup(producer);
+        }
+    });
+}); 

client/js/tests/producer.test.ts

@@ -0,0 +1,217 @@
+/**
+ * Tests for RoboticsProducer - equivalent to Python's test_producer.py
+ */
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { robotics } from "../src/index";
+import { TEST_SERVER_URL, TestRoomManager, MessageCollector, sleep, assertIsConnected, assertIsDisconnected } from "./setup";
+
+const { RoboticsProducer } = robotics;
+
+describe("RoboticsProducer", () => {
+    let producer: robotics.RoboticsProducer;
+    let roomManager: TestRoomManager;
+
+    beforeEach(() => {
+        producer = new RoboticsProducer(TEST_SERVER_URL);
+        roomManager = new TestRoomManager();
+    });
+
+    afterEach(async () => {
+        if (producer.isConnected()) {
+            await producer.disconnect();
+        }
+        await roomManager.cleanup(producer);
+    });
+
+    test("producer connection", async () => {
+        // Create room first
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        expect(producer.isConnected()).toBe(false);
+
+        const success = await producer.connect(workspaceId, roomId);
+        expect(success).toBe(true);
+        assertIsConnected(producer, workspaceId, roomId);
+
+        const info = producer.getConnectionInfo();
+        expect(info.role).toBe("producer");
+
+        await producer.disconnect();
+        assertIsDisconnected(producer);
+    });
+
+    test("producer connection info", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+        await producer.connect(workspaceId, roomId);
+
+        const info = producer.getConnectionInfo();
+        expect(info.connected).toBe(true);
+        expect(info.room_id).toBe(roomId);
+        expect(info.workspace_id).toBe(workspaceId);
+        expect(info.role).toBe("producer");
+        expect(info.participant_id).toBeTruthy();
+        expect(info.base_url).toBe(TEST_SERVER_URL);
+    });
+
+    test("send joint update", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+        await producer.connect(workspaceId, roomId);
+
+        const joints = [
+            { name: "shoulder", value: 45.0 },
+            { name: "elbow", value: -20.0 },
+            { name: "wrist", value: 10.0 }
+        ];
+
+        // Should not throw an exception
+        await producer.sendJointUpdate(joints);
+    });
+
+    test("send state sync", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+        await producer.connect(workspaceId, roomId);
+
+        const state = { shoulder: 45.0, elbow: -20.0, wrist: 10.0 };
+
+        // Should not throw an exception
+        await producer.sendStateSync(state);
+    });
+
+    test("send emergency stop", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+        await producer.connect(workspaceId, roomId);
+
+        // Should not throw an exception
+        await producer.sendEmergencyStop("Test emergency stop");
+        await producer.sendEmergencyStop(); // Default reason
+    });
+
+    test("producer callbacks", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        let connectedCalled = false;
+        let disconnectedCalled = false;
+        let errorCalled = false;
+        let errorMessage: string | null = null;
+
+        producer.onConnected(() => {
+            connectedCalled = true;
+        });
+
+        producer.onDisconnected(() => {
+            disconnectedCalled = true;
+        });
+
+        producer.onError((error) => {
+            errorCalled = true;
+            errorMessage = error;
+        });
+
+        // Connect and disconnect
+        await producer.connect(workspaceId, roomId);
+        await sleep(100); // Give callbacks time to execute
+        expect(connectedCalled).toBe(true);
+
+        await producer.disconnect();
+        await sleep(100); // Give callbacks time to execute
+        expect(disconnectedCalled).toBe(true);
+    });
+
+    test("send without connection", async () => {
+        expect(producer.isConnected()).toBe(false);
+
+        await expect(producer.sendJointUpdate([{ name: "test", value: 0 }]))
+            .rejects.toThrow("Must be connected");
+
+        await expect(producer.sendStateSync({ test: 0 }))
+            .rejects.toThrow("Must be connected");
+
+        await expect(producer.sendEmergencyStop())
+            .rejects.toThrow("Must be connected");
+    });
+
+    test("multiple connections", async () => {
+        // Connect to first room
+        const { workspaceId: workspaceId1, roomId: roomId1 } = await producer.createRoom();
+        roomManager.addRoom(workspaceId1, roomId1);
+        await producer.connect(workspaceId1, roomId1);
+        
+        expect(producer.getConnectionInfo().room_id).toBe(roomId1);
+        expect(producer.getConnectionInfo().workspace_id).toBe(workspaceId1);
+
+        // Create second room
+        const { workspaceId: workspaceId2, roomId: roomId2 } = await producer.createRoom();
+        roomManager.addRoom(workspaceId2, roomId2);
+
+        // Connect to second room (should disconnect from first)
+        await producer.connect(workspaceId2, roomId2);
+        expect(producer.getConnectionInfo().room_id).toBe(roomId2);
+        expect(producer.getConnectionInfo().workspace_id).toBe(workspaceId2);
+        expect(producer.isConnected()).toBe(true);
+    });
+
+    test("duplicate producer connection", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+        
+        const producer2 = new RoboticsProducer(TEST_SERVER_URL);
+
+        try {
+            // First producer connects successfully
+            const success1 = await producer.connect(workspaceId, roomId);
+            expect(success1).toBe(true);
+
+            // Second producer should fail to connect as producer
+            const success2 = await producer2.connect(workspaceId, roomId);
+            expect(success2).toBe(false); // Should fail since room already has producer
+        } finally {
+            if (producer2.isConnected()) {
+                await producer2.disconnect();
+            }
+        }
+    });
+
+    test("custom participant id", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+        const customId = "custom-producer-123";
+
+        await producer.connect(workspaceId, roomId, customId);
+
+        const info = producer.getConnectionInfo();
+        expect(info.participant_id).toBe(customId);
+    });
+
+    test("large joint update", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+        await producer.connect(workspaceId, roomId);
+
+        // Create a large joint update
+        const joints = Array.from({ length: 100 }, (_, i) => ({
+            name: `joint_${i}`,
+            value: i
+        }));
+
+        // Should handle large updates without issue
+        await producer.sendJointUpdate(joints);
+    });
+
+    test("rapid updates", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+        await producer.connect(workspaceId, roomId);
+
+        // Send multiple rapid updates
+        for (let i = 0; i < 10; i++) {
+            await producer.sendStateSync({ joint1: i, joint2: i * 2 });
+            await sleep(10); // Small delay
+        }
+    });
+}); 

client/js/tests/rest-api.test.ts

@@ -0,0 +1,156 @@
+/**
+ * Tests for REST API functionality - equivalent to Python's test_rest_api.py
+ */
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { robotics } from "../src/index";
+import { TEST_SERVER_URL, TestRoomManager } from "./setup";
+
+const { RoboticsProducer } = robotics;
+
+describe("REST API", () => {
+    let producer: robotics.RoboticsProducer;
+    let roomManager: TestRoomManager;
+
+    beforeEach(() => {
+        producer = new RoboticsProducer(TEST_SERVER_URL);
+        roomManager = new TestRoomManager();
+    });
+
+    afterEach(async () => {
+        if (producer.isConnected()) {
+            await producer.disconnect();
+        }
+        await roomManager.cleanup(producer);
+    });
+
+    test("list rooms empty", async () => {
+        // Use a temporary workspace ID
+        const workspaceId = `test-workspace-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const rooms = await producer.listRooms(workspaceId);
+        expect(Array.isArray(rooms)).toBe(true);
+    });
+
+    test("create room", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        expect(typeof workspaceId).toBe("string");
+        expect(typeof roomId).toBe("string");
+        expect(workspaceId.length).toBeGreaterThan(0);
+        expect(roomId.length).toBeGreaterThan(0);
+    });
+
+    test("create room with id", async () => {
+        const customRoomId = "test-room-123";
+        const customWorkspaceId = "test-workspace-456";
+        const { workspaceId, roomId } = await producer.createRoom(customWorkspaceId, customRoomId);
+        roomManager.addRoom(workspaceId, roomId);
+
+        expect(workspaceId).toBe(customWorkspaceId);
+        expect(roomId).toBe(customRoomId);
+    });
+
+    test("list rooms with rooms", async () => {
+        // Create a test room
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        const rooms = await producer.listRooms(workspaceId);
+        expect(Array.isArray(rooms)).toBe(true);
+        expect(rooms.length).toBeGreaterThanOrEqual(1);
+
+        // Check if our room is in the list
+        const roomIds = rooms.map(room => room.id);
+        expect(roomIds).toContain(roomId);
+
+        // Verify room structure
+        const testRoom = rooms.find(room => room.id === roomId);
+        expect(testRoom).toBeDefined();
+        expect(testRoom!).toHaveProperty("participants");
+        expect(testRoom!).toHaveProperty("joints_count");
+    });
+
+    test("get room info", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        const roomInfo = await producer.getRoomInfo(workspaceId, roomId);
+        expect(typeof roomInfo).toBe("object");
+        expect(roomInfo.id).toBe(roomId);
+        expect(roomInfo.workspace_id).toBe(workspaceId);
+        expect(roomInfo).toHaveProperty("participants");
+        expect(roomInfo).toHaveProperty("joints_count");
+        expect(roomInfo).toHaveProperty("has_producer");
+        expect(roomInfo).toHaveProperty("active_consumers");
+    });
+
+    test("get room state", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+        roomManager.addRoom(workspaceId, roomId);
+
+        const roomState = await producer.getRoomState(workspaceId, roomId);
+        expect(typeof roomState).toBe("object");
+        expect(roomState).toHaveProperty("room_id");
+        expect(roomState).toHaveProperty("workspace_id");
+        expect(roomState).toHaveProperty("joints");
+        expect(roomState).toHaveProperty("participants");
+        expect(roomState).toHaveProperty("timestamp");
+        expect(roomState.room_id).toBe(roomId);
+        expect(roomState.workspace_id).toBe(workspaceId);
+    });
+
+    test("delete room", async () => {
+        const { workspaceId, roomId } = await producer.createRoom();
+
+        // Verify room exists
+        const roomsBefore = await producer.listRooms(workspaceId);
+        const roomIdsBefore = roomsBefore.map(room => room.id);
+        expect(roomIdsBefore).toContain(roomId);
+
+        // Delete room
+        const success = await producer.deleteRoom(workspaceId, roomId);
+        expect(success).toBe(true);
+
+        // Verify room is deleted
+        const roomsAfter = await producer.listRooms(workspaceId);
+        const roomIdsAfter = roomsAfter.map(room => room.id);
+        expect(roomIdsAfter).not.toContain(roomId);
+    });
+
+    test("delete nonexistent room", async () => {
+        const workspaceId = `test-workspace-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const fakeRoomId = "nonexistent-room-id";
+        const success = await producer.deleteRoom(workspaceId, fakeRoomId);
+        expect(success).toBe(false);
+    });
+
+    test("get room info nonexistent", async () => {
+        const workspaceId = `test-workspace-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const fakeRoomId = "nonexistent-room-id";
+
+        // This should raise an exception or return error info
+        try {
+            await producer.getRoomInfo(workspaceId, fakeRoomId);
+            // If no exception, this is unexpected for nonexistent room
+            expect(true).toBe(false); // Force test failure
+        } catch (error) {
+            // Expected behavior for nonexistent room
+            expect(error).toBeDefined();
+        }
+    });
+
+    test("get room state nonexistent", async () => {
+        const workspaceId = `test-workspace-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const fakeRoomId = "nonexistent-room-id";
+
+        // This should raise an exception or return error info
+        try {
+            await producer.getRoomState(workspaceId, fakeRoomId);
+            // If no exception, this is unexpected for nonexistent room
+            expect(true).toBe(false); // Force test failure
+        } catch (error) {
+            // Expected behavior for nonexistent room
+            expect(error).toBeDefined();
+        }
+    });
+}); 

client/js/tests/setup.ts

@@ -0,0 +1,130 @@
+/**
+ * Test setup and utilities for RobotHub TransportServer JS Client Tests
+ * Equivalent to Python's conftest.py
+ */
+import { expect } from "bun:test";
+
+// Default server URL for tests
+export const TEST_SERVER_URL = "http://localhost:8000";
+
+// Test timeout configuration
+export const TEST_TIMEOUT = 10000; // 10 seconds
+
+// Helper to generate test IDs
+export function generateTestId(prefix: string = "test"): string {
+    return `${prefix}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+
+// Helper to wait for async operations
+export function sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// Test workspace and room management
+export class TestRoomManager {
+    private createdRooms: Array<{ workspaceId: string; roomId: string }> = [];
+
+    addRoom(workspaceId: string, roomId: string) {
+        this.createdRooms.push({ workspaceId, roomId });
+    }
+
+    async cleanup(client: any) {
+        for (const { workspaceId, roomId } of this.createdRooms) {
+            try {
+                await client.deleteRoom(workspaceId, roomId);
+            } catch (error) {
+                // Ignore cleanup errors
+                console.warn(`Failed to cleanup room ${roomId}:`, error);
+            }
+        }
+        this.createdRooms = [];
+    }
+}
+
+// Mock frame source for video tests
+export async function mockFrameSource(): Promise<ArrayBuffer | null> {
+    // Create a simple test frame (RGBA data)
+    const width = 320;
+    const height = 240;
+    const size = width * height * 4; // RGBA
+    const buffer = new ArrayBuffer(size);
+    const view = new Uint8Array(buffer);
+    
+    // Fill with test pattern
+    for (let i = 0; i < size; i += 4) {
+        view[i] = 255;     // R
+        view[i + 1] = 0;   // G
+        view[i + 2] = 0;   // B
+        view[i + 3] = 255; // A
+    }
+    
+    return buffer;
+}
+
+// Test assertion helpers
+export function assertIsConnected(client: any, workspaceId: string, roomId: string) {
+    if (!client.isConnected()) {
+        throw new Error("Expected client to be connected");
+    }
+    const info = client.getConnectionInfo();
+    if (!info.connected) {
+        throw new Error("Expected connection info to show connected");
+    }
+    if (info.workspace_id !== workspaceId) {
+        throw new Error(`Expected workspace_id ${workspaceId}, got ${info.workspace_id}`);
+    }
+    if (info.room_id !== roomId) {
+        throw new Error(`Expected room_id ${roomId}, got ${info.room_id}`);
+    }
+}
+
+export function assertIsDisconnected(client: any) {
+    if (client.isConnected()) {
+        throw new Error("Expected client to be disconnected");
+    }
+    const info = client.getConnectionInfo();
+    if (info.connected) {
+        throw new Error("Expected connection info to show disconnected");
+    }
+}
+
+// Message collection helper for testing callbacks
+export class MessageCollector<T = any> {
+    private messages: T[] = [];
+    private promise: Promise<T[]> | null = null;
+    private resolve: ((value: T[]) => void) | null = null;
+
+    constructor(private expectedCount: number = 1) {}
+
+    collect = (message: T) => {
+        this.messages.push(message);
+        if (this.messages.length >= this.expectedCount && this.resolve) {
+            this.resolve([...this.messages]);
+        }
+    };
+
+    async waitForMessages(timeoutMs: number = 5000): Promise<T[]> {
+        if (this.messages.length >= this.expectedCount) {
+            return [...this.messages];
+        }
+
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            setTimeout(() => {
+                reject(new Error(`Timeout waiting for ${this.expectedCount} messages, got ${this.messages.length}`));
+            }, timeoutMs);
+        });
+
+        return this.promise;
+    }
+
+    getMessages(): T[] {
+        return [...this.messages];
+    }
+
+    clear() {
+        this.messages = [];
+        this.promise = null;
+        this.resolve = null;
+    }
+} 

client/js/tests/video-client.test.ts

@@ -0,0 +1,254 @@
+/**
+ * Tests for Video Client - equivalent to Python's test_video_client.py
+ */
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { video } from "../src/index";
+import { TEST_SERVER_URL, TestRoomManager, mockFrameSource } from "./setup";
+
+const { VideoProducer, VideoConsumer, createProducerClient, createConsumerClient } = video;
+
+describe("Video Types", () => {
+    test("resolution creation", () => {
+        const resolution = { width: 1920, height: 1080 };
+        expect(resolution.width).toBe(1920);
+        expect(resolution.height).toBe(1080);
+    });
+
+    test("video config creation", () => {
+        const config = {
+            encoding: "vp8" as video.VideoEncoding,
+            resolution: { width: 640, height: 480 },
+            framerate: 30,
+            bitrate: 1000000
+        };
+        expect(config.encoding).toBe("vp8");
+        expect(config.resolution?.width).toBe(640);
+        expect(config.framerate).toBe(30);
+    });
+
+    test("participant role enum", () => {
+        const producerRole = "producer";
+        const consumerRole = "consumer";
+        expect(producerRole).toBe("producer");
+        expect(consumerRole).toBe("consumer");
+    });
+});
+
+describe("Video Core", () => {
+    let roomManager: TestRoomManager;
+
+    beforeEach(() => {
+        roomManager = new TestRoomManager();
+    });
+
+    afterEach(async () => {
+        await roomManager.cleanup(new VideoProducer(TEST_SERVER_URL));
+    });
+
+    test("video producer creation", () => {
+        const producer = new VideoProducer(TEST_SERVER_URL);
+        expect(producer.getConnectionInfo().base_url).toBe(TEST_SERVER_URL);
+        expect(producer.isConnected()).toBe(false);
+        expect(producer.getConnectionInfo().room_id).toBeNull();
+    });
+
+    test("video consumer creation", () => {
+        const consumer = new VideoConsumer(TEST_SERVER_URL);
+        expect(consumer.getConnectionInfo().base_url).toBe(TEST_SERVER_URL);
+        expect(consumer.isConnected()).toBe(false);
+        expect(consumer.getConnectionInfo().room_id).toBeNull();
+    });
+
+    test("producer room creation", async () => {
+        try {
+            const producer = new VideoProducer(TEST_SERVER_URL);
+            const { workspaceId, roomId } = await producer.createRoom();
+            roomManager.addRoom(workspaceId, roomId);
+
+            expect(typeof roomId).toBe("string");
+            expect(roomId.length).toBeGreaterThan(0);
+            console.log(`✅ Created room: ${roomId}`);
+        } catch (error) {
+            console.warn(`⚠️ Server not available: ${error}`);
+            // Skip test if server not available
+        }
+    }, { timeout: 5000 });
+
+    test("consumer list rooms", async () => {
+        try {
+            const consumer = new VideoConsumer(TEST_SERVER_URL);
+            const workspaceId = "test-workspace-id";
+            const rooms = await consumer.listRooms(workspaceId);
+            expect(Array.isArray(rooms)).toBe(true);
+            console.log(`✅ Listed ${rooms.length} rooms`);
+        } catch (error) {
+            console.warn(`⚠️ Server not available: ${error}`);
+            // Skip test if server not available
+        }
+    }, { timeout: 5000 });
+});
+
+describe("Video Client Integration", () => {
+    let roomManager: TestRoomManager;
+
+    beforeEach(() => {
+        roomManager = new TestRoomManager();
+    });
+
+    afterEach(async () => {
+        await roomManager.cleanup(new VideoProducer(TEST_SERVER_URL));
+    });
+
+    test("producer consumer setup", () => {
+        // Test producer setup
+        const producer = new VideoProducer(TEST_SERVER_URL);
+        expect(producer.getLocalStream()).toBeNull();
+
+        // Test consumer setup
+        const consumer = new VideoConsumer(TEST_SERVER_URL);
+        expect(consumer.getRemoteStream()).toBeNull();
+
+        console.log("✅ Producer/Consumer setup test passed");
+    });
+
+    test("custom stream setup validation", async () => {
+        const producer = new VideoProducer(TEST_SERVER_URL);
+
+        // This will fail because we're not connected, but it tests the setup
+        try {
+            // Simulate starting a custom stream when not connected
+            await producer.startCamera();
+            expect(true).toBe(false); // Should not reach here
+        } catch (error: any) {
+            expect(error.message).toContain("Must be connected");
+            console.log("✅ Custom stream setup validation passed");
+        }
+    });
+
+    test("factory functions", async () => {
+        // Test that factory functions create the right types
+        // (We can't actually connect without a server)
+
+        try {
+            await createProducerClient(TEST_SERVER_URL);
+        } catch (error) {
+            // Expected to fail without server
+            console.log("✅ Producer factory function exists");
+        }
+
+        try {
+            await createConsumerClient("test-workspace", "test-room", TEST_SERVER_URL);
+        } catch (error) {
+            // Expected to fail without server
+            console.log("✅ Consumer factory function exists");
+        }
+
+        console.log("✅ Factory functions test passed");
+    });
+
+    test("mock frame source", async () => {
+        const frameData = await mockFrameSource();
+        expect(frameData).not.toBeNull();
+        expect(frameData).toBeInstanceOf(ArrayBuffer);
+        
+        if (frameData) {
+            expect(frameData.byteLength).toBe(320 * 240 * 4); // RGBA
+            console.log("✅ Mock frame source test passed");
+        }
+    });
+
+    test("video config types", () => {
+        const config: video.VideoConfig = {
+            encoding: "h264",
+            resolution: { width: 1280, height: 720 },
+            framerate: 60,
+            bitrate: 2000000,
+            quality: 90
+        };
+
+        expect(config.encoding).toBe("h264");
+        expect(config.resolution?.width).toBe(1280);
+        expect(config.resolution?.height).toBe(720);
+        expect(config.framerate).toBe(60);
+        expect(config.bitrate).toBe(2000000);
+        expect(config.quality).toBe(90);
+
+        console.log("✅ Video config types test passed");
+    });
+
+    test("recovery config types", () => {
+        const recoveryConfig: video.RecoveryConfig = {
+            frame_timeout_ms: 200,
+            max_frame_reuse_count: 5,
+            recovery_policy: "freeze_last_frame",
+            fallback_policy: "connection_info",
+            show_hold_indicators: true,
+            fade_intensity: 0.8
+        };
+
+        expect(recoveryConfig.frame_timeout_ms).toBe(200);
+        expect(recoveryConfig.recovery_policy).toBe("freeze_last_frame");
+        expect(recoveryConfig.fallback_policy).toBe("connection_info");
+
+        console.log("✅ Recovery config types test passed");
+    });
+
+    test("participant info types", () => {
+        const participantInfo: video.ParticipantInfo = {
+            producer: "producer-123",
+            consumers: ["consumer-1", "consumer-2"],
+            total: 3
+        };
+
+        expect(participantInfo.producer).toBe("producer-123");
+        expect(participantInfo.consumers).toHaveLength(2);
+        expect(participantInfo.total).toBe(3);
+
+        console.log("✅ Participant info types test passed");
+    });
+
+    test("room info types", () => {
+        const roomInfo: video.RoomInfo = {
+            id: "room-123",
+            workspace_id: "workspace-456",
+            participants: {
+                producer: "producer-1",
+                consumers: ["consumer-1"],
+                total: 2
+            },
+            frame_count: 1000,
+            config: {
+                encoding: "vp8",
+                resolution: { width: 640, height: 480 },
+                framerate: 30
+            },
+            has_producer: true,
+            active_consumers: 1
+        };
+
+        expect(roomInfo.id).toBe("room-123");
+        expect(roomInfo.workspace_id).toBe("workspace-456");
+        expect(roomInfo.has_producer).toBe(true);
+        expect(roomInfo.active_consumers).toBe(1);
+
+        console.log("✅ Room info types test passed");
+    });
+
+    test("stream stats types", () => {
+        const streamStats: video.StreamStats = {
+            stream_id: "stream-123",
+            duration_seconds: 120.5,
+            frame_count: 3615,
+            total_bytes: 1048576,
+            average_fps: 30.0,
+            average_bitrate: 1000000
+        };
+
+        expect(streamStats.stream_id).toBe("stream-123");
+        expect(streamStats.duration_seconds).toBe(120.5);
+        expect(streamStats.frame_count).toBe(3615);
+        expect(streamStats.average_fps).toBe(30.0);
+
+        console.log("✅ Stream stats types test passed");
+    });
+}); 

client/python/.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

server/.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

server/launch_with_ui.py

@@ -107,7 +107,7 @@ else:
 
 if __name__ == "__main__":
     port = int(os.getenv("PORT", 7860))
-    host = os.getenv("HOST", "0.0.0.0")
+    host = os.getenv("HOST", "localhost")
 
     logger.info("🤖 Starting RobotHub TransportServer Combined Server...")
     logger.info(f"   - API available at: http://{host}:{port}/api/")

server/launch_without_ui.py

@@ -0,0 +1,35 @@
+import logging
+import os
+
+import uvicorn
+
+# Import the existing API
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[logging.StreamHandler(), logging.FileHandler("server.log")],
+)
+
+logger = logging.getLogger(__name__)
+
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", 8000))
+    host = os.getenv("HOST", "localhost")
+
+    logger.info("🤖 Starting RobotHub TransportServer API Server (Hot Reload Mode)...")
+    logger.info(f"   - API available at: http://{host}:{port}/")
+    logger.info(f"   - API docs at: http://{host}:{port}/docs")
+    logger.info("   - Hot reload enabled for development")
+
+    print(
+        f"🤖 Starting RobotHub TransportServer API Server on {host}:{port} (Hot Reload)"
+    )
+
+    uvicorn.run(
+        "src.api:app",
+        host=host,
+        port=port,
+        reload=True,
+        log_level="info",
+    )

server/server.log

@@ -2949,3 +2949,53 @@ RuntimeError: WebSocket is not connected. Need to call "accept" first.
 2025-06-24 23:21:44,637 - src.robotics.core - INFO - Producer producer_1750800104635_8x1wksqls left room 2d5e7658-50e7-4353-984a-3f242071514c in workspace 66f07ebe-6ed2-474a-83b8-961f30d15134
 2025-06-24 23:21:44,637 - src.robotics.core - INFO - Deleted room 2d5e7658-50e7-4353-984a-3f242071514c from workspace 66f07ebe-6ed2-474a-83b8-961f30d15134
 2025-06-24 23:21:44,643 - src.video.core - INFO - Producer producer_1750800100711_nxb7n7u43 left video room 4995e7c2-a10c-4017-b49d-9bcb60468ad9 in workspace 72b50832-75e5-447c-b8b5-07837b54c0fc
+2025-06-25 01:50:30,088 - __main__ - INFO - 🤖 Starting RobotHub TransportServer API Server (Hot Reload Mode)...
+2025-06-25 01:50:30,088 - __main__ - INFO -    - API available at: http://localhost:8000/
+2025-06-25 01:50:30,088 - __main__ - INFO -    - API docs at: http://localhost:8000/docs
+2025-06-25 01:50:30,088 - __main__ - INFO -    - Hot reload enabled for development
+2025-06-25 01:50:57,314 - src.video.core - INFO - Created video room quick-example-1750809057304-front in workspace 095e87f9-6331-4c0a-b13c-ede63936ef78
+2025-06-25 01:50:57,319 - src.robotics.core - INFO - Created room quick-example-1750809057304-joint-input in workspace 095e87f9-6331-4c0a-b13c-ede63936ef78
+2025-06-25 01:50:57,321 - src.robotics.core - INFO - Created room quick-example-1750809057304-joint-output in workspace 095e87f9-6331-4c0a-b13c-ede63936ef78
+2025-06-25 01:51:08,913 - watchfiles.main - INFO - 3 changes detected
+2025-06-25 01:51:25,277 - src.video.core - INFO - Created video room quick-example-1750809085270-front in workspace f0e7d351-fb17-4bfa-8285-6d24f6887bbd
+2025-06-25 01:51:25,282 - src.robotics.core - INFO - Created room quick-example-1750809085270-joint-input in workspace f0e7d351-fb17-4bfa-8285-6d24f6887bbd
+2025-06-25 01:51:25,283 - src.robotics.core - INFO - Created room quick-example-1750809085270-joint-output in workspace f0e7d351-fb17-4bfa-8285-6d24f6887bbd
+2025-06-25 01:52:33,163 - src.video.core - INFO - Created video room quick-example-1750809153152-front in workspace 117d5428-eca1-455f-a8c3-1e27c311213e
+2025-06-25 01:52:33,168 - src.robotics.core - INFO - Created room quick-example-1750809153152-joint-input in workspace 117d5428-eca1-455f-a8c3-1e27c311213e
+2025-06-25 01:52:33,169 - src.robotics.core - INFO - Created room quick-example-1750809153152-joint-output in workspace 117d5428-eca1-455f-a8c3-1e27c311213e
+2025-06-25 01:52:42,075 - src.video.core - INFO - Consumer quick-example-1750809153152-front-consumer joined video room quick-example-1750809153152-front in workspace 117d5428-eca1-455f-a8c3-1e27c311213e
+2025-06-25 01:52:42,581 - src.robotics.core - INFO - Consumer quick-example-1750809153152-joint-input-consumer joined room quick-example-1750809153152-joint-input in workspace 117d5428-eca1-455f-a8c3-1e27c311213e
+2025-06-25 01:52:42,585 - src.robotics.core - INFO - Producer quick-example-1750809153152-joint-output-producer joined room quick-example-1750809153152-joint-output in workspace 117d5428-eca1-455f-a8c3-1e27c311213e
+2025-06-25 01:52:44,608 - src.video.core - INFO - Consumer quick-example-1750809153152-front-consumer left video room quick-example-1750809153152-front in workspace 117d5428-eca1-455f-a8c3-1e27c311213e
+2025-06-25 01:52:44,611 - src.robotics.core - INFO - Consumer quick-example-1750809153152-joint-input-consumer left room quick-example-1750809153152-joint-input in workspace 117d5428-eca1-455f-a8c3-1e27c311213e
+2025-06-25 01:52:44,612 - src.robotics.core - INFO - Producer quick-example-1750809153152-joint-output-producer left room quick-example-1750809153152-joint-output in workspace 117d5428-eca1-455f-a8c3-1e27c311213e
+2025-06-25 01:53:27,540 - src.video.core - INFO - Created video room quick-example-1750809207533-front in workspace 05a016a6-04f8-428e-8ca1-ecf1c01f8886
+2025-06-25 01:53:27,543 - src.robotics.core - INFO - Created room quick-example-1750809207533-joint-input in workspace 05a016a6-04f8-428e-8ca1-ecf1c01f8886
+2025-06-25 01:53:27,545 - src.robotics.core - INFO - Created room quick-example-1750809207533-joint-output in workspace 05a016a6-04f8-428e-8ca1-ecf1c01f8886
+2025-06-25 01:53:29,118 - src.video.core - INFO - Consumer quick-example-1750809207533-front-consumer joined video room quick-example-1750809207533-front in workspace 05a016a6-04f8-428e-8ca1-ecf1c01f8886
+2025-06-25 01:53:29,627 - src.robotics.core - INFO - Consumer quick-example-1750809207533-joint-input-consumer joined room quick-example-1750809207533-joint-input in workspace 05a016a6-04f8-428e-8ca1-ecf1c01f8886
+2025-06-25 01:53:29,631 - src.robotics.core - INFO - Producer quick-example-1750809207533-joint-output-producer joined room quick-example-1750809207533-joint-output in workspace 05a016a6-04f8-428e-8ca1-ecf1c01f8886
+2025-06-25 01:53:31,654 - src.video.core - INFO - Consumer quick-example-1750809207533-front-consumer left video room quick-example-1750809207533-front in workspace 05a016a6-04f8-428e-8ca1-ecf1c01f8886
+2025-06-25 01:53:31,660 - src.robotics.core - INFO - Consumer quick-example-1750809207533-joint-input-consumer left room quick-example-1750809207533-joint-input in workspace 05a016a6-04f8-428e-8ca1-ecf1c01f8886
+2025-06-25 01:53:31,661 - src.robotics.core - INFO - Producer quick-example-1750809207533-joint-output-producer left room quick-example-1750809207533-joint-output in workspace 05a016a6-04f8-428e-8ca1-ecf1c01f8886
+2025-06-25 01:53:39,480 - src.video.core - INFO - Created video room example-session-1750809219478-front in workspace 756391fd-94b7-46dd-ad05-09def2b8c5e5
+2025-06-25 01:53:39,481 - src.video.core - INFO - Created video room example-session-1750809219478-wrist in workspace 756391fd-94b7-46dd-ad05-09def2b8c5e5
+2025-06-25 01:53:39,482 - src.robotics.core - INFO - Created room example-session-1750809219478-joint-input in workspace 756391fd-94b7-46dd-ad05-09def2b8c5e5
+2025-06-25 01:53:39,483 - src.robotics.core - INFO - Created room example-session-1750809219478-joint-output in workspace 756391fd-94b7-46dd-ad05-09def2b8c5e5
+2025-06-25 01:53:41,045 - src.video.core - INFO - Consumer example-session-1750809219478-front-consumer joined video room example-session-1750809219478-front in workspace 756391fd-94b7-46dd-ad05-09def2b8c5e5
+2025-06-25 01:53:41,554 - src.video.core - INFO - Consumer example-session-1750809219478-wrist-consumer joined video room example-session-1750809219478-wrist in workspace 756391fd-94b7-46dd-ad05-09def2b8c5e5
+2025-06-25 01:53:42,059 - src.robotics.core - INFO - Consumer example-session-1750809219478-joint-input-consumer joined room example-session-1750809219478-joint-input in workspace 756391fd-94b7-46dd-ad05-09def2b8c5e5
+2025-06-25 01:53:42,063 - src.robotics.core - INFO - Producer example-session-1750809219478-joint-output-producer joined room example-session-1750809219478-joint-output in workspace 756391fd-94b7-46dd-ad05-09def2b8c5e5
+2025-06-25 01:53:52,092 - src.video.core - INFO - Consumer example-session-1750809219478-front-consumer left video room example-session-1750809219478-front in workspace 756391fd-94b7-46dd-ad05-09def2b8c5e5
+2025-06-25 01:53:52,094 - src.video.core - INFO - Consumer example-session-1750809219478-wrist-consumer left video room example-session-1750809219478-wrist in workspace 756391fd-94b7-46dd-ad05-09def2b8c5e5
+2025-06-25 01:53:52,094 - src.robotics.core - INFO - Consumer example-session-1750809219478-joint-input-consumer left room example-session-1750809219478-joint-input in workspace 756391fd-94b7-46dd-ad05-09def2b8c5e5
+2025-06-25 01:53:52,094 - src.robotics.core - INFO - Producer example-session-1750809219478-joint-output-producer left room example-session-1750809219478-joint-output in workspace 756391fd-94b7-46dd-ad05-09def2b8c5e5
+2025-06-25 01:55:11,230 - src.video.core - INFO - Created video room my-robot-01-front in workspace 3a6e0b4d-21e1-4625-9af9-61bc8cabe831
+2025-06-25 01:55:11,248 - src.robotics.core - INFO - Created room my-robot-01-joint-input in workspace 3a6e0b4d-21e1-4625-9af9-61bc8cabe831
+2025-06-25 01:55:11,254 - src.robotics.core - INFO - Created room my-robot-01-joint-output in workspace 3a6e0b4d-21e1-4625-9af9-61bc8cabe831
+2025-06-25 01:55:12,987 - src.video.core - INFO - Consumer my-robot-01-front-consumer joined video room my-robot-01-front in workspace 3a6e0b4d-21e1-4625-9af9-61bc8cabe831
+2025-06-25 01:55:13,501 - src.robotics.core - INFO - Consumer my-robot-01-joint-input-consumer joined room my-robot-01-joint-input in workspace 3a6e0b4d-21e1-4625-9af9-61bc8cabe831
+2025-06-25 01:55:13,504 - src.robotics.core - INFO - Producer my-robot-01-joint-output-producer joined room my-robot-01-joint-output in workspace 3a6e0b4d-21e1-4625-9af9-61bc8cabe831
+2025-06-25 01:55:13,508 - src.video.core - INFO - Consumer my-robot-01-front-consumer left video room my-robot-01-front in workspace 3a6e0b4d-21e1-4625-9af9-61bc8cabe831
+2025-06-25 01:55:13,509 - src.robotics.core - INFO - Consumer my-robot-01-joint-input-consumer left room my-robot-01-joint-input in workspace 3a6e0b4d-21e1-4625-9af9-61bc8cabe831
+2025-06-25 01:55:13,509 - src.robotics.core - INFO - Producer my-robot-01-joint-output-producer left room my-robot-01-joint-output in workspace 3a6e0b4d-21e1-4625-9af9-61bc8cabe831